Ejemplos de initializeV8Common en C++ (Cpp)

Ejemplo n.º 1

Archivo: V8Initializer.cpp Proyecto: joone/blink-crosswalk

void V8Initializer::initializeMainThreadIfNeeded()
{
    ASSERT(isMainThread());

    static bool initialized = false;
    if (initialized)
        return;
    initialized = true;

    DEFINE_STATIC_LOCAL(ArrayBufferAllocator, arrayBufferAllocator, ());
    gin::IsolateHolder::Initialize(gin::IsolateHolder::kNonStrictMode, &arrayBufferAllocator);

    v8::Isolate* isolate = V8PerIsolateData::initialize();

    initializeV8Common(isolate);

    v8::V8::SetFatalErrorHandler(reportFatalErrorInMainThread);
    v8::V8::AddMessageListener(messageHandlerInMainThread);
    v8::V8::SetFailedAccessCheckCallbackFunction(failedAccessCheckCallbackInMainThread);
    v8::V8::SetAllowCodeGenerationFromStringsCallback(codeGenerationCheckCallbackInMainThread);

    if (RuntimeEnabledFeatures::v8IdleTasksEnabled())
        Platform::current()->currentThread()->scheduler()->postIdleTask(FROM_HERE, WTF::bind<double>(idleGCTaskInMainThread));

    isolate->SetEventLogger(timerTraceProfilerInMainThread);
    isolate->SetPromiseRejectCallback(promiseRejectHandlerInMainThread);

    ScriptProfiler::initialize();
}

Ejemplo n.º 2

Archivo: V8Initializer.cpp Proyecto: techtonik/chromium

void V8Initializer::initializeMainThreadIfNeeded()
{
    ASSERT(isMainThread());

    static bool initialized = false;
    if (initialized)
        return;
    initialized = true;

    DEFINE_STATIC_LOCAL(ArrayBufferAllocator, arrayBufferAllocator, ());
    gin::IsolateHolder::Initialize(gin::IsolateHolder::kNonStrictMode, &arrayBufferAllocator);

    v8::Isolate* isolate = V8PerIsolateData::initialize();

    initializeV8Common(isolate);

    v8::V8::SetFatalErrorHandler(reportFatalErrorInMainThread);
    v8::V8::AddMessageListener(messageHandlerInMainThread);
    v8::V8::SetFailedAccessCheckCallbackFunction(failedAccessCheckCallbackInMainThread);
    v8::V8::SetAllowCodeGenerationFromStringsCallback(codeGenerationCheckCallbackInMainThread);

    if (RuntimeEnabledFeatures::v8IdleTasksEnabled()) {
        WebScheduler* scheduler = Platform::current()->currentThread()->scheduler();
        V8PerIsolateData::enableIdleTasks(isolate, adoptPtr(new V8IdleTaskRunner(scheduler)));
    }

    isolate->SetEventLogger(timerTraceProfilerInMainThread);
    isolate->SetPromiseRejectCallback(promiseRejectHandlerInMainThread);

    if (v8::HeapProfiler* profiler = isolate->GetHeapProfiler())
        profiler->SetWrapperClassInfoProvider(WrapperTypeInfo::NodeClassId, &RetainedDOMInfo::retainedDOMInfo);
}

Ejemplo n.º 3

Archivo: V8Initializer.cpp Proyecto: endlessm/chromium-browser

// This function uses a local stack variable to determine the isolate's stack limit. AddressSanitizer may
// relocate that local variable to a fake stack, which may lead to problems during JavaScript execution.
// Therefore we disable AddressSanitizer for V8Initializer::initializeWorker().
NO_SANITIZE_ADDRESS
void V8Initializer::initializeWorker(v8::Isolate* isolate)
{
    initializeV8Common(isolate);

    isolate->AddMessageListener(messageHandlerInWorker);
    isolate->SetFatalErrorHandler(reportFatalErrorInWorker);

    uint32_t here;
    isolate->SetStackLimit(reinterpret_cast<uintptr_t>(&here - kWorkerMaxStackSize / sizeof(uint32_t*)));
    isolate->SetPromiseRejectCallback(promiseRejectHandlerInWorker);
}

Ejemplo n.º 4

Archivo: V8Initializer.cpp Proyecto: ollie314/chromium

