Move work done in CreateAndConnectStreamWithCreateHelper into StreamRequestImpl's ctor

net/websockets/websocket_stream.cc

 // Copyright 2013 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.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "net/base/load_flags.h"
@@ skipping 49 matching lines @@
  private:
   StreamRequestImpl* owner_;
   HandshakeResult result_;
 };
 
 class StreamRequestImpl : public WebSocketStreamRequest {
  public:
   StreamRequestImpl(
       const GURL& url,
       const URLRequestContext* context,
+      const url::Origin& origin,
       scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate,
-      WebSocketHandshakeStreamCreateHelper* create_helper)
+      scoped_ptr<WebSocketHandshakeStreamCreateHelper> create_helper)
       : delegate_(new Delegate(this)),
         url_request_(url, DEFAULT_PRIORITY, delegate_.get(), context),
         connect_delegate_(connect_delegate.Pass()),
-        create_helper_(create_helper) {}
+        create_helper_(create_helper.release()) {
+    HttpRequestHeaders headers;
+    headers.SetHeader(websockets::kUpgrade, websockets::kWebSocketLowercase);
+    headers.SetHeader(HttpRequestHeaders::kConnection, websockets::kUpgrade);
+    headers.SetHeader(HttpRequestHeaders::kOrigin, origin.string());
+    headers.SetHeader(websockets::kSecWebSocketVersion,
+                      websockets::kSupportedVersion);
+    url_request_.SetExtraRequestHeaders(headers);
+
+    // This passes the ownership of |create_helper_| to |url_request_|.
+    url_request_.SetUserData(
+        WebSocketHandshakeStreamBase::CreateHelper::DataKey(),
+        create_helper_);
+    url_request_.SetLoadFlags(LOAD_DISABLE_CACHE |
+                              LOAD_BYPASS_CACHE |
+                              LOAD_DO_NOT_PROMPT_FOR_LOGIN);
+  }
 
   // Destroying this object destroys the URLRequest, which cancels the request
   // and so terminates the handshake if it is incomplete.
   virtual ~StreamRequestImpl() {}
 
-  URLRequest* url_request() { return &url_request_; }
+  void Start() {
+    url_request_.Start();
+  }
 
   void PerformUpgrade() {
     connect_delegate_->OnSuccess(create_helper_->stream()->Upgrade());
   }
 
   void ReportFailure() {
     std::string failure_message;
     if (create_helper_->stream()) {
       failure_message = create_helper_->stream()->GetFailureMessage();
     } else {
@@ skipping 59 matching lines @@
 void Delegate::OnSSLCertificateError(URLRequest* request,
                                      const SSLInfo& ssl_info,
                                      bool fatal) {
   request->Cancel();
 }
 
 void Delegate::OnReadCompleted(URLRequest* request, int bytes_read) {
   NOTREACHED();
 }
 
-// Internal implementation of CreateAndConnectStream and
-// CreateAndConnectStreamForTesting.
-scoped_ptr<WebSocketStreamRequest> CreateAndConnectStreamWithCreateHelper(
-    const GURL& socket_url,
-    scoped_ptr<WebSocketHandshakeStreamCreateHelper> create_helper,
-    const url::Origin& origin,
-    URLRequestContext* url_request_context,
-    const BoundNetLog& net_log,
-    scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate) {
-  scoped_ptr<StreamRequestImpl> request(
-      new StreamRequestImpl(socket_url,
-                            url_request_context,
-                            connect_delegate.Pass(),
-                            create_helper.get()));
-  HttpRequestHeaders headers;
-  headers.SetHeader(websockets::kUpgrade, websockets::kWebSocketLowercase);
-  headers.SetHeader(HttpRequestHeaders::kConnection, websockets::kUpgrade);
-  headers.SetHeader(HttpRequestHeaders::kOrigin, origin.string());
-  headers.SetHeader(websockets::kSecWebSocketVersion,
-                    websockets::kSupportedVersion);
-  request->url_request()->SetExtraRequestHeaders(headers);
-  request->url_request()->SetUserData(
-      WebSocketHandshakeStreamBase::CreateHelper::DataKey(),
-      create_helper.release());
-  request->url_request()->SetLoadFlags(LOAD_DISABLE_CACHE |
-                                       LOAD_BYPASS_CACHE |
-                                       LOAD_DO_NOT_PROMPT_FOR_LOGIN);
-  request->url_request()->Start();
-  return request.PassAs<WebSocketStreamRequest>();
-}
-
 }  // namespace
 
 WebSocketStreamRequest::~WebSocketStreamRequest() {}
 
 WebSocketStream::WebSocketStream() {}
 WebSocketStream::~WebSocketStream() {}
 
 WebSocketStream::ConnectDelegate::~ConnectDelegate() {}
 
 scoped_ptr<WebSocketStreamRequest> WebSocketStream::CreateAndConnectStream(
     const GURL& socket_url,
     const std::vector<std::string>& requested_subprotocols,
     const url::Origin& origin,
     URLRequestContext* url_request_context,
     const BoundNetLog& net_log,
     scoped_ptr<ConnectDelegate> connect_delegate) {
   scoped_ptr<WebSocketHandshakeStreamCreateHelper> create_helper(
       new WebSocketHandshakeStreamCreateHelper(connect_delegate.get(),
                                                requested_subprotocols));
-  return CreateAndConnectStreamWithCreateHelper(socket_url,
-                                                create_helper.Pass(),
-                                                origin,
-                                                url_request_context,
-                                                net_log,
-                                                connect_delegate.Pass());
+  scoped_ptr<StreamRequestImpl> request(
+      new StreamRequestImpl(socket_url,
+                            url_request_context,
+                            origin,
+                            connect_delegate.Pass(),
+                            create_helper.Pass()));
+  request->Start();
+  return request.PassAs<WebSocketStreamRequest>();
 }
 
 // This is declared in websocket_test_util.h.
 scoped_ptr<WebSocketStreamRequest> CreateAndConnectStreamForTesting(
     const GURL& socket_url,
     scoped_ptr<WebSocketHandshakeStreamCreateHelper> create_helper,
     const url::Origin& origin,
     URLRequestContext* url_request_context,
     const BoundNetLog& net_log,
     scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate) {
-  return CreateAndConnectStreamWithCreateHelper(socket_url,
-                                                create_helper.Pass(),
-                                                origin,
-                                                url_request_context,
-                                                net_log,
-                                                connect_delegate.Pass());
+  scoped_ptr<StreamRequestImpl> request(
+      new StreamRequestImpl(socket_url,
+                            url_request_context,
+                            origin,
+                            connect_delegate.Pass(),
+                            create_helper.Pass()));
+  request->Start();
+  return request.PassAs<WebSocketStreamRequest>();
 }
 
 }  // namespace net