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

mojo/services/network/url_loader_impl.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/url_loader_impl.h"
 
+#include <utility>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/common/url_type_converters.h"
 #include "mojo/services/network/net_adapters.h"
 #include "mojo/services/network/network_context.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/io_buffer.h"
@@ skipping 54 matching lines @@
     response->status_line = headers->GetStatusLine();
 
     response->headers = Array<HttpHeaderPtr>::New(0);
     std::vector<String> header_lines;
     void* iter = nullptr;
     std::string name, value;
     while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
       HttpHeaderPtr header = HttpHeader::New();
       header->name = name;
       header->value = value;
-      response->headers.push_back(header.Pass());
+      response->headers.push_back(std::move(header));
     }
   }
 
   std::string mime_type;
   url_request->GetMimeType(&mime_type);
   response->mime_type = mime_type;
 
   std::string charset;
   url_request->GetCharset(&charset);
   response->charset = charset;
 
-  return response.Pass();
+  return response;
 }
 
 // Reads the request body upload data from a DataPipe.
 class UploadDataPipeElementReader : public net::UploadElementReader {
  public:
   UploadDataPipeElementReader(ScopedDataPipeConsumerHandle pipe)
-      : pipe_(pipe.Pass()), num_bytes_(0) {}
+      : pipe_(std::move(pipe)), num_bytes_(0) {}
   ~UploadDataPipeElementReader() override {}
 
   // UploadElementReader overrides:
   int Init(const net::CompletionCallback& callback) override {
     offset_ = 0;
     ReadDataRaw(pipe_.get(), nullptr, &num_bytes_, MOJO_READ_DATA_FLAG_QUERY);
     return net::OK;
   }
   uint64 GetContentLength() const override { return num_bytes_; }
   uint64 BytesRemaining() const override { return num_bytes_ - offset_; }
@@ skipping 24 matching lines @@
 }  // namespace
 
 URLLoaderImpl::URLLoaderImpl(NetworkContext* context,
                              InterfaceRequest<URLLoader> request,
                              scoped_ptr<mojo::AppRefCount> app_refcount)
     : context_(context),
       response_body_buffer_size_(0),
       response_body_bytes_read_(0),
       auto_follow_redirects_(true),
       connected_(true),
-      binding_(this, request.Pass()),
-      app_refcount_(app_refcount.Pass()),
+      binding_(this, std::move(request)),
+      app_refcount_(std::move(app_refcount)),
       weak_ptr_factory_(this) {
   binding_.set_connection_error_handler([this]() { OnConnectionError(); });
   context_->RegisterURLLoader(this);
 }
 
 URLLoaderImpl::~URLLoaderImpl() {
   context_->DeregisterURLLoader(this);
 }
 
 void URLLoaderImpl::Cleanup() {
@@ skipping 32 matching lines @@
       } else {
         headers.SetHeader(header, value);
       }
     }
     url_request_->SetExtraRequestHeaders(headers);
   }
   if (request->body) {
     std::vector<scoped_ptr<net::UploadElementReader>> element_readers;
     for (size_t i = 0; i < request->body.size(); ++i) {
       element_readers.push_back(make_scoped_ptr(
-          new UploadDataPipeElementReader(request->body[i].Pass())));
+          new UploadDataPipeElementReader(std::move(request->body[i]))));
     }
     url_request_->set_upload(make_scoped_ptr<net::UploadDataStream>(
         new net::ElementsUploadDataStream(std::move(element_readers), 0)));
   }
   if (request->bypass_cache)
     url_request_->SetLoadFlags(net::LOAD_BYPASS_CACHE);
 
   callback_ = callback;
   response_body_buffer_size_ = request->response_body_buffer_size;
   auto_follow_redirects_ = request->auto_follow_redirects;
@@ skipping 28 matching lines @@
     if (!url_request_->status().is_success())
       status->error = MakeNetworkError(url_request_->status().error());
     if (url_request_->response_info().headers) {
       status->content_length =
           url_request_->response_info().headers->GetContentLength();
     }
   } else {
     status->is_loading = false;
   }
   // TODO(darin): Populate more status fields.