void V8Initializer::initializeMainThread() {
  ASSERT(isMainThread());

  WTF::ArrayBufferContents::initialize(adjustAmountOfExternalAllocatedMemory);

  DEFINE_STATIC_LOCAL(ArrayBufferAllocator, arrayBufferAllocator, ());
  auto v8ExtrasMode = RuntimeEnabledFeatures::experimentalV8ExtrasEnabled()
                          ? gin::IsolateHolder::kStableAndExperimentalV8Extras
                          : gin::IsolateHolder::kStableV8Extras;
  gin::IsolateHolder::Initialize(gin::IsolateHolder::kNonStrictMode,
                                 v8ExtrasMode, &arrayBufferAllocator);

  v8::Isolate* isolate = V8PerIsolateData::initialize();

  initializeV8Common(isolate);

  isolate->SetOOMErrorHandler(reportOOMErrorInMainThread);
  isolate->SetFatalErrorHandler(reportFatalErrorInMainThread);
  isolate->AddMessageListener(messageHandlerInMainThread);
  isolate->SetFailedAccessCheckCallbackFunction(
      failedAccessCheckCallbackInMainThread);
  isolate->SetAllowCodeGenerationFromStringsCallback(
      codeGenerationCheckCallbackInMainThread);

  if (RuntimeEnabledFeatures::v8IdleTasksEnabled()) {
    WebScheduler* scheduler = Platform::current()->currentThread()->scheduler();
    V8PerIsolateData::enableIdleTasks(
        isolate, wrapUnique(new V8IdleTaskRunner(scheduler)));
  }

  isolate->SetPromiseRejectCallback(promiseRejectHandlerInMainThread);

  if (v8::HeapProfiler* profiler = isolate->GetHeapProfiler())
    profiler->SetWrapperClassInfoProvider(
        WrapperTypeInfo::NodeClassId, &RetainedDOMInfo::createRetainedDOMInfo);

  ASSERT(ThreadState::mainThreadState());
  ThreadState::mainThreadState()->addInterruptor(
      wrapUnique(new V8IsolateInterruptor(isolate)));
  if (RuntimeEnabledFeatures::traceWrappablesEnabled()) {
    ThreadState::mainThreadState()->registerTraceDOMWrappers(
        isolate, V8GCController::traceDOMWrappers,
        ScriptWrappableVisitor::invalidateDeadObjectsInMarkingDeque,
        ScriptWrappableVisitor::performCleanup);
  } else {
    ThreadState::mainThreadState()->registerTraceDOMWrappers(
        isolate, V8GCController::traceDOMWrappers, nullptr, nullptr);
  }

  V8PerIsolateData::from(isolate)->setThreadDebugger(
      wrapUnique(new MainThreadDebugger(isolate)));
}

Ejemplo n.º 5

Archivo: V8Initializer.cpp Proyecto: IllusionRom-deprecated/android_platform_external_chromium_org_third_party_WebKit

void V8Initializer::initializeWorker(v8::Isolate* isolate)
{
    initializeV8Common();

    v8::V8::AddMessageListener(messageHandlerInWorker);
    v8::V8::SetFatalErrorHandler(reportFatalErrorInWorker);

    v8::ResourceConstraints resourceConstraints;
    uint32_t here;
    resourceConstraints.set_stack_limit(&here - kWorkerMaxStackSize / sizeof(uint32_t*));
    v8::SetResourceConstraints(&resourceConstraints);

    V8PerIsolateData::ensureInitialized(isolate);
}

Ejemplo n.º 6

Archivo: V8Initializer.cpp Proyecto: IllusionRom-deprecated/android_platform_external_chromium_org_third_party_WebKit

void V8Initializer::initializeMainThreadIfNeeded(v8::Isolate* isolate)
{
    ASSERT(isMainThread());

    static bool initialized = false;
    if (initialized)
        return;
    initialized = true;

    initializeV8Common();

    v8::V8::SetFatalErrorHandler(reportFatalErrorInMainThread);
    v8::V8::AddMessageListener(messageHandlerInMainThread);
    v8::V8::SetFailedAccessCheckCallbackFunction(failedAccessCheckCallbackInMainThread);
    v8::V8::SetAllowCodeGenerationFromStringsCallback(codeGenerationCheckCallbackInMainThread);
    ScriptProfiler::initialize();
    V8PerIsolateData::ensureInitialized(isolate);
}

Ejemplo n.º 7

Archivo: V8Initializer.cpp Proyecto: esprehn/mojo

void V8Initializer::initializeMainThreadIfNeeded()
{
    ASSERT(isMainThread());

    static bool initialized = false;
    if (initialized)
        return;
    initialized = true;

    gin::IsolateHolder::Initialize(gin::IsolateHolder::kStrictMode, v8ArrayBufferAllocator());

    v8::Isolate* isolate = V8PerIsolateData::initialize();

    initializeV8Common(isolate);

    v8::V8::SetFatalErrorHandler(reportFatalErrorInMainThread);
    v8::V8::AddMessageListener(messageHandlerInMainThread);
    v8::V8::SetFailedAccessCheckCallbackFunction(failedAccessCheckCallbackInMainThread);

    isolate->SetEventLogger(timerTraceProfilerInMainThread);

    ScriptProfiler::initialize();
}