Split V8Binding

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

Index: third_party/WebKit/Source/bindings/core/v8/V8BindingForCore.h
diff --git a/third_party/WebKit/Source/bindings/core/v8/V8Binding.h b/third_party/WebKit/Source/bindings/core/v8/V8BindingForCore.h
similarity index 67%
copy from third_party/WebKit/Source/bindings/core/v8/V8Binding.h
copy to third_party/WebKit/Source/bindings/core/v8/V8BindingForCore.h
index f14d0f6aa2d144028a2f165f035cae3cfcf5ff6f..5a3409e967092942d4c4f258608f9c9ad89b086e 100644
--- a/third_party/WebKit/Source/bindings/core/v8/V8Binding.h
+++ b/third_party/WebKit/Source/bindings/core/v8/V8BindingForCore.h
@@ -1,36 +1,36 @@
 /*
-* Copyright (C) 2009 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.
-*     * Redistributions in binary form must reproduce the above
-* copyright notice, this list of conditions and the following disclaimer
-* in the documentation and/or other materials provided with the
-* distribution.
-*     * Neither the name of Google Inc. nor the names of its
-* contributors may be used to endorse or promote products derived from
-* this software without specific prior written permission.
-*
-* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef V8Binding_h
-#define V8Binding_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.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef V8BindingForCore_h
+#define V8BindingForCore_h
 
 #include "bindings/core/v8/DOMDataStore.h"
 #include "bindings/core/v8/DOMWrapperWorld.h"
@@ -40,6 +40,7 @@
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/ScriptWrappable.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"
@@ -66,185 +67,18 @@ class LocalFrame;
 class NodeFilter;
 class XPathNSResolver;
 
-template <typename T>
-struct V8TypeOf {
-  STATIC_ONLY(V8TypeOf);
-  // |Type| provides C++ -> V8 type conversion for DOM wrappers.
-  // The Blink binding code generator will generate specialized version of
-  // V8TypeOf for each wrapper class.
-  typedef void Type;
-};
-
-template <typename CallbackInfo, typename S>
-inline void V8SetReturnValue(const CallbackInfo& info,
-                             const v8::Persistent<S>& handle) {
-  info.GetReturnValue().Set(handle);
-}
-
-template <typename CallbackInfo, typename S>
-inline void V8SetReturnValue(const CallbackInfo& info,
-                             const v8::Local<S> handle) {
-  info.GetReturnValue().Set(handle);
-}
-
-template <typename CallbackInfo, typename S>
-inline void V8SetReturnValue(const CallbackInfo& info,
-                             v8::MaybeLocal<S> maybe) {
-  if (LIKELY(!maybe.IsEmpty()))
-    info.GetReturnValue().Set(maybe.ToLocalChecked());
-}
-
-template <typename CallbackInfo>
-inline void V8SetReturnValue(const CallbackInfo& info, bool value) {
-  info.GetReturnValue().Set(value);
-}
-
-template <typename CallbackInfo>
-inline void V8SetReturnValue(const CallbackInfo& info, double value) {
-  info.GetReturnValue().Set(value);
-}
-
-template <typename CallbackInfo>
-inline void V8SetReturnValue(const CallbackInfo& info, int32_t value) {
-  info.GetReturnValue().Set(value);
-}
-
-template <typename CallbackInfo>
-inline void V8SetReturnValue(const CallbackInfo& info, uint32_t value) {
-  info.GetReturnValue().Set(value);
-}
-
-template <typename CallbackInfo>
-inline void V8SetReturnValueBool(const CallbackInfo& info, bool v) {
-  info.GetReturnValue().Set(v);
-}
-
-template <typename CallbackInfo>
-inline void V8SetReturnValueInt(const CallbackInfo& info, int v) {
-  info.GetReturnValue().Set(v);
-}
-
-template <typename CallbackInfo>
-inline void V8SetReturnValueUnsigned(const CallbackInfo& info, unsigned v) {
-  info.GetReturnValue().Set(v);
-}
-
-template <typename CallbackInfo>
-inline void V8SetReturnValueNull(const CallbackInfo& info) {
-  info.GetReturnValue().SetNull();
-}
-
-template <typename CallbackInfo>
-inline void V8SetReturnValueUndefined(const CallbackInfo& info) {
-  info.GetReturnValue().SetUndefined();
-}
-
-template <typename CallbackInfo>
-inline void V8SetReturnValueEmptyString(const CallbackInfo& info) {
-  info.GetReturnValue().SetEmptyString();
-}
-
-template <typename CallbackInfo>
-inline void V8SetReturnValueString(const CallbackInfo& info,
-                                   const String& string,
-                                   v8::Isolate* isolate) {
-  if (string.IsNull()) {
-    V8SetReturnValueEmptyString(info);
-    return;
-  }
-  V8PerIsolateData::From(isolate)->GetStringCache()->SetReturnValueFromString(
-      info.GetReturnValue(), string.Impl());
-}
-
-template <typename CallbackInfo>
-inline void V8SetReturnValueStringOrNull(const CallbackInfo& info,
-                                         const String& string,
-                                         v8::Isolate* isolate) {
-  if (string.IsNull()) {
-    V8SetReturnValueNull(info);
-    return;
-  }
-  V8PerIsolateData::From(isolate)->GetStringCache()->SetReturnValueFromString(
-      info.GetReturnValue(), string.Impl());
-}
-
-template <typename CallbackInfo>
-inline void V8SetReturnValue(const CallbackInfo& callback_info,
-                             ScriptWrappable* impl,
-                             v8::Local<v8::Object> creation_context) {
-  if (UNLIKELY(!impl)) {
-    V8SetReturnValueNull(callback_info);
-    return;
-  }
-  if (DOMDataStore::SetReturnValue(callback_info.GetReturnValue(), impl))
-    return;
-  v8::Local<v8::Object> wrapper =
-      impl->Wrap(callback_info.GetIsolate(), creation_context);
-  V8SetReturnValue(callback_info, wrapper);
-}
-
-template <typename CallbackInfo>
-inline void V8SetReturnValue(const CallbackInfo& callback_info,
-                             ScriptWrappable* impl) {
-  V8SetReturnValue(callback_info, impl, callback_info.Holder());
-}
-
 template <typename CallbackInfo>
 inline void V8SetReturnValue(const CallbackInfo& callback_info, Node* impl) {
   V8SetReturnValue(callback_info, ScriptWrappable::FromNode(impl));
 }
 
 template <typename CallbackInfo, typename T>
-inline void V8SetReturnValue(const CallbackInfo& callback_info,
-                             PassRefPtr<T> impl) {
-  V8SetReturnValue(callback_info, impl.Get());
-}
-
-template <typename CallbackInfo, typename T>
 inline void V8SetReturnValue(const CallbackInfo& callbackInfo,
                              NotShared<T> notShared) {
   V8SetReturnValue(callbackInfo, notShared.View());
 }
 
 template <typename CallbackInfo>
-inline void V8SetReturnValueForMainWorld(const CallbackInfo& callback_info,
-                                         ScriptWrappable* impl) {
-  DCHECK(DOMWrapperWorld::Current(callback_info.GetIsolate()).IsMainWorld());
-  if (UNLIKELY(!impl)) {
-    V8SetReturnValueNull(callback_info);
-    return;
-  }
-  if (DOMDataStore::SetReturnValueForMainWorld(callback_info.GetReturnValue(),
-                                               impl))
-    return;
-  v8::Local<v8::Object> wrapper =
-      impl->Wrap(callback_info.GetIsolate(), callback_info.Holder());
-  V8SetReturnValue(callback_info, wrapper);
-}
-
-template <typename CallbackInfo, typename T>
-inline void V8SetReturnValueForMainWorld(const CallbackInfo& callback_info,
-                                         PassRefPtr<T> impl) {
-  V8SetReturnValueForMainWorld(callback_info, impl.Get());
-}
-
-template <typename CallbackInfo>
-inline void V8SetReturnValueFast(const CallbackInfo& callback_info,
-                                 ScriptWrappable* impl,
-                                 const ScriptWrappable* wrappable) {
-  if (UNLIKELY(!impl)) {
-    V8SetReturnValueNull(callback_info);
-    return;
-  }
-  if (DOMDataStore::SetReturnValueFast(callback_info.GetReturnValue(), impl,
-                                       callback_info.Holder(), wrappable))
-    return;
-  v8::Local<v8::Object> wrapper =
-      impl->Wrap(callback_info.GetIsolate(), callback_info.Holder());
-  V8SetReturnValue(callback_info, wrapper);
-}
-
-template <typename CallbackInfo>
 inline void V8SetReturnValueFast(const CallbackInfo& callback_info,
                                  Node* impl,
                                  const ScriptWrappable* wrappable) {
@@ -252,20 +86,6 @@ inline void V8SetReturnValueFast(const CallbackInfo& callback_info,
                        wrappable);
 }
 
-template <typename CallbackInfo, typename T, typename Wrappable>
-inline void V8SetReturnValueFast(const CallbackInfo& callback_info,
-                                 PassRefPtr<T> impl,
-                                 const Wrappable* wrappable) {
-  V8SetReturnValueFast(callback_info, impl.Get(), wrappable);
-}
-
-template <typename CallbackInfo, typename T>
-inline void V8SetReturnValueFast(const CallbackInfo& callback_info,
-                                 const v8::Local<T> handle,
-                                 const ScriptWrappable*) {
-  V8SetReturnValue(callback_info, handle);
-}
-
 template <typename CallbackInfo, typename T>
 inline void V8SetReturnValueFast(const CallbackInfo& callbackInfo,
                                  NotShared<T> notShared,
@@ -273,124 +93,6 @@ inline void V8SetReturnValueFast(const CallbackInfo& callbackInfo,
   V8SetReturnValueFast(callbackInfo, notShared.View(), wrappable);
 }
 
-// Convert v8::String to a WTF::String. If the V8 string is not already
-// an external string then it is transformed into an external string at this
-// point to avoid repeated conversions.
-inline String ToCoreString(v8::Local<v8::String> value) {
-  return V8StringToWebCoreString<String>(value, kExternalize);
-}
-
-inline String ToCoreStringWithNullCheck(v8::Local<v8::String> value) {
-  if (value.IsEmpty() || value->IsNull())
-    return String();
-  return ToCoreString(value);
-}
-
-inline String ToCoreStringWithUndefinedOrNullCheck(
-    v8::Local<v8::String> value) {
-  if (value.IsEmpty() || value->IsNull() || value->IsUndefined())
-    return String();
-  return ToCoreString(value);
-}
-
-inline AtomicString ToCoreAtomicString(v8::Local<v8::String> value) {
-  return V8StringToWebCoreString<AtomicString>(value, kExternalize);
-}
-
-// This method will return a null String if the v8::Value does not contain a
-// v8::String.  It will not call ToString() on the v8::Value. If you want
-// ToString() to be called, please use the TONATIVE_FOR_V8STRINGRESOURCE_*()
-// macros instead.
-inline String ToCoreStringWithUndefinedOrNullCheck(v8::Local<v8::Value> value) {
-  if (value.IsEmpty() || !value->IsString())
-    return String();
-  return ToCoreString(value.As<v8::String>());
-}
-
-// Convert a string to a V8 string.
-
-inline v8::Local<v8::String> V8String(v8::Isolate* isolate,
-                                      const StringView& string) {
-  DCHECK(isolate);
-  if (string.IsNull())
-    return v8::String::Empty(isolate);
-  if (StringImpl* impl = string.SharedImpl())
-    return V8PerIsolateData::From(isolate)->GetStringCache()->V8ExternalString(
-        isolate, impl);
-  if (string.Is8Bit())
-    return v8::String::NewFromOneByte(
-               isolate, reinterpret_cast<const uint8_t*>(string.Characters8()),
-               v8::NewStringType::kNormal, static_cast<int>(string.length()))
-        .ToLocalChecked();
-  return v8::String::NewFromTwoByte(
-             isolate, reinterpret_cast<const uint16_t*>(string.Characters16()),
-             v8::NewStringType::kNormal, static_cast<int>(string.length()))
-      .ToLocalChecked();
-}
-
-// As above, for string literals. The compiler doesn't optimize away the is8Bit
-// and sharedImpl checks for string literals in the StringView version.
-inline v8::Local<v8::String> V8String(v8::Isolate* isolate,
-                                      const char* string) {
-  DCHECK(isolate);
-  if (!string || string[0] == '\0')
-    return v8::String::Empty(isolate);
-  return v8::String::NewFromOneByte(isolate,
-                                    reinterpret_cast<const uint8_t*>(string),
-                                    v8::NewStringType::kNormal, strlen(string))
-      .ToLocalChecked();
-}
-
-inline v8::Local<v8::Value> V8StringOrNull(v8::Isolate* isolate,
-                                           const AtomicString& string) {
-  if (string.IsNull())
-    return v8::Null(isolate);
-  return V8PerIsolateData::From(isolate)->GetStringCache()->V8ExternalString(
-      isolate, string.Impl());
-}
-
-inline v8::Local<v8::String> V8AtomicString(v8::Isolate* isolate,
-                                            const StringView& string) {
-  DCHECK(isolate);
-  if (string.Is8Bit())
-    return v8::String::NewFromOneByte(
-               isolate, reinterpret_cast<const uint8_t*>(string.Characters8()),
-               v8::NewStringType::kInternalized,
-               static_cast<int>(string.length()))
-        .ToLocalChecked();
-  return v8::String::NewFromTwoByte(
-             isolate, reinterpret_cast<const uint16_t*>(string.Characters16()),
-             v8::NewStringType::kInternalized,
-             static_cast<int>(string.length()))
-      .ToLocalChecked();
-}
-
-// As above, for string literals. The compiler doesn't optimize away the is8Bit
-// check for string literals in the StringView version.
-inline v8::Local<v8::String> V8AtomicString(v8::Isolate* isolate,
-                                            const char* string) {
-  DCHECK(isolate);
-  if (!string || string[0] == '\0')
-    return v8::String::Empty(isolate);
-  return v8::String::NewFromOneByte(
-             isolate, reinterpret_cast<const uint8_t*>(string),
-             v8::NewStringType::kInternalized, strlen(string))
-      .ToLocalChecked();
-}
-
-inline v8::Local<v8::String> V8StringFromUtf8(v8::Isolate* isolate,
-                                              const char* bytes,
-                                              int length) {
-  DCHECK(isolate);
-  return v8::String::NewFromUtf8(isolate, bytes, v8::NewStringType::kNormal,
-                                 length)
-      .ToLocalChecked();
-}
-
-inline v8::Local<v8::Value> V8Undefined() {
-  return v8::Local<v8::Value>();
-}
-
 // Conversion flags, used in toIntXX/toUIntXX.
 enum IntegerConversionConfiguration {
   kNormalConversion,
@@ -565,10 +267,6 @@ CORE_EXPORT String ToUSVString(v8::Isolate*,
                                v8::Local<v8::Value>,
                                ExceptionState&);
 
-inline v8::Local<v8::Boolean> V8Boolean(bool value, v8::Isolate* isolate) {
-  return value ? v8::True(isolate) : v8::False(isolate);
-}
-
 inline double ToCoreDate(v8::Isolate* isolate,
                          v8::Local<v8::Value> object,
                          ExceptionState& exception_state) {
@@ -581,12 +279,6 @@ inline double ToCoreDate(v8::Isolate* isolate,
   return object.As<v8::Date>()->ValueOf();
 }
 
-inline v8::MaybeLocal<v8::Value> V8DateOrNaN(v8::Isolate* isolate,
-                                             double value) {
-  DCHECK(isolate);
-  return v8::Date::New(isolate->GetCurrentContext(), value);
-}
-
 // FIXME: Remove the special casing for NodeFilter and XPathNSResolver.
 NodeFilter* ToNodeFilter(v8::Local<v8::Value>,
                          v8::Local<v8::Object>,
@@ -608,9 +300,10 @@ HeapVector<Member<T>> ToMemberNativeArray(v8::Local<v8::Value> value,
   if (value->IsArray()) {
     length = v8::Local<v8::Array>::Cast(v8_value)->Length();
   } else if (!ToV8Sequence(value, length, isolate, exception_state)) {
-    if (!exception_state.HadException())
+    if (!exception_state.HadException()) {
       exception_state.ThrowTypeError(
           ExceptionMessages::NotAnArrayTypeArgumentOrValue(argument_index));
+    }
     return HeapVector<Member<T>>();
   }
 
@@ -652,9 +345,10 @@ HeapVector<Member<T>> ToMemberNativeArray(v8::Local<v8::Value> value,
   if (value->IsArray()) {
     length = v8::Local<v8::Array>::Cast(v8_value)->Length();
   } else if (!ToV8Sequence(value, length, isolate, exception_state)) {
-    if (!exception_state.HadException())
+    if (!exception_state.HadException()) {
       exception_state.ThrowTypeError(
           ExceptionMessages::NotASequenceTypeProperty(property_name));
+    }
     return HeapVector<Member<T>>();
   }
 
@@ -700,9 +394,10 @@ VectorType ToImplArray(v8::Local<v8::Value> value,
   if (value->IsArray()) {
     length = v8::Local<v8::Array>::Cast(value)->Length();
   } else if (!ToV8Sequence(value, length, isolate, exception_state)) {
-    if (!exception_state.HadException())
+    if (!exception_state.HadException()) {
       exception_state.ThrowTypeError(
           ExceptionMessages::NotAnArrayTypeArgumentOrValue(argument_index));
+    }
     return VectorType();
   }
 
@@ -1034,32 +729,6 @@ VectorType ToImplSequence(v8::Isolate* isolate,
   return result;
 }
 
-// If the current context causes out of memory, JavaScript setting
-// is disabled and it returns true.
-bool HandleOutOfMemory();
-
-inline bool IsUndefinedOrNull(v8::Local<v8::Value> value) {
-  return value.IsEmpty() || value->IsNull() || value->IsUndefined();
-}
-v8::Local<v8::Function> GetBoundFunction(v8::Local<v8::Function>);
-
-// FIXME: This will be soon embedded in the generated code.
-template <typename Collection>
-static void IndexedPropertyEnumerator(
-    const v8::PropertyCallbackInfo<v8::Array>& info) {
-  Collection* collection =
-      ToScriptWrappable(info.Holder())->ToImpl<Collection>();
-  int length = collection->length();
-  v8::Local<v8::Array> properties = v8::Array::New(info.GetIsolate(), length);
-  v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
-  for (int i = 0; i < length; ++i) {
-    v8::Local<v8::Integer> integer = v8::Integer::New(info.GetIsolate(), i);
-    if (!V8CallBoolean(properties->CreateDataProperty(context, i, integer)))
-      return;
-  }
-  V8SetReturnValue(info, properties);
-}
-
 CORE_EXPORT bool IsValidEnum(const String& value,
                              const char** valid_values,
                              size_t length,
@@ -1071,16 +740,6 @@ CORE_EXPORT bool IsValidEnum(const Vector<String>& values,
                              const String& enum_name,
                              ExceptionState&);
 
-// These methods store hidden values into an array that is stored in the
-// internal field of a DOM wrapper.
-bool AddHiddenValueToArray(v8::Isolate*,
-                           v8::Local<v8::Object>,
-                           v8::Local<v8::Value>,
-                           int cache_index);
-void RemoveHiddenValueFromArray(v8::Isolate*,
-                                v8::Local<v8::Object>,
-                                v8::Local<v8::Value>,
-                                int cache_index);
 CORE_EXPORT void MoveEventListenerToNewWrapper(v8::Isolate*,
                                                v8::Local<v8::Object>,
                                                EventListener* old_value,
@@ -1091,12 +750,6 @@ CORE_EXPORT void MoveEventListenerToNewWrapper(v8::Isolate*,
 // http://www.w3.org/TR/WebIDL/#delete
 enum DeleteResult { kDeleteSuccess, kDeleteReject, kDeleteUnknownProperty };
 
-// Freeze a V8 object. The type of the first parameter and the return value is
-// intentionally v8::Value so that this function can wrap ToV8().
-// If the argument isn't an object, this will crash.
-CORE_EXPORT v8::Local<v8::Value> FreezeV8Object(v8::Local<v8::Value>,
-                                                v8::Isolate*);
-
 CORE_EXPORT v8::Local<v8::Value> FromJSONString(v8::Isolate*,
                                                 const String& stringified_json,
                                                 ExceptionState&);
@@ -1133,4 +786,4 @@ MaybeSharedType ToMaybeShared(v8::Isolate* isolate,
 
 }  // namespace blink
 
-#endif  // V8Binding_h
+#endif  // V8BindingForCore_h