Use scoped_ptr::Pass instead of scoped_ptr::PassAs<T>.

ui/gfx/geometry/r_tree_unittest.cc

 // Copyright 2014 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.
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/r_tree.h"
 #include "ui/gfx/geometry/r_tree_base.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace gfx {
@@ skipping 261 matching lines @@
   EXPECT_FALSE(NodeCompareHorizontal(&low, &shorter_tie));
 }
 
 TEST_F(RTreeNodeTest, CompareCenterDistanceFromParent) {
   // Create a test node we can add children to, for distance comparisons.
   scoped_ptr<RTreeNode> parent(new RTreeNode);
 
   // Add three children, one each with centers at (0, 0), (10, 10), (-9, -9),
   // around which a bounding box will be centered at (0, 0)
   scoped_ptr<RTreeRecord> center_zero(new RTreeRecord(Rect(-1, -1, 2, 2), 1));
-  parent->AddChild(center_zero.PassAs<RTreeNodeBase>());
+  parent->AddChild(center_zero.Pass());
 
   scoped_ptr<RTreeRecord> center_positive(new RTreeRecord(Rect(9, 9, 2, 2), 2));
-  parent->AddChild(center_positive.PassAs<RTreeNodeBase>());
+  parent->AddChild(center_positive.Pass());
 
   scoped_ptr<RTreeRecord> center_negative(
       new RTreeRecord(Rect(-10, -10, 2, 2), 3));
-  parent->AddChild(center_negative.PassAs<RTreeNodeBase>());
+  parent->AddChild(center_negative.Pass());
 
   ValidateNode(parent.get(), 1U, 5U);
   EXPECT_EQ(Rect(-10, -10, 21, 21), parent->rect());
 
   EXPECT_TRUE(
       NodeCompareCenterDistanceFromParent(parent->child(0), parent->child(1)));
   EXPECT_FALSE(
       NodeCompareCenterDistanceFromParent(parent->child(1), parent->child(0)));
   EXPECT_TRUE(
       NodeCompareCenterDistanceFromParent(parent->child(0), parent->child(2)));
@@ skipping 204 matching lines @@
 TEST_F(RTreeNodeTest, DivideChildren) {
   // Create a test node to split.
   scoped_ptr<RTreeNode> test_node(new RTreeNode);
   std::vector<RTreeNodeBase*> sorted_children;
   RTreeRects low_bounds;
   RTreeRects high_bounds;
   // Insert 10 record nodes, also inserting them into our children array.
   for (int i = 1; i <= 10; ++i) {
     scoped_ptr<RTreeRecord> record(new RTreeRecord(Rect(0, 0, i, i), i));
     sorted_children.push_back(record.get());
-    test_node->AddChild(record.PassAs<RTreeNodeBase>());
+    test_node->AddChild(record.Pass());
     low_bounds.push_back(Rect(0, 0, i, i));
     high_bounds.push_back(Rect(0, 0, 10, 10));
   }
   // Split the children in half.
   scoped_ptr<RTreeNodeBase> split_node_base(NodeDivideChildren(
       test_node.get(), low_bounds, high_bounds, sorted_children, 5));
   RTreeNode* split_node = static_cast<RTreeNode*>(split_node_base.get());
   // Both nodes should be valid.
   ValidateNode(test_node.get(), 1U, 10U);
   ValidateNode(split_node, 1U, 10U);
@@ skipping 52 matching lines @@
   scoped_ptr<RTreeNode> root(NewNodeAtLevel(2));
   for (int i = 0; i < 2; ++i) {
     scoped_ptr<RTreeNode> level_1_child(NewNodeAtLevel(1));
     for (int j = 0; j < 2; ++j) {
       scoped_ptr<RTreeNode> level_0_child(new RTreeNode);
       for (int k = 0; k < 2; ++k) {
         scoped_ptr<RTreeRecord> record(
             new RTreeRecord(Rect(0, 0, id, id), id));
         ++id;
         records.push_back(record.get());
-        level_0_child->AddChild(record.PassAs<RTreeNodeBase>());
+        level_0_child->AddChild(record.Pass());
       }
       level_0_children.push_back(level_0_child.get());
-      level_1_child->AddChild(level_0_child.PassAs<RTreeNodeBase>());
+      level_1_child->AddChild(level_0_child.Pass());
     }
     level_1_children.push_back(level_1_child.get());
-    root->AddChild(level_1_child.PassAs<RTreeNodeBase>());
+    root->AddChild(level_1_child.Pass());
   }
 
   // This should now be a valid tree structure.
   ValidateNode(root.get(), 2U, 2U);
   EXPECT_EQ(2U, level_1_children.size());
   EXPECT_EQ(4U, level_0_children.size());
   EXPECT_EQ(8U, records.size());
 
   // Now remove all of the level 0 nodes so we get the record nodes as orphans.
   RTreeNodes orphans;
@@ skipping 48 matching lines @@
   scoped_ptr<RTreeNode> test_parent(NewNodeAtLevel(1));
   // Construct 4 nodes with 1x2 rects spaced horizontally 1 pixel apart, or:
   //
   // a b c d
   // a b c d
   //
   for (int i = 0; i < 4; ++i) {
     scoped_ptr<RTreeNode> node(new RTreeNode);
     scoped_ptr<RTreeRecord> record(
         new RTreeRecord(Rect(i * 2, 0, 1, 2), i + 1));
-    node->AddChild(record.PassAs<RTreeNodeBase>());
-    test_parent->AddChild(node.PassAs<RTreeNodeBase>());
+    node->AddChild(record.Pass());
+    test_parent->AddChild(node.Pass());
   }
 
   ValidateNode(test_parent.get(), 1U, 5U);
 
   // Test rect at (7, 0) should require minimum overlap on the part of the
   // fourth rectangle to add:
   //
   // a b c dT
   // a b c d
   //
@@ skipping 29 matching lines @@
 
   // Add a rectangle that overlaps completely with rectangle c, to test
   // when there is a tie between two completely contained rectangles:
   //
   // a b Ted
   // a b eed
   //
   scoped_ptr<RTreeNode> record_parent(new RTreeNode);
   record_parent->AddChild(
       scoped_ptr<RTreeNodeBase>(new RTreeRecord(Rect(4, 0, 2, 2), 9)));
-  test_parent->AddChild(record_parent.PassAs<RTreeNodeBase>());
+  test_parent->AddChild(record_parent.Pass());
   BuildExpandedRects(test_parent.get(), test_rect_inside, &expanded_rects);
   result = NodeLeastOverlapIncrease(
       test_parent.get(), test_rect_inside, expanded_rects);
   EXPECT_TRUE(result == NULL);
 }
 
 TEST_F(RTreeNodeTest, LeastAreaEnlargement) {
   scoped_ptr<RTreeNode> test_parent(NewNodeAtLevel(1));
   // Construct 4 nodes in a cross-hairs style configuration:
   //
   //  a
   // b c
   //  d
   //
   scoped_ptr<RTreeNode> node(new RTreeNode);
   node->AddChild(
       scoped_ptr<RTreeNodeBase>(new RTreeRecord(Rect(1, 0, 1, 1), 1)));
-  test_parent->AddChild(node.PassAs<RTreeNodeBase>());
+  test_parent->AddChild(node.Pass());
   node.reset(new RTreeNode);
   node->AddChild(
       scoped_ptr<RTreeNodeBase>(new RTreeRecord(Rect(0, 1, 1, 1), 2)));
-  test_parent->AddChild(node.PassAs<RTreeNodeBase>());
+  test_parent->AddChild(node.Pass());
   node.reset(new RTreeNode);
   node->AddChild(
       scoped_ptr<RTreeNodeBase>(new RTreeRecord(Rect(2, 1, 1, 1), 3)));
-  test_parent->AddChild(node.PassAs<RTreeNodeBase>());
+  test_parent->AddChild(node.Pass());
   node.reset(new RTreeNode);
   node->AddChild(
       scoped_ptr<RTreeNodeBase>(new RTreeRecord(Rect(1, 2, 1, 1), 4)));
-  test_parent->AddChild(node.PassAs<RTreeNodeBase>());
+  test_parent->AddChild(node.Pass());
 
   ValidateNode(test_parent.get(), 1U, 5U);
 
   // Test rect at (1, 3) should require minimum area to add to Node d:
   //
   //  a
   // b c
   //  d
   //  T
   //
@@ skipping 18 matching lines @@
 
   // Add e at (0, 1) to overlap b and c, to test tie-breaking:
   //
   //  a
   // eee
   //  d
   //
   node.reset(new RTreeNode);
   node->AddChild(
       scoped_ptr<RTreeNodeBase>(new RTreeRecord(Rect(0, 1, 3, 1), 7)));
-  test_parent->AddChild(node.PassAs<RTreeNodeBase>());
+  test_parent->AddChild(node.Pass());
 
   ValidateNode(test_parent.get(), 1U, 5U);
 
   // Test rect at (3, 1) should tie between c and e, but c has smaller area so
   // the algorithm should select c:
   //
   //
   //  a
   // eeeT
   //  d
@@ skipping 223 matching lines @@
   AddStackedSquares(&rt, 100);
   ValidateRTree(&rt);
 
   for (int i = 1; i <= 100; ++i) {
     rt.Insert(Rect(0, 0, 0, 0), i);
     ValidateRTree(&rt);
   }
 }
 
 }  // namespace gfx