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

cc/layers/texture_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/texture_layer.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/synchronization/lock.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/simple_enclosed_region.h"
 #include "cc/layers/texture_layer_client.h"
 #include "cc/layers/texture_layer_impl.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/resources/single_release_callback_impl.h"
 #include "cc/trees/blocking_task_runner.h"
 #include "cc/trees/layer_tree_host.h"
 
@@ skipping 25 matching lines @@
 void TextureLayer::ClearClient() {
   client_ = nullptr;
   ClearTexture();
   UpdateDrawsContent(HasDrawableContent());
 }
 
 void TextureLayer::ClearTexture() {
   SetTextureMailbox(TextureMailbox(), nullptr);
 }
 
-scoped_ptr<LayerImpl> TextureLayer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
+std::unique_ptr<LayerImpl> TextureLayer::CreateLayerImpl(
+    LayerTreeImpl* tree_impl) {
   return TextureLayerImpl::Create(tree_impl, id());
 }
 
 void TextureLayer::SetFlipped(bool flipped) {
   if (flipped_ == flipped)
     return;
   flipped_ = flipped;
   SetNeedsCommit();
 }
 
@@ skipping 42 matching lines @@
 
 void TextureLayer::SetBlendBackgroundColor(bool blend) {
   if (blend_background_color_ == blend)
     return;
   blend_background_color_ = blend;
   SetNeedsCommit();
 }
 
 void TextureLayer::SetTextureMailboxInternal(
     const TextureMailbox& mailbox,
-    scoped_ptr<SingleReleaseCallback> release_callback,
+    std::unique_ptr<SingleReleaseCallback> release_callback,
     bool requires_commit,
     bool allow_mailbox_reuse) {
   DCHECK(!mailbox.IsValid() || !holder_ref_ ||
          !mailbox.Equals(holder_ref_->holder()->mailbox()) ||
          allow_mailbox_reuse);
   DCHECK_EQ(mailbox.IsValid(), !!release_callback);
 
   // If we never commited the mailbox, we need to release it here.
   if (mailbox.IsValid()) {
     holder_ref_ =
         TextureMailboxHolder::Create(mailbox, std::move(release_callback));
   } else {
     holder_ref_ = nullptr;
   }
   needs_set_mailbox_ = true;
   // If we are within a commit, no need to do it again immediately after.
   if (requires_commit)
     SetNeedsCommit();
   else
     SetNeedsPushProperties();
 
   UpdateDrawsContent(HasDrawableContent());
   // The active frame needs to be replaced and the mailbox returned before the
   // commit is called complete.
   SetNextCommitWaitsForActivation();
 }
 
 void TextureLayer::SetTextureMailbox(
     const TextureMailbox& mailbox,
-    scoped_ptr<SingleReleaseCallback> release_callback) {
+    std::unique_ptr<SingleReleaseCallback> release_callback) {
   bool requires_commit = true;
   bool allow_mailbox_reuse = false;
   SetTextureMailboxInternal(mailbox, std::move(release_callback),
                             requires_commit, allow_mailbox_reuse);
 }
 
 static void IgnoreReleaseCallback(const gpu::SyncToken& sync_token, bool lost) {
 }
 
 void TextureLayer::SetTextureMailboxWithoutReleaseCallback(
     const TextureMailbox& mailbox) {
   // We allow reuse of the mailbox if there is a new sync point signalling new
   // content, and the release callback goes nowhere since we'll be calling it
   // multiple times for the same mailbox.
   DCHECK(!mailbox.IsValid() || !holder_ref_ ||
          !mailbox.Equals(holder_ref_->holder()->mailbox()) ||
          mailbox.sync_token() != holder_ref_->holder()->mailbox().sync_token());
-  scoped_ptr<SingleReleaseCallback> release;
+  std::unique_ptr<SingleReleaseCallback> release;
   bool requires_commit = true;
   bool allow_mailbox_reuse = true;
   if (mailbox.IsValid())
     release = SingleReleaseCallback::Create(base::Bind(&IgnoreReleaseCallback));
   SetTextureMailboxInternal(mailbox, std::move(release), requires_commit,
                             allow_mailbox_reuse);
 }
 
 void TextureLayer::SetNeedsDisplayRect(const gfx::Rect& dirty_rect) {
   Layer::SetNeedsDisplayRect(dirty_rect);
@@ skipping 18 matching lines @@
 }
 
 bool TextureLayer::HasDrawableContent() const {
   return (client_ || holder_ref_) && Layer::HasDrawableContent();
 }
 
 bool TextureLayer::Update() {
   bool updated = Layer::Update();
   if (client_) {
     TextureMailbox mailbox;
-    scoped_ptr<SingleReleaseCallback> release_callback;
+    std::unique_ptr<SingleReleaseCallback> release_callback;
     if (client_->PrepareTextureMailbox(
             &mailbox,
             &release_callback,
             layer_tree_host()->UsingSharedMemoryResources())) {
       // Already within a commit, no need to do another one immediately.
       bool requires_commit = false;
       bool allow_mailbox_reuse = false;
       SetTextureMailboxInternal(mailbox, std::move(release_callback),
                                 requires_commit, allow_mailbox_reuse);
       updated = true;
@@ skipping 13 matching lines @@
   TextureLayerImpl* texture_layer = static_cast<TextureLayerImpl*>(layer);
   texture_layer->SetFlipped(flipped_);
   texture_layer->SetNearestNeighbor(nearest_neighbor_);
   texture_layer->SetUVTopLeft(uv_top_left_);
   texture_layer->SetUVBottomRight(uv_bottom_right_);
   texture_layer->SetVertexOpacity(vertex_opacity_);
   texture_layer->SetPremultipliedAlpha(premultiplied_alpha_);
   texture_layer->SetBlendBackgroundColor(blend_background_color_);
   if (needs_set_mailbox_) {
     TextureMailbox texture_mailbox;
-    scoped_ptr<SingleReleaseCallbackImpl> release_callback_impl;
+    std::unique_ptr<SingleReleaseCallbackImpl> release_callback_impl;
     if (holder_ref_) {
       TextureMailboxHolder* holder = holder_ref_->holder();
       texture_mailbox = holder->mailbox();
       release_callback_impl = holder->GetCallbackForImplThread();
     }
     texture_layer->SetTextureMailbox(texture_mailbox,
                                      std::move(release_callback_impl));
     needs_set_mailbox_ = false;
   }
 }
 
 TextureLayer::TextureMailboxHolder::MainThreadReference::MainThreadReference(
     TextureMailboxHolder* holder)
     : holder_(holder) {
   holder_->InternalAddRef();
 }
 
 TextureLayer::TextureMailboxHolder::MainThreadReference::
     ~MainThreadReference() {
   holder_->InternalRelease();
 }
 
 TextureLayer::TextureMailboxHolder::TextureMailboxHolder(
     const TextureMailbox& mailbox,
-    scoped_ptr<SingleReleaseCallback> release_callback)
+    std::unique_ptr<SingleReleaseCallback> release_callback)
     : internal_references_(0),
       mailbox_(mailbox),
       release_callback_(std::move(release_callback)),
       sync_token_(mailbox.sync_token()),
       is_lost_(false) {}
 
 TextureLayer::TextureMailboxHolder::~TextureMailboxHolder() {
   DCHECK_EQ(0u, internal_references_);
 }
 
-scoped_ptr<TextureLayer::TextureMailboxHolder::MainThreadReference>
+std::unique_ptr<TextureLayer::TextureMailboxHolder::MainThreadReference>
 TextureLayer::TextureMailboxHolder::Create(
     const TextureMailbox& mailbox,
-    scoped_ptr<SingleReleaseCallback> release_callback) {
-  return make_scoped_ptr(new MainThreadReference(
+    std::unique_ptr<SingleReleaseCallback> release_callback) {
+  return base::WrapUnique(new MainThreadReference(
       new TextureMailboxHolder(mailbox, std::move(release_callback))));
 }
 
 void TextureLayer::TextureMailboxHolder::Return(
     const gpu::SyncToken& sync_token,
     bool is_lost) {
   base::AutoLock lock(arguments_lock_);
   sync_token_ = sync_token;
   is_lost_ = is_lost;
 }
 
-scoped_ptr<SingleReleaseCallbackImpl>
+std::unique_ptr<SingleReleaseCallbackImpl>
 TextureLayer::TextureMailboxHolder::GetCallbackForImplThread() {
   // We can't call GetCallbackForImplThread if we released the main thread
   // reference.
   DCHECK_GT(internal_references_, 0u);
   InternalAddRef();
   return SingleReleaseCallbackImpl::Create(
       base::Bind(&TextureMailboxHolder::ReturnAndReleaseOnImplThread, this));
 }
 
 void TextureLayer::TextureMailboxHolder::InternalAddRef() {
@@ skipping 12 matching lines @@
 void TextureLayer::TextureMailboxHolder::ReturnAndReleaseOnImplThread(
     const gpu::SyncToken& sync_token,
     bool is_lost,
     BlockingTaskRunner* main_thread_task_runner) {
   Return(sync_token, is_lost);
   main_thread_task_runner->PostTask(
       FROM_HERE, base::Bind(&TextureMailboxHolder::InternalRelease, this));
 }
 
 }  // namespace cc