Replace scoped_ptr with std::unique_ptr in //ui

ui/compositor/layer.cc

 // Copyright (c) 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 "ui/compositor/layer.h"
 
 #include <algorithm>
+#include <memory>
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/layers/nine_patch_layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/surface_layer.h"
 #include "cc/layers/texture_layer.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/filter_operation.h"
 #include "cc/output/filter_operations.h"
 #include "cc/playback/display_item_list_settings.h"
@@ skipping 322 matching lines @@
   }
 }
 
 void Layer::SetBackgroundZoom(float zoom, int inset) {
   zoom_ = zoom;
   zoom_inset_ = inset;
 
   SetLayerBackgroundFilters();
 }
 
-void Layer::SetAlphaShape(scoped_ptr<SkRegion> region) {
+void Layer::SetAlphaShape(std::unique_ptr<SkRegion> region) {
   alpha_shape_ = std::move(region);
 
   SetLayerFilters();
 }
 
 void Layer::SetLayerFilters() {
   cc::FilterOperations filters;
   if (layer_saturation_) {
     filters.Append(cc::FilterOperation::CreateSaturateFilter(
         layer_saturation_));
@@ skipping 153 matching lines @@
 }
 
 void Layer::SwitchCCLayerForTest() {
   scoped_refptr<cc::Layer> new_layer = cc::PictureLayer::Create(this);
   SwitchToLayer(new_layer);
   content_layer_ = new_layer;
 }
 
 void Layer::SetTextureMailbox(
     const cc::TextureMailbox& mailbox,
-    scoped_ptr<cc::SingleReleaseCallback> release_callback,
+    std::unique_ptr<cc::SingleReleaseCallback> release_callback,
     gfx::Size texture_size_in_dip) {
   DCHECK(type_ == LAYER_TEXTURED || type_ == LAYER_SOLID_COLOR);
   DCHECK(mailbox.IsValid());
   DCHECK(release_callback);
   if (!texture_layer_.get()) {
     scoped_refptr<cc::TextureLayer> new_layer =
         cc::TextureLayer::CreateForMailbox(this);
     new_layer->SetFlipped(true);
     SwitchToLayer(new_layer);
     texture_layer_ = new_layer;
@@ skipping 174 matching lines @@
     layer_mask_->OnDeviceScaleFactorChanged(device_scale_factor);
 }
 
 void Layer::OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) {
   DCHECK(surface_layer_.get());
   if (!delegate_)
     return;
   delegate_->OnDelegatedFrameDamage(damage_rect_in_dip);
 }
 
-void Layer::RequestCopyOfOutput(scoped_ptr<cc::CopyOutputRequest> request) {
+void Layer::RequestCopyOfOutput(
+    std::unique_ptr<cc::CopyOutputRequest> request) {
   cc_layer_->RequestCopyOfOutput(std::move(request));
 }
 
 gfx::Rect Layer::PaintableRegion() {
   return gfx::Rect(size());
 }
 
 scoped_refptr<cc::DisplayItemList> Layer::PaintContentsToDisplayList(
     ContentLayerClient::PaintingControlSetting painting_control) {
   TRACE_EVENT1("ui", "Layer::PaintContentsToDisplayList", "name", name_);
@@ skipping 16 matching lines @@
 bool Layer::FillsBoundsCompletely() const { return fills_bounds_completely_; }
 
 size_t Layer::GetApproximateUnsharedMemoryUsage() const {
   // Most of the "picture memory" is shared with the cc::DisplayItemList, so
   // there's nothing significant to report here.
   return 0;
 }
 
 bool Layer::PrepareTextureMailbox(
     cc::TextureMailbox* mailbox,
-    scoped_ptr<cc::SingleReleaseCallback>* release_callback,
+    std::unique_ptr<cc::SingleReleaseCallback>* release_callback,
     bool use_shared_memory) {
   if (!mailbox_release_callback_)
     return false;
   *mailbox = mailbox_;
   *release_callback = std::move(mailbox_release_callback_);
   return true;
 }
 
 void Layer::SetForceRenderSurface(bool force) {
   if (force_render_surface_ == force)
@@ skipping 10 matching lines @@
   void AppendAsTraceFormat(std::string* out) const override {
     base::DictionaryValue dictionary;
     dictionary.SetString("layer_name", name_);
     base::JSONWriter::Write(dictionary, out);
   }
 
  private:
   std::string name_;
 };
 
-scoped_ptr<base::trace_event::ConvertableToTraceFormat> Layer::TakeDebugInfo(
-    cc::Layer* layer) {
-  return make_scoped_ptr(new LayerDebugInfo(name_));
+std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
+Layer::TakeDebugInfo(cc::Layer* layer) {
+  return base::WrapUnique(new LayerDebugInfo(name_));
 }
 
 void Layer::CollectAnimators(
     std::vector<scoped_refptr<LayerAnimator>>* animators) {
   if (animator_ && animator_->is_animating())
     animators->push_back(animator_);
   for (auto* child : children_)
     child->CollectAnimators(animators);
 }
 
@@ skipping 218 matching lines @@
   if (animator_) {
     animator_->ResetCompositor(compositor);
     animator_->RemoveFromCollection(collection);
   }
 
   for (auto* child : children_)
     child->ResetCompositorForAnimatorsInTree(compositor);
 }
 
 }  // namespace ui