Convert //cc from scoped_ptr to std::unique_ptr.

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 <stddef.h>
 
 #include <vector>
 
@@ skipping 60 matching lines @@
       transform, send_quad, points, &num_vertices_in_clipped_quad);
   for (int i = 0; i < num_vertices_in_clipped_quad; i++) {
     points_.push_back(points[i]);
   }
   ConstructNormal();
 }
 
 DrawPolygon::~DrawPolygon() {
 }
 
-scoped_ptr<DrawPolygon> DrawPolygon::CreateCopy() {
-  scoped_ptr<DrawPolygon> new_polygon(new DrawPolygon());
+std::unique_ptr<DrawPolygon> DrawPolygon::CreateCopy() {
+  std::unique_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;
 }
 
@@ skipping 157 matching lines @@
 // inverse transformation back to the polygon to move it back into layer space
 // but we can ignore the costly process of applying the inverse to the normal
 // since we know the normal will just reset to its original state.
 void DrawPolygon::TransformToLayerSpace(
     const gfx::Transform& inverse_transform) {
   ApplyTransform(inverse_transform);
   normal_ = gfx::Vector3dF(0.0f, 0.0f, -1.0f);
 }
 
 bool DrawPolygon::Split(const DrawPolygon& splitter,
-                        scoped_ptr<DrawPolygon>* front,
-                        scoped_ptr<DrawPolygon>* back) {
+                        std::unique_ptr<DrawPolygon>* front,
+                        std::unique_ptr<DrawPolygon>* back) {
   gfx::Point3F intersections[2];
   std::vector<gfx::Point3F> out_points[2];
   // vertex_before stores the index of the vertex before its matching
   // intersection.
   // i.e. vertex_before[0] stores the vertex we saw before we crossed the plane
   // which resulted in the line/plane intersection giving us intersections[0].
   size_t vertex_before[2];
   size_t points_size = points_.size();
   size_t current_intersection = 0;
 
@@ skipping 39 matching lines @@
   out_points[1].push_back(intersections[1]);
   size_t index = start2;
   for (size_t i = 0; i < points_remaining; i++) {
     out_points[1].push_back(points_[index % points_size]);
     ++index;
   }
   out_points[1].push_back(intersections[0]);
 
   // Give both polygons the original splitting polygon's ID, so that they'll
   // still be sorted properly in co-planar instances.
-  scoped_ptr<DrawPolygon> poly1(
+  std::unique_ptr<DrawPolygon> poly1(
       new DrawPolygon(original_ref_, out_points[0], normal_, order_index_));
-  scoped_ptr<DrawPolygon> poly2(
+  std::unique_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 = std::move(poly1);
     *back = std::move(poly2);
   } else {
     *front = std::move(poly2);
@@ skipping 29 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