Rename V8WindowShell to WindowProxy

Source/bindings/core/v8/WindowProxy.cpp

 /*
  * Copyright (C) 2008, 2009, 2011 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 11 matching lines @@
  * OWNER OR 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 "config.h"
-#include "bindings/core/v8/V8WindowShell.h"
+#include "bindings/core/v8/WindowProxy.h"
 
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8DOMActivityLogger.h"
 #include "bindings/core/v8/V8Document.h"
 #include "bindings/core/v8/V8GCForContextDispose.h"
 #include "bindings/core/v8/V8HTMLCollection.h"
 #include "bindings/core/v8/V8HTMLDocument.h"
 #include "bindings/core/v8/V8HiddenValue.h"
@@ skipping 24 matching lines @@
 #include <v8.h>
 
 namespace blink {
 
 static void checkDocumentWrapper(v8::Handle<v8::Object> wrapper, Document* document)
 {
     ASSERT(V8Document::toNative(wrapper) == document);
     ASSERT(!document->isHTMLDocument() || (V8Document::toNative(v8::Handle<v8::Object>::Cast(wrapper->GetPrototype())) == document));
 }
 
-PassOwnPtr<V8WindowShell> V8WindowShell::create(LocalFrame* frame, DOMWrapperWorld& world, v8::Isolate* isolate)
+PassOwnPtr<WindowProxy> WindowProxy::create(LocalFrame* frame, DOMWrapperWorld& world, v8::Isolate* isolate)
 {
-    return adoptPtr(new V8WindowShell(frame, &world, isolate));
+    return adoptPtr(new WindowProxy(frame, &world, isolate));
 }
 
-V8WindowShell::V8WindowShell(LocalFrame* frame, PassRefPtr<DOMWrapperWorld> world, v8::Isolate* isolate)
+WindowProxy::WindowProxy(LocalFrame* frame, PassRefPtr<DOMWrapperWorld> world, v8::Isolate* isolate)
     : m_frame(frame)
     , m_isolate(isolate)
     , m_world(world)
 {
 }
 
-void V8WindowShell::disposeContext(GlobalDetachmentBehavior behavior)
+void WindowProxy::disposeContext(GlobalDetachmentBehavior behavior)
 {
     if (!isContextInitialized())
         return;
 
     v8::HandleScope handleScope(m_isolate);
     v8::Handle<v8::Context> context = m_scriptState->context();
     m_frame->loader().client()->willReleaseScriptContext(context, m_world->worldId());
 
     if (behavior == DetachGlobal)
         context->DetachGlobal();
 
     m_scriptState->disposePerContextData();
 
     // It's likely that disposing the context has created a lot of
     // garbage. Notify V8 about this so it'll have a chance of cleaning
     // it up when idle.
     V8GCForContextDispose::instanceTemplate().notifyContextDisposed(m_frame->isMainFrame());
 }
 
-void V8WindowShell::clearForClose()
+void WindowProxy::clearForClose()
 {
     if (!isContextInitialized())
         return;
 
     m_document.clear();
     disposeContext(DoNotDetachGlobal);
 }
 
-void V8WindowShell::clearForNavigation()
+void WindowProxy::clearForNavigation()
 {
     if (!isContextInitialized())
         return;
 
     ScriptState::Scope scope(m_scriptState.get());
 
     m_document.clear();
 
     // Clear the document wrapper cache before turning on access checks on
     // the old LocalDOMWindow wrapper. This way, access to the document wrapper
@@ skipping 34 matching lines @@
 // via window.window, window.self, window.parent, etc. The outer window
 // has a security token which is the domain. The outer window cannot
 // have its own properties. window.foo = 'x' is delegated to the
 // inner window.
 //
 // When a frame navigates to a new page, the inner window is cut off
 // the outer window, and the outer window identify is preserved for
 // the frame. However, a new inner window is created for the new page.
 // If there are JS code holds a closure to the old inner window,
 // it won't be able to reach the outer window via its global object.
-bool V8WindowShell::initializeIfNeeded()
+bool WindowProxy::initializeIfNeeded()
 {
     if (isContextInitialized())
         return true;
 
     DOMWrapperWorld::setWorldOfInitializingWindow(m_world.get());
     bool result = initialize();
     DOMWrapperWorld::setWorldOfInitializingWindow(0);
     return result;
 }
 
-bool V8WindowShell::initialize()
+bool WindowProxy::initialize()
 {
-    TRACE_EVENT0("v8", "V8WindowShell::initialize");
+    TRACE_EVENT0("v8", "WindowProxy::initialize");
     TRACE_EVENT_SCOPED_SAMPLING_STATE("blink", "InitializeWindow");
 
     ScriptForbiddenScope::AllowUserAgentScript allowScript;
 
     v8::HandleScope handleScope(m_isolate);
 
     createContext();
 
     if (!isContextInitialized())
         return false;
@@ skipping 27 matching lines @@
         SecurityOrigin* origin = m_world->isolatedWorldSecurityOrigin();
         setSecurityToken(origin);
         if (origin && InspectorInstrumentation::hasFrontends()) {
             InspectorInstrumentation::didCreateIsolatedContext(m_frame, m_scriptState.get(), origin);
         }
     }
     m_frame->loader().client()->didCreateScriptContext(context, m_world->extensionGroup(), m_world->worldId());
     return true;
 }
 
-void V8WindowShell::createContext()
+void WindowProxy::createContext()
 {
     // The documentLoader pointer could be 0 during frame shutdown.
     // FIXME: Can we remove this check?
     if (!m_frame->loader().documentLoader())
         return;
 
     // Create a new environment using an empty template for the shadow
     // object. Reuse the global object if one has been created earlier.
     v8::Handle<v8::ObjectTemplate> globalTemplate = V8Window::getShadowObjectTemplate(m_isolate);
     if (globalTemplate.IsEmpty())
@@ skipping 14 matching lines @@
         extensionNames[index++] = extensions[i]->name();
     }
     v8::ExtensionConfiguration extensionConfiguration(index, extensionNames.get());
 
     v8::Handle<v8::Context> context = v8::Context::New(m_isolate, &extensionConfiguration, globalTemplate, m_global.newLocal(m_isolate));
     if (context.IsEmpty())
         return;
     m_scriptState = ScriptState::create(context, m_world);
 
     double contextCreationDurationInMilliseconds = (currentTime() - contextCreationStartInSeconds) * 1000;
-    const char* histogramName = "WebCore.V8WindowShell.createContext.MainWorld";
+    const char* histogramName = "WebCore.WindowProxy.createContext.MainWorld";
     if (!m_world->isMainWorld())
-        histogramName = "WebCore.V8WindowShell.createContext.IsolatedWorld";
+        histogramName = "WebCore.WindowProxy.createContext.IsolatedWorld";
     blink::Platform::current()->histogramCustomCounts(histogramName, contextCreationDurationInMilliseconds, 0, 10000, 50);
 }
 
 static v8::Handle<v8::Object> toInnerGlobalObject(v8::Handle<v8::Context> context)
 {
     return v8::Handle<v8::Object>::Cast(context->Global()->GetPrototype());
 }
 
-bool V8WindowShell::installDOMWindow()
+bool WindowProxy::installDOMWindow()
 {
     LocalDOMWindow* window = m_frame->domWindow();
     v8::Local<v8::Object> windowWrapper = V8ObjectConstructor::newInstance(m_isolate, m_scriptState->perContextData()->constructorForType(&V8Window::wrapperTypeInfo));
     if (windowWrapper.IsEmpty())
         return false;
 
     V8DOMWrapper::setNativeInfoForHiddenWrapper(v8::Handle<v8::Object>::Cast(windowWrapper->GetPrototype()), &V8Window::wrapperTypeInfo, window);
 
     // Install the windowWrapper as the prototype of the innerGlobalObject.
     // The full structure of the global object is as follows:
@@ skipping 16 matching lines @@
     //       views of the LocalDOMWindow will die together once that wrapper clears the persistent
     //       reference.
     v8::Handle<v8::Object> innerGlobalObject = toInnerGlobalObject(m_scriptState->context());
     V8DOMWrapper::setNativeInfoForHiddenWrapper(innerGlobalObject, &V8Window::wrapperTypeInfo, window);
     innerGlobalObject->SetPrototype(windowWrapper);
     V8DOMWrapper::associateObjectWithWrapper<V8Window>(PassRefPtrWillBeRawPtr<LocalDOMWindow>(window), &V8Window::wrapperTypeInfo, windowWrapper, m_isolate, WrapperConfiguration::Dependent);
     V8Window::installPerContextEnabledProperties(windowWrapper, window, m_isolate);
     return true;
 }
 
-void V8WindowShell::updateDocumentWrapper(v8::Handle<v8::Object> wrapper)
+void WindowProxy::updateDocumentWrapper(v8::Handle<v8::Object> wrapper)
 {
     ASSERT(m_world->isMainWorld());
     m_document.set(m_isolate, wrapper);
 }
 
-void V8WindowShell::updateDocumentProperty()
+void WindowProxy::updateDocumentProperty()
 {
     if (!m_world->isMainWorld())
         return;
 
     ScriptState::Scope scope(m_scriptState.get());
     v8::Handle<v8::Context> context = m_scriptState->context();
     v8::Handle<v8::Value> documentWrapper = toV8(m_frame->document(), context->Global(), context->GetIsolate());
     ASSERT(documentWrapper == m_document.newLocal(m_isolate) || m_document.isEmpty());
     if (m_document.isEmpty())
         updateDocumentWrapper(v8::Handle<v8::Object>::Cast(documentWrapper));
     checkDocumentWrapper(m_document.newLocal(m_isolate), m_frame->document());
 
     // If instantiation of the document wrapper fails, clear the cache
     // and let the LocalDOMWindow accessor handle access to the document.
     if (documentWrapper.IsEmpty()) {
         clearDocumentProperty();
         return;
     }
     ASSERT(documentWrapper->IsObject());
     context->Global()->ForceSet(v8AtomicString(m_isolate, "document"), documentWrapper, static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete));
 
     // We also stash a reference to the document on the inner global object so that
     // LocalDOMWindow objects we obtain from JavaScript references are guaranteed to have
     // live Document objects.
     V8HiddenValue::setHiddenValue(m_isolate, toInnerGlobalObject(context), V8HiddenValue::document(m_isolate), documentWrapper);
 }
 
-void V8WindowShell::clearDocumentProperty()
+void WindowProxy::clearDocumentProperty()
 {
     ASSERT(isContextInitialized());
     if (!m_world->isMainWorld())
         return;
     v8::HandleScope handleScope(m_isolate);
     m_scriptState->context()->Global()->ForceDelete(v8AtomicString(m_isolate, "document"));
 }
 
-void V8WindowShell::updateActivityLogger()
+void WindowProxy::updateActivityLogger()
 {
     m_scriptState->perContextData()->setActivityLogger(V8DOMActivityLogger::activityLogger(
         m_world->worldId(), m_frame->document() ? m_frame->document()->baseURI() : KURL()));
 }
 
-void V8WindowShell::setSecurityToken(SecurityOrigin* origin)
+void WindowProxy::setSecurityToken(SecurityOrigin* origin)
 {
     // If two tokens are equal, then the SecurityOrigins canAccess each other.
     // If two tokens are not equal, then we have to call canAccess.
     // Note: we can't use the HTTPOrigin if it was set from the DOM.
     String token;
     // We stick with an empty token if document.domain was modified or if we
     // are in the initial empty document, so that we can do a full canAccess
     // check in those cases.
     bool delaySet = m_world->isMainWorld()
         && (origin->domainWasSetInDOM()
@@ skipping 16 matching lines @@
 
     if (m_world->isPrivateScriptIsolatedWorld())
         token = "private-script://" + token;
 
     CString utf8Token = token.utf8();
     // NOTE: V8 does identity comparison in fast path, must use a symbol
     // as the security token.
     context->SetSecurityToken(v8AtomicString(m_isolate, utf8Token.data(), utf8Token.length()));
 }
 
-void V8WindowShell::updateDocument()
+void WindowProxy::updateDocument()
 {
     ASSERT(m_world->isMainWorld());
     if (!isGlobalInitialized())
         return;
     if (!isContextInitialized())
         return;
     updateActivityLogger();
     updateDocumentProperty();
     updateSecurityOrigin(m_frame->document()->securityOrigin());
 }
@@ skipping 29 matching lines @@
         v8SetReturnValue(info, result);
         return;
     }
     v8::Handle<v8::Value> prototype = info.Holder()->GetPrototype();
     if (prototype->IsObject()) {
         v8SetReturnValue(info, prototype.As<v8::Object>()->Get(property));
         return;
     }
 }
 
-void V8WindowShell::namedItemAdded(HTMLDocument* document, const AtomicString& name)
+void WindowProxy::namedItemAdded(HTMLDocument* document, const AtomicString& name)
 {
     ASSERT(m_world->isMainWorld());
 
     if (!isContextInitialized())
         return;
 
     ScriptState::Scope scope(m_scriptState.get());
     ASSERT(!m_document.isEmpty());
     v8::Handle<v8::Object> documentHandle = m_document.newLocal(m_isolate);
     checkDocumentWrapper(documentHandle, document);
     documentHandle->SetAccessor(v8String(m_isolate, name), getter);
 }
 
-void V8WindowShell::namedItemRemoved(HTMLDocument* document, const AtomicString& name)
+void WindowProxy::namedItemRemoved(HTMLDocument* document, const AtomicString& name)
 {
     ASSERT(m_world->isMainWorld());
 
     if (!isContextInitialized())
         return;
 
     if (document->hasNamedItem(name) || document->hasExtraNamedItem(name))
         return;
 
     ScriptState::Scope scope(m_scriptState.get());
     ASSERT(!m_document.isEmpty());
     v8::Handle<v8::Object> documentHandle = m_document.newLocal(m_isolate);
     checkDocumentWrapper(documentHandle, document);
     documentHandle->Delete(v8String(m_isolate, name));
 }
 
-void V8WindowShell::updateSecurityOrigin(SecurityOrigin* origin)
+void WindowProxy::updateSecurityOrigin(SecurityOrigin* origin)
 {
     ASSERT(m_world->isMainWorld());
     if (!isContextInitialized())
         return;
     setSecurityToken(origin);
 }
 
 } // namespace blink