Abstract out ThreadDebugger from V8PerIsolateData

third_party/WebKit/Source/bindings/core/v8/V8Initializer.cpp

 /*
  * Copyright (C) 2009 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.
  */
 
 #include "bindings/core/v8/V8Initializer.h"
 
+#include <v8-debug.h>
+#include <v8-profiler.h>
+#include <memory>
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/RejectedPromises.h"
 #include "bindings/core/v8/RetainedDOMInfo.h"
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/ScriptWrappableVisitor.h"
 #include "bindings/core/v8/SourceLocation.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8DOMException.h"
 #include "bindings/core/v8/V8ErrorEvent.h"
 #include "bindings/core/v8/V8ErrorHandler.h"
 #include "bindings/core/v8/V8GCController.h"
+#include "bindings/core/v8/V8HiddenValue.h"
 #include "bindings/core/v8/V8IdleTaskRunner.h"
 #include "bindings/core/v8/V8Location.h"
 #include "bindings/core/v8/V8PerContextData.h"
 #include "bindings/core/v8/V8PrivateProperty.h"
 #include "bindings/core/v8/V8Window.h"
 #include "bindings/core/v8/WorkerOrWorkletScriptController.h"
 #include "core/dom/Document.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/inspector/MainThreadDebugger.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "platform/EventDispatchForbiddenScope.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/loader/fetch/AccessControlStatus.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebThread.h"
 #include "wtf/AddressSanitizer.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/RefPtr.h"
 #include "wtf/text/WTFString.h"
 #include "wtf/typed_arrays/ArrayBufferContents.h"
-#include <memory>
-#include <v8-debug.h>
-#include <v8-profiler.h>
 
 namespace blink {
 
 static Frame* findFrame(v8::Isolate* isolate,
                         v8::Local<v8::Object> host,
                         v8::Local<v8::Value> data) {
   const WrapperTypeInfo* type = WrapperTypeInfo::unwrap(data);
 
   if (V8Window::wrapperTypeInfo.equals(type)) {
     v8::Local<v8::Object> windowWrapper =
@@ skipping 238 matching lines @@
                                ContentSecurityPolicy::WillThrowException);
   }
   return false;
 }
 
 static void initializeV8Common(v8::Isolate* isolate) {
   isolate->AddGCPrologueCallback(V8GCController::gcPrologue);
   isolate->AddGCEpilogueCallback(V8GCController::gcEpilogue);
   std::unique_ptr<ScriptWrappableVisitor> visitor(
       new ScriptWrappableVisitor(isolate));
-  V8PerIsolateData::from(isolate)->setScriptWrappableVisitor(
-      std::move(visitor));
+  V8PerIsolateData* isolateData = V8PerIsolateData::from(isolate);
+  isolateData->setScriptWrappableVisitor(std::move(visitor));
   isolate->SetEmbedderHeapTracer(
       V8PerIsolateData::from(isolate)->scriptWrappableVisitor());
 
   v8::Debug::SetLiveEditEnabled(isolate, false);
 
   isolate->SetMicrotasksPolicy(v8::MicrotasksPolicy::kScoped);
+
+  V8HiddenValue::initialize(isolate);
+  V8PrivateProperty::initialize(isolate);
 }
 
 namespace {
 
 class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
   // Allocate() methods return null to signal allocation failure to V8, which
   // should respond by throwing a RangeError, per
   // http://www.ecma-international.org/ecma-262/6.0/#sec-createbytedatablock.
   void* Allocate(size_t size) override {
     void* data;
@@ skipping 82 matching lines @@
   }
 
   ASSERT(ThreadState::mainThreadState());
   ThreadState::mainThreadState()->addInterruptor(
       WTF::makeUnique<V8IsolateInterruptor>(isolate));
   ThreadState::mainThreadState()->registerTraceDOMWrappers(
       isolate, V8GCController::traceDOMWrappers,
       ScriptWrappableVisitor::invalidateDeadObjectsInMarkingDeque,
       ScriptWrappableVisitor::performCleanup);
 
-  V8PerIsolateData::from(isolate)->setThreadDebugger(
-      WTF::makeUnique<MainThreadDebugger>(isolate));
+  ThreadDebugger::setThreadDebugger(isolate, new MainThreadDebugger(isolate));

[jbroman, 2017/02/15 02:25:23]

This looks like it was more or less fine as-is. I'm not clear on what value the
indirection through ThreadDebugger adds.

[adithyas, 2017/02/15 18:12:12]

I thought it was weird having a getter and setter in a different place, but yeah
I think you're right, no additional value.

 }
 
 static void reportFatalErrorInWorker(const char* location,
                                      const char* message) {
   // FIXME: We temporarily deal with V8 internal error situations such as
   // out-of-memory by crashing the worker.
   CRASH();
 }
 
 static void messageHandlerInWorker(v8::Local<v8::Message> message,
@@ skipping 65 matching lines @@
           v8::Isolate::kMessageLog);
   isolate->SetFatalErrorHandler(reportFatalErrorInWorker);
 
   uint32_t here;
   isolate->SetStackLimit(reinterpret_cast<uintptr_t>(&here) -
                          kWorkerMaxStackSize);
   isolate->SetPromiseRejectCallback(promiseRejectHandlerInWorker);
 }
 
 }  // namespace blink