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

mojo/services/network/network_context.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/services/network/network_context.h"
 
 #include <algorithm>
+#include <utility>
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "mojo/common/user_agent.h"
 #include "mojo/services/network/mojo_persistent_cookie_store.h"
@@ skipping 54 matching lines @@
 #elif defined(OS_POSIX)
     file.reset(fopen(log_path.value().c_str(), "w"));
 #endif
     if (!file) {
       LOG(ERROR) << "Could not open file " << log_path.value()
                  << " for net logging";
     } else {
       write_to_file_observer_.reset(new net::WriteToFileNetLogObserver());
       write_to_file_observer_->set_capture_mode(
           net::NetLogCaptureMode::IncludeCookiesAndCredentials());
-      write_to_file_observer_->StartObserving(this, file.Pass(), nullptr,
+      write_to_file_observer_->StartObserving(this, std::move(file), nullptr,
                                               nullptr);
     }
   }
 
   ~MojoNetLog() override {
     if (write_to_file_observer_)
       write_to_file_observer_->StopObserving(nullptr);
   }
 
  private:
   scoped_ptr<net::WriteToFileNetLogObserver> write_to_file_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(MojoNetLog);
 };
 
 NetworkContext::NetworkContext(
     scoped_ptr<net::URLRequestContext> url_request_context)
     : net_log_(new MojoNetLog),
-      url_request_context_(url_request_context.Pass()),
+      url_request_context_(std::move(url_request_context)),
       in_shutdown_(false) {
   url_request_context_->set_net_log(net_log_.get());
 }
 
 NetworkContext::NetworkContext(
     const base::FilePath& base_path,
     const scoped_refptr<base::SequencedTaskRunner>& background_task_runner,
     NetworkServiceDelegate* delegate)
     : NetworkContext(MakeURLRequestContext(base_path, background_task_runner,
                                            delegate)) {
@@ skipping 46 matching lines @@
   if (command_line->HasSwitch(kTestingFixedHttpsPort)) {
     params.testing_fixed_https_port =
         GetPortNumber(*command_line, kTestingFixedHttpsPort);
   }
   builder.set_http_network_session_params(params);
 
   if (command_line->HasSwitch(kHostResolverRules)) {
     scoped_ptr<net::HostResolver> host_resolver(
         net::HostResolver::CreateDefaultResolver(nullptr));
     scoped_ptr<net::MappedHostResolver> remapped_host_resolver(
-        new net::MappedHostResolver(host_resolver.Pass()));
+        new net::MappedHostResolver(std::move(host_resolver)));
     remapped_host_resolver->SetRulesFromString(
         command_line->GetSwitchValueASCII(kHostResolverRules));
-    builder.set_host_resolver(remapped_host_resolver.Pass());
+    builder.set_host_resolver(std::move(remapped_host_resolver));
   }
 
   builder.set_accept_language("en-us,en");
   builder.set_user_agent(mojo::common::GetUserAgent());
   builder.set_proxy_service(net::ProxyService::CreateDirect());
   builder.set_transport_security_persister_path(base_path);
 
   net::URLRequestContextBuilder::HttpCacheParams cache_params;
 #if defined(OS_ANDROID)
   // On Android, we store the cache on disk becase we can run only a single
@@ skipping 20 matching lines @@
             delegate,
             base::FilePath(FILE_PATH_LITERAL("Cookies")),
             base::MessageLoop::current()->task_runner(),
             background_task_runner,
             false,  // TODO(erg): Make RESTORED_SESSION_COOKIES configurable.
             nullptr);
     builder.SetCookieAndChannelIdStores(
         new net::CookieMonster(cookie_store, nullptr), nullptr);
   }
 
-  return builder.Build().Pass();
+  return builder.Build();
 }
 
 }  // namespace mojo