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

cc/output/direct_renderer.cc

 // Copyright 2012 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/output/direct_renderer.h"
 
 #include <stddef.h>
 
 #include <unordered_map>
 #include <utility>
@@ skipping 163 matching lines @@
       texture->Free();
   }
 
   // Delete RenderPass textures from the previous frame that will not be used
   // again.
   for (size_t i = 0; i < passes_to_delete.size(); ++i)
     render_pass_textures_.erase(passes_to_delete[i]);
 
   for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i) {
     if (render_pass_textures_.count(render_passes_in_draw_order[i]->id) == 0) {
-      scoped_ptr<ScopedResource> texture =
+      std::unique_ptr<ScopedResource> texture =
           ScopedResource::Create(resource_provider_);
       render_pass_textures_[render_passes_in_draw_order[i]->id] =
           std::move(texture);
     }
   }
 }
 
 void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
                                float device_scale_factor,
                                const gfx::Rect& device_viewport_rect,
@@ skipping 195 matching lines @@
   }
 
   std::vector<gfx::QuadF> quads;
   poly.ToQuads2D(&quads);
   for (size_t i = 0; i < quads.size(); ++i) {
     DoDrawQuad(frame, poly.original_ref(), &quads[i]);
   }
 }
 
 void DirectRenderer::FlushPolygons(
-    std::deque<scoped_ptr<DrawPolygon>>* poly_list,
+    std::deque<std::unique_ptr<DrawPolygon>>* poly_list,
     DrawingFrame* frame,
     const gfx::Rect& render_pass_scissor,
     bool use_render_pass_scissor) {
   if (poly_list->empty()) {
     return;
   }
 
   BspTree bsp_tree(poly_list);
   BspWalkActionDrawPolygon action_handler(this, frame, render_pass_scissor,
                                           use_render_pass_scissor);
@@ skipping 64 matching lines @@
     mode = SURFACE_INITIALIZATION_MODE_FULL_SURFACE_CLEAR;
   } else {
     mode = SURFACE_INITIALIZATION_MODE_PRESERVE;
   }
 
   PrepareSurfaceForPass(
       frame, mode,
       MoveFromDrawToWindowSpace(frame, render_pass_scissor_in_draw_space));
 
   const QuadList& quad_list = render_pass->quad_list;
-  std::deque<scoped_ptr<DrawPolygon>> poly_list;
+  std::deque<std::unique_ptr<DrawPolygon>> poly_list;
 
   int next_polygon_id = 0;
   int last_sorting_context_id = 0;
   for (auto it = quad_list.BackToFrontBegin(); it != quad_list.BackToFrontEnd();
        ++it) {
     const DrawQuad& quad = **it;
 
     if (render_pass_is_clipped &&
         ShouldSkipQuad(quad, render_pass_scissor_in_draw_space)) {
       continue;
     }
 
     if (last_sorting_context_id != quad.shared_quad_state->sorting_context_id) {
       last_sorting_context_id = quad.shared_quad_state->sorting_context_id;
       FlushPolygons(&poly_list, frame, render_pass_scissor_in_draw_space,
                     render_pass_is_clipped);
     }
 
     // This layer is in a 3D sorting context so we add it to the list of
     // polygons to go into the BSP tree.
     if (quad.shared_quad_state->sorting_context_id != 0) {
-      scoped_ptr<DrawPolygon> new_polygon(new DrawPolygon(
+      std::unique_ptr<DrawPolygon> new_polygon(new DrawPolygon(
           *it, gfx::RectF(quad.visible_rect),
           quad.shared_quad_state->quad_to_target_transform, next_polygon_id++));
       if (new_polygon->points().size() > 2u) {
         poly_list.push_back(std::move(new_polygon));
       }
       continue;
     }
 
     // We are not in a 3d sorting context, so we should draw the quad normally.
     SetScissorStateForQuad(frame, quad, render_pass_scissor_in_draw_space,
@@ skipping 46 matching lines @@
   auto iter = render_pass_textures_.find(id);
   return iter != render_pass_textures_.end() && iter->second->id();
 }
 
 // static
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 }  // namespace cc