Move ScriptWrappable and dependencies to platform/bindings

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

Index: third_party/WebKit/Source/bindings/core/v8/V8Binding.h
diff --git a/third_party/WebKit/Source/bindings/core/v8/V8Binding.h b/third_party/WebKit/Source/bindings/core/v8/V8Binding.h
index fb39d29a6ed5e8b106ba0150a327069570d595e4..2fc80e86522e934dad56a15eba2a0baa1efe67f7 100644
--- a/third_party/WebKit/Source/bindings/core/v8/V8Binding.h
+++ b/third_party/WebKit/Source/bindings/core/v8/V8Binding.h
@@ -29,354 +29,6 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef V8Binding_h
-#define V8Binding_h
-
-#include "bindings/core/v8/DOMDataStore.h"
-#include "bindings/core/v8/DOMWrapperWorld.h"
-#include "bindings/core/v8/ScriptWrappable.h"
-#include "bindings/core/v8/StringResource.h"
-#include "bindings/core/v8/V8BindingMacros.h"
-#include "bindings/core/v8/V8PerIsolateData.h"
-#include "bindings/core/v8/V8ScriptRunner.h"
-#include "bindings/core/v8/V8ValueCache.h"
-#include "core/CoreExport.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 bindings helper functions that do not have dependencies
-// to core/ or bindings/core. For core-specific helper functions, see
-// bindings/core/v8/V8BindingForCore.h.
-
-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 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>
-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, typename T>
-inline void V8SetReturnValueFast(const CallbackInfo& callback_info,
-                                 const v8::Local<T> handle,
-                                 const ScriptWrappable*) {
-  V8SetReturnValue(callback_info, handle);
-}
-
-// 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())
-    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>();
-}
-
-inline v8::MaybeLocal<v8::Value> V8DateOrNaN(v8::Isolate* isolate,
-                                             double value) {
-  DCHECK(isolate);
-  return v8::Date::New(isolate->GetCurrentContext(), value);
-}
-
-inline bool IsUndefinedOrNull(v8::Local<v8::Value> value) {
-  return value.IsEmpty() || value->IsNullOrUndefined();
-}
-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);
-}
-
-// 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);
-
-// 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*);
-
-}  // namespace blink
-
-#endif  // V8Binding_h
+// This file has been moved to platform/bindings/V8Binding.h.
+// TODO(adithyas): Remove this file.
+#include "platform/bindings/V8Binding.h"