2010-02-08 Nate Chapin <japhet@chromium.org>

        Reviewed by Dimitri Glazkov.

        [V8] Unify the WorkerContext V8 object wrapping code with
        the standard V8 object wrapping code.

        https://bugs.webkit.org/show_bug.cgi?id=34658

        * bindings/scripts/CodeGeneratorV8.pm:
        * bindings/v8/V8DOMWrapper.cpp:
        (WebCore::V8DOMWrapper::instantiateV8Object):
        (WebCore::V8DOMWrapper::convertEventTargetToV8Object):
        * bindings/v8/V8WorkerContextEventListener.cpp:
        (WebCore::V8WorkerContextEventListener::handleEvent):
        (WebCore::V8WorkerContextEventListener::getReceiverObject):
        * bindings/v8/WorkerContextExecutionProxy.cpp:
        * bindings/v8/WorkerContextExecutionProxy.h:
        * bindings/v8/custom/V8NotificationCenterCustom.cpp:
        (WebCore::V8NotificationCenter::createHTMLNotificationCallback):
        (WebCore::V8NotificationCenter::createNotificationCallback):
        * bindings/v8/custom/V8WorkerContextCustom.cpp:
        (WebCore::toV8):


git-svn-id: svn://svn.chromium.org/blink/trunk@54499 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/WebCore/ChangeLog

+2010-02-08  Nate Chapin  <japhet@chromium.org>
+
+        Reviewed by Dimitri Glazkov.
+
+        [V8] Unify the WorkerContext V8 object wrapping code with
+        the standard V8 object wrapping code.
+
+        https://bugs.webkit.org/show_bug.cgi?id=34658
+
+        * bindings/scripts/CodeGeneratorV8.pm:
+        * bindings/v8/V8DOMWrapper.cpp:
+        (WebCore::V8DOMWrapper::instantiateV8Object):
+        (WebCore::V8DOMWrapper::convertEventTargetToV8Object):
+        * bindings/v8/V8WorkerContextEventListener.cpp:
+        (WebCore::V8WorkerContextEventListener::handleEvent):
+        (WebCore::V8WorkerContextEventListener::getReceiverObject):
+        * bindings/v8/WorkerContextExecutionProxy.cpp:
+        * bindings/v8/WorkerContextExecutionProxy.h:
+        * bindings/v8/custom/V8NotificationCenterCustom.cpp:
+        (WebCore::V8NotificationCenter::createHTMLNotificationCallback):
+        (WebCore::V8NotificationCenter::createNotificationCallback):
+        * bindings/v8/custom/V8WorkerContextCustom.cpp:
+        (WebCore::toV8):
+
 2010-02-08  Kwang Yul Seo  <skyul@company100.net>
 
         Reviewed by Darin Adler.

third_party/WebKit/WebCore/bindings/scripts/CodeGeneratorV8.pm

@@ -272,6 +272,7 @@ sub GenerateHeader
  public:
   static bool HasInstance(v8::Handle<v8::Value> value);
   static v8::Persistent<v8::FunctionTemplate> GetRawTemplate();
+  static v8::Persistent<v8::FunctionTemplate> GetTemplate();
   static ${nativeType}* toNative(v8::Handle<v8::Object>);
   static v8::Handle<v8::Object> wrap(${nativeType}*${forceNewObjectParameter});
 END
@@ -336,8 +337,6 @@ END
     }
 
     push(@headerContent, <<END);
-
-  static v8::Persistent<v8::FunctionTemplate> GetTemplate();
 };
 
   v8::Handle<v8::Value> toV8(${nativeType}*${forceNewObjectParameter});
@@ -608,7 +607,6 @@ END
     return V8DOMWrapper::getConstructor(type, V8DOMWindow::toNative(info.Holder()));
 END
     } elsif ($classIndex eq "DEDICATEDWORKERCONTEXT" or $classIndex eq "WORKERCONTEXT" or $classIndex eq "SHAREDWORKERCONTEXT") {
-        $implIncludes{"WorkerContextExecutionProxy.h"} = 1;
         push(@implContentDecls, <<END);
     return V8DOMWrapper::getConstructor(type, V8WorkerContext::toNative(info.Holder()));
 END
@@ -1954,12 +1952,8 @@ sub GenerateToV8Converters
 
 v8::Handle<v8::Object> ${className}::wrap(${nativeType}* impl${forceNewObjectInput}) {
   v8::Handle<v8::Object> wrapper;
-END
-    if (!NeedsWorkerContextExecutionProxyToV8($interfaceName)) {
-        push(@implContent, <<END);
   V8Proxy* proxy = 0;
 END
-    }
 
     if (IsNodeSubType($dataNode)) {
         push(@implContent, <<END);
@@ -1997,17 +1991,10 @@ END
     context->Enter();
 END
     }
-
-    if (NeedsWorkerContextExecutionProxyToV8($interfaceName)) {
-        $implIncludes{"WorkerContextExecutionProxy.h"} = 1;
-        push(@implContent, <<END);
-  wrapper = WorkerContextExecutionProxy::toV8(${wrapperType}, impl);
-END
-    } else {
-        push(@implContent, <<END);
+    
+    push(@implContent, <<END);
   wrapper = V8DOMWrapper::instantiateV8Object(proxy, ${wrapperType}, impl);
 END
-    }
 
     if (IsNodeSubType($dataNode)) {
         push(@implContent, <<END);
@@ -2055,19 +2042,6 @@ END
     }
 }
 
-sub NeedsWorkerContextExecutionProxyToV8 {
-    # These objects can be constructed under WorkerContextExecutionProxy. They need special
-    # handling, since if we call V8Proxy::retrieve(), we will crash.
-    # FIXME: websocket?
-    $interfaceName = shift;
-    return 1 if $interfaceName eq "DOMCoreException";
-    return 1 if $interfaceName eq "EventException";
-    return 1 if $interfaceName eq "RangeException";
-    return 1 if $interfaceName eq "XMLHttpRequestException";
-    return 1 if $interfaceName eq "MessagePort";
-    return 0;
-}
-
 sub HasCustomToV8Implementation {
     # FIXME: This subroutine is lame. Probably should be an .idl attribute (CustomToV8)?
     $dataNode = shift;
@@ -2089,6 +2063,7 @@ sub HasCustomToV8Implementation {
     return 1 if $interfaceName eq "SVGDocument";
     return 1 if $interfaceName eq "SVGElement";
     return 1 if $interfaceName eq "Screen";
+    return 1 if $interfaceName eq "WorkerContext";
     
     # We don't generate a custom converter (but JSC does) for the following:
     return 0 if $interfaceName eq "AbstractWorker";
@@ -2779,18 +2754,6 @@ sub ReturnNativeToJSValue
         return "return $value->deserialize()";
     }
 
-    if ($type eq "DedicatedWorkerContext" or $type eq "WorkerContext" or $type eq "SharedWorkerContext") {
-        $implIncludes{"WorkerContextExecutionProxy.h"} = 1;
-        return "return WorkerContextExecutionProxy::convertWorkerContextToV8Object($value)";
-    }
-
-    if ($type eq "WorkerLocation" or $type eq "WorkerNavigator" or $type eq "NotificationCenter") {
-        $implIncludes{"WorkerContextExecutionProxy.h"} = 1;
-        my $classIndex = uc($type);
-
-        return "return WorkerContextExecutionProxy::convertToV8Object(V8ClassIndex::$classIndex, $value)";
-    }
-
     $implIncludes{"wtf/RefCounted.h"} = 1;
     $implIncludes{"wtf/RefPtr.h"} = 1;
     $implIncludes{"wtf/GetPtr.h"} = 1;

third_party/WebKit/WebCore/bindings/v8/V8DOMWrapper.cpp

@@ -64,6 +64,8 @@
 #include "V8StyleSheet.h"
 #include "V8WebSocket.h"
 #include "V8Worker.h"
+#include "V8WorkerContext.h"
+#include "V8XMLHttpRequest.h"
 #include "WebGLArray.h"
 #include "WebGLContextAttributes.h"
 #include "WebGLUniformLocation.h"
@@ -267,13 +269,16 @@ PassRefPtr<NodeFilter> V8DOMWrapper::wrapNativeNodeFilter(v8::Handle<v8::Value>
 
 v8::Local<v8::Object> V8DOMWrapper::instantiateV8Object(V8Proxy* proxy, V8ClassIndex::V8WrapperType type, void* impl)
 {
+    // Get the WorkerContextExecutionProxy first. If we are in a WorkerContext and we try to call V8Proxy::retrieve(),
+    // we crash trying to retrieve a DOMWindow.
+    WorkerContextExecutionProxy* workerContextProxy = WorkerContextExecutionProxy::retrieve();
     if (V8IsolatedContext::getEntered()) {
         // This effectively disables the wrapper cache for isolated worlds.
         proxy = 0;
         // FIXME: Do we need a wrapper cache for the isolated world?  We should
         //        see if the performance gains are worth while.
         // We'll get one once we give the isolated context a proper window shell.
-    } else if (!proxy)
+    } else if (!proxy && !workerContextProxy)
         proxy = V8Proxy::retrieve();
 
     v8::Local<v8::Object> instance;
@@ -281,7 +286,11 @@ v8::Local<v8::Object> V8DOMWrapper::instantiateV8Object(V8Proxy* proxy, V8ClassI
         // FIXME: Fix this to work properly with isolated worlds (see above).
         instance = proxy->windowShell()->createWrapperFromCache(type);
     else {
-        v8::Local<v8::Function> function = V8ClassIndex::getTemplate(type)->GetFunction();
+        v8::Local<v8::Function> function;
+        if (workerContextProxy)
+            function = getConstructor(type, workerContextProxy->workerContext());
+        else
+            function = V8ClassIndex::getTemplate(type)->GetFunction();
         instance = SafeAllocation::newInstance(function);
     }
     if (!instance.IsEmpty()) {
@@ -365,11 +374,17 @@ v8::Handle<v8::Value> V8DOMWrapper::convertEventTargetToV8Object(EventTarget* ta
 #if ENABLE(WORKERS)
     if (Worker* worker = target->toWorker())
         return toV8(worker);
+
+    if (DedicatedWorkerContext* workerContext = target->toDedicatedWorkerContext())
+        return toV8(workerContext);
 #endif // WORKERS
 
 #if ENABLE(SHARED_WORKERS)
     if (SharedWorker* sharedWorker = target->toSharedWorker())
         return toV8(sharedWorker);
+
+    if (SharedWorkerContext* sharedWorkerContext = target->toSharedWorkerContext())
+        return toV8(sharedWorkerContext);
 #endif // SHARED_WORKERS
 
 #if ENABLE(NOTIFICATIONS)
@@ -395,6 +410,9 @@ v8::Handle<v8::Value> V8DOMWrapper::convertEventTargetToV8Object(EventTarget* ta
         return wrapper;
     }
 
+    if (XMLHttpRequest* xhr = target->toXMLHttpRequest())
+        return toV8(xhr);
+
     // MessagePort is created within its JS counterpart
     if (MessagePort* port = target->toMessagePort()) {
         v8::Handle<v8::Object> wrapper = getActiveDOMObjectMap().get(port);

third_party/WebKit/WebCore/bindings/v8/V8WorkerContextEventListener.cpp

@@ -34,8 +34,9 @@
 
 #include "V8WorkerContextEventListener.h"
 
-#include "Event.h"
 #include "V8Binding.h"
+#include "V8DOMWrapper.h"
+#include "V8Event.h"
 #include "WorkerContext.h"
 #include "WorkerContextExecutionProxy.h"
 
@@ -76,7 +77,7 @@ void V8WorkerContextEventListener::handleEvent(ScriptExecutionContext* context,
     v8::Context::Scope scope(v8Context);
 
     // Get the V8 wrapper for the event object.
-    v8::Handle<v8::Value> jsEvent = WorkerContextExecutionProxy::convertEventToV8Object(event);
+    v8::Handle<v8::Value> jsEvent = toV8(event);
 
     invokeEventHandler(context, event, jsEvent);
 }
@@ -155,7 +156,7 @@ v8::Local<v8::Object> V8WorkerContextEventListener::getReceiverObject(ScriptExec
         return listener;
 
     EventTarget* target = event->currentTarget();
-    v8::Handle<v8::Value> value = WorkerContextExecutionProxy::convertEventTargetToV8Object(target);
+    v8::Handle<v8::Value> value = V8DOMWrapper::convertEventTargetToV8Object(target);
     if (value.IsEmpty())
         return v8::Local<v8::Object>();
     return v8::Local<v8::Object>::New(v8::Handle<v8::Object>::Cast(value));

third_party/WebKit/WebCore/bindings/v8/WorkerContextExecutionProxy.cpp

@@ -176,195 +176,6 @@ void WorkerContextExecutionProxy::initContextIfNeeded()
     globalObject->Set(implicitProtoString, jsWorkerContext);
 }
 
-v8::Handle<v8::Value> WorkerContextExecutionProxy::convertToV8Object(V8ClassIndex::V8WrapperType type, void* impl)
-{
-    if (!impl)
-        return v8::Null();
-
-    if (type == V8ClassIndex::DEDICATEDWORKERCONTEXT
-#if ENABLE(SHARED_WORKERS)
-        || type == V8ClassIndex::SHAREDWORKERCONTEXT
-#endif
-        )
-        return convertWorkerContextToV8Object(static_cast<WorkerContext*>(impl));
-
-    bool isActiveDomObject = false;
-    switch (type) {
-#define MAKE_CASE(TYPE, NAME) case V8ClassIndex::TYPE:
-        ACTIVE_DOM_OBJECT_TYPES(MAKE_CASE)
-        isActiveDomObject = true;
-        break;
-#undef MAKE_CASE
-    default:
-        break;
-    }
-
-    if (isActiveDomObject) {
-        v8::Persistent<v8::Object> result = getActiveDOMObjectMap().get(impl);
-        if (!result.IsEmpty())
-            return result;
-
-        v8::Local<v8::Object> object = toV8(type, type, impl);
-        switch (type) {
-#define MAKE_CASE(TYPE, NAME) \
-        case V8ClassIndex::TYPE: static_cast<NAME*>(impl)->ref(); break;
-            ACTIVE_DOM_OBJECT_TYPES(MAKE_CASE)
-#undef MAKE_CASE
-        default:
-            ASSERT_NOT_REACHED();
-        }
-
-        result = v8::Persistent<v8::Object>::New(object);
-        V8DOMWrapper::setJSWrapperForActiveDOMObject(impl, result);
-        return result;
-    }
-
-    // Non DOM node
-    v8::Persistent<v8::Object> result = getDOMObjectMap().get(impl);
-    if (result.IsEmpty()) {
-        v8::Local<v8::Object> object = toV8(type, type, impl);
-        if (!object.IsEmpty()) {
-            switch (type) {
-            case V8ClassIndex::WORKERLOCATION:
-                static_cast<WorkerLocation*>(impl)->ref();
-                break;
-            case V8ClassIndex::WORKERNAVIGATOR:
-                static_cast<WorkerNavigator*>(impl)->ref();
-                break;
-#if ENABLE(NOTIFICATIONS)
-            case V8ClassIndex::NOTIFICATIONCENTER:
-                static_cast<NotificationCenter*>(impl)->ref();
-                break;
-            case V8ClassIndex::NOTIFICATION:
-                static_cast<Notification*>(impl)->ref();
-                break;
-#endif
-            case V8ClassIndex::DOMCOREEXCEPTION:
-                static_cast<DOMCoreException*>(impl)->ref();
-                break;
-            case V8ClassIndex::RANGEEXCEPTION:
-                static_cast<RangeException*>(impl)->ref();
-                break;
-            case V8ClassIndex::EVENTEXCEPTION:
-                static_cast<EventException*>(impl)->ref();
-                break;
-            case V8ClassIndex::XMLHTTPREQUESTEXCEPTION:
-                static_cast<XMLHttpRequestException*>(impl)->ref();
-                break;
-            default:
-                ASSERT(false);
-            }
-            result = v8::Persistent<v8::Object>::New(object);
-            V8DOMWrapper::setJSWrapperForDOMObject(impl, result);
-        }
-    }
-    return result;
-}
-
-v8::Handle<v8::Value> WorkerContextExecutionProxy::convertEventToV8Object(Event* event)
-{
-    if (!event)
-        return v8::Null();
-
-    v8::Handle<v8::Object> wrapper = getDOMObjectMap().get(event);
-    if (!wrapper.IsEmpty())
-        return wrapper;
-
-    V8ClassIndex::V8WrapperType type = V8ClassIndex::EVENT;
-
-    if (event->isMessageEvent())
-        type = V8ClassIndex::MESSAGEEVENT;
-
-    v8::Handle<v8::Object> result = toV8(type, V8ClassIndex::EVENT, event);
-    if (result.IsEmpty()) {
-        // Instantiation failed. Avoid updating the DOM object map and return null which
-        // is already handled by callers of this function in case the event is null.
-        return v8::Null();
-    }
-
-    event->ref();  // fast ref
-    V8DOMWrapper::setJSWrapperForDOMObject(event, v8::Persistent<v8::Object>::New(result));
-
-    return result;
-}
-
-v8::Handle<v8::Value> WorkerContextExecutionProxy::convertEventTargetToV8Object(EventTarget* target)
-{
-    if (!target)
-        return v8::Null();
-
-    DedicatedWorkerContext* workerContext = target->toDedicatedWorkerContext();
-    if (workerContext)
-        return convertWorkerContextToV8Object(workerContext);
-
-#if ENABLE(SHARED_WORKERS)
-    SharedWorkerContext* sharedWorkerContext = target->toSharedWorkerContext();
-    if (sharedWorkerContext)
-        return convertWorkerContextToV8Object(sharedWorkerContext);
-#endif
-
-    Worker* worker = target->toWorker();
-    if (worker)
-        return convertToV8Object(V8ClassIndex::WORKER, worker);
-
-#if ENABLE(SHARED_WORKERS)
-    SharedWorker* sharedWorker = target->toSharedWorker();
-    if (sharedWorker)
-        return convertToV8Object(V8ClassIndex::SHAREDWORKER, sharedWorker);
-#endif
-
-    XMLHttpRequest* xhr = target->toXMLHttpRequest();
-    if (xhr)
-        return convertToV8Object(V8ClassIndex::XMLHTTPREQUEST, xhr);
-
-    MessagePort* mp = target->toMessagePort();
-    if (mp)
-        return convertToV8Object(V8ClassIndex::MESSAGEPORT, mp);
-
-#if ENABLE(WEB_SOCKETS)
-    WebSocket* webSocket = target->toWebSocket();
-    if (webSocket)
-        return convertToV8Object(V8ClassIndex::WEBSOCKET, webSocket);
-#endif
-
-#if ENABLE(EVENTSOURCE)
-    EventSource* eventSource = target->toEventSource();
-    if (eventSource)
-        return convertToV8Object(V8ClassIndex::EVENTSOURCE, eventSource);
-#endif
-
-    ASSERT_NOT_REACHED();
-    return v8::Handle<v8::Value>();
-}
-
-v8::Handle<v8::Value> WorkerContextExecutionProxy::convertWorkerContextToV8Object(WorkerContext* workerContext)
-{
-    if (!workerContext)
-        return v8::Null();
-
-    v8::Handle<v8::Context> context = workerContext->script()->proxy()->context();
-
-    v8::Handle<v8::Object> global = context->Global();
-    ASSERT(!global.IsEmpty());
-    return global;
-}
-
-v8::Local<v8::Object> WorkerContextExecutionProxy::toV8(V8ClassIndex::V8WrapperType descriptorType, V8ClassIndex::V8WrapperType cptrType, void* impl)
-{
-    v8::Local<v8::Function> function;
-    WorkerContextExecutionProxy* proxy = retrieve();
-    if (proxy)
-        function = V8DOMWrapper::getConstructor(descriptorType, proxy->workerContext());
-    else
-        function = V8ClassIndex::getTemplate(descriptorType)->GetFunction();
-
-    v8::Local<v8::Object> instance = SafeAllocation::newInstance(function);
-    if (!instance.IsEmpty())
-        // Avoid setting the DOM wrapper for failed allocations.
-        V8DOMWrapper::setDOMWrapper(instance, V8ClassIndex::ToInt(cptrType), impl);
-    return instance;
-}
-
 bool WorkerContextExecutionProxy::forgetV8EventObject(Event* event)
 {
     if (getDOMObjectMap().contains(event)) {

third_party/WebKit/WebCore/bindings/v8/WorkerContextExecutionProxy.h

@@ -84,22 +84,6 @@ namespace WebCore {
         // Returns WorkerContextExecutionProxy object of the currently executing context. 0 will be returned if the current executing context is not the worker context.
         static WorkerContextExecutionProxy* retrieve();
 
-        // We have to keep all these conversion functions here before WorkerContextExecutionProxy is refactor-ed.
-        template<typename T>
-        static v8::Handle<v8::Value> convertToV8Object(V8ClassIndex::V8WrapperType type, PassRefPtr<T> impl)
-        {
-            return convertToV8Object(type, impl.get());
-        }
-        static v8::Handle<v8::Value> convertToV8Object(V8ClassIndex::V8WrapperType, void* impl);
-        static v8::Handle<v8::Value> convertEventToV8Object(Event*);
-        static v8::Handle<v8::Value> convertEventTargetToV8Object(EventTarget*);
-        static v8::Handle<v8::Value> convertWorkerContextToV8Object(WorkerContext*);
-
-        static v8::Local<v8::Object> toV8(V8ClassIndex::V8WrapperType type, void* impl)
-        {
-            return toV8(type, type, impl);
-        }
-
     private:
         void initV8IfNeeded();
         void initContextIfNeeded();
@@ -108,8 +92,6 @@ namespace WebCore {
         // Run an already compiled script.
         v8::Local<v8::Value> runScript(v8::Handle<v8::Script>);
 
-        static v8::Local<v8::Object> toV8(V8ClassIndex::V8WrapperType descriptorType, V8ClassIndex::V8WrapperType cptrType, void* impl);
-
         static bool forgetV8EventObject(Event*);
 
         static const int kWorkerMaxStackSize = 500 * 1024;

third_party/WebKit/WebCore/bindings/v8/custom/V8NotificationCenterCustom.cpp

@@ -43,7 +43,6 @@
 #include "V8Proxy.h"
 #include "V8Utilities.h"
 #include "WorkerContext.h"
-#include "WorkerContextExecutionProxy.h"
 
 namespace WebCore {
 
@@ -91,9 +90,6 @@ v8::Handle<v8::Value> V8NotificationCenter::createHTMLNotificationCallback(const
     if (ec)
         return throwError(ec);
 
-    if (notificationCenter->context()->isWorkerContext())
-        return WorkerContextExecutionProxy::convertToV8Object(V8ClassIndex::NOTIFICATION, notification.get());
-
     return toV8(notification.get());
 }
 
@@ -108,9 +104,6 @@ v8::Handle<v8::Value> V8NotificationCenter::createNotificationCallback(const v8:
     if (ec)
         return throwError(ec);
 
-    if (notificationCenter->context()->isWorkerContext())
-        return WorkerContextExecutionProxy::convertToV8Object(V8ClassIndex::NOTIFICATION, notification.get());
-
     return toV8(notification.get());
 }
 

third_party/WebKit/WebCore/bindings/v8/custom/V8WorkerContextCustom.cpp

@@ -173,6 +173,16 @@ v8::Handle<v8::Value> V8WorkerContext::removeEventListenerCallback(const v8::Arg
     return v8::Undefined();
 }
 
+v8::Handle<v8::Value> toV8(WorkerContext* impl)
+{
+    if (!impl)
+        return v8::Null();
+
+    v8::Handle<v8::Object> global = impl->script()->proxy()->context()->Global();
+    ASSERT(!global.IsEmpty());
+    return global;
+}
+
 } // namespace WebCore
 
 #endif // ENABLE(WORKERS)