// Copyright © 2014 The CefSharp Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.

#pragma once

#include "Stdafx.h"

#include "CefBrowserWrapper.h"
#include "CefAppUnmanagedWrapper.h"
#include "RegisterBoundObjectHandler.h"
#include "BindObjectAsyncHandler.h"
#include "JavascriptPostMessageHandler.h"
#include "JavascriptRootObjectWrapper.h"
#include "Async\JavascriptAsyncMethodCallback.h"
#include "Serialization\V8Serialization.h"
#include "Serialization\JsObjectsSerialization.h"
#include "Wrapper\V8Context.h"
#include "Wrapper\Frame.h"
#include "Wrapper\Browser.h"
#include "..\CefSharp.Core\Internals\Messaging\Messages.h"
#include "..\CefSharp.Core\Internals\Serialization\Primitives.h"

using namespace System;
using namespace System::Diagnostics;
using namespace System::Collections::Generic;
using namespace CefSharp::BrowserSubprocess;
using namespace CefSharp::Internals::Messaging;
using namespace CefSharp::Internals::Serialization;

namespace CefSharp
{
    const CefString CefAppUnmanagedWrapper::kPromiseCreatorScript = ""
        "(function()"
        "{"
        "   var result = {};"
        "   var promise = new Promise(function(resolve, reject) {"
        "       result.res = resolve; result.rej = reject;"
        "   });"
        "   result.p = promise;"
        "   return result;"
        "})();";

    CefRefPtr<CefRenderProcessHandler> CefAppUnmanagedWrapper::GetRenderProcessHandler()
    {
        return this;
    };

    // CefRenderProcessHandler
    void CefAppUnmanagedWrapper::OnBrowserCreated(CefRefPtr<CefBrowser> browser, CefRefPtr<CefDictionaryValue> extraInfo)
    {
        auto wrapper = gcnew CefBrowserWrapper(browser);
        _onBrowserCreated->Invoke(wrapper);

        //Multiple CefBrowserWrappers created when opening popups
        _browserWrappers->TryAdd(browser->GetIdentifier(), wrapper);

        //For the main browser only we check LegacyBindingEnabled and
        //load the objects. Popups don't send this information and checking
        //will override the _legacyBindingEnabled field
        if (!browser->IsPopup())
        {
            _legacyBindingEnabled = extraInfo->GetBool("LegacyBindingEnabled");

            if (_legacyBindingEnabled)
            {
                auto objects = extraInfo->GetList("LegacyBindingObjects");
                if (objects.get() && objects->IsValid())
                {
                    auto javascriptObjects = DeserializeJsObjects(objects, 0);

                    for each (JavascriptObject^ obj in Enumerable::OfType<JavascriptObject^>(javascriptObjects))
                    {
                        //Using LegacyBinding with multiple ChromiumWebBrowser instances that share the same
                        //render process and using LegacyBinding will cause problems for the limited caching implementation
                        //that exists at the moment, for now we'll remove an object if already exists, same behaviour
                        //as the new binding method. 
                        //TODO: This should be removed when https://github.com/cefsharp/CefSharp/issues/2306
                        //Is complete as objects will be stored at the browser level
                        if (_javascriptObjects->ContainsKey(obj->JavascriptName))
                        {
                            _javascriptObjects->Remove(obj->JavascriptName);
                        }
                        _javascriptObjects->Add(obj->JavascriptName, obj);
                    }
                }
            }
        }
    }

    void CefAppUnmanagedWrapper::OnBrowserDestroyed(CefRefPtr<CefBrowser> browser)
    {
        CefBrowserWrapper^ wrapper;
        if (_browserWrappers->TryRemove(browser->GetIdentifier(), wrapper))
        {
            _onBrowserDestroyed->Invoke(wrapper);
            delete wrapper;
        }
    };

    void CefAppUnmanagedWrapper::OnContextCreated(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, CefRefPtr<CefV8Context> context)
    {
        if (!Object::ReferenceEquals(_handler, nullptr))
        {
            Browser browserWrapper(browser);
            Frame frameWrapper(frame);
            V8Context contextWrapper(context);

            _handler->OnContextCreated(%browserWrapper, %frameWrapper, %contextWrapper);
        }

        auto rootObject = GetJsRootObjectWrapper(browser->GetIdentifier(), frame->GetIdentifier());

        if (_legacyBindingEnabled)
        {
            if (_javascriptObjects->Count > 0 && rootObject != nullptr)
            {
                rootObject->Bind(_javascriptObjects->Values, context->GetGlobal());
            }
        }

        //TODO: Look at adding some sort of javascript mapping layer to reduce the code duplication
        auto global = context->GetGlobal();
        auto browserWrapper = FindBrowserWrapper(browser->GetIdentifier());

        auto cefSharpObj = CefV8Value::CreateObject(NULL, NULL);
        global->SetValue("CefSharp", cefSharpObj, CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_READONLY);

        //We'll support both CefSharp and cefSharp, for those who prefer the JS style
        auto cefSharpObjCamelCase = CefV8Value::CreateObject(NULL, NULL);
        global->SetValue("cefSharp", cefSharpObjCamelCase, CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_READONLY);

        //TODO: JSB: Split functions into their own classes
        //Browser wrapper is only used for BindObjectAsync
        auto bindObjAsyncFunction = CefV8Value::CreateFunction(kBindObjectAsync, new BindObjectAsyncHandler(_registerBoundObjectRegistry, _javascriptObjects, browserWrapper));
        auto unBindObjFunction = CefV8Value::CreateFunction(kDeleteBoundObject, new RegisterBoundObjectHandler(_javascriptObjects));
        auto removeObjectFromCacheFunction = CefV8Value::CreateFunction(kRemoveObjectFromCache, new RegisterBoundObjectHandler(_javascriptObjects));
        auto isObjectCachedFunction = CefV8Value::CreateFunction(kIsObjectCached, new RegisterBoundObjectHandler(_javascriptObjects));
        auto postMessageFunction = CefV8Value::CreateFunction(kPostMessage, new JavascriptPostMessageHandler(rootObject == nullptr ? nullptr : rootObject->CallbackRegistry));

        cefSharpObj->SetValue(kBindObjectAsync, bindObjAsyncFunction, CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_NONE);
        cefSharpObj->SetValue(kDeleteBoundObject, unBindObjFunction, CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_NONE);
        cefSharpObj->SetValue(kRemoveObjectFromCache, removeObjectFromCacheFunction, CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_NONE);
        cefSharpObj->SetValue(kIsObjectCached, isObjectCachedFunction, CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_NONE);
        cefSharpObj->SetValue(kPostMessage, postMessageFunction, CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_NONE);

        cefSharpObjCamelCase->SetValue(kBindObjectAsyncCamelCase, bindObjAsyncFunction, CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_NONE);
        cefSharpObjCamelCase->SetValue(kDeleteBoundObjectCamelCase, unBindObjFunction, CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_NONE);
        cefSharpObjCamelCase->SetValue(kRemoveObjectFromCacheCamelCase, removeObjectFromCacheFunction, CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_NONE);
        cefSharpObjCamelCase->SetValue(kIsObjectCachedCamelCase, isObjectCachedFunction, CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_NONE);
        cefSharpObjCamelCase->SetValue(kPostMessageCamelCase, postMessageFunction, CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_NONE);

        //Send a message to the browser processing signaling that OnContextCreated has been called
        //only param is the FrameId. Previous sent only for main frame, now sent for all frames
        //Message sent after legacy objects have been bound and the CefSharp bind async helper methods
        //have been created
        auto contextCreatedMessage = CefProcessMessage::Create(kOnContextCreatedRequest);

        frame->SendProcessMessage(CefProcessId::PID_BROWSER, contextCreatedMessage);
    };

    void CefAppUnmanagedWrapper::OnContextReleased(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, CefRefPtr<CefV8Context> context)
    {
        if (!Object::ReferenceEquals(_handler, nullptr))
        {
            Browser browserWrapper(browser);
            Frame frameWrapper(frame);
            V8Context contextWrapper(context);

            _handler->OnContextReleased(%browserWrapper, %frameWrapper, %contextWrapper);
        }

        auto contextReleasedMessage = CefProcessMessage::Create(kOnContextReleasedRequest);

        frame->SendProcessMessage(CefProcessId::PID_BROWSER, contextReleasedMessage);

        auto browserWrapper = FindBrowserWrapper(browser->GetIdentifier());

        //If we no longer have a browser wrapper reference then there's nothing we can do
        if (browserWrapper == nullptr)
        {
            return;
        }

        auto rootObjectWrappers = browserWrapper->JavascriptRootObjectWrappers;

        JavascriptRootObjectWrapper^ wrapper;
        if (rootObjectWrappers->TryRemove(frame->GetIdentifier(), wrapper))
        {
            delete wrapper;
        }
    };

    void CefAppUnmanagedWrapper::OnFocusedNodeChanged(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, CefRefPtr<CefDOMNode> node)
    {
        if (!_focusedNodeChangedEnabled)
        {
            return;
        }

        auto focusedNodeChangedMessage = CefProcessMessage::Create(kOnFocusedNodeChanged);
        auto list = focusedNodeChangedMessage->GetArgumentList();

        // The node will be empty if an element loses focus but another one
        // doesn't gain focus. Only transfer information if the node is an
        // element.
        if (node != nullptr && node->IsElement())
        {
            // True when a node exists, false if it doesn't.
            list->SetBool(0, true);

            // Store the tag name.
            list->SetString(1, node->GetElementTagName());

            // Transfer the attributes in a Dictionary.
            auto attributes = CefDictionaryValue::Create();
            CefDOMNode::AttributeMap attributeMap;
            node->GetElementAttributes(attributeMap);
            for (auto iter : attributeMap)
            {
                attributes->SetString(iter.first, iter.second);
            }

            list->SetDictionary(2, attributes);
        }
        else
        {
            list->SetBool(0, false);
        }

        frame->SendProcessMessage(CefProcessId::PID_BROWSER, focusedNodeChangedMessage);
    }

    void CefAppUnmanagedWrapper::OnUncaughtException(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, CefRefPtr<CefV8Context> context, CefRefPtr<CefV8Exception> exception, CefRefPtr<CefV8StackTrace> stackTrace)
    {
        auto uncaughtExceptionMessage = CefProcessMessage::Create(kOnUncaughtException);
        auto list = uncaughtExceptionMessage->GetArgumentList();

        list->SetString(0, exception->GetMessage());

        auto frames = CefListValue::Create();
        for (auto i = 0; i < stackTrace->GetFrameCount(); i++)
        {
            auto stackTraceFrame = CefListValue::Create();
            auto frameArg = stackTrace->GetFrame(i);

            stackTraceFrame->SetString(0, frameArg->GetFunctionName());
            stackTraceFrame->SetInt(1, frameArg->GetLineNumber());
            stackTraceFrame->SetInt(2, frameArg->GetColumn());
            stackTraceFrame->SetString(3, frameArg->GetScriptNameOrSourceURL());

            frames->SetList(i, stackTraceFrame);
        }

        list->SetList(1, frames);

        frame->SendProcessMessage(CefProcessId::PID_BROWSER, uncaughtExceptionMessage);
    }

    JavascriptRootObjectWrapper^ CefAppUnmanagedWrapper::GetJsRootObjectWrapper(int browserId, int64 frameId)
    {
        auto browserWrapper = FindBrowserWrapper(browserId);

        if (browserWrapper == nullptr)
        {
            return nullptr;
        }

        auto rootObjectWrappers = browserWrapper->JavascriptRootObjectWrappers;

        JavascriptRootObjectWrapper^ rootObject;
        if (!rootObjectWrappers->TryGetValue(frameId, rootObject))
        {
            rootObject = gcnew JavascriptRootObjectWrapper(browserId, browserWrapper->BrowserProcess);
            rootObjectWrappers->TryAdd(frameId, rootObject);
        }

        return rootObject;
    }

    CefBrowserWrapper^ CefAppUnmanagedWrapper::FindBrowserWrapper(int browserId)
    {
        CefBrowserWrapper^ wrapper = nullptr;

        _browserWrappers->TryGetValue(browserId, wrapper);

        if (wrapper == nullptr)
        {
            //TODO: Find the syntax for delcaring the native string directly
            LOG(ERROR) << StringUtils::ToNative("Failed to identify BrowserWrapper in OnContextCreated BrowserId:" + browserId).ToString();
        }

        return wrapper;
    }

