Convert Pass()→std::move() in mojo/

mojo/shell/application_manager_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 "mojo/shell/application_manager.h"
+
+#include <utility>
+
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_delegate.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/application/public/cpp/interface_factory.h"
 #include "mojo/application/public/interfaces/service_provider.mojom.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/shell/application_loader.h"
-#include "mojo/shell/application_manager.h"
 #include "mojo/shell/connect_util.h"
 #include "mojo/shell/fetcher.h"
 #include "mojo/shell/package_manager.h"
 #include "mojo/shell/test.mojom.h"
 #include "mojo/shell/test_package_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace shell {
 namespace test {
@@ skipping 10 matching lines @@
 };
 
 void QuitClosure(bool* value) {
   *value = true;
   base::MessageLoop::current()->QuitWhenIdle();
 }
 
 class TestServiceImpl : public TestService {
  public:
   TestServiceImpl(TestContext* context, InterfaceRequest<TestService> request)
-      : context_(context), binding_(this, request.Pass()) {
+      : context_(context), binding_(this, std::move(request)) {
     ++context_->num_impls;
   }
 
   ~TestServiceImpl() override {
     --context_->num_impls;
     if (!base::MessageLoop::current()->is_running())
       return;
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
   // TestService implementation:
   void Test(const String& test_string,
             const Callback<void()>& callback) override {
     context_->last_test_string = test_string;
     callback.Run();
   }
 
  private:
   TestContext* context_;
   StrongBinding<TestService> binding_;
 };
 
 class TestClient {
  public:
   explicit TestClient(TestServicePtr service)
-      : service_(service.Pass()), quit_after_ack_(false) {}
+      : service_(std::move(service)), quit_after_ack_(false) {}
 
   void AckTest() {
     if (quit_after_ack_)
       base::MessageLoop::current()->QuitWhenIdle();
   }
 
   void Test(const std::string& test_string) {
     quit_after_ack_ = true;
     service_->Test(test_string,
                    base::Bind(&TestClient::AckTest, base::Unretained(this)));
@@ skipping 20 matching lines @@
 
   void set_context(TestContext* context) { context_ = context; }
   int num_loads() const { return num_loads_; }
   const GURL& last_requestor_url() const { return last_requestor_url_; }
 
  private:
   // ApplicationLoader implementation.
   void Load(const GURL& url,
             InterfaceRequest<Application> application_request) override {
     ++num_loads_;
-    test_app_.reset(new ApplicationImpl(this, application_request.Pass()));
+    test_app_.reset(new ApplicationImpl(this, std::move(application_request)));
   }
 
   // ApplicationDelegate implementation.
   bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
     connection->AddService<TestService>(this);
     last_requestor_url_ = GURL(connection->GetRemoteApplicationURL());
     return true;
   }
 
   // InterfaceFactory<TestService> implementation.
   void Create(ApplicationConnection* connection,
               InterfaceRequest<TestService> request) override {
-    new TestServiceImpl(context_, request.Pass());
+    new TestServiceImpl(context_, std::move(request));
   }
 
   scoped_ptr<ApplicationImpl> test_app_;
   TestContext* context_;
   int num_loads_;
   GURL last_requestor_url_;
 
   DISALLOW_COPY_AND_ASSIGN(TestApplicationLoader);
 };
 
@@ skipping 98 matching lines @@
 
   base::MessageLoop* loop_;
 };
 
 // Used to test that the requestor url will be correctly passed.
 class TestAImpl : public TestA {
  public:
   TestAImpl(ApplicationImpl* app_impl,
             TesterContext* test_context,
             InterfaceRequest<TestA> request)
-      : test_context_(test_context), binding_(this, request.Pass()) {
+      : test_context_(test_context), binding_(this, std::move(request)) {
     connection_ = app_impl->ConnectToApplication(kTestBURLString);
     connection_->ConnectToService(&b_);
   }
 
   ~TestAImpl() override {
     test_context_->IncrementNumADeletes();
     if (base::MessageLoop::current()->is_running())
       Quit();
   }
 
@@ skipping 16 matching lines @@
   TesterContext* test_context_;
   TestBPtr b_;
   StrongBinding<TestA> binding_;
 };
 
 class TestBImpl : public TestB {
  public:
   TestBImpl(ApplicationConnection* connection,
             TesterContext* test_context,
             InterfaceRequest<TestB> request)
-      : test_context_(test_context), binding_(this, request.Pass()) {
+      : test_context_(test_context), binding_(this, std::move(request)) {
     connection->ConnectToService(&c_);
   }
 
   ~TestBImpl() override {
     test_context_->IncrementNumBDeletes();
     if (base::MessageLoop::current()->is_running())
       base::MessageLoop::current()->QuitWhenIdle();
     test_context_->QuitSoon();
   }
 
@@ skipping 11 matching lines @@
   TesterContext* test_context_;
   TestCPtr c_;
   StrongBinding<TestB> binding_;
 };
 
 class TestCImpl : public TestC {
  public:
   TestCImpl(ApplicationConnection* connection,
             TesterContext* test_context,
             InterfaceRequest<TestC> request)
-      : test_context_(test_context), binding_(this, request.Pass()) {}
+      : test_context_(test_context), binding_(this, std::move(request)) {}
 
   ~TestCImpl() override { test_context_->IncrementNumCDeletes(); }
 
  private:
   void C(const Callback<void()>& callback) override {
     test_context_->IncrementNumCCalls();
     callback.Run();
   }
 
   TesterContext* test_context_;
   StrongBinding<TestC> binding_;
 };
 
 class Tester : public ApplicationDelegate,
                public ApplicationLoader,
                public InterfaceFactory<TestA>,
                public InterfaceFactory<TestB>,
                public InterfaceFactory<TestC> {
  public:
   Tester(TesterContext* context, const std::string& requestor_url)
       : context_(context), requestor_url_(requestor_url) {}
   ~Tester() override {}
 
  private:
   void Load(const GURL& url,
             InterfaceRequest<Application> application_request) override {
-    app_.reset(new ApplicationImpl(this, application_request.Pass()));
+    app_.reset(new ApplicationImpl(this, std::move(application_request)));
   }
 
   bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
     if (!requestor_url_.empty() &&
         requestor_url_ != connection->GetRemoteApplicationURL()) {
       context_->set_tester_called_quit();
       context_->QuitSoon();
       base::MessageLoop::current()->QuitWhenIdle();
       return false;
     }
     // If we're coming from A, then add B, otherwise A.
     if (connection->GetRemoteApplicationURL() == kTestAURLString)
       connection->AddService<TestB>(this);
     else
       connection->AddService<TestA>(this);
     return true;
   }
 
   bool ConfigureOutgoingConnection(ApplicationConnection* connection) override {
     // If we're connecting to B, then add C.
     if (connection->GetRemoteApplicationURL() == kTestBURLString)
       connection->AddService<TestC>(this);
     return true;
   }
 
   void Create(ApplicationConnection* connection,
               InterfaceRequest<TestA> request) override {
-    a_bindings_.push_back(new TestAImpl(app_.get(), context_, request.Pass()));
+    a_bindings_.push_back(
+        new TestAImpl(app_.get(), context_, std::move(request)));
   }
 
   void Create(ApplicationConnection* connection,
               InterfaceRequest<TestB> request) override {
-    new TestBImpl(connection, context_, request.Pass());
+    new TestBImpl(connection, context_, std::move(request));
   }
 
   void Create(ApplicationConnection* connection,
               InterfaceRequest<TestC> request) override {
-    new TestCImpl(connection, context_, request.Pass());
+    new TestCImpl(connection, context_, std::move(request));
   }
 
   TesterContext* context_;
   scoped_ptr<ApplicationImpl> app_;
   std::string requestor_url_;
   ScopedVector<TestAImpl> a_bindings_;
 };
 
 class ApplicationManagerTest : public testing::Test {
  public:
   ApplicationManagerTest() : tester_context_(&loop_) {}
 
   ~ApplicationManagerTest() override {}
 
   void SetUp() override {
     application_manager_.reset(new ApplicationManager(
         make_scoped_ptr(new TestPackageManager)));
     test_loader_ = new TestApplicationLoader;
     test_loader_->set_context(&context_);
     application_manager_->set_default_loader(
         scoped_ptr<ApplicationLoader>(test_loader_));
 
     TestServicePtr service_proxy;
     ConnectToService(application_manager_.get(), GURL(kTestURLString),
                      &service_proxy);
-    test_client_.reset(new TestClient(service_proxy.Pass()));
+    test_client_.reset(new TestClient(std::move(service_proxy)));
   }
 
   void TearDown() override {
     test_client_.reset();
     application_manager_.reset();
   }
 
   void AddLoaderForURL(const GURL& url, const std::string& requestor_url) {
     application_manager_->SetLoaderForURL(
         make_scoped_ptr(new Tester(&tester_context_, requestor_url)), url);
@@ skipping 164 matching lines @@
 TEST_F(ApplicationManagerTest, TestEndApplicationClosure) {
   ClosingApplicationLoader* loader = new ClosingApplicationLoader();
   application_manager_->SetLoaderForURL(
       scoped_ptr<ApplicationLoader>(loader), GURL("test:test"));
 
   bool called = false;
   scoped_ptr<ConnectToApplicationParams> params(new ConnectToApplicationParams);
   params->SetTargetURL(GURL("test:test"));
   params->set_on_application_end(
       base::Bind(&QuitClosure, base::Unretained(&called)));
-  application_manager_->ConnectToApplication(params.Pass());
+  application_manager_->ConnectToApplication(std::move(params));
   loop_.Run();
   EXPECT_TRUE(called);
 }
 
 TEST_F(ApplicationManagerTest, SameIdentityShouldNotCauseDuplicateLoad) {
   // 1 because ApplicationManagerTest connects once at startup.
   EXPECT_EQ(1, test_loader_->num_loads());
 
   TestServicePtr test_service;
   ConnectToService(application_manager_.get(),
@@ skipping 18 matching lines @@
 
   // A different identity because the domain is different.
   ConnectToService(application_manager_.get(),
                    GURL("http://www.another_domain.org/abc"), &test_service);
   EXPECT_EQ(4, test_loader_->num_loads());
 }
 
 }  // namespace test
 }  // namespace shell
 }  // namespace mojo