Revert of binding: Changes the association among global-proxy/global/window-instance (2nd attempt).…

third_party/WebKit/Source/bindings/core/v8/V8BindingForCore.h

 /*
  * Copyright (C) 2017 Google Inc. All rights reserved.
  * Copyright (C) 2012 Ericsson AB. 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.
@@ skipping 22 matching lines @@
 #define V8BindingForCore_h
 
 #include "bindings/core/v8/DOMDataStore.h"
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/NativeValueTraits.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/ScriptWrappable.h"
+#include "bindings/core/v8/ToV8ForCore.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8BindingMacros.h"
 #include "bindings/core/v8/V8PerIsolateData.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "bindings/core/v8/V8StringResource.h"
 #include "bindings/core/v8/V8ThrowException.h"
 #include "bindings/core/v8/V8ValueCache.h"
 #include "core/CoreExport.h"
 #include "core/dom/ArrayBufferViewHelpers.h"
+#include "core/dom/Node.h"
 #include "platform/heap/Handle.h"
 #include "platform/wtf/text/AtomicString.h"
 #include "platform/wtf/text/StringView.h"
 #include "v8/include/v8.h"
 
 namespace blink {
 
 // This file contains core-specific bindings utility functions. For functions
 // that are core independent, see bindings/core/v8/V8Binding.h. When adding a
 // new utility function, consider adding it to V8Binding.h instead unless it has
 // dependencies to core/.
 
 class DOMWindow;
 class EventListener;
+class EventTarget;
 class ExceptionState;
 class ExecutionContext;
 class FlexibleArrayBufferView;
 class Frame;
 class LocalDOMWindow;
 class LocalFrame;
 class NodeFilter;
 class XPathNSResolver;
 
+template <typename CallbackInfo>
+inline void V8SetReturnValue(const CallbackInfo& callback_info,
+                             DOMWindow* impl) {
+  V8SetReturnValue(callback_info, ToV8(impl, callback_info.Holder(),
+                                       callback_info.GetIsolate()));
+}
+
+template <typename CallbackInfo>
+inline void V8SetReturnValue(const CallbackInfo& callback_info,
+                             EventTarget* impl) {
+  V8SetReturnValue(callback_info, ToV8(impl, callback_info.Holder(),
+                                       callback_info.GetIsolate()));
+}
+
+template <typename CallbackInfo>
+inline void V8SetReturnValue(const CallbackInfo& callback_info, Node* impl) {
+  V8SetReturnValue(callback_info, static_cast<ScriptWrappable*>(impl));
+}
+
+template <typename CallbackInfo>
+inline void V8SetReturnValueForMainWorld(const CallbackInfo& callback_info,
+                                         DOMWindow* impl) {
+  V8SetReturnValue(callback_info, ToV8(impl, callback_info.Holder(),
+                                       callback_info.GetIsolate()));
+}
+
+template <typename CallbackInfo>
+inline void V8SetReturnValueForMainWorld(const CallbackInfo& callback_info,
+                                         EventTarget* impl) {
+  V8SetReturnValue(callback_info, ToV8(impl, callback_info.Holder(),
+                                       callback_info.GetIsolate()));
+}
+
+template <typename CallbackInfo>
+inline void V8SetReturnValueForMainWorld(const CallbackInfo& callback_info,
+                                         Node* impl) {
+  // Since EventTarget has a special version of ToV8 and V8EventTarget.h
+  // defines its own v8SetReturnValue family, which are slow, we need to
+  // override them with optimized versions for Node and its subclasses.
+  // Without this overload, V8SetReturnValueForMainWorld for Node would be
+  // very slow.
+  //
+  // class hierarchy:
+  //     ScriptWrappable <-- EventTarget <--+-- Node <-- ...
+  //                                        +-- Window
+  // overloads:
+  //     V8SetReturnValueForMainWorld(ScriptWrappable*)
+  //         Optimized and very fast.
+  //     V8SetReturnValueForMainWorld(EventTarget*)
+  //         Uses custom ToV8 function and slow.
+  //     V8SetReturnValueForMainWorld(Node*)
+  //         Optimized and very fast.
+  //     V8SetReturnValueForMainWorld(Window*)
+  //         Uses custom ToV8 function and slow.
+  V8SetReturnValueForMainWorld(callback_info,
+                               static_cast<ScriptWrappable*>(impl));
+}
+
+template <typename CallbackInfo>
+inline void V8SetReturnValueFast(const CallbackInfo& callback_info,
+                                 DOMWindow* impl,
+                                 const ScriptWrappable*) {
+  V8SetReturnValue(callback_info, ToV8(impl, callback_info.Holder(),
+                                       callback_info.GetIsolate()));
+}
+
+template <typename CallbackInfo>
+inline void V8SetReturnValueFast(const CallbackInfo& callback_info,
+                                 EventTarget* impl,
+                                 const ScriptWrappable*) {
+  V8SetReturnValue(callback_info, ToV8(impl, callback_info.Holder(),
+                                       callback_info.GetIsolate()));
+}
+
+template <typename CallbackInfo>
+inline void V8SetReturnValueFast(const CallbackInfo& callback_info,
+                                 Node* impl,
+                                 const ScriptWrappable* wrappable) {
+  V8SetReturnValueFast(callback_info, static_cast<ScriptWrappable*>(impl),
+                       wrappable);
+}
+
 template <typename CallbackInfo, typename T>
 inline void V8SetReturnValue(const CallbackInfo& callbackInfo,
                              NotShared<T> notShared) {
   V8SetReturnValue(callbackInfo, notShared.View());
 }
 
 template <typename CallbackInfo, typename T>
 inline void V8SetReturnValueFast(const CallbackInfo& callbackInfo,
                                  NotShared<T> notShared,
                                  const ScriptWrappable* wrappable) {
@@ skipping 444 matching lines @@
                               ExceptionState& exception_state) {
   using DOMTypedArray = typename MaybeSharedType::TypedArrayType;
   DOMTypedArray* dom_typed_array =
       V8TypeOf<DOMTypedArray>::Type::toImplWithTypeCheck(isolate, value);
   return MaybeSharedType(dom_typed_array);
 }
 
 }  // namespace blink
 
 #endif  // V8BindingForCore_h