Improvements to scheme handling (issue #246).

- Break CefRegisterScheme into separate CefRegisterCustomScheme and CefRegisterSchemeHandlerFactory functions.
- Allow registration of handlers for built-in schemes.
- Supply scheme and request information to CefSchemeHandlerFactory::Create.
- Add CrossOriginWhitelist functions for bypassing the same-origin policy with both built-in and custom standard schemes.

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

libcef_dll/cpptoc/scheme_handler_factory_cpptoc.cc

@@ -12,17 +12,22 @@
 
 #include "libcef_dll/cpptoc/scheme_handler_cpptoc.h"
 #include "libcef_dll/cpptoc/scheme_handler_factory_cpptoc.h"
+#include "libcef_dll/ctocpp/request_ctocpp.h"
 
 
 // MEMBER FUNCTIONS - Body may be edited by hand.
 
 struct _cef_scheme_handler_t* CEF_CALLBACK scheme_handler_factory_create(
-    struct _cef_scheme_handler_factory_t* self)
+    struct _cef_scheme_handler_factory_t* self, const cef_string_t* scheme_name,
+    cef_request_t* request)
 {
   CefRefPtr<CefSchemeHandler> rv =
-      CefSchemeHandlerFactoryCppToC::Get(self)->Create();
+      CefSchemeHandlerFactoryCppToC::Get(self)->Create(CefString(scheme_name),
+          CefRequestCToCpp::Wrap(request));
+  if (rv.get())
+    return CefSchemeHandlerCppToC::Wrap(rv);
 
-  return CefSchemeHandlerCppToC::Wrap(rv);
+  return NULL;
 }
 
 

libcef_dll/ctocpp/scheme_handler_factory_ctocpp.cc

@@ -10,20 +10,25 @@
 // tools directory for more information.
 //
 
+#include "libcef_dll/cpptoc/request_cpptoc.h"
 #include "libcef_dll/ctocpp/scheme_handler_ctocpp.h"
 #include "libcef_dll/ctocpp/scheme_handler_factory_ctocpp.h"
 
 
 // VIRTUAL METHODS - Body may be edited by hand.
 
-CefRefPtr<CefSchemeHandler> CefSchemeHandlerFactoryCToCpp::Create()
+CefRefPtr<CefSchemeHandler> CefSchemeHandlerFactoryCToCpp::Create(
+    const CefString& scheme_name, CefRefPtr<CefRequest> request)
 {
   if(CEF_MEMBER_MISSING(struct_, create))
     return NULL;
 
-  _cef_scheme_handler_t* rv = struct_->create(struct_);
+  cef_scheme_handler_t* rv = struct_->create(struct_, scheme_name.GetStruct(),
+      CefRequestCppToC::Wrap(request));
+  if (rv)
+    return CefSchemeHandlerCToCpp::Wrap(rv);
 
-  return CefSchemeHandlerCToCpp::Wrap(rv);
+  return NULL;
 }
 
 

libcef_dll/ctocpp/scheme_handler_factory_ctocpp.h

@@ -33,7 +33,8 @@ public:
   virtual ~CefSchemeHandlerFactoryCToCpp() {}
 
   // CefSchemeHandlerFactory methods
-  virtual CefRefPtr<CefSchemeHandler> Create() OVERRIDE;
+  virtual CefRefPtr<CefSchemeHandler> Create(const CefString& scheme_name,
+      CefRefPtr<CefRequest> request) OVERRIDE;
 };
 
 #endif // BUILDING_CEF_SHARED

libcef_dll/libcef_dll.cc

@@ -118,17 +118,71 @@ CEF_EXPORT int cef_register_plugin(const cef_plugin_info_t* plugin_info)
   return CefRegisterPlugin(*plugin_info);
 }
 
