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

cc/layers/layer.cc

 // Copyright 2010 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/layers/layer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 333 matching lines @@
 }
 
 bool Layer::HasAncestor(const Layer* ancestor) const {
   for (const Layer* layer = parent(); layer; layer = layer->parent()) {
     if (layer == ancestor)
       return true;
   }
   return false;
 }
 
-void Layer::RequestCopyOfOutput(
-    scoped_ptr<CopyOutputRequest> request) {
+void Layer::RequestCopyOfOutput(std::unique_ptr<CopyOutputRequest> request) {
   DCHECK(IsPropertyChangeAllowed());
   if (void* source = request->source()) {
-    auto it = std::find_if(copy_requests_.begin(), copy_requests_.end(),
-                           [source](const scoped_ptr<CopyOutputRequest>& x) {
-                             return x->source() == source;
-                           });
+    auto it =
+        std::find_if(copy_requests_.begin(), copy_requests_.end(),
+                     [source](const std::unique_ptr<CopyOutputRequest>& x) {
+                       return x->source() == source;
+                     });
     if (it != copy_requests_.end())
       copy_requests_.erase(it);
   }
   if (request->IsEmpty())
     return;
   copy_requests_.push_back(std::move(request));
   SetSubtreePropertyChanged();
   SetNeedsCommit();
 }
 
@@ skipping 717 matching lines @@
 }
 
 void Layer::SetPositionConstraint(const LayerPositionConstraint& constraint) {
   DCHECK(IsPropertyChangeAllowed());
   if (position_constraint_ == constraint)
     return;
   position_constraint_ = constraint;
   SetNeedsCommit();
 }
 
-static void RunCopyCallbackOnMainThread(scoped_ptr<CopyOutputRequest> request,
-                                        scoped_ptr<CopyOutputResult> result) {
+static void RunCopyCallbackOnMainThread(
+    std::unique_ptr<CopyOutputRequest> request,
+    std::unique_ptr<CopyOutputResult> result) {
   request->SendResult(std::move(result));
 }
 
 static void PostCopyCallbackToMainThread(
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
-    scoped_ptr<CopyOutputRequest> request,
-    scoped_ptr<CopyOutputResult> result) {
+    std::unique_ptr<CopyOutputRequest> request,
+    std::unique_ptr<CopyOutputResult> result) {
   main_thread_task_runner->PostTask(FROM_HERE,
                                     base::Bind(&RunCopyCallbackOnMainThread,
                                                base::Passed(&request),
                                                base::Passed(&result)));
 }
 
 void Layer::PushPropertiesTo(LayerImpl* layer) {
   TRACE_EVENT0("cc", "Layer::PushPropertiesTo");
   DCHECK(layer_tree_host_);
 
@@ skipping 117 matching lines @@
   // active tree. To do so, avoid scrolling the pending tree along with it
   // instead of trying to undo that scrolling later.
   if (ScrollOffsetAnimationWasInterrupted())
     layer_tree_host()
         ->property_trees()
         ->scroll_tree.SetScrollOffsetClobberActiveValue(layer->id());
 
   {
     TRACE_EVENT0("cc", "Layer::PushPropertiesTo::CopyOutputRequests");
     // Wrap the copy_requests_ in a PostTask to the main thread.
-    std::vector<scoped_ptr<CopyOutputRequest>> main_thread_copy_requests;
+    std::vector<std::unique_ptr<CopyOutputRequest>> main_thread_copy_requests;
     for (auto it = copy_requests_.begin(); it != copy_requests_.end(); ++it) {
       scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner =
           layer_tree_host()->task_runner_provider()->MainThreadTaskRunner();
-      scoped_ptr<CopyOutputRequest> original_request = std::move(*it);
+      std::unique_ptr<CopyOutputRequest> original_request = std::move(*it);
       const CopyOutputRequest& original_request_ref = *original_request;
-      scoped_ptr<CopyOutputRequest> main_thread_request =
+      std::unique_ptr<CopyOutputRequest> main_thread_request =
           CopyOutputRequest::CreateRelayRequest(
               original_request_ref,
               base::Bind(&PostCopyCallbackToMainThread, main_thread_task_runner,
                          base::Passed(&original_request)));
       main_thread_copy_requests.push_back(std::move(main_thread_request));
     }
     if (!copy_requests_.empty() && layer_tree_host_)
       layer_tree_host_->property_trees()->needs_rebuild = true;
 
     copy_requests_.clear();
@@ skipping 305 matching lines @@
     int child_id = base.clip_children_ids(i);
     scoped_refptr<Layer> child = layer_tree_host_->LayerById(child_id);
     clip_children_->insert(child.get());
   }
 
   scroll_offset_ = ProtoToScrollOffset(base.scroll_offset());
 
   update_rect_.Union(ProtoToRect(base.update_rect()));
 }
 
-scoped_ptr<LayerImpl> Layer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
+std::unique_ptr<LayerImpl> Layer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
   return LayerImpl::Create(tree_impl, layer_id_);
 }
 
 bool Layer::DrawsContent() const {
   return draws_content_;
 }
 
 bool Layer::HasDrawableContent() const {
   return is_drawable_;
 }
@@ skipping 30 matching lines @@
   DCHECK_EQ(layer_tree_host_->source_frame_number(),
             paint_properties_.source_frame_number) <<
       "SavePaintProperties must be called for any layer that is painted.";
   return false;
 }
 
 bool Layer::IsSuitableForGpuRasterization() const {
   return true;
 }
 
-scoped_ptr<base::trace_event::ConvertableToTraceFormat> Layer::TakeDebugInfo() {
+std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
+Layer::TakeDebugInfo() {
   if (client_)
     return client_->TakeDebugInfo(this);
   else
     return nullptr;
 }
 
 void Layer::SetHasRenderSurface(bool has_render_surface) {
   if (has_render_surface_ == has_render_surface)
     return;
   has_render_surface_ = has_render_surface;
@@ skipping 197 matching lines @@
       ->data.num_copy_requests_in_subtree;
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, -1);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc