Fix switching interceptor if element needs to upgraded after custom element is registered

Source/bindings/core/dart/DartJsInterop.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 1679 matching lines @@
         cache->m_typedInterop = 0; // Clear existing handle.
         scopes.setReturnValue(JsObject::createTyped(v8Object, domData, &tempInterceptor, cache));
         return;
     }
 
 fail:
     Dart_ThrowException(exception);
     ASSERT_NOT_REACHED();
 }
 
+// Callback to force an instance to adopt a a specific custom element type.
+// Element accessed before custom class registerElement called.  After which
+// each element with 'is' attribute custom type createdCallback is called with
+// the element to upgrade.
+static void setInstanceInterceptorCustomUpgradeCallback(Dart_NativeArguments args)
+{
+    Dart_Handle exception = 0;
+    {
+        DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
+        auto v8Isolate = domData->v8Isolate();
+        v8::Local<v8::Context> context = domData->v8Context();
+        JsInteropScopes scopes(args, context);
+        JsObject* jsObject = toJsObject(args, 0, exception);
+        if (exception)
+            goto fail;
+        v8::Local<v8::Object> v8Object = jsObject->localV8Object(v8Isolate);
+        if (scopes.handleJsException(&exception))
+            goto fail;
+
+        // Get the type of the element (check to see if the interceptor is the
+        // CustomElementType).
+        Dart_Handle arg0 = Dart_GetNativeArgument(args, 0);
+        Dart_Handle dartType = Dart_InstanceGetType(arg0);
+        ASSERT(Dart_IsType(dartType));
+        ASSERT(!Dart_IsError(dartType));
+        Dart_Handle instanceType = Dart_TypeName(dartType);
+
+        // Get the interceptor
+        auto cache = domData->m_dartHandles.get(v8Object, v8Isolate);
+        InterceptorData* interceptor = jsObject->computeInterceptor(v8Object, domData, cache);
+
+        // Get the interceptor's custom element type.
+        Dart_Handle interceptorType = Dart_HandleFromPersistent(interceptor->m_type);
+        ASSERT(Dart_IsType(interceptorType));
+        ASSERT(!Dart_IsError(interceptorType));
+        Dart_Handle customType = Dart_TypeName(interceptorType);
+        ASSERT(Dart_IsType(customType));
+        ASSERT(!Dart_IsError(customType));

[Jacob, 2016/04/22 16:46:16]

no need to have both the IsType and not IsError asserts.

[terry, 2016/04/22 18:48:29]

Yep, eliminated Dart_IsError.

+
+        bool equal;

[Jacob, 2016/04/22 16:46:16]

For safety change to
bool equal = false;
as you aren't checking whether Dart_ObjectEquals blows up.

[terry, 2016/04/22 18:48:29]

Done.

+        Dart_ObjectEquals(instanceType, customType, &equal);
+        if (!equal) {
+          // Type of the instance isn't the same as the custom element type so
+          // then we must change the interceptor.  Upgrade to the registered
+          // element.
+          RELEASE_ASSERT(interceptor->m_isCustomElement);
+          cache->m_typedInterop = 0; // Clear existing handle.
+          scopes.setReturnValue(JsObject::createTyped(v8Object, domData, interceptor, cache));
+
+          if (scopes.handleJsException(&exception))
+            goto fail;
+        }
+        return;
+    }
+
+fail:
+    Dart_ThrowException(exception);
+    ASSERT_NOT_REACHED();
+}
+
+
 static void callMethodCallbackHelper(Dart_NativeArguments args, bool legacy)
 {
     Dart_Handle exception = 0;
     {
         DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
         JsInteropScopes scopes(args, domData->v8Context());
         auto v8Isolate = domData->v8Isolate();
         JsObject* receiver = DartDOMWrapper::receiver<JsObject>(args);
         v8::Local<v8::Object> v8Receiver = receiver->localV8Object(v8Isolate);
         Dart_Handle name = Dart_GetNativeArgument(args, 1);
@@ skipping 669 matching lines @@
 
     { JsInteropInternal::typedHashCodeCallback, 1, "JSObject_hashCode" },
     { JsInteropInternal::typedCallMethodCallback, 3, "JSObject_callMethod" },
     { JsInteropInternal::typedIndexGetter, 2, "JSArray_indexed_getter" },
     { JsInteropInternal::typedIndexSetter, 3, "JSArray_indexed_setter" },
     { JsInteropInternal::callConstructor0Callback, 1, "JSNative_callConstructor0" },
     { JsInteropInternal::callConstructorCallback, 2, "JSNative_callConstructor" },
     { JsInteropInternal::defineInterceptorCustomElementCallback, 2, "Utils_defineInterceptorCustomElement" },
     { JsInteropInternal::defineInterceptorCallback, 2, "Utils_defineInterceptor" },
     { JsInteropInternal::setInstanceInterceptorCallback, 3, "Utils_setInstanceInterceptor" },
+    { JsInteropInternal::setInstanceInterceptorCustomUpgradeCallback, 1, "Utils_setInstanceInterceptorCustomUpgrade" },
     { JsInteropInternal::initializeCustomElement, 1, "Utils_initializeCustomElement" },
 
     { JsInteropInternal::toTypedObjectCallback, 1, "JSNative_toTypedObject" },
 
     { JsInteropInternal::typedApplyCallback, 3, "JSFunction_apply" },
     { JsInteropInternal::typedFunctionCreateWithThisCallback, 1, "JSFunction_createWithThis" },
     { JsInteropInternal::typedFunctionCreateCallback, 1, "JSFunction_create" },
 
     // TODO(jacobr): do we want to do anything differently for JSObject
     // toString relative to JsObject.toString?
@@ skipping 394 matching lines @@
 
         proxyTemplateLocal->SetClassName(v8::String::NewFromUtf8(v8Isolate, "DartObject"));
         setupInstanceTemplate(proxyTemplateLocal);
     } else {
         proxyTemplateLocal = v8::Local<v8::FunctionTemplate>::New(v8Isolate, proxyTemplate);
     }
     return proxyTemplateLocal;
 }
 
 }