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

cc/layers/texture_layer_unittest.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/texture_layer.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 74 matching lines @@
   FakeTextureLayerClient() : mailbox_changed_(true) {}
 
   bool PrepareTextureMailbox(
       TextureMailbox* mailbox,
       scoped_ptr<SingleReleaseCallback>* release_callback,
       bool use_shared_memory) override {
     if (!mailbox_changed_)
       return false;
 
     *mailbox = mailbox_;
-    *release_callback = release_callback_.Pass();
+    *release_callback = std::move(release_callback_);
     mailbox_changed_ = false;
     return true;
   }
 
   void set_mailbox(const TextureMailbox& mailbox,
                    scoped_ptr<SingleReleaseCallback> release_callback) {
     mailbox_ = mailbox;
-    release_callback_ = release_callback.Pass();
+    release_callback_ = std::move(release_callback);
     mailbox_changed_ = true;
   }
 
  private:
   TextureMailbox mailbox_;
   scoped_ptr<SingleReleaseCallback> release_callback_;
   bool mailbox_changed_;
   DISALLOW_COPY_AND_ASSIGN(FakeTextureLayerClient);
 };
 
@@ skipping 527 matching lines @@
   }
 
   void SetMailbox(char mailbox_char) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
     scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
         base::Bind(
             &TextureLayerImplWithMailboxThreadedCallback::ReleaseCallback,
             base::Unretained(this)));
     layer_->SetTextureMailbox(TextureMailbox(MailboxFromChar(mailbox_char),
                                              gpu::SyncToken(), GL_TEXTURE_2D),
-                              callback.Pass());
+                              std::move(callback));
   }
 
   void BeginTest() override {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
 
     gfx::Size bounds(100, 100);
     root_ = Layer::Create(layer_settings());
     root_->SetBounds(bounds);
 
     layer_ = TextureLayer::CreateForMailbox(layer_settings(), nullptr);
@@ skipping 95 matching lines @@
 
   static void ReleaseCallback(const gpu::SyncToken& sync_token,
                               bool lost_resource) {}
 
   void SetMailbox(char mailbox_char) {
     scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
         base::Bind(
             &TextureLayerMailboxIsActivatedDuringCommit::ReleaseCallback));
     layer_->SetTextureMailbox(TextureMailbox(MailboxFromChar(mailbox_char),
                                              gpu::SyncToken(), GL_TEXTURE_2D),
-                              callback.Pass());
+                              std::move(callback));
   }
 
   void BeginTest() override {
     gfx::Size bounds(100, 100);
     root_ = Layer::Create(layer_settings());
     root_->SetBounds(bounds);
 
     layer_ = TextureLayer::CreateForMailbox(layer_settings(), nullptr);
     layer_->SetIsDrawable(true);
     layer_->SetBounds(bounds);
@@ skipping 567 matching lines @@
   }
 
   void SetMailbox(char mailbox_char) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
     scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
         base::Bind(
             &TextureLayerWithMailboxMainThreadDeleted::ReleaseCallback,
             base::Unretained(this)));
     layer_->SetTextureMailbox(TextureMailbox(MailboxFromChar(mailbox_char),
                                              gpu::SyncToken(), GL_TEXTURE_2D),
-                              callback.Pass());
+                              std::move(callback));
   }
 
   void SetupTree() override {
     gfx::Size bounds(100, 100);
     root_ = Layer::Create(layer_settings());
     root_->SetBounds(bounds);
 
     layer_ = TextureLayer::CreateForMailbox(layer_settings(), nullptr);
     layer_->SetIsDrawable(true);
     layer_->SetBounds(bounds);
@@ skipping 48 matching lines @@
   }
 
   void SetMailbox(char mailbox_char) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
     scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
         base::Bind(
             &TextureLayerWithMailboxImplThreadDeleted::ReleaseCallback,
             base::Unretained(this)));
     layer_->SetTextureMailbox(TextureMailbox(MailboxFromChar(mailbox_char),
                                              gpu::SyncToken(), GL_TEXTURE_2D),
-                              callback.Pass());
+                              std::move(callback));
   }
 
   void SetupTree() override {
     gfx::Size bounds(100, 100);
     root_ = Layer::Create(layer_settings());
     root_->SetBounds(bounds);
 
     layer_ = TextureLayer::CreateForMailbox(layer_settings(), nullptr);
     layer_->SetIsDrawable(true);
     layer_->SetBounds(bounds);
@@ skipping 36 matching lines @@
   int callback_count_;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     TextureLayerWithMailboxImplThreadDeleted);
 
 }  // namespace
 }  // namespace cc