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

content/browser/service_worker/embedded_worker_instance_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/embedded_worker_instance.h"
+
 #include <stdint.h>
+#include <utility>
 
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
-#include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
@@ skipping 237 matching lines @@
   worker->AddListener(this);
 
   scoped_ptr<EmbeddedWorkerMsg_StartWorker_Params> params(
       new EmbeddedWorkerMsg_StartWorker_Params());
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
 
   // Pretend the worker got stopped before the start sequence reached
   // SendStartWorker.
   worker->status_ = EmbeddedWorkerInstance::STOPPED;
   base::RunLoop run_loop;
-  worker->SendStartWorker(params.Pass(), base::Bind(&SaveStatusAndCall, &status,
-                                                    run_loop.QuitClosure()),
-                          true, -1, false);
+  worker->SendStartWorker(
+      std::move(params),
+      base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure()), true, -1,
+      false);
   run_loop.Run();
   EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT, status);
   // Don't expect SendStartWorker() to dispatch an OnStopped/Detached() message
   // since the worker was already stopped.
   EXPECT_FALSE(stopped_);
   EXPECT_FALSE(detached_);
 
   // Repeat, this time have the start callback destroy the worker, as is
   // usual when starting a worker fails, and ensure a crash doesn't occur.
   worker->status_ = EmbeddedWorkerInstance::STOPPED;
   EmbeddedWorkerInstance* worker_ptr = worker.get();
   worker_ptr->SendStartWorker(
-      params.Pass(), base::Bind(&DestroyWorker, base::Passed(&worker), &status),
-      true, -1, false);
+      std::move(params),
+      base::Bind(&DestroyWorker, base::Passed(&worker), &status), true, -1,
+      false);
   // No crash.
   EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT, status);
 }
 
 // Test stopping in the middle of the start worker sequence, before
 // a process is allocated.
 TEST_F(EmbeddedWorkerInstanceTest, StopDuringStart) {
   scoped_ptr<EmbeddedWorkerInstance> worker =
       embedded_worker_registry()->CreateWorker();
   worker->AddListener(this);
@@ skipping 58 matching lines @@
       base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure()));
   run_loop.Run();
 
   // The callback should have run, and we should have got an OnStopped message.
   EXPECT_EQ(SERVICE_WORKER_ERROR_IPC_FAILED, status);
   EXPECT_TRUE(stopped_);
   EXPECT_EQ(EmbeddedWorkerInstance::STARTING, stopped_old_status_);
 }
 
 }  // namespace content