Implement Javascript Binding v2

CefSharp.BrowserSubprocess.Core/CefAppUnmanagedWrapper.cpp

@@ -8,6 +8,7 @@
 #include "include\base\cef_logging.h"
 #include "CefBrowserWrapper.h"
 #include "CefAppUnmanagedWrapper.h"
+#include "RegisterBoundObjectHandler.h"
 #include "JavascriptRootObjectWrapper.h"
 #include "Serialization\V8Serialization.h"
 #include "Serialization\JsObjectsSerialization.h"
@@ -72,29 +73,40 @@ namespace CefSharp
             browser->SendProcessMessage(CefProcessId::PID_BROWSER, contextCreatedMessage);
         }
 
-        auto browserWrapper = FindBrowserWrapper(browser->GetIdentifier(), true);
-
-        auto rootObjectWrappers = browserWrapper->JavascriptRootObjectWrappers;
-        auto frameId = frame->GetIdentifier();
-
-        JavascriptRootObjectWrapper^ rootObject;
-        if (!rootObjectWrappers->TryGetValue(frameId, rootObject))
+        if (_legacyBindingEnabled)
         {
-            rootObject = gcnew JavascriptRootObjectWrapper(browser->GetIdentifier(), browserWrapper->BrowserProcess);
-            rootObjectWrappers->TryAdd(frameId, rootObject);
-        }
+            auto browserWrapper = FindBrowserWrapper(browser->GetIdentifier(), true);
 
-        if (rootObject->IsBound)
-        {
-            LOG(WARNING) << "A context has been created for the same browser / frame without context released called previously";
-        }
-        else
-        {
-            if (!Object::ReferenceEquals(_javascriptRootObject, nullptr) || !Object::ReferenceEquals(_javascriptAsyncRootObject, nullptr))
+            auto rootObjectWrappers = browserWrapper->JavascriptRootObjectWrappers;
+            auto frameId = frame->GetIdentifier();
+
+            if (_javascriptObjects->Count > 0)
             {
-                rootObject->Bind(_javascriptRootObject, _javascriptAsyncRootObject, context->GetGlobal());
+                JavascriptRootObjectWrapper^ rootObject;
+                if (!rootObjectWrappers->TryGetValue(frameId, rootObject))
+                {
+                    rootObject = gcnew JavascriptRootObjectWrapper(browser->GetIdentifier(), browserWrapper->BrowserProcess);
+                    rootObjectWrappers->TryAdd(frameId, rootObject);
+                }
+
+                rootObject->Bind(_javascriptObjects->Values, context->GetGlobal());
             }
         }
+
+        auto global = context->GetGlobal();
+
+        auto cefSharpObj = CefV8Value::CreateObject(NULL, NULL);
+        global->SetValue("CefSharp", cefSharpObj, CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_READONLY);
+
+        auto bindObjAsyncFunction = CefV8Value::CreateFunction("BindObjectAsync", new RegisterBoundObjectHandler(_registerBoundObjectRegistry, _javascriptObjects));
+        cefSharpObj->SetValue("BindObjectAsync", bindObjAsyncFunction, CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_NONE);
+
+        auto unBindObFunction = CefV8Value::CreateFunction("DeleteBoundObject", new RegisterBoundObjectHandler(_registerBoundObjectRegistry, _javascriptObjects));
+        cefSharpObj->SetValue("DeleteBoundObject", unBindObFunction, CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_NONE);
+
+        //TODO: JSB We could in theory auto bind all the cached objects which would resemble the original JSB behaviour, if
+        //the cache is empty which would be the case for any cross-site navigation request or the first request made to a browser instance
+        //then no objects would be bound by default
     };
 
     void CefAppUnmanagedWrapper::OnContextReleased(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, CefRefPtr<CefV8Context> context)
