Track all extension frames in ProcessManager, inspect extensionoptions

extensions/browser/extension_web_contents_observer.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/browser/extension_web_contents_observer.h"
 
+#include "components/guest_view/browser/guest_view_base.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extensions_browser_client.h"
@@ skipping 26 matching lines @@
 }
 
 ExtensionWebContentsObserver::~ExtensionWebContentsObserver() {
 }
 
 void ExtensionWebContentsObserver::InitializeRenderFrame(
     content::RenderFrameHost* render_frame_host) {
   DCHECK(render_frame_host);
   DCHECK(render_frame_host->IsRenderFrameLive());
 
+  ViewType view_type = GetViewType(web_contents());
+  if (view_type == VIEW_TYPE_INVALID) {
+    // This is expected to happen only for non-extension pages (e.g. devtools)
+    // and GuestViews.
+    DCHECK(guest_view::GuestViewBase::FromWebContents(web_contents()) ||
+           GetExtensionIdFromFrame(render_frame_host).empty());
+    return;
+  }
   // Notify the render frame of the view type.
   render_frame_host->Send(new ExtensionMsg_NotifyRenderViewType(
-      render_frame_host->GetRoutingID(), GetViewType(web_contents())));
+      render_frame_host->GetRoutingID(), view_type));
 
   const Extension* frame_extension = GetExtensionFromFrame(render_frame_host);
   if (frame_extension) {
     ExtensionsBrowserClient::Get()->RegisterMojoServices(render_frame_host,
                                                          frame_extension);
     ProcessManager::Get(browser_context_)
         ->RegisterRenderFrameHost(web_contents(), render_frame_host,
                                   frame_extension);
   }
 }
@@ skipping 28 matching lines @@
   // the process level, not at the view level. However, without some mild
   // refactoring this isn't trivial to do, and this way is simpler.
   //
   // Plus, we can delete the concept of activating an extension once site
   // isolation is turned on.
   render_view_host->Send(new ExtensionMsg_ActivateExtension(extension->id()));
 }
 
 void ExtensionWebContentsObserver::RenderFrameCreated(
     content::RenderFrameHost* render_frame_host) {
   InitializeRenderFrame(render_frame_host);

[ncarter (slow), 2015/11/05 20:03:23]

A couple layers down, InitializeRenderFrame calls
render_frame_host->GetLastCommittedURL(). This is not correct.

GetLastCommittedURL is currently implemented as frame tree node state, not RFH
state.RenderFrameCreated can happen while |render_frame_host| is a pending frame
that's about to be committed. It hasn't committed yet. In this case,
GetLastCommittedURL will actually return the URL of the frame it's about to
replace.

 }
 
 void ExtensionWebContentsObserver::RenderFrameDeleted(
     content::RenderFrameHost* render_frame_host) {
   ProcessManager::Get(browser_context_)
       ->UnregisterRenderFrameHost(render_frame_host);
 }
 
+void ExtensionWebContentsObserver::RenderFrameHostChanged(
+    content::RenderFrameHost* old_host,
+    content::RenderFrameHost* new_host) {

[ncarter (slow), 2015/11/05 20:03:23]

Do not override RenderFrameHostChanged. All you're doing here is looking at the
SiteInstance's SiteURL, which won't have changed from RenderFrameCreated time.

+  // If the frame was opened by a non-extension frame, a process swap can occur.
+  // Before the process swap, RenderFrameCreated will be called, but
+  // InitializeRenderFrame will not consider the RenderFrameHost as an extension
+  // frame. Therefore we call this method again to ensure that the frame is
+  // registered if it is an extension frame.
+  if (new_host->IsRenderFrameLive())
+    InitializeRenderFrame(new_host);
+}
+
+void ExtensionWebContentsObserver::DidNavigateAnyFrame(
+    content::RenderFrameHost* render_frame_host,
+    const content::LoadCommittedDetails& details,
+    const content::FrameNavigateParams& params) {

[ncarter (slow), 2015/11/05 20:03:23]

It should be okay to call GetLastCommittedURL from this function (since |rfh|
just committed). You can also look at params.url. They should match.

+  if (details.is_in_page)
+    return;
+
+  const Extension* frame_extension = GetExtensionFromFrame(render_frame_host);
+  if (frame_extension) {
+    // Notify ProcessManager, because some clients do not just want to know
+    // whether the frame is in an extension process, but also whether the frame
+    // was navigated.
+    ProcessManager::Get(browser_context_)
+        ->DidNavigateRenderFrameHost(render_frame_host);
+  }
+}
+
 bool ExtensionWebContentsObserver::OnMessageReceived(
     const IPC::Message& message,
     content::RenderFrameHost* render_frame_host) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(
       ExtensionWebContentsObserver, message, render_frame_host)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_Request, OnRequest)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ skipping 17 matching lines @@
     const Extension* const extension =
         process_manager->GetExtensionForWebContents(web_contents());
     if (extension)
       process_manager->DecrementLazyKeepaliveCount(extension);
   }
 }
 
 std::string ExtensionWebContentsObserver::GetExtensionIdFromFrame(
     content::RenderFrameHost* render_frame_host) const {
   content::SiteInstance* site_instance = render_frame_host->GetSiteInstance();
   GURL url = render_frame_host->GetLastCommittedURL();

[ncarter (slow), 2015/11/05 20:03:23]

My hunch is that we should remove this call to GetLastCommittedURL, and look
only at the SiteInstance's SiteURL.

   if (!url.is_empty()) {
     if (site_instance->GetSiteURL().GetOrigin() != url.GetOrigin())
       return std::string();
   } else {
     url = site_instance->GetSiteURL();
   }
 
   return url.SchemeIs(kExtensionScheme) ? url.host() : std::string();
 }
 
@@ skipping 30 matching lines @@
 
   return site.host();
 }
 
 void ExtensionWebContentsObserver::OnRequest(
     content::RenderFrameHost* render_frame_host,
     const ExtensionHostMsg_Request_Params& params) {
   dispatcher_.Dispatch(params, render_frame_host);
 }
 
 void ExtensionWebContentsObserver::InitializeFrameHelper(

[ncarter (slow), 2015/11/05 20:03:23]

FYI, from this function, it would also be okay to call GetLastCommittedURL,
since we know that |render_frame_host| is a current host (ForEachFrame only
visits current hosts).

     content::RenderFrameHost* render_frame_host) {
   // Since this is called for all existing RenderFrameHosts during the
   // ExtensionWebContentsObserver's creation, it's possible that not all hosts
   // are ready.
   // We only initialize the frame if the renderer counterpart is live; otherwise
   // we wait for the RenderFrameCreated notification.
   if (render_frame_host->IsRenderFrameLive())
     InitializeRenderFrame(render_frame_host);
 }
 
 }  // namespace extensions