Deal with frame removal by content scripts

chrome/renderer/chrome_content_renderer_client.cc

 // Copyright (c) 2012 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 "chrome/renderer/chrome_content_renderer_client.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
@@ skipping 1368 matching lines @@
       data_reduction_proxy::chrome_proxy_header()));
   if (!response.httpHeaderField(header_key).isNull() &&
       response.httpHeaderField(header_key).utf8().find(
           data_reduction_proxy::chrome_proxy_lo_fi_directive()) !=
               std::string::npos) {
     (*properties)[data_reduction_proxy::chrome_proxy_header()] =
         data_reduction_proxy::chrome_proxy_lo_fi_directive();
   }
 }
 
+void ChromeContentRendererClient::AfterDidCreateDocumentElement(
+    content::RenderFrame* render_frame) {
+#if defined(ENABLE_EXTENSIONS)
+  ChromeExtensionsRendererClient::GetInstance()
+      ->AfterDidCreateDocumentElement(render_frame);

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

hmm... I'd say we should probably mention that |render_frame| can be invalid
after this point (I know it's mentioned elsewhere, but it's good to have it at
the main entry points).

Unfortunately, there's also not really a good way of *checking* if the render
frame is alive at this point - I suppose if we really need to, we could cache
the routing id, and then RenderFrame::FromRoutingID() if we need to (or expose
something from the extensions layer but...yuck).  I suppose I'm fine with
crossing that bridge when we come to it, but it is kind of a shame.

[robwu, 2016/02/12 22:37:13]

Will do.
When it is really needed, we can pass a WeakPtr<RenderFrame> from content/. But
it's not needed at the moment.

[ncarter (slow), 2016/02/16 18:22:32]

If it comes to that, I'd rather we just expose a GetWeakPtr on RenderFrame (as
devlin points out, it's a bit redundant to the routing pair lookup).

For now, documenting up the call stack that "// |frame| may have been deleted."
(as you've done) is probably a best practice.

+#endif
+}
+
+void ChromeContentRendererClient::AfterDidFinishDocumentLoad(
+    content::RenderFrame* render_frame) {
+#if defined(ENABLE_EXTENSIONS)
+  ChromeExtensionsRendererClient::GetInstance()
+      ->AfterDidFinishDocumentLoad(render_frame);
+#endif
+}
+
 void
 ChromeContentRendererClient::DidInitializeServiceWorkerContextOnWorkerThread(
     v8::Local<v8::Context> context,
     const GURL& url) {
 #if defined(ENABLE_EXTENSIONS)
   extensions::Dispatcher::DidInitializeServiceWorkerContextOnWorkerThread(
       context, url);
 #endif
 }
 
@@ skipping 10 matching lines @@
 // chrome.system.network.getNetworkInterfaces provides the same
 // information. Also, the enforcement of sending and binding UDP is already done
 // by chrome extension permission model.
 bool ChromeContentRendererClient::ShouldEnforceWebRTCRoutingPreferences() {
 #if defined(ENABLE_EXTENSIONS)
   return !IsStandaloneExtensionProcess();
 #else
   return true;
 #endif
 }