@@ -190,7 +202,7 @@ namespace CefSharp
         if (browserWrapper == nullptr)
         {
             if (name == kJavascriptCallbackDestroyRequest ||
-                name == kJavascriptRootObjectRequest ||
+                name == kJavascriptRootObjectResponse ||
                 name == kJavascriptAsyncMethodCallResponse)
             {
                 //If we can't find the browser wrapper then we'll just
@@ -398,10 +410,78 @@ namespace CefSharp
 
             handled = true;
         }
-        else if (name == kJavascriptRootObjectRequest)
+        else if (name == kJavascriptRootObjectResponse)
         {
-            _javascriptAsyncRootObject = DeserializeJsRootObject(argList, 0);
-            _javascriptRootObject = DeserializeJsRootObject(argList, 1);
+            auto useLegacyBehaviour = argList->GetBool(0);
+
+            //For the old legacy behaviour we add the objects
+            //to the cache
+            if (useLegacyBehaviour)
+            {
+                _legacyBindingEnabled = true;
+
+                auto javascriptObjects = DeserializeJsObjects(argList, 4);
+
+                for each (JavascriptObject^ obj in Enumerable::OfType<JavascriptObject^>(javascriptObjects))
+                {
+                    _javascriptObjects->Add(obj->JavascriptName, obj);
+                }
+            }
+            else
+            {
+                auto browserId = argList->GetInt(1);
+                auto frameId = GetInt64(argList, 2);
+                auto callbackId = GetInt64(argList, 3);
+                auto javascriptObjects = DeserializeJsObjects(argList, 4);
+
+                //TODO: JSB Implement Caching of JavascriptObjects
+                //Should caching be configurable? On a per object basis?
+                /*for each (JavascriptObject^ obj in Enumerable::OfType<JavascriptObject^>(javascriptObjects))
+                {
+                    if (_javascriptObjects->ContainsKey(obj->JavascriptName))
+                    {
+                        _javascriptObjects->Remove(obj->JavascriptName);
+                    }
+                    _javascriptObjects->Add(obj->JavascriptName, obj);
+                }*/
+
+                auto browserWrapper = FindBrowserWrapper(browser->GetIdentifier(), true);
+
+                auto rootObjectWrappers = browserWrapper->JavascriptRootObjectWrappers;
+                auto frame = browser->GetFrame(frameId);
+                if (frame.get())
+                {
+                    JavascriptRootObjectWrapper^ rootObject;
+                    if (!rootObjectWrappers->TryGetValue(frameId, rootObject))
+                    {
+                        rootObject = gcnew JavascriptRootObjectWrapper(browser->GetIdentifier(), browserWrapper->BrowserProcess);
+                        rootObjectWrappers->TryAdd(frameId, rootObject);
+                    }
+
+                    auto context = frame->GetV8Context();
+
+                    if (context.get() && context->Enter())
+                    {
+                        try
+                        {
+                            rootObject->Bind(javascriptObjects, context->GetGlobal());
+
+                            JavascriptAsyncMethodCallback^ callback;
+                            if (_registerBoundObjectRegistry->TryGetAndRemoveMethodCallback(callbackId, callback))
+                            {
+                                callback->Success(CefV8Value::CreateBool(true));
+
+                                //TODO: JSB deal with failure - no object matching bound
+                            }
+                        }
+                        finally
+                        {
+                            context->Exit();
+                        }
+                    }
+                }
+            }
+
             handled = true;
         }
         else if (name == kJavascriptAsyncMethodCallResponse)

CefSharp.BrowserSubprocess.Core/CefAppUnmanagedWrapper.h

@@ -9,6 +9,7 @@
 #include "include/cef_base.h"
 
 #include "CefBrowserWrapper.h"
+#include "RegisterBoundObjectRegistry.h"
 
 using namespace System::Collections::Generic;
 
@@ -26,12 +27,12 @@ namespace CefSharp
         gcroot<List<CefExtension^>^> _extensions;
         gcroot<List<CefCustomScheme^>^> _schemes;
         bool _focusedNodeChangedEnabled;
-
-        // The serialized registered object data waiting to be used (only contains methods and bound async).
-        gcroot<JavascriptRootObject^> _javascriptAsyncRootObject;
+        bool _legacyBindingEnabled;
 
         // The serialized registered object data waiting to be used.
-        gcroot<JavascriptRootObject^> _javascriptRootObject;
+        gcroot<Dictionary<String^, JavascriptObject^>^> _javascriptObjects;
+
+        gcroot<RegisterBoundObjectRegistry^> _registerBoundObjectRegistry;
 
     public:
         static const CefString kPromiseCreatorFunction;
@@ -44,6 +45,9 @@ namespace CefSharp
             _extensions = gcnew List<CefExtension^>();
             _schemes = schemes;
             _focusedNodeChangedEnabled = enableFocusedNodeChanged;
+            _javascriptObjects = gcnew Dictionary<String^, JavascriptObject^>();
+            _registerBoundObjectRegistry = gcnew RegisterBoundObjectRegistry();
+            _legacyBindingEnabled = false;
         }
 
         ~CefAppUnmanagedWrapper()

