bindings: Makes the window object be the inner global object.

third_party/WebKit/Source/bindings/core/v8/V8PerIsolateData.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
@@ skipping 34 matching lines @@
 static void beforeCallEnteredCallback(v8::Isolate* isolate)
 {
     RELEASE_ASSERT(!ScriptForbiddenScope::isScriptForbidden());
 }
 
 static void microtasksCompletedCallback(v8::Isolate* isolate)
 {
     V8PerIsolateData::from(isolate)->runEndOfScopeTasks();
 }
 
-static void useCounterCallback(v8::Isolate* isolate, v8::Isolate::UseCounterFeature feature)
+V8PerIsolateData::V8PerIsolateData()
+    : m_isolateHolder(adoptPtr(new gin::IsolateHolder()))
+    , m_stringCache(adoptPtr(new StringCache(isolate())))
+    , m_hiddenValue(V8HiddenValue::create())
+    , m_constructorMode(ConstructorMode::CreateNewObject)
+    , m_useCounterDisabled(false)
+    , m_isHandlingRecursionLevelError(false)
+    , m_isReportingException(false)
 {
+    // FIXME: Remove once all v8::Isolate::GetCurrent() calls are gone.
+    isolate()->Enter();
+    isolate()->AddBeforeCallEnteredCallback(&beforeCallEnteredCallback);
+    isolate()->AddMicrotasksCompletedCallback(&microtasksCompletedCallback);
+    if (isMainThread())
+        mainThreadPerIsolateData = this;
+    isolate()->SetUseCounterCallback(&useCounterCallback);
+}
+
+V8PerIsolateData::~V8PerIsolateData()
+{
+}
+
+v8::Isolate* V8PerIsolateData::mainThreadIsolate()
+{
+    ASSERT(isMainThread());
+    ASSERT(mainThreadPerIsolateData);
+    return mainThreadPerIsolateData->isolate();
+}
+
+v8::Isolate* V8PerIsolateData::initialize()
+{
+    V8PerIsolateData* data = new V8PerIsolateData();
+    v8::Isolate* isolate = data->isolate();
+    isolate->SetData(gin::kEmbedderBlink, data);
+    return isolate;
+}
+
+void V8PerIsolateData::enableIdleTasks(v8::Isolate* isolate, PassOwnPtr<gin::V8IdleTaskRunner> taskRunner)
+{
+    from(isolate)->m_isolateHolder->EnableIdleTasks(std::unique_ptr<gin::V8IdleTaskRunner>(taskRunner.leakPtr()));
+}
+
+void V8PerIsolateData::useCounterCallback(v8::Isolate* isolate, v8::Isolate::UseCounterFeature feature)
+{
+    if (V8PerIsolateData::from(isolate)->m_useCounterDisabled)

[haraken, 2016/04/18 09:26:40]

Why does the useCounterCallback crash if it's called during context
initialization? If it's just because isolate->EnteredContext returns an empty
context, we can just check it and immediately return here.

[Yuki, 2016/04/18 09:39:30]

On line 174, currentExecutionContext(isolate) has the problem.
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

I'm not sure if isolate->GetCurrentContext() returns an empty handle or not. 
Even if so, is it reliable that the current context is empty while we create a
new context?

If the current context is NOT empty (I need to check it),
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...
toExecutionContext() is doing something wrong.  The window object is NOT YET
associated with the native DOMWindow object.

If necessary, I'll dig into deeper.

+        return;
+
     UseCounter::Feature blinkFeature;
     bool deprecated = false;
     switch (feature) {
     case v8::Isolate::kUseAsm:
         blinkFeature = UseCounter::UseAsm;
         break;
     case v8::Isolate::kBreakIterator:
         blinkFeature = UseCounter::BreakIterator;
         break;
     case v8::Isolate::kLegacyConst:
@@ skipping 55 matching lines @@
         // This can happen if V8 has added counters that this version of Blink
         // does not know about. It's harmless.
         return;
     }
     if (deprecated)
         Deprecation::countDeprecation(currentExecutionContext(isolate), blinkFeature);
     else
         UseCounter::count(currentExecutionContext(isolate), blinkFeature);
 }
 
-V8PerIsolateData::V8PerIsolateData()
-    : m_isolateHolder(adoptPtr(new gin::IsolateHolder()))
-    , m_stringCache(adoptPtr(new StringCache(isolate())))
-    , m_hiddenValue(V8HiddenValue::create())
-    , m_constructorMode(ConstructorMode::CreateNewObject)
-    , m_isHandlingRecursionLevelError(false)
-    , m_isReportingException(false)
-{
-    // FIXME: Remove once all v8::Isolate::GetCurrent() calls are gone.
-    isolate()->Enter();
-    isolate()->AddBeforeCallEnteredCallback(&beforeCallEnteredCallback);
-    isolate()->AddMicrotasksCompletedCallback(&microtasksCompletedCallback);
-    if (isMainThread())
-        mainThreadPerIsolateData = this;
-    isolate()->SetUseCounterCallback(&useCounterCallback);
-}
-
-V8PerIsolateData::~V8PerIsolateData()
-{
-}
-
-v8::Isolate* V8PerIsolateData::mainThreadIsolate()
-{
-    ASSERT(isMainThread());
-    ASSERT(mainThreadPerIsolateData);
-    return mainThreadPerIsolateData->isolate();
-}
-
-v8::Isolate* V8PerIsolateData::initialize()
-{
-    V8PerIsolateData* data = new V8PerIsolateData();
-    v8::Isolate* isolate = data->isolate();
-    isolate->SetData(gin::kEmbedderBlink, data);
-    return isolate;
-}
-
-void V8PerIsolateData::enableIdleTasks(v8::Isolate* isolate, PassOwnPtr<gin::V8IdleTaskRunner> taskRunner)
-{
-    from(isolate)->m_isolateHolder->EnableIdleTasks(std::unique_ptr<gin::V8IdleTaskRunner>(taskRunner.leakPtr()));
-}
-
 v8::Persistent<v8::Value>& V8PerIsolateData::ensureLiveRoot()
 {
     if (m_liveRoot.isEmpty())
         m_liveRoot.set(isolate(), v8::Null(isolate()));
     return m_liveRoot.getUnsafe();
 }
 
 // willBeDestroyed() clear things that should be cleared before
 // ThreadState::detach() gets called.
 void V8PerIsolateData::willBeDestroyed(v8::Isolate* isolate)
@@ skipping 149 matching lines @@
     ASSERT(!m_threadDebugger);
     m_threadDebugger = std::move(threadDebugger);
 }
 
 ThreadDebugger* V8PerIsolateData::threadDebugger()
 {
     return m_threadDebugger.get();
 }
 
 } // namespace blink