original change

net/websockets/websocket_job.cc

 // Copyright (c) 2012 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_job.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 18 matching lines @@
 
 // lower-case header names.
 const char* const kCookieHeaders[] = {
   "cookie", "cookie2"
 };
 const char* const kSetCookieHeaders[] = {
   "set-cookie", "set-cookie2"
 };
 
 net::SocketStreamJob* WebSocketJobFactory(
-    const GURL& url, net::SocketStream::Delegate* delegate) {
+    const GURL& url, net::SocketStream::Delegate* delegate,
+    net::URLRequestContext* context, net::CookieStore* cookie_store) {
   net::WebSocketJob* job = new net::WebSocketJob(delegate);
-  job->InitSocketStream(new net::SocketStream(url, job));
+  job->InitSocketStream(new net::SocketStream(url, job, context, cookie_store));
   return job;
 }
 
 class WebSocketJobInitSingleton {
  private:
   friend struct base::DefaultLazyInstanceTraits<WebSocketJobInitSingleton>;
   WebSocketJobInitSingleton() {
     net::SocketStreamJob::RegisterProtocolFactory("ws", WebSocketJobFactory);
     net::SocketStreamJob::RegisterProtocolFactory("wss", WebSocketJobFactory);
   }
@@ skipping 311 matching lines @@
 }
 
 void WebSocketJob::AddCookieHeaderAndSend() {
   bool allow = true;
   if (delegate_ && !delegate_->CanGetCookies(socket_.get(), GetURLForCookies()))
     allow = false;
 
   if (socket_.get() && delegate_ && state_ == CONNECTING) {
     handshake_request_->RemoveHeaders(kCookieHeaders,
                                       arraysize(kCookieHeaders));
-    if (allow && socket_->context()->cookie_store()) {
+    if (allow && socket_->cookie_store()) {
       // Add cookies, including HttpOnly cookies.
       CookieOptions cookie_options;
       cookie_options.set_include_httponly();
-      socket_->context()->cookie_store()->GetCookiesWithOptionsAsync(
+      socket_->cookie_store()->GetCookiesWithOptionsAsync(
           GetURLForCookies(), cookie_options,
           base::Bind(&WebSocketJob::LoadCookieCallback,
                      weak_ptr_factory_.GetWeakPtr()));
     } else {
       DoSendData();
     }
   }
 }
 
 void WebSocketJob::LoadCookieCallback(const std::string& cookie) {
@@ skipping 110 matching lines @@
   WebSocketThrottle::GetInstance()->RemoveFromQueue(this);
 }
 
 void WebSocketJob::SaveNextCookie() {
   if (!socket_.get() || !delegate_ || state_ != CONNECTING)
     return;
 
   callback_pending_ = false;
   save_next_cookie_running_ = true;
 
-  if (socket_->context()->cookie_store()) {
+  if (socket_->cookie_store()) {
     GURL url_for_cookies = GetURLForCookies();
 
     CookieOptions options;
     options.set_include_httponly();
 
     // Loop as long as SetCookieWithOptionsAsync completes synchronously. Since
     // CookieMonster's asynchronous operation APIs queue the callback to run it
     // on the thread where the API was called, there won't be race. I.e. unless
     // the callback is run synchronously, it won't be run in parallel with this
     // method.
     while (!callback_pending_ &&
            response_cookies_save_index_ < response_cookies_.size()) {
       std::string cookie = response_cookies_[response_cookies_save_index_];
       response_cookies_save_index_++;
 
       if (!delegate_->CanSetCookie(
               socket_.get(), url_for_cookies, cookie, &options))
         continue;
 
       callback_pending_ = true;
-      socket_->context()->cookie_store()->SetCookieWithOptionsAsync(
+      socket_->cookie_store()->SetCookieWithOptionsAsync(
           url_for_cookies, cookie, options,
           base::Bind(&WebSocketJob::OnCookieSaved,
                      weak_ptr_factory_.GetWeakPtr()));
     }
   }
 
   save_next_cookie_running_ = false;
 
   if (callback_pending_)
     return;
@@ skipping 152 matching lines @@
 
   scoped_refptr<IOBufferWithSize> next_buffer = send_buffer_queue_.front();
   send_buffer_queue_.pop_front();
   current_send_buffer_ =
       new DrainableIOBuffer(next_buffer.get(), next_buffer->size());
   SendDataInternal(current_send_buffer_->data(),
                    current_send_buffer_->BytesRemaining());
 }
 
 }  // namespace net