Clean up the proxy code for handling frame navigation....

webkit/port/bindings/v8/v8_proxy.cpp

 // Copyright (c) 2008, 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 1001 matching lines @@
 {
     v8::Local<v8::Context> context = v8::Context::GetCurrent();
 
     if (!context->HasOutOfMemoryException())
         return false;
 
     // Warning, error, disable JS for this frame?
     Frame* frame = V8Proxy::retrieveFrame(context);
 
     V8Proxy* proxy = V8Proxy::retrieve(frame);
-    // Clean m_context, m_document, and event handlers.
+    // Clean m_context, and event handlers.
     proxy->clearForClose();
     // Destroy the global object.
     proxy->DestroyGlobal();
 
     webkit_glue::NotifyJSOutOfMemory(frame);
 
     // Disable JS.
     Settings* settings = frame->settings();
     ASSERT(settings);
     settings->setJavaScriptEnabled(false);
@@ skipping 516 matching lines @@
     for (size_t i = 0; i < arraysize(kDirProtocols); ++i) {
         if (origin->protocol() == kDirProtocols[i]) {
             ASSERT(url.SchemeIs(kDirProtocols[i]));
             return url.ExtractFileName().empty();
         }
     }
 
     return false;  // Other protocols fall through to here
 }
 
-void V8Proxy::clearDocumentWrapper()
-{
-    v8::Local<v8::Context> context = GetContext();
-    if (context.IsEmpty())
-        return;  // not initialize yet
-
-    if (!m_document.IsEmpty()) {
-#ifndef NDEBUG
-        UnregisterGlobalHandle(this, m_document);
-#endif
-        m_document.Dispose();
-        m_document.Clear();
-    }
-}
 
 // static
 void V8Proxy::DomainChanged(Frame* frame)
 {
     V8Proxy* proxy = retrieve(frame);
     // Restore to default security token.
     proxy->m_context->UseDefaultSecurityToken();
 }
 
 
 void V8Proxy::clearForClose()
 {
     if (m_context.IsEmpty())
         return;
 
-    {   v8::HandleScope handle_scope;
-        clearDocumentWrapper();
-    }
-
     m_context.Dispose();
     m_context.Clear();
 }
 
 
 void V8Proxy::clearForNavigation()
 {
     if (m_context.IsEmpty())
         return;
 
     {   v8::HandleScope handle;
-        clearDocumentWrapper();
+
+        v8::Context::Scope context_scope(m_context);
 
         // Turn on access check on the old DOMWindow wrapper.
         v8::Handle<v8::Object> wrapper =
             LookupDOMWrapper(V8ClassIndex::DOMWINDOW, m_global);
         ASSERT(!wrapper.IsEmpty());
         wrapper->TurnOnAccessCheck();
 
         // Clear all timeouts.
         DOMWindow* domWindow =
             ToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, wrapper);
         domWindow->clearAllTimeouts();
 
         // disconnect all event listeners
         DisconnectEventListeners();
 
         // Separate the context from its global object.
         m_context->DetachGlobal();
-    }
 
-    // Corresponds to the context creation in initContextIfNeeded().
-    m_context.Dispose();
-    m_context.Clear();
-}
+        m_context.Dispose();
+        m_context.Clear();
 
-
-void V8Proxy::domWindowReady()
-{
-    // Reinitialize context so the global object is reused by
-    // the new context.
-    if (!m_global.IsEmpty() && m_context.IsEmpty()) {
-        v8::HandleScope scope;
+        // Reinitialize the context so the global object points to
+        // the new DOM window.
         initContextIfNeeded();
     }
 }
 
 
+void V8Proxy::SetSecurityToken() {
+    Document* document = m_frame->document();
+    // Setup security origin and security token
+    if (!document) {
+        m_context->UseDefaultSecurityToken();
+        return;
+    }
+
+    // Ask the document's SecurityOrigin to generate a security token.
+    // 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.
+    SecurityOrigin* origin = document->securityOrigin();
+    String token;
+    if (!origin->domainWasSetInDOM())
+        token = document->securityOrigin()->toString();
+
+    // An empty token means we always have to call canAccess.  In this case, we
+    // use the global object as the security token to avoid calling canAccess
+    // when a script accesses its own objects.
+    if (token.isEmpty()) {
+        m_context->UseDefaultSecurityToken();
+        return;
+    }
+
+    CString utf8_token = token.utf8();
+    // NOTE: V8 does identity comparison in fast path, must use a symbol
+    // as the security token.
+    m_context->SetSecurityToken(
+        v8::String::NewSymbol(utf8_token.data(), utf8_token.length()));
+

[Mike Belshe, 2008/11/13 18:13:50]

extra line

[Feng Qian, 2008/11/13 21:30:18]

Done.

+}
+
+
+void V8Proxy::updateDocument()
+{
+    if (!m_frame->document())
+        return;
+
+    if (m_global.IsEmpty()) {
+        ASSERT(m_context.IsEmpty());
+        return;
+    }
+
+    {   v8::HandleScope scope;

[Mike Belshe, 2008/11/13 18:13:50]

funky braces

[Feng Qian, 2008/11/13 21:30:18]

Done.

+        SetSecurityToken();
+    }
+}
+
+
 // Check if the current execution context can access a target frame.
 // First it checks same domain policy using the lexical context
 //
 // This is equivalent to KJS::Window::allowsAccessFrom(ExecState*, String&).
 bool V8Proxy::CanAccessPrivate(DOMWindow* target_window)
 {
     ASSERT(target_window);
 
     String message;
 
@@ skipping 63 matching lines @@
 
     Frame* target = node->document()->frame();
 
     if (!target)
         return false;
 
     return CanAccessFrame(target, true);
 }
 
 
-static void GenerateSecurityToken(v8::Local<v8::Context> context)
-{
-  Document* document = V8Proxy::retrieveFrame(context)->document();
-  if (!document) {
-    context->UseDefaultSecurityToken();
-    return;
-  }
-
-  // Ask the document's SecurityOrigin to generate a security token.
-  // 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.
-  SecurityOrigin* origin = document->securityOrigin();
-  String token;
-  if (!origin->domainWasSetInDOM())
-    token = document->securityOrigin()->toString();
-
-  // An empty token means we always have to call canAccess.  In this case, we
-  // use the global object as the security token to avoid calling canAccess
-  // when a script accesses its own objects.
-  if (token.isEmpty()) {
-    context->UseDefaultSecurityToken();
-    return;
-  }
-
-  CString utf8_token = token.utf8();
-  // NOTE: V8 does identity comparison in fast path, must use a symbol
-  // as the security token.
-  context->SetSecurityToken(
-    v8::String::NewSymbol(utf8_token.data(), utf8_token.length()));
-}
-
-
 // Create a new environment and setup the global object.
 //
 // The global object corresponds to a DOMWindow instance.  However, to
 // allow properties of the JS DOMWindow instance to be shadowed, we
 // use a shadow object as the global object and use the JS DOMWindow
 // instance as the prototype for that shadow object.  The JS DOMWindow
 // instance is undetectable from javascript code because the __proto__
 // accessors skip that object.
 //
 // The shadow object and the DOMWindow instance are seen as one object
@@ skipping 99 matching lines @@
   // Setup the peer object for the DOM window.
   dom_object_map().set(window, v8::Persistent<v8::Object>::New(window_peer));
   // Wrap the window.
   SetDOMWrapper(window_peer,
                 V8ClassIndex::ToInt(V8ClassIndex::DOMWINDOW),
                 window);
   // Insert the window instance as the prototype of the shadow object.
   v8::Handle<v8::Object> v8_global = context->Global();
   v8_global->Set(v8::String::New("__proto__"), window_peer);
 
-  // Setup security origin and security token
-  GenerateSecurityToken(context);
+  SetSecurityToken();
 
   m_frame->loader()->dispatchWindowObjectAvailable();
 
   if (ScriptController::RecordPlaybackMode()) {
     // Inject code which overrides a few common JS functions for implementing
     // randomness.  In order to implement effective record & playback of
     // websites, it is important that the URLs not change.  Many popular web
     // based apps use randomness in URLs to unique-ify urls for proxies.
     // Unfortunately, this breaks playback.
     // To work around this, we take the two most common client-side randomness
@@ skipping 732 matching lines @@
     // If instantiation failed it's important not to add the result
     // to the DOM node map. Instead we return an empty handle, which
     // should already be handled by callers of this function in case
     // the node is NULL.
     return result;
   }
 
   dom_node_map().set(node, v8::Persistent<v8::Object>::New(result));
 
   if (is_document) {
-    Document* doc = static_cast<Document*>(node);
-    V8Proxy* proxy = V8Proxy::retrieve(doc->frame());
-    if (proxy)
-      proxy->UpdateDocumentHandle(result);
-
     if (type == V8ClassIndex::HTMLDOCUMENT) {
       // Create marker object and insert it in two internal fields.
       // This is used to implement temporary shadowing of
       // document.all.
       ASSERT(result->InternalFieldCount() ==
              V8Custom::kHTMLDocumentInternalFieldCount);
       v8::Local<v8::Object> marker = v8::Object::New();
       result->SetInternalField(V8Custom::kHTMLDocumentMarkerIndex, marker);
       result->SetInternalField(V8Custom::kHTMLDocumentShadowIndex, marker);
     }
   }
 
   return result;
 }
 
 
-void V8Proxy::UpdateDocumentHandle(v8::Local<v8::Object> handle)
-{
-  // If the old handle is not empty, release it.
-  if (!m_document.IsEmpty()) {
-#ifndef NDEBUG
-    UnregisterGlobalHandle(this, m_document);
-#endif
-    m_document.Dispose();
-    m_document.Clear();
-  }
-
-  m_document = v8::Persistent<v8::Object>::New(handle);
-#ifndef NDEBUG
-  RegisterGlobalHandle(PROXY, this, m_document);
-#endif
-}
-
-
 // A JS object of type EventTarget can only be five possible types:
 // 1) EventTargetNode; 2) XMLHttpRequest; 3) MessagePort; 4) SVGElementInstance;
 // 5) XMLHttpRequestUpload
 // check EventTarget.h for new type conversion methods
 // also make sure to sync with V8EventListener::GetThisObject (v8_events.cpp)
 v8::Handle<v8::Value> V8Proxy::EventTargetToV8Object(EventTarget* target)
 {
   if (!target)
       return v8::Null();
 
@@ skipping 216 matching lines @@
     v8::Handle<v8::Object> global = context->Global();
     global->Set(v8::String::New(name), instance);
 }
 
 void V8Proxy::ProcessConsoleMessages()
 {
     ConsoleMessageManager::ProcessDelayedMessages();
 }
 
 }  // namespace WebCore