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

net/websockets/websocket_stream_create_test_base.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 "net/websockets/websocket_stream_create_test_base.h"
 
+#include <utility>
+
 #include "base/callback.h"
 #include "base/macros.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/websockets/websocket_basic_handshake_stream.h"
 #include "net/websockets/websocket_handshake_request_info.h"
 #include "net/websockets/websocket_handshake_response_info.h"
 #include "net/websockets/websocket_handshake_stream_create_helper.h"
 #include "net/websockets/websocket_stream.h"
 #include "url/gurl.h"
@@ skipping 38 matching lines @@
   void OnFailure(const std::string& message) override {
     owner_->has_failed_ = true;
     owner_->failure_message_ = message;
     done_callback_.Run();
   }
 
   void OnStartOpeningHandshake(
       scoped_ptr<WebSocketHandshakeRequestInfo> request) override {
     // Can be called multiple times (in the case of HTTP auth). Last call
     // wins.
-    owner_->request_info_ = request.Pass();
+    owner_->request_info_ = std::move(request);
   }
 
   void OnFinishOpeningHandshake(
       scoped_ptr<WebSocketHandshakeResponseInfo> response) override {
     if (owner_->response_info_)
       ADD_FAILURE();
-    owner_->response_info_ = response.Pass();
+    owner_->response_info_ = std::move(response);
   }
 
   void OnSSLCertificateError(
       scoped_ptr<WebSocketEventInterface::SSLErrorCallbacks>
           ssl_error_callbacks,
       const SSLInfo& ssl_info,
       bool fatal) override {
-    owner_->ssl_error_callbacks_ = ssl_error_callbacks.Pass();
+    owner_->ssl_error_callbacks_ = std::move(ssl_error_callbacks);
     owner_->ssl_info_ = ssl_info;
     owner_->ssl_fatal_ = fatal;
   }
 
  private:
   WebSocketStreamCreateTestBase* owner_;
   base::Closure done_callback_;
   DISALLOW_COPY_AND_ASSIGN(TestConnectDelegate);
 };
 
@@ skipping 13 matching lines @@
     url_request_context_host_.AddSSLSocketDataProvider(std::move(ssl_data_[i]));
   }
   ssl_data_.clear();
   scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate(
       new TestConnectDelegate(this, connect_run_loop_.QuitClosure()));
   WebSocketStream::ConnectDelegate* delegate = connect_delegate.get();
   scoped_ptr<WebSocketHandshakeStreamCreateHelper> create_helper(
       new DeterministicKeyWebSocketHandshakeStreamCreateHelper(delegate,
                                                                sub_protocols));
   stream_request_ = CreateAndConnectStreamForTesting(
-      GURL(socket_url), create_helper.Pass(), origin,
+      GURL(socket_url), std::move(create_helper), origin,
       url_request_context_host_.GetURLRequestContext(), BoundNetLog(),
-      connect_delegate.Pass(),
-      timer ? timer.Pass()
+      std::move(connect_delegate),
+      timer ? std::move(timer)
             : scoped_ptr<base::Timer>(new base::Timer(false, false)));
 }
 
 std::vector<HeaderKeyValuePair>
 WebSocketStreamCreateTestBase::RequestHeadersToVector(
     const HttpRequestHeaders& headers) {
   HttpRequestHeaders::Iterator it(headers);
   std::vector<HeaderKeyValuePair> result;
   while (it.GetNext())
     result.push_back(HeaderKeyValuePair(it.name(), it.value()));
@@ skipping 13 matching lines @@
 
 void WebSocketStreamCreateTestBase::WaitUntilConnectDone() {
   connect_run_loop_.Run();
 }
 
 std::vector<std::string> WebSocketStreamCreateTestBase::NoSubProtocols() {
   return std::vector<std::string>();
 }
 
 }  // namespace net