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

mojo/shell/capability_filter_test.cc

 // Copyright 2015 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/capability_filter_test.h"
 
+#include <utility>
+
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/application/public/cpp/connect.h"
 #include "mojo/application/public/cpp/interface_factory.h"
 #include "mojo/application/public/cpp/service_provider_impl.h"
 #include "mojo/common/weak_binding_set.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/shell/application_loader.h"
@@ skipping 25 matching lines @@
   void PrintUnmetExpectations() {
     for (auto expectation : expectations_)
       ADD_FAILURE() << "Unmet: " << expectation;
     for (auto unexpected : unexpected_)
       ADD_FAILURE() << "Unexpected: " << unexpected;
   }
 
  private:
   // Overridden from ApplicationLoader:
   void Load(const GURL& url, InterfaceRequest<Application> request) override {
-    app_.reset(new ApplicationImpl(this, request.Pass()));
+    app_.reset(new ApplicationImpl(this, std::move(request)));
   }
 
   // Overridden from ApplicationDelegate:
   bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
     connection->AddService<Validator>(this);
     return true;
   }
 
   // Overridden from InterfaceFactory<Validator>:
   void Create(ApplicationConnection* connection,
               InterfaceRequest<Validator> request) override {
-    validator_bindings_.AddBinding(this, request.Pass());
+    validator_bindings_.AddBinding(this, std::move(request));
   }
 
   // Overridden from Validator:
   void AddServiceCalled(const String& app_url,
                         const String& service_url,
                         const String& name,
                         bool blocked) override {
     Validate(base::StringPrintf("%s %s %s %s",
         blocked ? "B" : "E", app_url.data(), service_url.data(), name.data()));
   }
@@ skipping 47 matching lines @@
   }
   bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
     AddService<Safe>(connection);
     AddService<Unsafe>(connection);
     return true;
   }
 
   // Overridden from InterfaceFactory<Safe>:
   void Create(ApplicationConnection* connection,
               InterfaceRequest<Safe> request) override {
-    safe_bindings_.AddBinding(this, request.Pass());
+    safe_bindings_.AddBinding(this, std::move(request));
   }
 
   // Overridden from InterfaceFactory<Unsafe>:
   void Create(ApplicationConnection* connection,
               InterfaceRequest<Unsafe> request) override {
-    unsafe_bindings_.AddBinding(this, request.Pass());
+    unsafe_bindings_.AddBinding(this, std::move(request));
   }
 
   template <typename Interface>
   void AddService(ApplicationConnection* connection) {
     validator_->AddServiceCalled(connection->GetRemoteApplicationURL(),
                                  connection->GetConnectionURL(),
                                  Interface::Name_,
                                  !connection->AddService<Interface>(this));
   }
 
@@ skipping 36 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TestLoader:
 
 TestLoader::TestLoader(ApplicationDelegate* delegate) : delegate_(delegate) {}
 TestLoader::~TestLoader() {}
 
 void TestLoader::Load(const GURL& url,
                       InterfaceRequest<Application> request) {
-  app_.reset(new ApplicationImpl(delegate_.get(), request.Pass()));
+  app_.reset(new ApplicationImpl(delegate_.get(), std::move(request)));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // CapabilityFilterTest:
 
 CapabilityFilterTest::CapabilityFilterTest() : validator_(nullptr) {}
 CapabilityFilterTest::~CapabilityFilterTest() {}
 
 void CapabilityFilterTest::RunBlockingTest() {
   std::set<std::string> expectations;
@@ skipping 89 matching lines @@
   // We expose Validator to the test application via ConnectToApplication
   // because we don't allow the test application to connect to test:validator.
   // Adding it to the CapabilityFilter would interfere with the test.
   ServiceProviderPtr exposed_services;
   (new ServiceProviderImpl(GetProxy(&exposed_services)))->
       AddService<Validator>(validator_);
   scoped_ptr<ConnectToApplicationParams> params(
       new ConnectToApplicationParams);
   params->SetTarget(Identity(GURL(url), std::string(), filter));
   params->set_services(GetProxy(&services));
-  params->set_exposed_services(exposed_services.Pass());
+  params->set_exposed_services(std::move(exposed_services));
   params->set_on_application_end(base::MessageLoop::QuitWhenIdleClosure());
-  application_manager_->ConnectToApplication(params.Pass());
+  application_manager_->ConnectToApplication(std::move(params));
 }
 
 void CapabilityFilterTest::InitValidator(
     const std::set<std::string>& expectations) {
   validator_ = new ConnectionValidator(expectations, &loop_);
   application_manager()->SetLoaderForURL(make_scoped_ptr(validator_),
                                           GURL("test:validator"));
 }
 
 void CapabilityFilterTest::RunTest() {
   loop()->Run();
   EXPECT_TRUE(validator_->expectations_met());
   if (!validator_->expectations_met())
     validator_->PrintUnmetExpectations();
 }
 
 }  // namespace test
 }  // namespace shell
 }  // namespace mojo