-  callback.Run(status.Pass());
+  callback.Run(std::move(status));
 }
 
 void URLLoaderImpl::OnConnectionError() {
   connected_ = false;
   DeleteIfNeeded();
 }
 
 void URLLoaderImpl::OnReceivedRedirect(net::URLRequest* url_request,
                                        const net::RedirectInfo& redirect_info,
                                        bool* defer_redirect) {
   DCHECK(url_request == url_request_.get());
   DCHECK(url_request->status().is_success());
 
   if (auto_follow_redirects_)
     return;
 
   // Send the redirect response to the client, allowing them to inspect it and
   // optionally follow the redirect.
   *defer_redirect = true;
 
   URLResponsePtr response = MakeURLResponse(url_request);
   response->redirect_method = redirect_info.new_method;
   response->redirect_url = String::From(redirect_info.new_url);
   response->redirect_referrer = redirect_info.new_referrer;
 
-  SendResponse(response.Pass());
+  SendResponse(std::move(response));
 
   DeleteIfNeeded();
 }
 
 void URLLoaderImpl::OnResponseStarted(net::URLRequest* url_request) {
   DCHECK(url_request == url_request_.get());
 
   if (!url_request->status().is_success()) {
     SendError(url_request->status().error(), callback_);
     callback_ = Callback<void(URLResponsePtr)>();
     DeleteIfNeeded();
     return;
   }
 
   // TODO(darin): Add support for optional MIME sniffing.
 
   DataPipe data_pipe;
   // TODO(darin): Honor given buffer size.
 
   URLResponsePtr response = MakeURLResponse(url_request);
-  response->body = data_pipe.consumer_handle.Pass();
-  response_body_stream_ = data_pipe.producer_handle.Pass();
+  response->body = std::move(data_pipe.consumer_handle);
+  response_body_stream_ = std::move(data_pipe.producer_handle);
   ListenForPeerClosed();
 
-  SendResponse(response.Pass());
+  SendResponse(std::move(response));
 
   // Start reading...
   ReadMore();
 }
 
 void URLLoaderImpl::OnReadCompleted(net::URLRequest* url_request,
                                     int bytes_read) {
   DCHECK(url_request == url_request_.get());
 
   if (url_request->status().is_success()) {
     DidRead(static_cast<uint32_t>(bytes_read), false);
   } else {
     handle_watcher_.Stop();
     pending_write_ = nullptr;  // This closes the data pipe.
     DeleteIfNeeded();
     return;
   }
 }
 
 void URLLoaderImpl::SendError(
     int error_code,
     const Callback<void(URLResponsePtr)>& callback) {
   URLResponsePtr response(URLResponse::New());
   if (url_request_)
     response->url = String::From(url_request_->url());
   response->error = MakeNetworkError(error_code);
-  callback.Run(response.Pass());
+  callback.Run(std::move(response));
 }
 
 void URLLoaderImpl::SendResponse(URLResponsePtr response) {
   Callback<void(URLResponsePtr)> callback;
   std::swap(callback_, callback);
-  callback.Run(response.Pass());
+  callback.Run(std::move(response));
 }
 
 void URLLoaderImpl::OnResponseBodyStreamReady(MojoResult result) {
   // TODO(darin): Handle a bad |result| value.
 
   // Continue watching the handle in case the peer is closed.
   ListenForPeerClosed();
   ReadMore();
 }
 
@@ skipping 69 matching lines @@
 
 void URLLoaderImpl::ListenForPeerClosed() {
   handle_watcher_.Start(response_body_stream_.get(),
                         MOJO_HANDLE_SIGNAL_PEER_CLOSED,
                         MOJO_DEADLINE_INDEFINITE,
                         base::Bind(&URLLoaderImpl::OnResponseBodyStreamClosed,
                                    base::Unretained(this)));
 }
 
 }  // namespace mojo