CefSharp.BrowserSubprocess.Core/CefBrowserWrapper.h

@@ -10,7 +10,6 @@
 #include "TypeUtils.h"
 #include "Stdafx.h"
 #include "JavascriptRootObjectWrapper.h"
-#include "Async/JavascriptAsyncMethodCallback.h"
 
 using namespace CefSharp::Internals::Async;
 using namespace System::ServiceModel;
@@ -27,6 +26,7 @@ namespace CefSharp
         MCefRefPtr<CefBrowser> _cefBrowser;
 
     internal:
+        //Frame Identifier is used as Key
         property ConcurrentDictionary<int64, JavascriptRootObjectWrapper^>^ JavascriptRootObjectWrappers;
 
     public:

CefSharp.BrowserSubprocess.Core/CefSharp.BrowserSubprocess.Core.vcxproj

@@ -171,6 +171,8 @@
     <ClInclude Include="Async\JavascriptAsyncMethodWrapper.h" />
     <ClInclude Include="Async\JavascriptAsyncObjectWrapper.h" />
     <ClInclude Include="CefAppUnmanagedWrapper.h" />
+    <ClInclude Include="RegisterBoundObjectHandler.h" />
+    <ClInclude Include="RegisterBoundObjectRegistry.h" />
     <ClInclude Include="resource.h" />
     <ClInclude Include="WcfEnabledSubProcess.h" />
     <ClInclude Include="SubProcess.h" />

CefSharp.BrowserSubprocess.Core/CefSharp.BrowserSubprocess.Core.vcxproj.filters

@@ -92,6 +92,12 @@
     <ClInclude Include="resource.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="RegisterBoundObjectHandler.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="RegisterBoundObjectRegistry.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="AssemblyInfo.cpp">

CefSharp.BrowserSubprocess.Core/JavascriptRootObjectWrapper.cpp

