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

include/cef_request_context.h

@@ -38,22 +38,26 @@
 #define CEF_INCLUDE_CEF_REQUEST_CONTEXT_H_
 #pragma once
 
+#include "include/cef_cookie.h"
 #include "include/cef_request_context_handler.h"
 
+class CefSchemeHandlerFactory;
+
 ///
 // A request context provides request handling for a set of related browser
-// objects. A request context is specified when creating a new browser object
-// via the CefBrowserHost static factory methods. Browser objects with different
-// request contexts will never be hosted in the same render process. Browser
-// objects with the same request context may or may not be hosted in the same
-// render process depending on the process model. Browser objects created
-// indirectly via the JavaScript window.open function or targeted links will
-// share the same render process and the same request context as the source
-// browser. When running in single-process mode there is only a single render
-// process (the main process) and so all browsers created in single-process mode
-// will share the same request context. This will be the first request context
-// passed into a CefBrowserHost static factory method and all other request
-// context objects will be ignored.
+// or URL request objects. A request context can be specified when creating a
+// new browser via the CefBrowserHost static factory methods or when creating a
+// new URL request via the CefURLRequest static factory methods. Browser objects
+// with different request contexts will never be hosted in the same render
+// process. Browser objects with the same request context may or may not be
+// hosted in the same render process depending on the process model. Browser
+// objects created indirectly via the JavaScript window.open function or
+// targeted links will share the same render process and the same request
+// context as the source browser. When running in single-process mode there is
+// only a single render process (the main process) and so all browsers created
+// in single-process mode will share the same request context. This will be the
+// first request context passed into a CefBrowserHost static factory method and
+// all other request context objects will be ignored.
 ///
 /*--cef(source=library,no_debugct_check)--*/
 class CefRequestContext : public virtual CefBase {
@@ -65,10 +69,21 @@ class CefRequestContext : public virtual CefBase {
   static CefRefPtr<CefRequestContext> GetGlobalContext();
 
   ///
-  // Creates a new context object with the specified handler.
+  // Creates a new context object with the specified |settings| and optional
+  // |handler|.
   ///
   /*--cef(optional_param=handler)--*/
   static CefRefPtr<CefRequestContext> CreateContext(
+      const CefRequestContextSettings& settings,
+      CefRefPtr<CefRequestContextHandler> handler);
+
+  ///
+  // Creates a new context object that shares storage with |other| and uses an
+  // optional |handler|.
+  ///
+  /*--cef(capi_name=create_context_shared,optional_param=handler)--*/
+  static CefRefPtr<CefRequestContext> CreateContext(
+      CefRefPtr<CefRequestContext> other,
       CefRefPtr<CefRequestContextHandler> handler);
 
   ///
@@ -79,7 +94,15 @@ class CefRequestContext : public virtual CefBase {
   virtual bool IsSame(CefRefPtr<CefRequestContext> other) =0;
 
   ///
-  // Returns true if this object is the global context.
+  // Returns true if this object is sharing the same storage as |that| object.
+  ///
+  /*--cef()--*/
+  virtual bool IsSharingWith(CefRefPtr<CefRequestContext> other) =0;
+
+  ///
+  // Returns true if this object is the global context. The global context is
+  // used by default when creating a browser or URL request with a NULL context
+  // argument.
   ///
   /*--cef()--*/
   virtual bool IsGlobal() =0;
@@ -89,6 +112,51 @@ class CefRequestContext : public virtual CefBase {
   ///
   /*--cef()--*/
   virtual CefRefPtr<CefRequestContextHandler> GetHandler() =0;
+
+  ///
+  // Returns the cache path for this object. If empty an "incognito mode"
+  // in-memory cache is being used.
+  ///
+  /*--cef()--*/
+  virtual CefString GetCachePath() =0;
+
+  ///
+  // Returns the default cookie manager for this object. This will be the global
+  // cookie manager if this object is the global request context. Otherwise,
+  // this will be the default cookie manager used when this request context does
+  // not receive a value via CefRequestContextHandler::GetCookieManager(). If
+  // |callback| is non-NULL it will be executed asnychronously on the IO thread
+  // after the manager's storage has been initialized.
+  ///
+  /*--cef(optional_param=callback)--*/
+  virtual CefRefPtr<CefCookieManager> GetDefaultCookieManager(
+      CefRefPtr<CefCompletionCallback> callback) =0;
+
+  ///
+  // Register a scheme handler factory for the specified |scheme_name| and
+  // optional |domain_name|. An empty |domain_name| value for a standard scheme
+  // will cause the factory to match all domain names. The |domain_name| value
+  // will be ignored for non-standard schemes. If |scheme_name| is a built-in
+  // scheme and no handler is returned by |factory| then the built-in scheme
+  // handler factory will be called. If |scheme_name| is a custom scheme then
+  // you must also implement the CefApp::OnRegisterCustomSchemes() method in all
+  // processes. This function may be called multiple times to change or remove
+  // the factory that matches the specified |scheme_name| and optional
+  // |domain_name|. Returns false if an error occurs. This function may be
+  // called on any thread in the browser process.
+  ///
+  /*--cef(optional_param=domain_name,optional_param=factory)--*/
+  virtual bool RegisterSchemeHandlerFactory(
+      const CefString& scheme_name,
+      const CefString& domain_name,
+      CefRefPtr<CefSchemeHandlerFactory> factory) =0;
+
+  ///
+  // Clear all registered scheme handler factories. Returns false on error. This
+  // function may be called on any thread in the browser process.
+  ///
+  /*--cef()--*/
+  virtual bool ClearSchemeHandlerFactories() =0;
 };
 
 #endif  // CEF_INCLUDE_CEF_REQUEST_CONTEXT_H_