Move ScriptWrappable and dependencies to platform/bindings

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

 /*
- * Copyright (C) 2009 Google Inc. All rights reserved.
+ * Copyright (C) 2017 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. 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.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS 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 APPLE INC. OR ITS 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 V8PerIsolateData_h
 #define V8PerIsolateData_h
 
 #include <memory>
 
-#include "bindings/core/v8/ScopedPersistent.h"
-#include "bindings/core/v8/ScriptState.h"
-#include "bindings/core/v8/ScriptWrappableVisitor.h"
-#include "bindings/core/v8/WrapperTypeInfo.h"
-#include "core/CoreExport.h"
 #include "gin/public/isolate_holder.h"
 #include "gin/public/v8_idle_task_runner.h"
+#include "platform/PlatformExport.h"
+#include "platform/bindings/ScopedPersistent.h"
+#include "platform/bindings/ScriptState.h"
+#include "platform/bindings/ScriptWrappableVisitor.h"
+#include "platform/bindings/WrapperTypeInfo.h"
 #include "platform/heap/Handle.h"
 #include "platform/wtf/HashMap.h"
 #include "platform/wtf/Noncopyable.h"
 #include "platform/wtf/Vector.h"
 #include "v8/include/v8.h"
 
 namespace blink {
 
 class ActiveScriptWrappableBase;
 class DOMDataStore;
 class StringCache;
 class V8PrivateProperty;
 class WebTaskRunner;
 struct WrapperTypeInfo;
 
 typedef WTF::Vector<DOMDataStore*> DOMDataStoreList;
 
-class CORE_EXPORT V8PerIsolateData {
+class PLATFORM_EXPORT V8PerIsolateData {
   USING_FAST_MALLOC(V8PerIsolateData);
   WTF_MAKE_NONCOPYABLE(V8PerIsolateData);
 
  public:
   class EndOfScopeTask {
     USING_FAST_MALLOC(EndOfScopeTask);
 
    public:
     virtual ~EndOfScopeTask() {}
     virtual void Run() = 0;
@@ skipping 20 matching lines @@
     }
 
    private:
     V8PerIsolateData* per_isolate_data_;
     const bool original_use_counter_disabled_;
   };
 
   // Use this class to abstract away types of members that are pointers to core/
   // objects, which are simply owned and released by V8PerIsolateData (see
   // m_threadDebugger for an example).
-  class CORE_EXPORT Data {
+  class PLATFORM_EXPORT Data {
    public:
     virtual ~Data() = default;
   };
 
   static v8::Isolate* Initialize(WebTaskRunner*);
 
   static V8PerIsolateData* From(v8::Isolate* isolate) {
     DCHECK(isolate);
     DCHECK(isolate->GetData(gin::kEmbedderBlink));
     return static_cast<V8PerIsolateData*>(
@@ skipping 71 matching lines @@
   void SetThreadDebugger(std::unique_ptr<Data>);
   Data* ThreadDebugger();
 
   using ActiveScriptWrappableSet =
       HeapHashSet<WeakMember<ActiveScriptWrappableBase>>;
   void AddActiveScriptWrappable(ActiveScriptWrappableBase*);
   const ActiveScriptWrappableSet* ActiveScriptWrappables() const {
     return active_script_wrappables_.Get();
   }
 
-  class CORE_EXPORT TemporaryScriptWrappableVisitorScope {
+  class PLATFORM_EXPORT TemporaryScriptWrappableVisitorScope {
     WTF_MAKE_NONCOPYABLE(TemporaryScriptWrappableVisitorScope);
     STACK_ALLOCATED();
 
    public:
     TemporaryScriptWrappableVisitorScope(
         v8::Isolate* isolate,
         std::unique_ptr<ScriptWrappableVisitor> visitor)
         : isolate_(isolate), saved_visitor_(std::move(visitor)) {
       SwapWithV8PerIsolateDataVisitor(saved_visitor_);
     }
@@ skipping 67 matching lines @@
   Vector<std::unique_ptr<EndOfScopeTask>> end_of_scope_tasks_;
   std::unique_ptr<Data> thread_debugger_;
 
   Persistent<ActiveScriptWrappableSet> active_script_wrappables_;
   std::unique_ptr<ScriptWrappableVisitor> script_wrappable_visitor_;
 };
 
 }  // namespace blink
 
 #endif  // V8PerIsolateData_h