    bool CefAppUnmanagedWrapper::OnProcessMessageReceived(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, CefProcessId sourceProcessId, CefRefPtr<CefProcessMessage> message)
    {
        auto handled = false;
        auto name = message->GetName();
        auto argList = message->GetArgumentList();

        auto browserWrapper = FindBrowserWrapper(browser->GetIdentifier());
        //Error handling for missing/closed browser
        if (browserWrapper == nullptr)
        {
            if (name == kJavascriptCallbackDestroyRequest ||
                name == kJavascriptRootObjectResponse ||
                name == kJavascriptAsyncMethodCallResponse)
            {
                //If we can't find the browser wrapper then we'll just
                //ignore this as it's likely already been disposed of
                return true;
            }

            CefString responseName;
            if (name == kEvaluateJavascriptRequest)
            {
                responseName = kEvaluateJavascriptResponse;
            }
            else if (name == kJavascriptCallbackRequest)
            {
                responseName = kJavascriptCallbackResponse;
            }
            else
            {
                //TODO: Should be throw an exception here? It's likely that only a CefSharp developer would see this
                // when they added a new message and haven't yet implemented the render process functionality.
                throw gcnew Exception("Unsupported message type");
            }

            auto callbackId = GetInt64(argList, 0);
            auto response = CefProcessMessage::Create(responseName);
            auto responseArgList = response->GetArgumentList();
            auto errorMessage = String::Format("Request BrowserId : {0} not found it's likely the browser is already closed", browser->GetIdentifier());

            //success: false
            responseArgList->SetBool(0, false);
            SetInt64(responseArgList, 1, callbackId);
            responseArgList->SetString(2, StringUtils::ToNative(errorMessage));
            frame->SendProcessMessage(sourceProcessId, response);

            return true;
        }

        //these messages are roughly handled the same way
        if (name == kEvaluateJavascriptRequest || name == kJavascriptCallbackRequest)
        {
            bool success = false;
            CefRefPtr<CefV8Value> result;
            CefString errorMessage;
            CefRefPtr<CefProcessMessage> response;

            if (name == kEvaluateJavascriptRequest)
            {
                response = CefProcessMessage::Create(kEvaluateJavascriptResponse);
            }
            else
            {
                response = CefProcessMessage::Create(kJavascriptCallbackResponse);
            }

            //both messages have callbackId stored at index 0
            auto frameId = frame->GetIdentifier();
            int64 callbackId = GetInt64(argList, 0);

            if (name == kEvaluateJavascriptRequest)
            {
                JavascriptRootObjectWrapper^ rootObjectWrapper;
                browserWrapper->JavascriptRootObjectWrappers->TryGetValue(frameId, rootObjectWrapper);

                //NOTE: In the rare case when when OnContextCreated hasn't been called we need to manually create the rootObjectWrapper
                //It appears that OnContextCreated is only called for pages that have javascript on them, which makes sense
                //as without javascript there is no need for a context.
                if (rootObjectWrapper == nullptr)
                {
                    rootObjectWrapper = gcnew JavascriptRootObjectWrapper(browser->GetIdentifier(), browserWrapper->BrowserProcess);

                    browserWrapper->JavascriptRootObjectWrappers->TryAdd(frameId, rootObjectWrapper);
                }

                auto callbackRegistry = rootObjectWrapper->CallbackRegistry;

                auto script = argList->GetString(1);
                auto scriptUrl = argList->GetString(2);
                auto startLine = argList->GetInt(3);

                if (frame.get() && frame->IsValid())
                {
                    auto context = frame->GetV8Context();

                    if (context.get() && context->Enter())
                    {
                        try
                        {
                            CefRefPtr<CefV8Exception> exception;
                            success = context->Eval(script, scriptUrl, startLine, result, exception);

                            //we need to do this here to be able to store the v8context
                            if (success)
                            {
                                auto responseArgList = response->GetArgumentList();
                                SerializeV8Object(result, responseArgList, 2, callbackRegistry);
                            }
                            else
                            {
                                errorMessage = StringUtils::CreateExceptionString(exception);
                            }
                        }
                        finally
                        {
                            context->Exit();
                        }
                    }
                    else
                    {
                        errorMessage = "Unable to Enter Context";
                    }
                }
                else
                {
                    errorMessage = StringUtils::ToNative("Frame " + frameId + " is no longer available, most likely the Frame has been Disposed or Removed.");
                }
            }
            else
            {
                JavascriptRootObjectWrapper^ rootObjectWrapper;
                browserWrapper->JavascriptRootObjectWrappers->TryGetValue(frameId, rootObjectWrapper);
                auto callbackRegistry = rootObjectWrapper == nullptr ? nullptr : rootObjectWrapper->CallbackRegistry;
                if (callbackRegistry == nullptr)
                {
                    errorMessage = StringUtils::ToNative("The callback registry for Frame " + frameId + " is no longer available, most likely the Frame has been Disposed.");
                }
                else
                {
                    auto jsCallbackId = GetInt64(argList, 1);

                    auto callbackWrapper = callbackRegistry->FindWrapper(jsCallbackId);
                    if (callbackWrapper == nullptr)
                    {
                        errorMessage = StringUtils::ToNative("Unable to find JavascriptCallback with Id " + jsCallbackId + " for Frame " + frameId);
                    }
                    else
                    {
                        auto context = callbackWrapper->GetContext();
                        auto value = callbackWrapper->GetValue();

                        if (context.get() && context->Enter())
                        {
                            try
                            {
                                auto parameterList = argList->GetList(2);
                                CefV8ValueList params;

                                //Needs to be called within the context as for Dictionary (mapped to struct)
                                //a V8Object will be created
                                for (CefV8ValueList::size_type i = 0; i < parameterList->GetSize(); i++)
                                {
                                    params.push_back(DeserializeV8Object(parameterList, static_cast<int>(i)));
                                }

                                result = value->ExecuteFunction(nullptr, params);
                                success = result.get() != nullptr;

                                //we need to do this here to be able to store the v8context
                                if (success)
                                {
                                    auto responseArgList = response->GetArgumentList();
                                    SerializeV8Object(result, responseArgList, 2, callbackRegistry);
                                }
                                else
                                {
                                    auto exception = value->GetException();
                                    errorMessage = StringUtils::CreateExceptionString(exception);
                                }
                            }
                            finally
                            {
                                context->Exit();
                            }
                        }
                        else
                        {
                            errorMessage = "Unable to Enter Context";
                        }
                    }
                }
            }

            auto responseArgList = response->GetArgumentList();
            responseArgList->SetBool(0, success);
            SetInt64(responseArgList, 1, callbackId);
            if (!success)
            {
                responseArgList->SetString(2, errorMessage);
            }
            frame->SendProcessMessage(sourceProcessId, response);

            handled = true;
        }
        else if (name == kJavascriptCallbackDestroyRequest)
        {
            if (frame.get() && frame->IsValid())
            {
                auto jsCallbackId = GetInt64(argList, 0);
                JavascriptRootObjectWrapper^ rootObjectWrapper;
                browserWrapper->JavascriptRootObjectWrappers->TryGetValue(frame->GetIdentifier(), rootObjectWrapper);
                if (rootObjectWrapper != nullptr && rootObjectWrapper->CallbackRegistry != nullptr)
                {
                    rootObjectWrapper->CallbackRegistry->Deregister(jsCallbackId);
                }
            }

            handled = true;
        }
        else if (name == kJavascriptRootObjectResponse)
        {
            if (browser.get() && frame.get() && frame->IsValid())
            {
                auto callbackId = GetInt64(argList, 0);
                auto javascriptObjects = DeserializeJsObjects(argList, 1);

                //Caching of JavascriptObjects
                //TODO: JSB 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 rootObject = GetJsRootObjectWrapper(browser->GetIdentifier(), frame->GetIdentifier());

                if (rootObject == nullptr)
                {
                    return false;
                }

                auto context = frame->GetV8Context();

                if (context.get() && context->Enter())
                {
                    JavascriptAsyncMethodCallback^ callback;

                    try
                    {
                        rootObject->Bind(javascriptObjects, context->GetGlobal());

                        if (_registerBoundObjectRegistry->TryGetAndRemoveMethodCallback(callbackId, callback))
                        {
                            //Response object has no Accessor or Interceptor
                            auto response = CefV8Value::CreateObject(NULL, NULL);

                            response->SetValue("Count", CefV8Value::CreateInt(javascriptObjects->Count), CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_READONLY);

                            if (javascriptObjects->Count > 0)
                            {
                                //TODO: JSB Should we include a list of successfully bound object names?
                                response->SetValue("Success", CefV8Value::CreateBool(true), CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_READONLY);
                                response->SetValue("Message", CefV8Value::CreateString("OK"), CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_READONLY);
                                callback->Success(response);
                            }
                            else
                            {
                                response->SetValue("Success", CefV8Value::CreateBool(false), CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_READONLY);
                                response->SetValue("Message", CefV8Value::CreateString("Zero objects bounds"), CefV8Value::PropertyAttribute::V8_PROPERTY_ATTRIBUTE_READONLY);
                                callback->Success(response);
                            }

                            //Send message notifying Browser Process of which objects were bound
                            //We do this after the objects have been created in the V8Context to gurantee
                            //they are accessible.
                            auto msg = CefProcessMessage::Create(kJavascriptObjectsBoundInJavascript);
                            auto args = msg->GetArgumentList();

                            auto boundObjects = CefListValue::Create();

                            for (auto i = 0; i < javascriptObjects->Count; i++)
                            {
                                auto dict = CefDictionaryValue::Create();
                                auto objectName = javascriptObjects[i]->JavascriptName;
                                dict->SetString("Name", StringUtils::ToNative(objectName));
                                dict->SetBool("IsCached", false);
                                dict->SetBool("AlreadyBound", false);

                                boundObjects->SetDictionary(i, dict);
                            }

                            args->SetList(0, boundObjects);

                            frame->SendProcessMessage(CefProcessId::PID_BROWSER, msg);
                        }
                    }
                    finally
                    {
                        context->Exit();

                        delete callback;
                    }
                }
            }
            else
            {
                LOG(INFO) << "CefAppUnmanagedWrapper Frame Invalid";
            }

            handled = true;
        }
        else if (name == kJavascriptAsyncMethodCallResponse)
        {
            if (frame.get() && frame->IsValid())
            {
                auto frameId = frame->GetIdentifier();
                auto callbackId = GetInt64(argList, 0);

                JavascriptRootObjectWrapper^ rootObjectWrapper;
                browserWrapper->JavascriptRootObjectWrappers->TryGetValue(frameId, rootObjectWrapper);

                if (rootObjectWrapper != nullptr)
                {
                    JavascriptAsyncMethodCallback^ callback;
                    if (rootObjectWrapper->TryGetAndRemoveMethodCallback(callbackId, callback))
                    {
                        try
                        {
                            auto context = frame->GetV8Context();

                            if (context.get() && context->Enter())
                            {
                                try
                                {
                                    auto success = argList->GetBool(1);
                                    if (success)
                                    {
                                        callback->Success(DeserializeV8Object(argList, 2));
                                    }
                                    else
                                    {
                                        callback->Fail(argList->GetString(2));
                                    }
                                }
                                finally
                                {
                                    context->Exit();
                                }
                            }
                            else
                            {
                                callback->Fail("Unable to Enter Context");
                            }
                        }
                        finally
                        {
                            //dispose
                            delete callback;
                        }
                    }
                }
            }
            handled = true;
        }

        return handled;
    };

    void CefAppUnmanagedWrapper::OnRenderThreadCreated(CefRefPtr<CefListValue> extraInfo)
    {
        //Check to see if we have a list
        if (extraInfo.get())
        {
            auto extensionList = extraInfo->GetList(0);
            if (extensionList.get())
            {
                for (size_t i = 0; i < extensionList->GetSize(); i++)
                {
                    auto extension = extensionList->GetList(i);
                    auto ext = gcnew V8Extension(StringUtils::ToClr(extension->GetString(0)), StringUtils::ToClr(extension->GetString(1)));

                    _extensions->Add(ext);
                }
            }
        }
    }

    void CefAppUnmanagedWrapper::OnWebKitInitialized()
    {
        for each(V8Extension^ extension in _extensions->AsReadOnly())
        {
            //only support extensions without handlers now
            CefRegisterExtension(StringUtils::ToNative(extension->Name), StringUtils::ToNative(extension->JavascriptCode), NULL);
        }
    }
}