original change

net/socket_stream/socket_stream.h

 // 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.
 
 #ifndef NET_SOCKET_STREAM_SOCKET_STREAM_H_
 #define NET_SOCKET_STREAM_SOCKET_STREAM_H_
 
 #include <deque>
 #include <map>
 #include <string>
 
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_export.h"
 #include "net/base/net_log.h"
 #include "net/base/privacy_mode.h"
+#include "net/cookies/cookie_store.h"
 #include "net/proxy/proxy_service.h"
 #include "net/ssl/ssl_config_service.h"
 #include "net/url_request/url_request.h"
 
 namespace net {
 
 class AuthChallengeInfo;
 class CertVerifier;
 class ClientSocketFactory;
 class ClientSocketHandle;
@@ skipping 75 matching lines @@
     // cookie.
     virtual bool CanSetCookie(SocketStream* request,
                               const GURL& url,
                               const std::string& cookie_line,
                               CookieOptions* options);
 
    protected:
     virtual ~Delegate() {}
   };
 
-  SocketStream(const GURL& url, Delegate* delegate);
+  SocketStream(const GURL& url, Delegate* delegate, URLRequestContext* context,
+               CookieStore* cookie_store);
 
   // The user data allows the clients to associate data with this job.
   // Multiple user data values can be stored under different keys.
   // This job will TAKE OWNERSHIP of the given data pointer, and will
   // delete the object if it is changed or the job is destroyed.
   UserData* GetUserData(const void* key) const;
   void SetUserData(const void* key, UserData* data);
 
   const GURL& url() const { return url_; }
   bool is_secure() const;
   const AddressList& address_list() const { return addresses_; }
   Delegate* delegate() const { return delegate_; }
   int max_pending_send_allowed() const { return max_pending_send_allowed_; }
 
   URLRequestContext* context() { return context_; }
-  // There're some asynchronous operations and members that are constructed from
-  // |context|. Be careful when you use this for the second time or more.
-  void set_context(URLRequestContext* context);
 
   const SSLConfig& server_ssl_config() const { return server_ssl_config_; }
   PrivacyMode privacy_mode() const { return privacy_mode_; }
   void CheckPrivacyMode();
 
   BoundNetLog* net_log() { return &net_log_; }
 
   // Opens the connection on the IO thread.
   // Once the connection is established, calls delegate's OnConnected.
   virtual void Connect();
 
   // Buffers |data| of |len| bytes for send and returns true if successful.
   // If size of buffered data exceeds |max_pending_send_allowed_|, sends no
   // data and returns false. |len| must be positive.
   virtual bool SendData(const char* data, int len);
 
   // Requests to close the connection.
   // Once the connection is closed, calls delegate's OnClose.
   virtual void Close();
 
   // Restarts with authentication info.
   // Should be used for response of OnAuthRequired.
   virtual void RestartWithAuth(const AuthCredentials& credentials);
 
   // Detach delegate.  Call before delegate is deleted.
   // Once delegate is detached, close the socket stream and never call delegate
   // back.
   virtual void DetachDelegate();
 
+  // Detach the context.
+  virtual void DetachContext();
+
   const ProxyServer& proxy_server() const;
 
   // Sets an alternative ClientSocketFactory.  Doesn't take ownership of
   // |factory|.  For testing purposes only.
   void SetClientSocketFactory(ClientSocketFactory* factory);
 
   // Cancels the connection because of an error.
   // |error| is net::Error which represents the error.
   void CancelWithError(int error);
 
   // Cancels the connection because of receiving a certificate with an error.
   void CancelWithSSLError(const SSLInfo& ssl_info);
 
   // Continues to establish the connection in spite of an error. Usually this
   // case happens because users allow certificate with an error by manual
   // actions on alert dialog or browser cached such kinds of user actions.
   void ContinueDespiteError();
 
+  CookieStore* cookie_store() const;
+
  protected:
   friend class base::RefCountedThreadSafe<SocketStream>;
   virtual ~SocketStream();
 
   Delegate* delegate_;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(SocketStreamTest, IOPending);
   FRIEND_TEST_ALL_PREFIXES(SocketStreamTest, SwitchAfterPending);
   FRIEND_TEST_ALL_PREFIXES(SocketStreamTest,
@@ skipping 189 matching lines @@
   // True iff there's no error and this instance is waiting for completion of
   // Write operation by socket_.
   bool waiting_for_write_completion_;
   PendingDataQueue pending_write_bufs_;
 
   bool closing_;
   bool server_closed_;
 
   scoped_ptr<SocketStreamMetrics> metrics_;
 
+  // Cookie store to use for this socket stream.
+  scoped_refptr<CookieStore> cookie_store_;
+
   DISALLOW_COPY_AND_ASSIGN(SocketStream);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_STREAM_SOCKET_STREAM_H_