Add support for complete isolation of storage and permissions (cache, cookies, localStorage, access grants, etc) on a per-request-context basis (issue #1044).

- CefRequestContext instances can be configured using a new CefRequestContextSettings structure passed to CefRequestContext::CreateContext.
- Scheme registration is now per-request-context using new CefRequestContext::RegisterSchemeHandlerFactory and ClearSchemeHandlerFactories methods.
- Cookie managers are now per-request-context by default and can be retrieved using a new CefRequestContext::GetDefaultCookieManager method.
- CefURLRequest::Create now accepts an optional CefRequestContext argument for associating a URL request with a context (browser process only).
- The CefRequestContextHandler associated with a CefRequestContext will not be released until all objects related to that context have been destroyed.
- When the cache path is empty an in-memory cache ("incognito mode") will be used for storage and no data will be persisted to disk.
- Add CefSettings.user_data_path which specifies the location where user data such as spell checking dictionary files will be stored on disk.
- Add asynchronous callbacks for all CefCookieManager methods.
- Add PK_LOCAL_APP_DATA and PK_USER_DATA path keys for retrieving user directories via CefGetPath.
- cefclient: Add "New Window" test that creates a new window unrelated to existing windows. When used in combination with `--request-context-per-browser` the new window will be given a new and isolated request context.

git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@2040 5089003a-bbd8-11dd-ad1f-f1f9622dbc98

libcef/browser/cookie_manager_impl.h

@@ -6,45 +6,113 @@
 #define CEF_LIBCEF_BROWSER_COOKIE_MANAGER_IMPL_H_
 
 #include "include/cef_cookie.h"
+#include "libcef/browser/request_context_impl.h"
+
 #include "base/files/file_path.h"
 #include "net/cookies/cookie_monster.h"
 
 // Implementation of the CefCookieManager interface.
 class CefCookieManagerImpl : public CefCookieManager {
  public:
-  CefCookieManagerImpl(bool is_global);
+  CefCookieManagerImpl();
   ~CefCookieManagerImpl() override;
 
-  // Initialize the cookie manager.
-  void Initialize(const CefString& path,
-                  bool persist_session_cookies);
+  // Must be called immediately after this object is created.
+  void Initialize(CefRefPtr<CefRequestContextImpl> request_context,
+                  const CefString& path,
+                  bool persist_session_cookies,
+                  CefRefPtr<CefCompletionCallback> callback);
+
+  // Executes |callback| either synchronously or asynchronously with the cookie
+  // monster object when it's available. If |task_runner| is NULL the callback
+  // will be executed on the originating thread. The resulting cookie monster
+  // object can only be accessed on the IO thread.
+  typedef base::Callback<void(scoped_refptr<net::CookieMonster>)>
+      CookieMonsterCallback;
+  void GetCookieMonster(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+      const CookieMonsterCallback& callback);
+
+  // Returns the existing cookie monster object. Logs an error if the cookie
+  // monster does not yet exist. Must be called on the IO thread.
+  scoped_refptr<net::CookieMonster> GetExistingCookieMonster();
 
   // CefCookieManager methods.
-  void SetSupportedSchemes(const std::vector<CefString>& schemes) override;
+  void SetSupportedSchemes(const std::vector<CefString>& schemes,
+                           CefRefPtr<CefCompletionCallback> callback) override;
   bool VisitAllCookies(CefRefPtr<CefCookieVisitor> visitor) override;
   bool VisitUrlCookies(const CefString& url, bool includeHttpOnly,
                        CefRefPtr<CefCookieVisitor> visitor) override;
   bool SetCookie(const CefString& url,
-                 const CefCookie& cookie) override;
+                 const CefCookie& cookie,
+                 CefRefPtr<CefSetCookieCallback> callback) override;
   bool DeleteCookies(const CefString& url,
-                     const CefString& cookie_name) override;
+                     const CefString& cookie_name,
+                     CefRefPtr<CefDeleteCookiesCallback> callback) override;
   bool SetStoragePath(const CefString& path,
-                      bool persist_session_cookies) override;
+                      bool persist_session_cookies,
+                      CefRefPtr<CefCompletionCallback> callback) override;
   bool FlushStore(CefRefPtr<CefCompletionCallback> callback) override;
 
-  net::CookieMonster* cookie_monster() { return cookie_monster_.get(); }
-
   static bool GetCefCookie(const net::CanonicalCookie& cc, CefCookie& cookie);
   static bool GetCefCookie(const GURL& url, const std::string& cookie_line,
                            CefCookie& cookie);
 
  private:
-  void SetGlobal();
+  // Returns true if a context is or will be available.
+  bool HasContext();
 
-  scoped_refptr<net::CookieMonster> cookie_monster_;
-  bool is_global_;
+  // Execute |method| on the IO thread once the request context is available.
+  void RunMethodWithContext(
+      const CefRequestContextImpl::RequestContextCallback& method);
+
+  void InitWithContext(
+      CefRefPtr<CefCompletionCallback> callback,
+      scoped_refptr<CefURLRequestContextGetterImpl> request_context);
+  void SetStoragePathWithContext(
+      const CefString& path,
+      bool persist_session_cookies,
+      CefRefPtr<CefCompletionCallback> callback,
+      scoped_refptr<CefURLRequestContextGetterImpl> request_context);
+  void SetSupportedSchemesWithContext(
+      const std::vector<CefString>& schemes,
+      CefRefPtr<CefCompletionCallback> callback,
+      scoped_refptr<CefURLRequestContextGetterImpl> request_context);
+  void GetCookieMonsterWithContext(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+      const CookieMonsterCallback& callback,
+      scoped_refptr<CefURLRequestContextGetterImpl> request_context);
+
+  void VisitAllCookiesInternal(
+      CefRefPtr<CefCookieVisitor> visitor,
+      scoped_refptr<net::CookieMonster> cookie_monster);
+  void VisitUrlCookiesInternal(
+      const CefString& url,
+      bool includeHttpOnly,
+      CefRefPtr<CefCookieVisitor> visitor,
+      scoped_refptr<net::CookieMonster> cookie_monster);
+  void SetCookieInternal(
+      const GURL& url,
+      const CefCookie& cookie,
+      CefRefPtr<CefSetCookieCallback> callback,
+      scoped_refptr<net::CookieMonster> cookie_monster);
+  void DeleteCookiesInternal(
+      const GURL& url,
+      const CefString& cookie_name,
+      CefRefPtr<CefDeleteCookiesCallback> callback,
+      scoped_refptr<net::CookieMonster> cookie_monster);
+  void FlushStoreInternal(
+      CefRefPtr<CefCompletionCallback> callback,
+      scoped_refptr<net::CookieMonster> cookie_monster);
+
+  // Used for cookie monsters owned by the context.
+  CefRefPtr<CefRequestContextImpl> request_context_;
+  scoped_refptr<CefURLRequestContextGetterImpl> request_context_impl_;
+
+  // Used for cookie monsters owned by this object.
   base::FilePath storage_path_;
   std::vector<CefString> supported_schemes_;
+  scoped_refptr<net::CookieMonster> cookie_monster_;
 
   IMPLEMENT_REFCOUNTING(CefCookieManagerImpl);
 };