cc: Remove ScopedPtrDeque.

This patch removes ScopedPtrDeque and replaces it with a deque of
scoped_ptrs. Note that this also adds a helper container_util file
that contains TakeBack and TakeFront helpers.

R=danakj
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1441613002

Cr-Commit-Position: refs/heads/master@{#359724}

Author: vmpstr

cc/base/BUILD.gn

@@ -7,6 +7,7 @@ source_set("base") {
 
   sources = [
     "completion_event.h",
+    "container_util.h",
     "delayed_unique_notifier.cc",
     "delayed_unique_notifier.h",
     "histograms.cc",
@@ -27,7 +28,6 @@ source_set("base") {
     "rtree.cc",
     "rtree.h",
     "scoped_ptr_algorithm.h",
-    "scoped_ptr_deque.h",
     "scoped_ptr_vector.h",
     "simple_enclosed_region.cc",
     "simple_enclosed_region.h",

cc/base/container_util.h

@@ -0,0 +1,34 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CC_BASE_CONTAINER_UTIL_H_
+#define CC_BASE_CONTAINER_UTIL_H_
+
+#include "base/memory/scoped_ptr.h"
+
+namespace cc {
+
+// Removes the front element from the container and returns it. Note that this
+// currently only works with types that implement Pass().
+// TODO(vmpstr): Use std::move instead of Pass when allowed.
+template <typename Container>
+typename Container::value_type PopFront(Container* container) {
+  typename Container::value_type element = container->front().Pass();
+  container->pop_front();
+  return element;
+}
+
+// Removes the back element from the container and returns it. Note that this
+// currently only works with types that implement Pass().
+// TODO(vmpstr): Use std::move instead of Pass when allowed.
+template <typename Container>
+typename Container::value_type PopBack(Container* container) {
+  typename Container::value_type element = container->back().Pass();
+  container->pop_back();
+  return element;
+}
+
+}  // namespace cc
+
+#endif  // CC_BASE_CONTAINER_UTIL_H_

cc/base/scoped_ptr_deque.h

@@ -76,6 +76,7 @@
         'animation/transform_operations.cc',
         'animation/transform_operations.h',
         'base/completion_event.h',
+        'base/container_util.h',
         'base/delayed_unique_notifier.cc',
         'base/delayed_unique_notifier.h',
         'base/histograms.cc',
@@ -96,7 +97,6 @@
         'base/rtree.cc',
         'base/rtree.h',
         'base/scoped_ptr_algorithm.h',
-        'base/scoped_ptr_deque.h',
         'base/scoped_ptr_vector.h',
         'base/simple_enclosed_region.cc',
         'base/simple_enclosed_region.h',

cc/cc.gyp

@@ -7,7 +7,7 @@
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
-#include "cc/base/scoped_ptr_deque.h"
+#include "cc/base/container_util.h"
 #include "cc/base/scoped_ptr_vector.h"
 #include "cc/output/bsp_compare_result.h"
 #include "cc/quads/draw_polygon.h"
@@ -20,11 +20,11 @@ BspNode::BspNode(scoped_ptr<DrawPolygon> data) : node_data(data.Pass()) {
 BspNode::~BspNode() {
 }
 
-BspTree::BspTree(ScopedPtrDeque<DrawPolygon>* list) {
+BspTree::BspTree(std::deque<scoped_ptr<DrawPolygon>>* list) {
   if (list->size() == 0)
     return;
 
-  root_ = make_scoped_ptr(new BspNode(list->take_front()));
+  root_ = make_scoped_ptr(new BspNode(PopFront(list)));
   BuildTree(root_.get(), list);
 }
 
@@ -35,14 +35,14 @@ BspTree::BspTree(ScopedPtrDeque<DrawPolygon>* list) {
 // can always simply just take from the front of the deque for our node's
 // data.
 void BspTree::BuildTree(BspNode* node,
-                        ScopedPtrDeque<DrawPolygon>* polygon_list) {
-  ScopedPtrDeque<DrawPolygon> front_list;
-  ScopedPtrDeque<DrawPolygon> back_list;
+                        std::deque<scoped_ptr<DrawPolygon>>* polygon_list) {
+  std::deque<scoped_ptr<DrawPolygon>> front_list;
+  std::deque<scoped_ptr<DrawPolygon>> back_list;
 
   // We take in a list of polygons at this level of the tree, and have to
   // find a splitting plane, then classify polygons as either in front of
   // or behind that splitting plane.
-  while (polygon_list->size() > 0) {
+  while (!polygon_list->empty()) {
     // Is this particular polygon in front of or behind our splitting polygon.
     BspCompareResult comparer_result =
         GetNodePositionRelative(*polygon_list->front(), *(node->node_data));
@@ -52,18 +52,18 @@ void BspTree::BuildTree(BspNode* node,
     // or front of the list.
     switch (comparer_result) {
       case BSP_FRONT:
-        front_list.push_back(polygon_list->take_front().Pass());
+        front_list.push_back(PopFront(polygon_list));
         break;
       case BSP_BACK:
-        back_list.push_back(polygon_list->take_front().Pass());
+        back_list.push_back(PopFront(polygon_list));
         break;
       case BSP_SPLIT:
       {
         scoped_ptr<DrawPolygon> polygon;
         scoped_ptr<DrawPolygon> new_front;
         scoped_ptr<DrawPolygon> new_back;
         // Time to split this geometry, *it needs to be split by node_data.
-        polygon = polygon_list->take_front();
+        polygon = PopFront(polygon_list);
         bool split_result =
             polygon->Split(*(node->node_data), &new_front, &new_back);
         DCHECK(split_result);
@@ -75,10 +75,10 @@ void BspTree::BuildTree(BspNode* node,
         break;
       }
       case BSP_COPLANAR_FRONT:
-        node->coplanars_front.push_back(polygon_list->take_front());
+        node->coplanars_front.push_back(PopFront(polygon_list));
         break;
       case BSP_COPLANAR_BACK:
-        node->coplanars_back.push_back(polygon_list->take_front());
+        node->coplanars_back.push_back(PopFront(polygon_list));
         break;
       default:
         NOTREACHED();
@@ -88,14 +88,13 @@ void BspTree::BuildTree(BspNode* node,
 
   // Build the back subtree using the front of the back_list as our splitter.
   if (back_list.size() > 0) {
-    node->back_child = make_scoped_ptr(new BspNode(back_list.take_front()));
+    node->back_child = make_scoped_ptr(new BspNode(PopFront(&back_list)));
     BuildTree(node->back_child.get(), &back_list);
   }
 
   // Build the front subtree using the front of the front_list as our splitter.
   if (front_list.size() > 0) {
-    node->front_child =
-        scoped_ptr<BspNode>(new BspNode(front_list.take_front()));
+    node->front_child = make_scoped_ptr(new BspNode(PopFront(&front_list)));
     BuildTree(node->front_child.get(), &front_list);
   }
 }

cc/output/bsp_tree.cc

@@ -5,10 +5,10 @@
 #ifndef CC_OUTPUT_BSP_TREE_H_
 #define CC_OUTPUT_BSP_TREE_H_
 
+#include <deque>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
-#include "cc/base/scoped_ptr_deque.h"
 #include "cc/base/scoped_ptr_vector.h"
 #include "cc/output/bsp_compare_result.h"
 #include "cc/quads/draw_polygon.h"
@@ -31,7 +31,7 @@ struct BspNode {
 
 class CC_EXPORT BspTree {
  public:
-  explicit BspTree(ScopedPtrDeque<DrawPolygon>* list);
+  explicit BspTree(std::deque<scoped_ptr<DrawPolygon>>* list);
   scoped_ptr<BspNode>& root() { return root_; }
 
   template <typename ActionHandlerType>
@@ -47,7 +47,7 @@ class CC_EXPORT BspTree {
   scoped_ptr<BspNode> root_;
 
   void FromList(ScopedPtrVector<DrawPolygon>* list);
-  void BuildTree(BspNode* node, ScopedPtrDeque<DrawPolygon>* data);
+  void BuildTree(BspNode* node, std::deque<scoped_ptr<DrawPolygon>>* data);
 
   template <typename ActionHandlerType>
   void WalkInOrderAction(ActionHandlerType* action_handler,