Convert Pass()→std::move() in //content/browser

content/browser/cache_storage/cache_storage_cache_unittest.cc

 // Copyright 2014 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 "content/browser/cache_storage/cache_storage_cache.h"
 
 #include <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/string_split.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
@@ skipping 29 matching lines @@
   // The FileSystemContext and thread task runner are not actually used but a
   // task runner is needed to avoid a DCHECK in BlobURLRequestJob ctor.
   return make_scoped_ptr(new storage::BlobProtocolHandler(
       blob_storage_context, NULL, base::ThreadTaskRunnerHandle::Get().get()));
 }
 
 // A disk_cache::Backend wrapper that can delay operations.
 class DelayableBackend : public disk_cache::Backend {
  public:
   DelayableBackend(scoped_ptr<disk_cache::Backend> backend)
-      : backend_(backend.Pass()), delay_open_(false) {}
+      : backend_(std::move(backend)), delay_open_(false) {}
 
   // disk_cache::Backend overrides
   net::CacheType GetCacheType() const override {
     return backend_->GetCacheType();
   }
   int32_t GetEntryCount() const override { return backend_->GetEntryCount(); }
   int OpenEntry(const std::string& key,
                 disk_cache::Entry** entry,
                 const CompletionCallback& callback) override {
     if (delay_open_) {
@@ skipping 158 matching lines @@
   }
 
   void set_delay_backend_creation(bool delay) {
     delay_backend_creation_ = delay;
   }
 
   // Swap the existing backend with a delayable one. The backend must have been
   // created before calling this.
   DelayableBackend* UseDelayableBackend() {
     EXPECT_TRUE(backend_);
-    DelayableBackend* delayable_backend = new DelayableBackend(backend_.Pass());
+    DelayableBackend* delayable_backend =
+        new DelayableBackend(std::move(backend_));
     backend_.reset(delayable_backend);
     return delayable_backend;
   }
 
  private:
   ~TestCacheStorageCache() override {}
 
   bool delay_backend_creation_;
   ErrorCallback backend_creation_callback_;
 
@@ skipping 191 matching lines @@
     if (run_loop)
       run_loop->Quit();
   }
 
   void ResponseAndErrorCallback(
       base::RunLoop* run_loop,
       CacheStorageError error,
       scoped_ptr<ServiceWorkerResponse> response,
       scoped_ptr<storage::BlobDataHandle> body_handle) {
     callback_error_ = error;
-    callback_response_ = response.Pass();
+    callback_response_ = std::move(response);
     callback_response_data_.reset();
     if (error == CACHE_STORAGE_OK && !callback_response_->blob_uuid.empty())
-      callback_response_data_ = body_handle.Pass();
+      callback_response_data_ = std::move(body_handle);
 
     if (run_loop)
       run_loop->Quit();
   }
 
   void ResponsesAndErrorCallback(
       const base::Closure& quit_closure,
       scoped_ptr<CacheStorageCache::Responses>* responses_out,
       scoped_ptr<CacheStorageCache::BlobDataHandles>* body_handles_out,
       CacheStorageError error,
@@ skipping 551 matching lines @@
   EXPECT_EQ(1, sequence_out);
   close_loop2->Run();
   EXPECT_EQ(2, sequence_out);
 }
 
 INSTANTIATE_TEST_CASE_P(CacheStorageCacheTest,
                         CacheStorageCacheTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content