Deal with frame removal by content scripts

extensions/renderer/script_injection_manager.cc

 // Copyright 2014 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/script_injection_manager.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 70 matching lines @@
   virtual void OnExecuteDeclarativeScript(int tab_id,
                                           const ExtensionId& extension_id,
                                           int script_id,
                                           const GURL& url);
   virtual void OnPermitScriptInjection(int64_t request_id);
 
   // Tells the ScriptInjectionManager to run tasks associated with
   // document_idle.
   void RunIdle();
 
+  void StartInjectScripts(UserScript::RunLocation run_location);
+
   // Indicate that the frame is no longer valid because it is starting
   // a new load or closing.
   void InvalidateAndResetFrame();
 
   // The owning ScriptInjectionManager.
   ScriptInjectionManager* manager_;
 
   bool should_run_idle_;
 
   base::WeakPtrFactory<RFOHelper> weak_factory_;
@@ skipping 28 matching lines @@
   // A new document is going to be shown, so invalidate the old document state.
   // Check that the frame's state is known before invalidating the frame,
   // because it is possible that a script injection was scheduled before the
   // page was loaded, e.g. by navigating to a javascript: URL before the page
   // has loaded.
   if (manager_->frame_statuses_.count(render_frame()) != 0)
     InvalidateAndResetFrame();
 }
 
 void ScriptInjectionManager::RFOHelper::DidCreateDocumentElement() {
-  manager_->StartInjectScripts(render_frame(), UserScript::DOCUMENT_START);
+  ExtensionFrameHelper::Get(render_frame())
+      ->ScheduleAtDocumentStart(
+          base::Bind(&ScriptInjectionManager::RFOHelper::StartInjectScripts,
+                     weak_factory_.GetWeakPtr(), UserScript::DOCUMENT_START));
 }
 
 void ScriptInjectionManager::RFOHelper::DidFailProvisionalLoad(
     const blink::WebURLError& error) {
   FrameStatusMap::iterator it = manager_->frame_statuses_.find(render_frame());
   if (it != manager_->frame_statuses_.end() &&
       it->second == UserScript::DOCUMENT_START) {
     // Since the provisional load failed, the frame stays at its previous loaded
     // state and origin (or the parent's origin for new/about:blank frames).
     // Reset the frame to DOCUMENT_IDLE in order to reflect that the frame is
     // done loading, and avoid any deadlock in the system.
     //
     // We skip injection of DOCUMENT_END and DOCUMENT_IDLE scripts, because the
     // injections closely follow the DOMContentLoaded (and onload) events, which
     // are not triggered after a failed provisional load.
     // This assumption is verified in the checkDOMContentLoadedEvent subtest of
     // ExecuteScriptApiTest.FrameWithHttp204 (browser_tests).
     InvalidateAndResetFrame();
     should_run_idle_ = false;
     manager_->frame_statuses_[render_frame()] = UserScript::DOCUMENT_IDLE;
   }
 }
 
 void ScriptInjectionManager::RFOHelper::DidFinishDocumentLoad() {
   DCHECK(content::RenderThread::Get());
-  manager_->StartInjectScripts(render_frame(), UserScript::DOCUMENT_END);
+  ExtensionFrameHelper::Get(render_frame())
+      ->ScheduleAtDocumentEnd(
+          base::Bind(&ScriptInjectionManager::RFOHelper::StartInjectScripts,
+                     weak_factory_.GetWeakPtr(), UserScript::DOCUMENT_END));
+
   // We try to run idle in two places: here and DidFinishLoad.
   // DidFinishDocumentLoad() corresponds to completing the document's load,
   // whereas DidFinishLoad corresponds to completing the document and all
   // subresources' load. We don't want to hold up script injection for a
   // particularly slow subresource, so we set a delayed task from here - but if
   // we finish everything before that point (i.e., DidFinishLoad() is
   // triggered), then there's no reason to keep waiting.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ScriptInjectionManager::RFOHelper::RunIdle,
@@ skipping 48 matching lines @@
 
 void ScriptInjectionManager::RFOHelper::RunIdle() {
   // Only notify the manager if the frame hasn't either been removed or already
   // had idle run since the task to RunIdle() was posted.
   if (should_run_idle_) {
     should_run_idle_ = false;
     manager_->StartInjectScripts(render_frame(), UserScript::DOCUMENT_IDLE);
   }
 }
 
+void ScriptInjectionManager::RFOHelper::StartInjectScripts(
+    UserScript::RunLocation run_location) {
+  manager_->StartInjectScripts(render_frame(), run_location);
+}
+
 void ScriptInjectionManager::RFOHelper::InvalidateAndResetFrame() {
   // Invalidate any pending idle injections, and reset the frame inject on idle.
   weak_factory_.InvalidateWeakPtrs();
   // We reset to inject on idle, because the frame can be reused (in the case of
   // navigation).
   should_run_idle_ = true;
   manager_->InvalidateForFrame(render_frame());
 }
 
 ScriptInjectionManager::ScriptInjectionManager(
@@ skipping 247 matching lines @@
   ScriptsRunInfo scripts_run_info(injection->render_frame(),
                                   UserScript::RUN_DEFERRED);
   ScriptInjection::InjectionResult res = injection->OnPermissionGranted(
       &scripts_run_info);
   if (res == ScriptInjection::INJECTION_BLOCKED)
     running_injections_.push_back(std::move(injection));
   scripts_run_info.LogRun();
 }
 
 }  // namespace extensions