-CEF_EXPORT int cef_register_scheme(const cef_string_t* scheme_name,
-    const cef_string_t* host_name, int is_standard,
+CEF_EXPORT int cef_register_custom_scheme(const cef_string_t* scheme_name,
+    int is_standard, int is_local, int is_display_isolated)
+{
+  DCHECK(scheme_name);
+  if (!scheme_name)
+    return 0;
+
+  return CefRegisterCustomScheme(CefString(scheme_name), is_standard?true:false,
+    is_local?true:false, is_display_isolated?true:false);
+}
+
+CEF_EXPORT int cef_register_scheme_handler_factory(
+    const cef_string_t* scheme_name, const cef_string_t* domain_name,
     struct _cef_scheme_handler_factory_t* factory)
 {
   DCHECK(scheme_name);
-  DCHECK(factory);
-  if(!scheme_name || !factory)
+  if (!scheme_name)
     return 0;
 
-  return CefRegisterScheme(CefString(scheme_name), CefString(host_name),
-      (is_standard?true:false), CefSchemeHandlerFactoryCToCpp::Wrap(factory));
+  CefRefPtr<CefSchemeHandlerFactory> factoryPtr;
+  if (factory)
+    factoryPtr = CefSchemeHandlerFactoryCToCpp::Wrap(factory);
+
+  return CefRegisterSchemeHandlerFactory(CefString(scheme_name),
+      CefString(domain_name), factoryPtr);
+}
+
+CEF_EXPORT int cef_clear_scheme_handler_factories()
+{
+  return CefClearSchemeHandlerFactories();
+}
+
+CEF_EXPORT int cef_add_cross_origin_whitelist_entry(
+    const cef_string_t* source_origin, const cef_string_t* target_protocol,
+    const cef_string_t* target_domain, int allow_target_subdomains)
+{
+  DCHECK(source_origin);
+  DCHECK(target_protocol);
+  DCHECK(target_domain);
+  if (!source_origin || !target_protocol || !target_domain)
+    return 0;
+
+  return CefAddCrossOriginWhitelistEntry(CefString(source_origin),
+      CefString(target_protocol), CefString(target_domain),
+      allow_target_subdomains?true:false);
+}
+
+CEF_EXPORT int cef_remove_cross_origin_whitelist_entry(
+    const cef_string_t* source_origin, const cef_string_t* target_protocol,
+    const cef_string_t* target_domain, int allow_target_subdomains)
+{
+  DCHECK(source_origin);
+  DCHECK(target_protocol);
+  DCHECK(target_domain);
+  if (!source_origin || !target_protocol || !target_domain)
+    return 0;
+
+  return CefRemoveCrossOriginWhitelistEntry(CefString(source_origin),
+      CefString(target_protocol), CefString(target_domain),
+      allow_target_subdomains?true:false);
+}
+
+CEF_EXPORT int cef_clear_cross_origin_whitelist()
+{
+  return CefClearCrossOriginWhitelist();
 }
 
 CEF_EXPORT int cef_currently_on(cef_thread_id_t threadId)

libcef_dll/wrapper/libcef_dll_wrapper.cc

@@ -99,13 +99,55 @@ bool CefRegisterPlugin(const CefPluginInfo& plugin_info)
   return cef_register_plugin(&plugin_info)?true:false;
 }
 
-bool CefRegisterScheme(const CefString& scheme_name,
-                       const CefString& host_name,
-                       bool is_standard,
-                       CefRefPtr<CefSchemeHandlerFactory> factory)
+bool CefRegisterCustomScheme(const CefString& scheme_name,
+                             bool is_standard,
+                             bool is_local,
+                             bool is_display_isolated)
 {
-  return cef_register_scheme(scheme_name.GetStruct(), host_name.GetStruct(),
-      is_standard, CefSchemeHandlerFactoryCppToC::Wrap(factory))?true:false;
+  return cef_register_custom_scheme(scheme_name.GetStruct(), is_standard,
+      is_local, is_display_isolated)?true:false;
+}
+
+bool CefRegisterSchemeHandlerFactory(const CefString& scheme_name,
+                                     const CefString& domain_name,
+                                     CefRefPtr<CefSchemeHandlerFactory> factory)
+{
+  cef_scheme_handler_factory_t* factory_struct = NULL;
+  if (factory.get())
+    factory_struct = CefSchemeHandlerFactoryCppToC::Wrap(factory);
+  
+  return cef_register_scheme_handler_factory(scheme_name.GetStruct(),
+      domain_name.GetStruct(), factory_struct)?true:false;
+}
+
+bool CefClearSchemeHandlerFactories()
+{
+  return cef_clear_scheme_handler_factories()?true:false;
+}
+
+bool CefAddCrossOriginWhitelistEntry(const CefString& source_origin,
+                                     const CefString& target_protocol,
+                                     const CefString& target_domain,
+                                     bool allow_target_subdomains)
+{
+  return cef_add_cross_origin_whitelist_entry(source_origin.GetStruct(),
+      target_protocol.GetStruct(), target_domain.GetStruct(),
+      allow_target_subdomains)?true:false;
+}
+
+bool CefRemoveCrossOriginWhitelistEntry(const CefString& source_origin,
+                                        const CefString& target_protocol,
+                                        const CefString& target_domain,
+                                        bool allow_target_subdomains)
+{
+  return cef_remove_cross_origin_whitelist_entry(source_origin.GetStruct(),
+      target_protocol.GetStruct(), target_domain.GetStruct(),
+      allow_target_subdomains)?true:false;
+}
+
+bool CefClearCrossOriginWhitelist()
+{
+  return cef_clear_cross_origin_whitelist()?true:false;
 }
 
 bool CefCurrentlyOn(CefThreadId threadId)