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

mojo/shell/application_manager_apptest_driver.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 <utility>
+
 #include "base/at_exit.h"
 #include "base/base_paths.h"
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/process/process.h"
@@ skipping 54 matching lines @@
 
     mojo::embedder::HandlePassingInformation handle_passing_info;
 
     // Create the channel to be shared with the target process.
     mojo::embedder::PlatformChannelPair platform_channel_pair;
     // Give one end to the shell so that it can create an instance.
     mojo::embedder::ScopedPlatformHandle platform_channel =
         platform_channel_pair.PassServerHandle();
 
     mojo::ScopedMessagePipeHandle handle(mojo::embedder::CreateChannel(
-        platform_channel.Pass(),
+        std::move(platform_channel),
         base::Bind(&TargetApplicationDelegate::DidCreateChannel,
                    weak_factory_.GetWeakPtr()),
         base::ThreadTaskRunnerHandle::Get()));
 
     // The platform handle used for the new EDK's broker.
     mojo::edk::PlatformChannelPair broker_channel_pair;
     if (base::CommandLine::ForCurrentProcess()->HasSwitch("use-new-edk")) {
       std::string client_handle_as_string =
           broker_channel_pair.PrepareToPassClientHandleToChildProcessAsString(
               &handle_passing_info);
       MojoResult rv = MojoWriteMessage(
           handle.get().value(), client_handle_as_string.c_str(),
           static_cast<uint32_t>(client_handle_as_string.size()), nullptr, 0,
           MOJO_WRITE_MESSAGE_FLAG_NONE);
       DCHECK_EQ(rv, MOJO_RESULT_OK);
     }
 
     mojo::CapabilityFilterPtr filter(mojo::CapabilityFilter::New());
     mojo::Array<mojo::String> test_interfaces;
     test_interfaces.push_back(
         mojo::shell::test::mojom::CreateInstanceForHandleTest::Name_);
-    filter->filter.insert("mojo:mojo_shell_apptests", test_interfaces.Pass());
+    filter->filter.insert("mojo:mojo_shell_apptests",
+                          std::move(test_interfaces));
     application_manager->CreateInstanceForHandle(
         mojo::ScopedHandle(mojo::Handle(handle.release().value())),
-        "exe:application_manager_apptest_target",
-        filter.Pass());
+        "exe:application_manager_apptest_target", std::move(filter));
     // Put the other end on the command line used to launch the target.
     platform_channel_pair.PrepareToPassClientHandleToChildProcess(
         &child_command_line, &handle_passing_info);
 
     base::LaunchOptions options;
   #if defined(OS_WIN)
     options.handles_to_inherit = &handle_passing_info;
   #elif defined(OS_POSIX)
     options.fds_to_remap = &handle_passing_info;
   #endif
@@ skipping 11 matching lines @@
   }
   bool ConfigureIncomingConnection(
       mojo::ApplicationConnection* connection) override {
     connection->AddService<Driver>(this);
     return true;
   }
 
   // mojo::InterfaceFactory<Driver>:
   void Create(mojo::ApplicationConnection* connection,
               mojo::InterfaceRequest<Driver> request) override {
-    bindings_.AddBinding(this, request.Pass());
+    bindings_.AddBinding(this, std::move(request));
   }
 
   // Driver:
   void QuitDriver() override {
     target_.Terminate(0, false);
     app_->Quit();
   }
 
   void DidCreateChannel(mojo::embedder::ChannelInfo* channel_info) {}
 
   mojo::ApplicationImpl* app_;
   base::Process target_;
   mojo::WeakBindingSet<Driver> bindings_;
   base::WeakPtrFactory<TargetApplicationDelegate> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TargetApplicationDelegate);
 };
 
 }  // namespace
 
 int main(int argc, char** argv) {
   base::AtExitManager at_exit;
   base::CommandLine::Init(argc, argv);
 
   mojo::runner::InitializeLogging();
 
   TargetApplicationDelegate delegate;
   return mojo::runner::TestNativeMain(&delegate);
 }