cc: Replace Pass() with std::move() in some subdirs.

cc/quads/draw_polygon.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 "cc/quads/draw_polygon.h"
 
 #include <vector>
 
 #include "cc/output/bsp_compare_result.h"
 #include "cc/quads/draw_quad.h"
@@ skipping 67 matching lines @@
 
 scoped_ptr<DrawPolygon> DrawPolygon::CreateCopy() {
   scoped_ptr<DrawPolygon> new_polygon(new DrawPolygon());
   new_polygon->order_index_ = order_index_;
   new_polygon->original_ref_ = original_ref_;
   new_polygon->points_.reserve(points_.size());
   new_polygon->points_ = points_;
   new_polygon->normal_.set_x(normal_.x());
   new_polygon->normal_.set_y(normal_.y());
   new_polygon->normal_.set_z(normal_.z());
-  return new_polygon.Pass();
+  return new_polygon;
 }
 
 float DrawPolygon::SignedPointDistance(const gfx::Point3F& point) const {
   return gfx::DotProduct(point - points_[0], normal_);
 }
 
 // Checks whether or not shape a lies on the front or back side of b, or
 // whether they should be considered coplanar. If on the back side, we
 // say A_BEFORE_B because it should be drawn in that order.
 // Assumes that layers are split and there are no intersecting planes.
@@ skipping 188 matching lines @@
   // still be sorted properly in co-planar instances.
   scoped_ptr<DrawPolygon> poly1(
       new DrawPolygon(original_ref_, out_points[0], normal_, order_index_));
   scoped_ptr<DrawPolygon> poly2(
       new DrawPolygon(original_ref_, out_points[1], normal_, order_index_));
 
   DCHECK_GE(poly1->points().size(), 3u);
   DCHECK_GE(poly2->points().size(), 3u);
 
   if (SideCompare(*poly1, splitter) == BSP_FRONT) {
-    *front = poly1.Pass();
-    *back = poly2.Pass();
+    *front = std::move(poly1);
+    *back = std::move(poly2);
   } else {
-    *front = poly2.Pass();
-    *back = poly1.Pass();
+    *front = std::move(poly2);
+    *back = std::move(poly1);
   }
   return true;
 }
 
 // This algorithm takes the first vertex in the polygon and uses that as a
 // pivot point to fan out and create quads from the rest of the vertices.
 // |offset| starts off as the second vertex, and then |op1| and |op2| indicate
 // offset+1 and offset+2 respectively.
 // After the first quad is created, the first vertex in the next quad is the
 // same as all the rest, the pivot point. The second vertex in the next quad is
@@ skipping 18 matching lines @@
     quads->push_back(
         gfx::QuadF(first,
                    gfx::PointF(points_[offset].x(), points_[offset].y()),
                    gfx::PointF(points_[op1].x(), points_[op1].y()),
                    gfx::PointF(points_[op2].x(), points_[op2].y())));
     offset = op2;
   }
 }
 
 }  // namespace cc