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

cc/layers/ui_resource_layer.cc

 // Copyright 2013 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/ui_resource_layer.h"
 
+#include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/layers/ui_resource_layer_impl.h"
 #include "cc/resources/scoped_ui_resource.h"
 #include "cc/resources/ui_resource_bitmap.h"
 #include "cc/trees/layer_tree_host.h"
 
 namespace cc {
 
 
 namespace {
 
 class ScopedUIResourceHolder : public UIResourceLayer::UIResourceHolder {
  public:
-  static scoped_ptr<ScopedUIResourceHolder> Create(LayerTreeHost* host,
-                                            const SkBitmap& skbitmap) {
-    return make_scoped_ptr(new ScopedUIResourceHolder(host, skbitmap));
+  static std::unique_ptr<ScopedUIResourceHolder> Create(
+      LayerTreeHost* host,
+      const SkBitmap& skbitmap) {
+    return base::WrapUnique(new ScopedUIResourceHolder(host, skbitmap));
   }
   UIResourceId id() override { return resource_->id(); }
 
  private:
   ScopedUIResourceHolder(LayerTreeHost* host, const SkBitmap& skbitmap) {
     resource_ = ScopedUIResource::Create(host, UIResourceBitmap(skbitmap));
   }
 
-  scoped_ptr<ScopedUIResource> resource_;
+  std::unique_ptr<ScopedUIResource> resource_;
 };
 
 class SharedUIResourceHolder : public UIResourceLayer::UIResourceHolder {
  public:
-  static scoped_ptr<SharedUIResourceHolder> Create(UIResourceId id) {
-    return make_scoped_ptr(new SharedUIResourceHolder(id));
+  static std::unique_ptr<SharedUIResourceHolder> Create(UIResourceId id) {
+    return base::WrapUnique(new SharedUIResourceHolder(id));
   }
 
   UIResourceId id() override { return id_; }
 
  private:
   explicit SharedUIResourceHolder(UIResourceId id) : id_(id) {}
 
   UIResourceId id_;
 };
 
 }  // anonymous namespace
 
 UIResourceLayer::UIResourceHolder::~UIResourceHolder() {}
 
 scoped_refptr<UIResourceLayer> UIResourceLayer::Create() {
   return make_scoped_refptr(new UIResourceLayer());
 }
 
 UIResourceLayer::UIResourceLayer()
     : uv_top_left_(0.f, 0.f), uv_bottom_right_(1.f, 1.f) {
   vertex_opacity_[0] = 1.0f;
   vertex_opacity_[1] = 1.0f;
   vertex_opacity_[2] = 1.0f;
   vertex_opacity_[3] = 1.0f;
 }
 
 UIResourceLayer::~UIResourceLayer() {}
 
-scoped_ptr<LayerImpl> UIResourceLayer::CreateLayerImpl(
+std::unique_ptr<LayerImpl> UIResourceLayer::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return UIResourceLayerImpl::Create(tree_impl, id());
 }
 
 void UIResourceLayer::SetUV(const gfx::PointF& top_left,
                             const gfx::PointF& bottom_right) {
   if (uv_top_left_ == top_left && uv_bottom_right_ == bottom_right)
     return;
   uv_top_left_ = top_left;
   uv_bottom_right_ = bottom_right;
@@ skipping 83 matching lines @@
     gfx::Size image_size =
         layer_tree_host()->GetUIResourceSize(ui_resource_holder_->id());
     layer_impl->SetUIResourceId(ui_resource_holder_->id());
     layer_impl->SetImageBounds(image_size);
     layer_impl->SetUV(uv_top_left_, uv_bottom_right_);
     layer_impl->SetVertexOpacity(vertex_opacity_);
   }
 }
 
 }  // namespace cc