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

mojo/fetcher/network_fetcher.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/fetcher/network_fetcher.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/process.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 13 matching lines @@
 namespace fetcher {
 
 NetworkFetcher::NetworkFetcher(bool disable_cache,
                                mojo::URLRequestPtr request,
                                URLLoaderFactory* url_loader_factory,
                                const FetchCallback& loader_callback)
     : Fetcher(loader_callback),
       disable_cache_(false),
       url_(request->url.To<GURL>()),
       weak_ptr_factory_(this) {
-  StartNetworkRequest(request.Pass(), url_loader_factory);
+  StartNetworkRequest(std::move(request), url_loader_factory);
 }
 
 NetworkFetcher::~NetworkFetcher() {
 }
 
 const GURL& NetworkFetcher::GetURL() const {
   return url_;
 }
 
 GURL NetworkFetcher::GetRedirectURL() const {
@@ skipping 16 matching lines @@
   return GURL(response_->redirect_referrer);
 }
 URLResponsePtr NetworkFetcher::AsURLResponse(base::TaskRunner* task_runner,
                                              uint32_t skip) {
   if (skip != 0) {
     MojoResult result = ReadDataRaw(
         response_->body.get(), nullptr, &skip,
         MOJO_READ_DATA_FLAG_ALL_OR_NONE | MOJO_READ_DATA_FLAG_DISCARD);
     DCHECK_EQ(result, MOJO_RESULT_OK);
   }
-  return response_.Pass();
+  return std::move(response_);
 }
 
 void NetworkFetcher::RecordCacheToURLMapping(const base::FilePath& path,
                                              const GURL& url) {
   // This is used to extract symbols on android.
   // TODO(eseidel): All users of this log should move to using the map file.
   VLOG(1) << "Caching mojo app " << url << " at " << path.value();
 
   base::FilePath temp_dir;
   base::GetTempDir(&temp_dir);
@@ skipping 102 matching lines @@
 void NetworkFetcher::AsPath(
     base::TaskRunner* task_runner,
     base::Callback<void(const base::FilePath&, bool)> callback) {
   if (!path_.empty() || !response_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, path_, base::PathExists(path_)));
     return;
   }
 
   base::CreateTemporaryFile(&path_);
-  common::CopyToFile(response_->body.Pass(), path_, task_runner,
+  common::CopyToFile(std::move(response_->body), path_, task_runner,
                      base::Bind(&NetworkFetcher::CopyCompleted,
                                 weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 std::string NetworkFetcher::MimeType() {
   return response_->mime_type;
 }
 
 bool NetworkFetcher::HasMojoMagic() {
   std::string magic;
   return shell::BlockingPeekNBytes(response_->body.get(), &magic,
                                    strlen(kMojoMagic), kPeekTimeout) &&
          magic == kMojoMagic;
 }
 
 bool NetworkFetcher::PeekFirstLine(std::string* line) {
   return shell::BlockingPeekLine(response_->body.get(), line, kMaxShebangLength,
                                  kPeekTimeout);
 }
 
 void NetworkFetcher::StartNetworkRequest(mojo::URLRequestPtr request,
                                          URLLoaderFactory* url_loader_factory) {
   TRACE_EVENT_ASYNC_BEGIN1("mojo_shell", "NetworkFetcher::NetworkRequest", this,
                            "url", request->url.To<std::string>());
   request->auto_follow_redirects = false;
   request->bypass_cache = disable_cache_;
 
   url_loader_factory->CreateURLLoader(GetProxy(&url_loader_));
-  url_loader_->Start(request.Pass(),
+  url_loader_->Start(std::move(request),
                      base::Bind(&NetworkFetcher::OnLoadComplete,
                                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void NetworkFetcher::OnLoadComplete(URLResponsePtr response) {
   TRACE_EVENT_ASYNC_END0("mojo_shell", "NetworkFetcher::NetworkRequest", this);
   scoped_ptr<Fetcher> owner(this);
   if (response->error) {
     LOG(ERROR) << "Error (" << response->error->code << ": "
                << response->error->description << ") while fetching "
                << response->url;
     loader_callback_.Run(nullptr);
     return;
   }
 
-  response_ = response.Pass();
-  loader_callback_.Run(owner.Pass());
+  response_ = std::move(response);
+  loader_callback_.Run(std::move(owner));
 }
 
 }  // namespace fetcher
 }  // namespace mojo