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 52 matching lines @@
 class ScriptInjectionManager::RFOHelper : public content::RenderFrameObserver {
  public:
   RFOHelper(content::RenderFrame* render_frame,
             ScriptInjectionManager* manager);
   ~RFOHelper() override;
 
  private:
   // RenderFrameObserver implementation.
   bool OnMessageReceived(const IPC::Message& message) override;
   void DidCreateNewDocument() override;
-  void DidCreateDocumentElement() override;
   void DidFailProvisionalLoad(const blink::WebURLError& error) override;
   void DidFinishDocumentLoad() override;
   void DidFinishLoad() override;
   void FrameDetached() override;
   void OnDestruct() override;
 
   virtual void OnExecuteCode(const ExtensionMsg_ExecuteCode_Params& params);
   virtual void OnExecuteDeclarativeScript(int tab_id,
                                           const ExtensionId& extension_id,
                                           int script_id,
@@ skipping 44 matching lines @@
 void ScriptInjectionManager::RFOHelper::DidCreateNewDocument() {
   // 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);
-}
-
 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);
   // 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,
                  weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kScriptIdleTimeoutInMs));
+
+  // Soon after this method returns, AfterDidFinishDocumentLoad will be called,
+  // which injects the DOCUMENT_END scripts.
 }
 
 void ScriptInjectionManager::RFOHelper::DidFinishLoad() {
   DCHECK(content::RenderThread::Get());
   // Ensure that we don't block any UI progress by running scripts.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&ScriptInjectionManager::RFOHelper::RunIdle,
                  weak_factory_.GetWeakPtr()));
 }
@@ skipping 59 matching lines @@
   user_script_set_manager_observer_.Add(user_script_set_manager_);
 }
 
 ScriptInjectionManager::~ScriptInjectionManager() {
   for (const auto& injection : pending_injections_)
     injection->invalidate_render_frame();
   for (const auto& injection : running_injections_)
     injection->invalidate_render_frame();
 }
 
+void ScriptInjectionManager::AfterDidCreateDocumentElement(

[Devlin, 2016/02/12 22:21:56]

In general, it kind of makes me sad that we can't centralize the protection for
render frames a little bit more.  We have this class, ScriptInjection, and
ExtensionFrameHelper all kinda-sorta trying to figure it out.  Unfortunately, I
don't immediately have ideas of how to make it better, either.

+    content::RenderFrame* render_frame) {
+  StartInjectScripts(render_frame, UserScript::DOCUMENT_START);
+}
+
+void ScriptInjectionManager::AfterDidFinishDocumentLoad(
+    content::RenderFrame* render_frame) {
+  StartInjectScripts(render_frame, UserScript::DOCUMENT_END);
+}
+
 void ScriptInjectionManager::OnRenderFrameCreated(
     content::RenderFrame* render_frame) {
   rfo_helpers_.push_back(make_scoped_ptr(new RFOHelper(render_frame, this)));
 }
 
 void ScriptInjectionManager::OnExtensionUnloaded(
     const std::string& extension_id) {
   for (auto iter = pending_injections_.begin();
       iter != pending_injections_.end();) {
     if ((*iter)->host_id().id() == extension_id) {
@@ skipping 224 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