cc: Replace Pass() with std::move() in some subdirs.

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/synchronization/lock.h"
@@ skipping 110 matching lines @@
     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, release_callback.Pass());
+        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) {
   bool requires_commit = true;
   bool allow_mailbox_reuse = false;
-  SetTextureMailboxInternal(
-      mailbox, release_callback.Pass(), requires_commit, allow_mailbox_reuse);
+  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;
   bool requires_commit = true;
   bool allow_mailbox_reuse = true;
   if (mailbox.IsValid())
     release = SingleReleaseCallback::Create(base::Bind(&IgnoreReleaseCallback));
-  SetTextureMailboxInternal(
-      mailbox, release.Pass(), requires_commit, allow_mailbox_reuse);
+  SetTextureMailboxInternal(mailbox, std::move(release), requires_commit,
+                            allow_mailbox_reuse);
 }
 
 void TextureLayer::SetNeedsDisplayRect(const gfx::Rect& dirty_rect) {
   Layer::SetNeedsDisplayRect(dirty_rect);
 }
 
 void TextureLayer::SetLayerTreeHost(LayerTreeHost* host) {
   if (layer_tree_host() == host) {
     Layer::SetLayerTreeHost(host);
     return;
@@ skipping 20 matching lines @@
   if (client_) {
     TextureMailbox mailbox;
     scoped_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,
-                                release_callback.Pass(),
-                                requires_commit,
-                                allow_mailbox_reuse);
+      SetTextureMailboxInternal(mailbox, std::move(release_callback),
+                                requires_commit, allow_mailbox_reuse);
       updated = true;
     }
   }
 
   // SetTextureMailbox could be called externally and the same mailbox used for
   // different textures.  Such callers notify this layer that the texture has
   // changed by calling SetNeedsDisplay, so check for that here.
   return updated || !update_rect_.IsEmpty();
 }
 
@@ skipping 10 matching lines @@
   texture_layer->SetBlendBackgroundColor(blend_background_color_);
   if (needs_set_mailbox_) {
     TextureMailbox texture_mailbox;
     scoped_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,
-                                     release_callback_impl.Pass());
+                                     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)
     : internal_references_(0),
       mailbox_(mailbox),
-      release_callback_(release_callback.Pass()),
+      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>
 TextureLayer::TextureMailboxHolder::Create(
     const TextureMailbox& mailbox,
     scoped_ptr<SingleReleaseCallback> release_callback) {
   return make_scoped_ptr(new MainThreadReference(
-      new TextureMailboxHolder(mailbox, release_callback.Pass())));
+      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;
 }
 
@@ skipping 23 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