[Extensions] Wait until the Window object is cleared before classifying contexts

extensions/renderer/extension_frame_helper.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "extensions/renderer/extension_frame_helper.h"
 
 #include "content/public/renderer/render_frame.h"
 #include "extensions/common/api/messaging/message.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_messages.h"
@@ skipping 29 matching lines @@
   if (url.host() != match_extension_id)
     return false;
   if (match_window_id != extension_misc::kUnknownWindowId &&
       frame_helper->browser_window_id() != match_window_id)
     return false;
   return true;
 }
 
 }  // namespace
 
+struct ExtensionFrameHelper::PendingContext {
+  v8::Global<v8::Context> v8_context;
+  int extension_group;
+  int world_id;
+  v8::Isolate* isolate;
+
+  PendingContext(v8::Local<v8::Context> context,
+                 int extension_group,
+                 int world_id)
+      : v8_context(context->GetIsolate(), context),
+        extension_group(extension_group),
+        world_id(world_id),
+        isolate(context->GetIsolate()) {}
+};
+
 ExtensionFrameHelper::ExtensionFrameHelper(content::RenderFrame* render_frame,
                                            Dispatcher* extension_dispatcher)
     : content::RenderFrameObserver(render_frame),
       content::RenderFrameObserverTracker<ExtensionFrameHelper>(render_frame),
+      did_clear_window_(false),
       view_type_(VIEW_TYPE_INVALID),
       tab_id_(-1),
       browser_window_id_(-1),
       extension_dispatcher_(extension_dispatcher),
       did_create_current_document_element_(false) {
   g_frame_helpers.Get().insert(this);
 }
 
 ExtensionFrameHelper::~ExtensionFrameHelper() {
   g_frame_helpers.Get().erase(this);
@@ skipping 39 matching lines @@
 void ExtensionFrameHelper::DidCreateDocumentElement() {
   did_create_current_document_element_ = true;
   extension_dispatcher_->DidCreateDocumentElement(
       render_frame()->GetWebFrame());
 }
 
 void ExtensionFrameHelper::DidCreateNewDocument() {
   did_create_current_document_element_ = false;
 }
 
+void ExtensionFrameHelper::DidStartProvisionalLoad() {
+  did_clear_window_ = false;
+}
+
 void ExtensionFrameHelper::DidMatchCSS(
     const blink::WebVector<blink::WebString>& newly_matching_selectors,
     const blink::WebVector<blink::WebString>& stopped_matching_selectors) {
   extension_dispatcher_->content_watcher()->DidMatchCSS(
       render_frame()->GetWebFrame(), newly_matching_selectors,
       stopped_matching_selectors);
 }
 
 void ExtensionFrameHelper::DidCreateScriptContext(
     v8::Local<v8::Context> context,
     int extension_group,
     int world_id) {
-  extension_dispatcher_->DidCreateScriptContext(
-      render_frame()->GetWebFrame(), context, extension_group, world_id);
+  if (did_clear_window_) {
+    extension_dispatcher_->DidCreateScriptContext(
+        render_frame()->GetWebFrame(), context, extension_group, world_id);
+  } else {
+    pending_contexts_.push_back(make_scoped_ptr(
+        new PendingContext(context, extension_group, world_id)));
+  }
+}
+
+void ExtensionFrameHelper::DidClearWindowObject() {
+  did_clear_window_ = true;
+  for (const auto& pending_context : pending_contexts_) {
+    v8::HandleScope scope(pending_context->isolate);
+    v8::Local<v8::Context> context_local =

[dcheng, 2015/11/18 18:42:51]

Sorry: my comment was unclear. You can just call this "context" (and the struct
member can stay named context). My only concern was a collision between the loop
variable and the name of this local. I leave it up to you what looks best.

+        v8::Local<v8::Context>::New(pending_context->isolate,
+                                    pending_context->v8_context);
+    v8::Context::Scope context_scope(context_local);
+    extension_dispatcher_->DidCreateScriptContext(
+        render_frame()->GetWebFrame(), context_local,
+        pending_context->extension_group, pending_context->world_id);
+  }
+  pending_contexts_.clear();
 }
 
 void ExtensionFrameHelper::WillReleaseScriptContext(
-    v8::Local<v8::Context> context,
+    v8::Local<v8::Context> v8_context,
     int world_id) {
-  extension_dispatcher_->WillReleaseScriptContext(
-      render_frame()->GetWebFrame(), context, world_id);
+  for (auto iter = pending_contexts_.begin(); iter != pending_contexts_.end();
+       ++iter) {
+    if ((*iter)->v8_context == v8_context) {
+      pending_contexts_.erase(iter);
+      return;
+    }
+  }
+  extension_dispatcher_->WillReleaseScriptContext(render_frame()->GetWebFrame(),
+                                                  v8_context, world_id);
 }
 
 bool ExtensionFrameHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ExtensionFrameHelper, message)
     IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchOnConnect,
                         OnExtensionDispatchOnConnect)
     IPC_MESSAGE_HANDLER(ExtensionMsg_DeliverMessage, OnExtensionDeliverMessage)
     IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchOnDisconnect,
                         OnExtensionDispatchOnDisconnect)
@@ skipping 71 matching lines @@
     const std::string& module_name,
     const std::string& function_name,
     const base::ListValue& args,
     bool user_gesture) {
   extension_dispatcher_->InvokeModuleSystemMethod(render_frame(), extension_id,
                                                   module_name, function_name,
                                                   args, user_gesture);
 }
 
 }  // namespace extensions