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

mojo/services/network/web_socket_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/web_socket_impl.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/message_pump/handle_watcher.h"
 #include "mojo/services/network/network_context.h"
 #include "mojo/services/network/public/cpp/web_socket_read_queue.h"
 #include "mojo/services/network/public/cpp/web_socket_write_queue.h"
 #include "net/websockets/websocket_channel.h"
 #include "net/websockets/websocket_errors.h"
 #include "net/websockets/websocket_event_interface.h"
 #include "net/websockets/websocket_frame.h"  // for WebSocketFrameHeader::OpCode
@@ skipping 39 matching lines @@
   }
 };
 
 namespace {
 
 typedef net::WebSocketEventInterface::ChannelState ChannelState;
 
 struct WebSocketEventHandler : public net::WebSocketEventInterface {
  public:
   WebSocketEventHandler(WebSocketClientPtr client)
-      : client_(client.Pass()) {
-  }
+      : client_(std::move(client)) {}
   ~WebSocketEventHandler() override {}
 
  private:
   // net::WebSocketEventInterface methods:
   ChannelState OnAddChannelResponse(const std::string& selected_subprotocol,
                                     const std::string& extensions) override;
   ChannelState OnDataFrame(bool fin,
                            WebSocketMessageType type,
                            const std::vector<char>& data) override;
   ChannelState OnClosingHandshake() override;
@@ skipping 21 matching lines @@
   ScopedDataPipeProducerHandle receive_stream_;
   scoped_ptr<WebSocketWriteQueue> write_queue_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketEventHandler);
 };
 
 ChannelState WebSocketEventHandler::OnAddChannelResponse(
     const std::string& selected_protocol,
     const std::string& extensions) {
   DataPipe data_pipe;
-  receive_stream_ = data_pipe.producer_handle.Pass();
+  receive_stream_ = std::move(data_pipe.producer_handle);
   write_queue_.reset(new WebSocketWriteQueue(receive_stream_.get()));
-  client_->DidConnect(
-      selected_protocol, extensions, data_pipe.consumer_handle.Pass());
+  client_->DidConnect(selected_protocol, extensions,
+                      std::move(data_pipe.consumer_handle));
   return WebSocketEventInterface::CHANNEL_ALIVE;
 }
 
 ChannelState WebSocketEventHandler::OnDataFrame(
     bool fin,
     net::WebSocketFrameHeader::OpCode type,
     const std::vector<char>& data) {
   uint32_t size = static_cast<uint32_t>(data.size());
   write_queue_->Write(
       &data[0], size,
@@ skipping 47 matching lines @@
     bool fin,
     net::WebSocketFrameHeader::OpCode type,
     uint32_t num_bytes,
     const char* buffer) {
   client_->DidReceiveData(
       fin, ConvertTo<WebSocket::MessageType>(type), num_bytes);
 }
 
 }  // namespace mojo
 
-WebSocketImpl::WebSocketImpl(
-    NetworkContext* context,
-    scoped_ptr<mojo::AppRefCount> app_refcount,
-    InterfaceRequest<WebSocket> request)
-    : context_(context), app_refcount_(app_refcount.Pass()),
-      binding_(this, request.Pass()) {
-}
+WebSocketImpl::WebSocketImpl(NetworkContext* context,
+                             scoped_ptr<mojo::AppRefCount> app_refcount,
+                             InterfaceRequest<WebSocket> request)
+    : context_(context),
+      app_refcount_(std::move(app_refcount)),
+      binding_(this, std::move(request)) {}
 
 WebSocketImpl::~WebSocketImpl() {
 }
 
 void WebSocketImpl::Connect(const String& url,
                             Array<String> protocols,
                             const String& origin,
                             ScopedDataPipeConsumerHandle send_stream,
                             WebSocketClientPtr client) {
   DCHECK(!channel_);
-  send_stream_ = send_stream.Pass();
+  send_stream_ = std::move(send_stream);
   read_queue_.reset(new WebSocketReadQueue(send_stream_.get()));
   scoped_ptr<net::WebSocketEventInterface> event_interface(
-      new WebSocketEventHandler(client.Pass()));
-  channel_.reset(new net::WebSocketChannel(event_interface.Pass(),
+      new WebSocketEventHandler(std::move(client)));
+  channel_.reset(new net::WebSocketChannel(std::move(event_interface),
                                            context_->url_request_context()));
   channel_->SendAddChannelRequest(GURL(url.get()),
                                   protocols.To<std::vector<std::string>>(),
                                   url::Origin(GURL(origin.get())));
 }
 
 void WebSocketImpl::Send(bool fin,
                          WebSocket::MessageType type,
                          uint32_t num_bytes) {
   DCHECK(channel_);
@@ skipping 18 matching lines @@
                                           uint32_t num_bytes,
                                           const char* data) {
   std::vector<char> buffer(num_bytes);
   memcpy(&buffer[0], data, num_bytes);
   DCHECK(channel_);
   channel_->SendFrame(
       fin, ConvertTo<net::WebSocketFrameHeader::OpCode>(type), buffer);
 }
 
 }  // namespace mojo