@@ -12,38 +12,29 @@ using namespace System::Threading;
 
 namespace CefSharp
 {
-    void JavascriptRootObjectWrapper::Bind(JavascriptRootObject^ rootObject, JavascriptRootObject^ asyncRootObject, const CefRefPtr<CefV8Value>& v8Value)
+    void JavascriptRootObjectWrapper::Bind(ICollection<JavascriptObject^>^ objects, const CefRefPtr<CefV8Value>& v8Value)
     {
-        if (_isBound)
+        if (objects->Count > 0)
         {
-            throw gcnew InvalidOperationException("This root object has already been bound.");
-        }
-
-        _isBound = true;
-
-        if (rootObject != nullptr)
-        {
-            auto memberObjects = rootObject->MemberObjects;
-            for each (JavascriptObject^ obj in Enumerable::OfType<JavascriptObject^>(memberObjects))
-            {
-                auto wrapperObject = gcnew JavascriptObjectWrapper(_browserProcess);
-                wrapperObject->Bind(obj, v8Value, _callbackRegistry);
-
-                _wrappedObjects->Add(wrapperObject);
-            }
-        }
-
-        if (asyncRootObject != nullptr)
-        {
-            auto memberObjects = asyncRootObject->MemberObjects;
             auto saveMethod = gcnew Func<JavascriptAsyncMethodCallback^, int64>(this, &JavascriptRootObjectWrapper::SaveMethodCallback);
             auto promiseCreator = v8Value->GetValue(CefAppUnmanagedWrapper::kPromiseCreatorFunction);
-            for each (JavascriptObject^ obj in Enumerable::OfType<JavascriptObject^>(memberObjects))
-            {
-                auto wrapperObject = gcnew JavascriptAsyncObjectWrapper(_callbackRegistry, saveMethod);
-                wrapperObject->Bind(obj, v8Value, promiseCreator);
 
-                _wrappedAsyncObjects->Add(wrapperObject);
+            for each (JavascriptObject^ obj in Enumerable::OfType<JavascriptObject^>(objects))
+            {
+                if (obj->IsAsync)
+                {
+                    auto wrapperObject = gcnew JavascriptAsyncObjectWrapper(_callbackRegistry, saveMethod);
+                    wrapperObject->Bind(obj, v8Value, promiseCreator);
+
+                    _wrappedAsyncObjects->Add(wrapperObject);
+                }
+                else
+                {
+                    auto wrapperObject = gcnew JavascriptObjectWrapper(_browserProcess);
+                    wrapperObject->Bind(obj, v8Value, _callbackRegistry);
+
+                    _wrappedObjects->Add(wrapperObject);
+                }
             }
         }
     }
@@ -53,12 +44,6 @@ namespace CefSharp
         return _callbackRegistry;
     }
 
-    bool JavascriptRootObjectWrapper::IsBound::get()
-    {
-        return _isBound;
-    }
-
-
     int64 JavascriptRootObjectWrapper::SaveMethodCallback(JavascriptAsyncMethodCallback^ callback)
     {
         auto callbackId = Interlocked::Increment(_lastCallback);

CefSharp.BrowserSubprocess.Core/JavascriptRootObjectWrapper.h

@@ -27,7 +27,6 @@ namespace CefSharp
         initonly List<JavascriptObjectWrapper^>^ _wrappedObjects;
         initonly List<JavascriptAsyncObjectWrapper^>^ _wrappedAsyncObjects;
         initonly Dictionary<int64, JavascriptAsyncMethodCallback^>^ _methodCallbacks;
-        bool _isBound;
         int64 _lastCallback;
         IBrowserProcess^ _browserProcess;
         // The entire set of possible JavaScript functions to
@@ -42,11 +41,6 @@ namespace CefSharp
             CefSharp::Internals::JavascriptCallbackRegistry^ get();
         }
 
-        property bool IsBound
-        {
-            bool get();
-        }
-
     public:
         JavascriptRootObjectWrapper(int browserId, IBrowserProcess^ browserProcess)
         {
@@ -55,7 +49,6 @@ namespace CefSharp
             _wrappedAsyncObjects = gcnew List<JavascriptAsyncObjectWrapper^>();
             _callbackRegistry = gcnew JavascriptCallbackRegistry(browserId);
             _methodCallbacks = gcnew Dictionary<int64, JavascriptAsyncMethodCallback^>();
-            _isBound = false;
         }
 
         ~JavascriptRootObjectWrapper()
@@ -87,7 +80,7 @@ namespace CefSharp
 
         bool TryGetAndRemoveMethodCallback(int64 id, JavascriptAsyncMethodCallback^% callback);
 
-        void Bind(JavascriptRootObject^ rootObject, JavascriptRootObject^ asyncRootObject, const CefRefPtr<CefV8Value>& v8Value);
+        void Bind(ICollection<JavascriptObject^>^ objects, const CefRefPtr<CefV8Value>& v8Value);
     };
 }