Changes to support new cookie policy....

chrome/browser/net/chrome_url_request_context.h

 // Copyright (c) 2010 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 CHROME_BROWSER_NET_CHROME_URL_REQUEST_CONTEXT_H_
 #define CHROME_BROWSER_NET_CHROME_URL_REQUEST_CONTEXT_H_
 
 #include "base/file_path.h"
 #include "base/linked_ptr.h"
+#include "net/base/cookie_policy.h"
 #include "chrome/browser/host_content_settings_map.h"
 #include "chrome/browser/host_zoom_map.h"
 #include "chrome/browser/privacy_blacklist/blacklist.h"
 #include "chrome/browser/net/url_request_context_getter.h"
 #include "chrome/common/appcache/chrome_appcache_service.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/pref_service.h"
 #include "net/url_request/url_request_context.h"
 
 class CommandLine;
 class Profile;
 
 namespace net {
 class ProxyConfig;
 }
 
 class ChromeURLRequestContext;
 class ChromeURLRequestContextFactory;
 class IOThread;
 
 // Subclass of URLRequestContext which can be used to store extra information
 // for requests.
 //
 // All methods of this class must be called from the IO thread,
 // including the constructor and destructor.
-class ChromeURLRequestContext : public URLRequestContext {
+class ChromeURLRequestContext : public URLRequestContext,
+                                public net::CookiePolicy {
  public:
   // Maintains some extension-related state we need on the IO thread.
   // TODO(aa): It would be cool if the Extension objects in ExtensionsService
   // could be immutable and ref-counted so that we could use them directly from
   // both threads. There is only a small amount of mutable state in Extension.
   struct ExtensionInfo {
     ExtensionInfo(const FilePath& path, const std::string& default_locale,
                   const Extension::URLPatternList& extent,
                   const std::vector<std::string>& api_permissions)
         : path(path), default_locale(default_locale),
@@ skipping 57 matching lines @@
     return host_content_settings_map_;
   }
 
   const HostZoomMap* host_zoom_map() const { return host_zoom_map_; }
 
   // Gets the Privacy Blacklist, if any for this context.
   const Blacklist* GetPrivacyBlacklist() const;
 
   // Callback for when new extensions are loaded. Takes ownership of
   // |extension_info|.
-  void OnNewExtensions(
-      const std::string& id,
-      ChromeURLRequestContext::ExtensionInfo* extension_info);
+  void OnNewExtensions(const std::string& id, ExtensionInfo* extension_info);
 
   // Callback for when an extension is unloaded.
   void OnUnloadedExtension(const std::string& id);
 
+  // False only if cookies are globally blocked without exception.
+  bool AreCookiesEnabled() const;
+
+  // CookiePolicy methods:
+  virtual bool CanGetCookies(const GURL& url, const GURL& first_party);
+  virtual bool CanSetCookie(const GURL& url, const GURL& first_party);
+
  protected:
   // Copies the dependencies from |other| into |this|. If you use this
   // constructor, then you should hold a reference to |other|, as we
   // depend on |other| being alive.
   explicit ChromeURLRequestContext(ChromeURLRequestContext* other);
   virtual ~ChromeURLRequestContext();
 
  public:
   // Setters to simplify initializing from factory objects.
 
   void set_accept_language(const std::string& accept_language) {
     accept_language_ = accept_language;
   }
   void set_accept_charset(const std::string& accept_charset) {
     accept_charset_ = accept_charset;
   }
   void set_referrer_charset(const std::string& referrer_charset) {
     referrer_charset_ = referrer_charset;
   }
-  void set_cookie_policy_type(net::CookiePolicy::Type type) {
-    cookie_policy_.set_type(type);
-  }
   void set_extension_info(
       const ChromeURLRequestContext::ExtensionInfoMap& info) {
     extension_info_ = info;
   }
   void set_transport_security_state(
       net::TransportSecurityState* state) {
     transport_security_state_ = state;
   }
   void set_ssl_config_service(net::SSLConfigService* service) {
     ssl_config_service_ = service;
@@ skipping 32 matching lines @@
   void set_privacy_blacklist(Blacklist* privacy_blacklist) {
     privacy_blacklist_ = privacy_blacklist;
   }
   void set_appcache_service(ChromeAppCacheService* service) {
     appcache_service_ = service;
   }
 
   // Callback for when the accept language changes.
   void OnAcceptLanguageChange(const std::string& accept_language);
 
-  // Callback for when the cookie policy changes.
-  void OnCookiePolicyChange(net::CookiePolicy::Type type);
-
   // Callback for when the default charset changes.
   void OnDefaultCharsetChange(const std::string& default_charset);
 
  protected:
   ExtensionInfoMap extension_info_;
 
   // Path to the directory user scripts are stored in.
   FilePath user_script_dir_path_;
 
   scoped_refptr<ChromeAppCacheService> appcache_service_;
@@ skipping 101 matching lines @@
   // Creates a request context for media resources from a regular request
   // context. This helper method is called from CreateOriginalForMedia and
   // CreateOffTheRecordForMedia.
   static ChromeURLRequestContextGetter* CreateRequestContextForMedia(
       Profile* profile, const FilePath& disk_cache_path, int cache_size,
       bool off_the_record);
 
   // These methods simply forward to the corresponding method on
   // ChromeURLRequestContext.
   void OnAcceptLanguageChange(const std::string& accept_language);
-  void OnCookiePolicyChange(net::CookiePolicy::Type type);
   void OnDefaultCharsetChange(const std::string& default_charset);
 
   // Saves the cookie store to |result| and signals |completion|.
   void GetCookieStoreAsyncHelper(base::WaitableEvent* completion,
                                  net::CookieStore** result);
 
   // Access only from the UI thread.
   PrefService* prefs_;
 
   // Deferred logic for creating a ChromeURLRequestContext.
@@ skipping 33 matching lines @@
 
   // Values extracted from the Profile.
   //
   // NOTE: If you add any parameters here, keep it in sync with
   // ApplyProfileParametersToContext().
   bool is_media_;
   bool is_off_the_record_;
   std::string accept_language_;
   std::string accept_charset_;
   std::string referrer_charset_;
-  net::CookiePolicy::Type cookie_policy_type_;
   ChromeURLRequestContext::ExtensionInfoMap extension_info_;
   // TODO(aa): I think this can go away now as we no longer support standalone
   // user scripts.
   FilePath user_script_dir_path_;
   scoped_refptr<HostContentSettingsMap> host_content_settings_map_;
   scoped_refptr<HostZoomMap> host_zoom_map_;
   scoped_refptr<Blacklist> privacy_blacklist_;
   net::TransportSecurityState* transport_security_state_;
   scoped_refptr<net::SSLConfigService> ssl_config_service_;
 
   FilePath profile_dir_path_;
 
  private:
   IOThread* const io_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeURLRequestContextFactory);
 };
 
 // Creates a proxy configuration using the overrides specified on the command
 // line. Returns NULL if the system defaults should be used instead.
 net::ProxyConfig* CreateProxyConfig(const CommandLine& command_line);
 
 #endif  // CHROME_BROWSER_NET_CHROME_URL_REQUEST_CONTEXT_H_