Move ScriptWrappable and dependencies to platform/bindings

third_party/WebKit/Source/platform/bindings/V8Binding.h

 /*
  * 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.
@@ skipping 14 matching lines @@
  * 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
 
-#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/PlatformExport.h"
+#include "platform/bindings/DOMDataStore.h"
+#include "platform/bindings/DOMWrapperWorld.h"
+#include "platform/bindings/ScriptWrappable.h"
+#include "platform/bindings/StringResource.h"
+#include "platform/bindings/V8BindingMacros.h"
+#include "platform/bindings/V8PerIsolateData.h"
+#include "platform/bindings/V8ValueCache.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.
@@ skipping 194 matching lines @@
   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())
+  if (StringImpl* impl = string.SharedImpl()) {
     return V8PerIsolateData::From(isolate)->GetStringCache()->V8ExternalString(
         isolate, impl);
-  if (string.Is8Bit())
+  }
+  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) {
@@ skipping 10 matching lines @@
                                            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())
+  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,
@@ skipping 22 matching lines @@
 
 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>);
+PLATFORM_EXPORT 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);
+PLATFORM_EXPORT bool AddHiddenValueToArray(v8::Isolate*,
+                                           v8::Local<v8::Object>,
+                                           v8::Local<v8::Value>,
+                                           int cache_index);
+PLATFORM_EXPORT 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*);
+PLATFORM_EXPORT v8::Local<v8::Value> FreezeV8Object(v8::Local<v8::Value>,
+                                                    v8::Isolate*);
 
 }  // namespace blink
 
 #endif  // V8Binding_h