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

content/browser/service_worker/service_worker_storage_unittest.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 "content/browser/service_worker/service_worker_storage.h"
+
 #include <stdint.h>
-
 #include <string>
+#include <utility>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_disk_cache.h"
 #include "content/browser/service_worker/service_worker_registration.h"
-#include "content/browser/service_worker/service_worker_storage.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/service_worker/service_worker_status_code.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "ipc/ipc_message.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_response_headers.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 241 matching lines @@
 class ServiceWorkerStorageTest : public testing::Test {
  public:
   ServiceWorkerStorageTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {
   }
 
   void SetUp() override {
     scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager(
         new MockServiceWorkerDatabaseTaskManager(
             base::ThreadTaskRunnerHandle::Get()));
-    context_.reset(
-        new ServiceWorkerContextCore(GetUserDataDirectory(),
-                                     database_task_manager.Pass(),
-                                     base::ThreadTaskRunnerHandle::Get(),
-                                     NULL,
-                                     NULL,
-                                     NULL,
-                                     NULL));
+    context_.reset(new ServiceWorkerContextCore(
+        GetUserDataDirectory(), std::move(database_task_manager),
+        base::ThreadTaskRunnerHandle::Get(), NULL, NULL, NULL, NULL));
     context_ptr_ = context_->AsWeakPtr();
   }
 
   void TearDown() override { context_.reset(); }
 
   base::FilePath GetUserDataDirectory() { return user_data_directory_.path(); }
 
   bool InitUserDataDirectory() {
     return user_data_directory_.CreateUniqueTempDir();
   }
@@ skipping 907 matching lines @@
   WriteBasicResponse(storage(), kStaleUncommittedResourceId);
   EXPECT_TRUE(
       VerifyBasicResponse(storage(), kStaleUncommittedResourceId, true));
 
   // Simulate browser shutdown. The purgeable and uncommitted resources are now
   // stale.
   context_.reset();
   scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager(
       new MockServiceWorkerDatabaseTaskManager(
           base::ThreadTaskRunnerHandle::Get()));
-  context_.reset(
-      new ServiceWorkerContextCore(GetUserDataDirectory(),
-                                   database_task_manager.Pass(),
-                                   base::ThreadTaskRunnerHandle::Get(),
-                                   NULL,
-                                   NULL,
-                                   NULL,
-                                   NULL));
+  context_.reset(new ServiceWorkerContextCore(
+      GetUserDataDirectory(), std::move(database_task_manager),
+      base::ThreadTaskRunnerHandle::Get(), NULL, NULL, NULL, NULL));
   storage()->LazyInitialize(base::Bind(&base::DoNothing));
   base::RunLoop().RunUntilIdle();
 
   // Store a new uncommitted resource. This triggers stale resource cleanup.
   int64_t kNewResourceId = storage()->NewResourceId();
   WriteBasicResponse(storage(), kNewResourceId);
   storage()->StoreUncommittedResourceId(kNewResourceId);
   base::RunLoop().RunUntilIdle();
 
   // The stale resources should be purged, but the new resource should persist.
@@ skipping 339 matching lines @@
   live_version1 = nullptr;
   live_registration2 = nullptr;
   live_version2 = nullptr;
   live_registration3 = nullptr;
   live_version3 = nullptr;
   context_.reset();
   scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager(
       new MockServiceWorkerDatabaseTaskManager(
           base::ThreadTaskRunnerHandle::Get()));
   context_.reset(new ServiceWorkerContextCore(
-      GetUserDataDirectory(), database_task_manager.Pass(),
+      GetUserDataDirectory(), std::move(database_task_manager),
       base::ThreadTaskRunnerHandle::Get(), nullptr, nullptr, nullptr, nullptr));
   LazyInitialize();
 
   // First origin should still have a registration left.
   EXPECT_TRUE(storage()->OriginHasForeignFetchRegistrations(kOrigin1));
   EXPECT_FALSE(storage()->OriginHasForeignFetchRegistrations(kOrigin2));
 
   // Remove other registration at first origin.
   EXPECT_EQ(SERVICE_WORKER_OK,
             DeleteRegistration(kRegistrationId2, kScope2.GetOrigin()));
 
   // No foreign fetch registrations remain.
   EXPECT_FALSE(storage()->OriginHasForeignFetchRegistrations(kOrigin1));
   EXPECT_FALSE(storage()->OriginHasForeignFetchRegistrations(kOrigin2));
 }
 
 }  // namespace content