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

third_party/WebKit/Source/bindings/core/v8/V8PerIsolateData.h

 /*
  * 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 41 matching lines @@
     USING_FAST_MALLOC(V8PerIsolateData);
     WTF_MAKE_NONCOPYABLE(V8PerIsolateData);
 public:
     class EndOfScopeTask {
         USING_FAST_MALLOC(EndOfScopeTask);
     public:
         virtual ~EndOfScopeTask() { }
         virtual void run() = 0;
     };
 
+    // Disables the UseCounter.
+    // UseCounter depends on the current context, but it's not available during
+    // the initialization of v8::Context and the global object.  So we need to
+    // disable the UseCounter while the initialization of the context and global
+    // object.
+    // TODO(yukishiino): Come up with an idea to remove this hack.
+    class UseCounterDisabledScope {
+        STACK_ALLOCATED();
+    public:
+        explicit UseCounterDisabledScope(V8PerIsolateData* perIsolateData)
+            : m_perIsolateData(perIsolateData)
+            , m_originalUseCounterDisabled(m_perIsolateData->m_useCounterDisabled)
+        {
+            m_perIsolateData->m_useCounterDisabled = true;
+        }
+        ~UseCounterDisabledScope()
+        {
+            m_perIsolateData->m_useCounterDisabled = m_originalUseCounterDisabled;
+        }
+
+    private:
+        V8PerIsolateData* m_perIsolateData;
+        const bool m_originalUseCounterDisabled;
+    };
+
     static v8::Isolate* initialize();
 
     static V8PerIsolateData* from(v8::Isolate* isolate)
     {
         ASSERT(isolate);
         ASSERT(isolate->GetData(gin::kEmbedderBlink));
         return static_cast<V8PerIsolateData*>(isolate->GetData(gin::kEmbedderBlink));
     }
 
     static void willBeDestroyed(v8::Isolate*);
@@ skipping 38 matching lines @@
     void runEndOfScopeTasks();
     void clearEndOfScopeTasks();
 
     void setThreadDebugger(PassOwnPtr<ThreadDebugger>);
     ThreadDebugger* threadDebugger();
 
 private:
     V8PerIsolateData();
     ~V8PerIsolateData();
 
+    static void useCounterCallback(v8::Isolate*, v8::Isolate::UseCounterFeature);
+
     typedef HashMap<const void*, v8::Eternal<v8::FunctionTemplate>> V8FunctionTemplateMap;
     V8FunctionTemplateMap& selectInterfaceTemplateMap(const DOMWrapperWorld&);
     V8FunctionTemplateMap& selectOperationTemplateMap(const DOMWrapperWorld&);
     bool hasInstance(const WrapperTypeInfo* untrusted, v8::Local<v8::Value>, V8FunctionTemplateMap&);
     v8::Local<v8::Object> findInstanceInPrototypeChain(const WrapperTypeInfo*, v8::Local<v8::Value>, V8FunctionTemplateMap&);
 
     OwnPtr<gin::IsolateHolder> m_isolateHolder;
 
     // m_interfaceTemplateMapFor{,Non}MainWorld holds function templates for
     // the inerface objects.
     V8FunctionTemplateMap m_interfaceTemplateMapForMainWorld;
     V8FunctionTemplateMap m_interfaceTemplateMapForNonMainWorld;
     // m_operationTemplateMapFor{,Non}MainWorld holds function templates for
     // the cross-origin accessible DOM operations.
     V8FunctionTemplateMap m_operationTemplateMapForMainWorld;
     V8FunctionTemplateMap m_operationTemplateMapForNonMainWorld;
 
     OwnPtr<StringCache> m_stringCache;
     OwnPtr<V8HiddenValue> m_hiddenValue;
     ScopedPersistent<v8::Value> m_liveRoot;
     RefPtr<ScriptState> m_scriptRegexpScriptState;
 
     bool m_constructorMode;
     friend class ConstructorMode;
 
+    bool m_useCounterDisabled;
+    friend class UseCounterDisabledScope;
+
     bool m_isHandlingRecursionLevelError;
     bool m_isReportingException;
 
     Vector<OwnPtr<EndOfScopeTask>> m_endOfScopeTasks;
     OwnPtr<ThreadDebugger> m_threadDebugger;
 };
 
 } // namespace blink
 
 #endif // V8PerIsolateData_h