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

cc/layers/layer_impl.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/layers/layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "base/json/json_reader.h"
+#include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/animation/mutable_properties.h"
 #include "cc/base/math_util.h"
 #include "cc/base/simple_enclosed_region.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/debug/layer_tree_debug_state.h"
 #include "cc/debug/micro_benchmark_impl.h"
@@ skipping 92 matching lines @@
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerImpl", this);
 
   if (mask_layer_)
     layer_tree_impl_->RemoveLayer(mask_layer_id_);
   if (replica_layer_)
     layer_tree_impl_->RemoveLayer(replica_layer_id_);
   ClearChildList();
 }
 
-void LayerImpl::AddChild(scoped_ptr<LayerImpl> child) {
+void LayerImpl::AddChild(std::unique_ptr<LayerImpl> child) {
   child->SetParent(this);
   DCHECK_EQ(layer_tree_impl(), child->layer_tree_impl());
   children_.push_back(child.get());
   layer_tree_impl_->AddLayer(std::move(child));
 }
 
-scoped_ptr<LayerImpl> LayerImpl::RemoveChildForTesting(LayerImpl* child) {
+std::unique_ptr<LayerImpl> LayerImpl::RemoveChildForTesting(LayerImpl* child) {
   auto it = std::find(children_.begin(), children_.end(), child);
   if (it != children_.end())
     children_.erase(it);
   return layer_tree_impl_->RemoveLayer(child->id());
 }
 
 void LayerImpl::SetParent(LayerImpl* parent) {
   parent_ = parent;
 }
 
@@ skipping 16 matching lines @@
     return;
 
   if (parent)
     DCHECK_EQ(layer_tree_impl()->LayerById(parent->id()), parent);
 
   scroll_parent_ = parent;
   SetNeedsPushProperties();
 }
 
 void LayerImpl::SetDebugInfo(
-    scoped_ptr<base::trace_event::ConvertableToTraceFormat> debug_info) {
+    std::unique_ptr<base::trace_event::ConvertableToTraceFormat> debug_info) {
   owned_debug_info_ = std::move(debug_info);
   debug_info_ = owned_debug_info_.get();
   SetNeedsPushProperties();
 }
 
 void LayerImpl::SetScrollChildren(std::set<LayerImpl*>* children) {
   if (scroll_children_.get() == children)
     return;
   scroll_children_.reset(children);
   SetNeedsPushProperties();
@@ skipping 61 matching lines @@
   effect_tree_index_ = index;
   SetNeedsPushProperties();
 }
 
 void LayerImpl::SetScrollTreeIndex(int index) {
   scroll_tree_index_ = index;
   SetNeedsPushProperties();
 }
 
 void LayerImpl::PassCopyRequests(
-    std::vector<scoped_ptr<CopyOutputRequest>>* requests) {
+    std::vector<std::unique_ptr<CopyOutputRequest>>* requests) {
   // In the case that a layer still has a copy request, this means that there's
   // a commit to the active tree without a draw.  This only happens in some
   // edge cases during lost context or visibility changes, so don't try to
   // handle preserving these output requests (and their surface).
   if (!copy_requests_.empty()) {
     layer_tree_impl()->RemoveLayerWithCopyOutputRequest(this);
     // Destroying these will abort them.
     copy_requests_.clear();
   }
 
   if (requests->empty())
     return;
 
   bool was_empty = copy_requests_.empty();
   for (auto& request : *requests)
     copy_requests_.push_back(std::move(request));
   requests->clear();
 
   if (was_empty && layer_tree_impl()->IsActiveTree())
     layer_tree_impl()->AddLayerWithCopyOutputRequest(this);
 }
 
 void LayerImpl::TakeCopyRequestsAndTransformToTarget(
-    std::vector<scoped_ptr<CopyOutputRequest>>* requests) {
+    std::vector<std::unique_ptr<CopyOutputRequest>>* requests) {
   DCHECK(!copy_requests_.empty());
   DCHECK(layer_tree_impl()->IsActiveTree());
   DCHECK_EQ(render_target(), this);
 
   size_t first_inserted_request = requests->size();
   for (auto& request : copy_requests_)
     requests->push_back(std::move(request));
   copy_requests_.clear();
 
   for (size_t i = first_inserted_request; i < requests->size(); ++i) {
@@ skipping 167 matching lines @@
 
 void LayerImpl::set_user_scrollable_vertical(bool scrollable) {
   user_scrollable_vertical_ = scrollable;
 }
 
 bool LayerImpl::user_scrollable(ScrollbarOrientation orientation) const {
   return (orientation == HORIZONTAL) ? user_scrollable_horizontal_
                                      : user_scrollable_vertical_;
 }
 
-scoped_ptr<LayerImpl> LayerImpl::CreateLayerImpl(LayerTreeImpl* tree_impl) {
+std::unique_ptr<LayerImpl> LayerImpl::CreateLayerImpl(
+    LayerTreeImpl* tree_impl) {
   return LayerImpl::Create(tree_impl, layer_id_);
 }
 
 void LayerImpl::set_main_thread_scrolling_reasons(
     uint32_t main_thread_scrolling_reasons) {
   if (main_thread_scrolling_reasons_ == main_thread_scrolling_reasons)
     return;
 
   if (main_thread_scrolling_reasons &
           MainThreadScrollingReason::kHasNonLayerViewportConstrainedObjects &&
@@ skipping 169 matching lines @@
 
   result->SetBoolean("DrawsContent", draws_content_);
   result->SetBoolean("Is3dSorted", Is3dSorted());
   result->SetDouble("OPACITY", opacity());
   result->SetBoolean("ContentsOpaque", contents_opaque_);
 
   if (scrollable())
     result->SetBoolean("Scrollable", true);
 
   if (!touch_event_handler_region_.IsEmpty()) {
-    scoped_ptr<base::Value> region = touch_event_handler_region_.AsValue();
+    std::unique_ptr<base::Value> region = touch_event_handler_region_.AsValue();
     result->Set("TouchRegion", region.release());
   }
 
   list = new base::ListValue;
   for (size_t i = 0; i < children_.size(); ++i)
     list->Append(children_[i]->LayerTreeAsJson());
   result->Set("Children", list);
 
   return result;
 }
@@ skipping 307 matching lines @@
           gfx::PointF() + offset_to_transform_parent(), gfx::SizeF(bounds()));
       property_trees->clip_tree.set_needs_update(true);
     }
     property_trees->full_tree_damaged = true;
     layer_tree_impl()->set_needs_update_draw_properties();
   } else {
     NoteLayerPropertyChanged();
   }
 }
 
-void LayerImpl::SetMaskLayer(scoped_ptr<LayerImpl> mask_layer) {
+void LayerImpl::SetMaskLayer(std::unique_ptr<LayerImpl> mask_layer) {
   int new_layer_id = mask_layer ? mask_layer->id() : -1;
 
   if (mask_layer) {
     DCHECK_EQ(layer_tree_impl(), mask_layer->layer_tree_impl());
     DCHECK_NE(new_layer_id, mask_layer_id_);
   } else if (new_layer_id == mask_layer_id_) {
     return;
   }
 
   if (mask_layer_)
     layer_tree_impl_->RemoveLayer(mask_layer_->id());
   mask_layer_ = mask_layer.get();
   if (mask_layer_)
     layer_tree_impl_->AddLayer(std::move(mask_layer));
 
   mask_layer_id_ = new_layer_id;
 }
 
-scoped_ptr<LayerImpl> LayerImpl::TakeMaskLayer() {
+std::unique_ptr<LayerImpl> LayerImpl::TakeMaskLayer() {
   mask_layer_id_ = -1;
-  scoped_ptr<LayerImpl> ret;
+  std::unique_ptr<LayerImpl> ret;
   if (mask_layer_)
     ret = layer_tree_impl_->RemoveLayer(mask_layer_->id());
   mask_layer_ = nullptr;
   return ret;
 }
 
-void LayerImpl::SetReplicaLayer(scoped_ptr<LayerImpl> replica_layer) {
+void LayerImpl::SetReplicaLayer(std::unique_ptr<LayerImpl> replica_layer) {
   int new_layer_id = replica_layer ? replica_layer->id() : -1;
 
   if (replica_layer) {
     DCHECK_EQ(layer_tree_impl(), replica_layer->layer_tree_impl());
     DCHECK_NE(new_layer_id, replica_layer_id_);
   } else if (new_layer_id == replica_layer_id_) {
     return;
   }
 
   if (replica_layer_)
     layer_tree_impl_->RemoveLayer(replica_layer_->id());
   replica_layer_ = replica_layer.get();
   if (replica_layer_)
     layer_tree_impl_->AddLayer(std::move(replica_layer));
 
   replica_layer_id_ = new_layer_id;
 }
 
-scoped_ptr<LayerImpl> LayerImpl::TakeReplicaLayer() {
+std::unique_ptr<LayerImpl> LayerImpl::TakeReplicaLayer() {
   replica_layer_id_ = -1;
-  scoped_ptr<LayerImpl> ret;
+  std::unique_ptr<LayerImpl> ret;
   if (replica_layer_)
     ret = layer_tree_impl_->RemoveLayer(replica_layer_->id());
   replica_layer_ = nullptr;
   return ret;
 }
 
 ScrollbarLayerImplBase* LayerImpl::ToScrollbarLayer() {
   return nullptr;
 }
 
@@ skipping 420 matching lines @@
                     layer_tree_impl_->HasAnimationThatInflatesBounds(this));
 
   gfx::BoxF box;
   if (LayerUtils::GetAnimationBounds(*this, &box))
     MathUtil::AddToTracedValue("animation_bounds", box, state);
 
   if (debug_info_) {
     std::string str;
     debug_info_->AppendAsTraceFormat(&str);
     base::JSONReader json_reader;
-    scoped_ptr<base::Value> debug_info_value(json_reader.ReadToValue(str));
+    std::unique_ptr<base::Value> debug_info_value(json_reader.ReadToValue(str));
 
     if (debug_info_value->IsType(base::Value::TYPE_DICTIONARY)) {
       base::DictionaryValue* dictionary_value = nullptr;
       bool converted_to_dictionary =
           debug_info_value->GetAsDictionary(&dictionary_value);
       DCHECK(converted_to_dictionary);
       for (base::DictionaryValue::Iterator it(*dictionary_value); !it.IsAtEnd();
            it.Advance()) {
         state->SetValue(it.key().data(), it.value().CreateDeepCopy());
       }
@@ skipping 28 matching lines @@
 int LayerImpl::NumDescendantsThatDrawContent() const {
   return num_descendants_that_draw_content_;
 }
 
 void LayerImpl::SetHasRenderSurface(bool should_have_render_surface) {
   if (!!render_surface() == should_have_render_surface)
     return;
 
   SetNeedsPushProperties();
   if (should_have_render_surface) {
-    render_surface_ = make_scoped_ptr(new RenderSurfaceImpl(this));
+    render_surface_ = base::WrapUnique(new RenderSurfaceImpl(this));
     return;
   }
   render_surface_.reset();
 }
 
 gfx::Transform LayerImpl::DrawTransform() const {
   // Only drawn layers have up-to-date draw properties.
   if (!IsDrawnRenderSurfaceLayerListMember()) {
     if (layer_tree_impl()->property_trees()->non_root_surfaces_enabled) {
       return draw_property_utils::DrawTransform(
@@ skipping 79 matching lines @@
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       DrawTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc