Make FunctionTemplate::HasInstance checks work with remote contexts.

src/api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 6523 matching lines @@
            Utils::OpenHandle(*InstanceTemplate()))
            .ToHandle(&object)) {
     if (isolate->has_pending_exception()) {
       isolate->OptionalRescheduleException(true);
     }
     return MaybeLocal<Object>();
   }
   return Utils::ToLocal(scope.CloseAndEscape(object));
 }
 
+static bool HasInstanceInGlobalProxy(
+    i::JSGlobalProxy* global_proxy,
+    i::FunctionTemplateInfo* function_template_info) {
+  auto* constructor_object = global_proxy->map()->GetConstructor();
+  if (!constructor_object->IsJSFunction()) return false;
+
+  auto* constructor = i::JSFunction::cast(constructor_object);
+  if (!constructor->shared()->function_data()->IsFunctionTemplateInfo())
+    return false;
+
+  auto* proxy_constructor_template =
+      i::FunctionTemplateInfo::cast(constructor->shared()->function_data());
+  if (!proxy_constructor_template->prototype_template()->IsObjectTemplateInfo())
+    return false;
+
+  auto* global_template = i::ObjectTemplateInfo::cast(
+      proxy_constructor_template->prototype_template());
+  return global_template->constructor() == function_template_info;
+}
+
 bool FunctionTemplate::HasInstance(v8::Local<v8::Value> value) {
   auto self = Utils::OpenHandle(this);
   auto obj = Utils::OpenHandle(*value);
   if (obj->IsJSObject() && self->IsTemplateFor(i::JSObject::cast(*obj))) {
     return true;
   }
   if (obj->IsJSGlobalProxy()) {
-    // If it's a global proxy object, then test with the global object.
-    i::PrototypeIterator iter(i::JSObject::cast(*obj)->map());
+    auto* global_proxy = i::JSGlobalProxy::cast(*obj);
+    // For global proxies, check the constructor's prototype. Remote global
+    // proxies have no associated global object, so trying to find an instance
+    // of this template in the prototype chain will fail.
+    if (HasInstanceInGlobalProxy(global_proxy, *self)) return true;
+
+    // Otherwise, fallback to testing the prototype chain.

[dcheng, 2017/02/16 07:12:45]

I tried to remove this section, but it makes a bunch of worker things fail. I'm
going to investigate and see if I can remove this exception for workers
(probably in a followup?)

+    i::PrototypeIterator iter(global_proxy->map());
     if (iter.IsAtEnd()) return false;
     return self->IsTemplateFor(iter.GetCurrent<i::JSGlobalObject>());
   }
   return false;
 }
 
 
 Local<External> v8::External::New(Isolate* isolate, void* value) {
   STATIC_ASSERT(sizeof(value) == sizeof(i::Address));
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
@@ skipping 3605 matching lines @@
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 }  // namespace internal
 }  // namespace v8