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

cc/quads/render_pass.cc

 // Copyright 2011 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/render_pass.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
+#include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/traced_value.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/io_surface_draw_quad.h"
 #include "cc/quads/largest_draw_quad.h"
@@ skipping 11 matching lines @@
 const size_t kDefaultNumSharedQuadStatesToReserve = 32;
 const size_t kDefaultNumQuadsToReserve = 128;
 }
 
 namespace cc {
 
 QuadList::QuadList(size_t default_size_to_reserve)
     : ListContainer<DrawQuad>(LargestDrawQuadSize(), default_size_to_reserve) {
 }
 
-scoped_ptr<RenderPass> RenderPass::Create() {
-  return make_scoped_ptr(new RenderPass());
+std::unique_ptr<RenderPass> RenderPass::Create() {
+  return base::WrapUnique(new RenderPass());
 }
 
-scoped_ptr<RenderPass> RenderPass::Create(size_t num_layers) {
-  return make_scoped_ptr(new RenderPass(num_layers));
+std::unique_ptr<RenderPass> RenderPass::Create(size_t num_layers) {
+  return base::WrapUnique(new RenderPass(num_layers));
 }
 
-scoped_ptr<RenderPass> RenderPass::Create(size_t shared_quad_state_list_size,
-                                          size_t quad_list_size) {
-  return make_scoped_ptr(
+std::unique_ptr<RenderPass> RenderPass::Create(
+    size_t shared_quad_state_list_size,
+    size_t quad_list_size) {
+  return base::WrapUnique(
       new RenderPass(shared_quad_state_list_size, quad_list_size));
 }
 
 RenderPass::RenderPass()
     : has_transparent_background(true),
       quad_list(kDefaultNumQuadsToReserve),
       shared_quad_state_list(sizeof(SharedQuadState),
                              kDefaultNumSharedQuadStatesToReserve) {
 }
 
@@ skipping 12 matching lines @@
       shared_quad_state_list(sizeof(SharedQuadState),
                              shared_quad_state_list_size) {
 }
 
 RenderPass::~RenderPass() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"),
       "cc::RenderPass", id.AsTracingId());
 }
 
-scoped_ptr<RenderPass> RenderPass::Copy(RenderPassId new_id) const {
-  scoped_ptr<RenderPass> copy_pass(
+std::unique_ptr<RenderPass> RenderPass::Copy(RenderPassId new_id) const {
+  std::unique_ptr<RenderPass> copy_pass(
       Create(shared_quad_state_list.size(), quad_list.size()));
   copy_pass->SetAll(new_id,
                     output_rect,
                     damage_rect,
                     transform_to_root_target,
                     has_transparent_background);
   return copy_pass;
 }
 
 // static
-void RenderPass::CopyAll(const std::vector<scoped_ptr<RenderPass>>& in,
-                         std::vector<scoped_ptr<RenderPass>>* out) {
+void RenderPass::CopyAll(const std::vector<std::unique_ptr<RenderPass>>& in,
+                         std::vector<std::unique_ptr<RenderPass>>* out) {
   for (const auto& source : in) {
     // Since we can't copy these, it's wrong to use CopyAll in a situation where
     // you may have copy_requests present.
     DCHECK_EQ(source->copy_requests.size(), 0u);
 
-    scoped_ptr<RenderPass> copy_pass(Create(
+    std::unique_ptr<RenderPass> copy_pass(Create(
         source->shared_quad_state_list.size(), source->quad_list.size()));
     copy_pass->SetAll(source->id,
                       source->output_rect,
                       source->damage_rect,
                       source->transform_to_root_target,
                       source->has_transparent_background);
     for (const auto& shared_quad_state : source->shared_quad_state_list) {
       SharedQuadState* copy_shared_quad_state =
           copy_pass->CreateAndAppendSharedQuadState();
       copy_shared_quad_state->CopyFrom(shared_quad_state);
@@ skipping 141 matching lines @@
     case DrawQuad::RENDER_PASS:
     case DrawQuad::INVALID:
       LOG(FATAL) << "Invalid DrawQuad material " << quad->material;
       break;
   }
   quad_list.back()->shared_quad_state = shared_quad_state;
   return quad_list.back();
 }
 
 }  // namespace cc