Allow a main interstitial frame to act as an ExtensionMessagePort opener

chrome/browser/extensions/api/messaging/extension_message_port.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/browser/extensions/api/messaging/extension_message_port.h"
 
 #include "base/scoped_observer.h"
 #include "chrome/browser/profiles/profile.h"
+#include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_manager_observer.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 
 namespace extensions {
 
 const char kReceivingEndDoesntExistError[] =
     "Could not establish connection. Receiving end does not exist.";
 
 // Helper class to detect when frames are destroyed.
 class ExtensionMessagePort::FrameTracker : public content::WebContentsObserver,
                                            public ProcessManagerObserver {
  public:
   explicit FrameTracker(ExtensionMessagePort* port)
-      : pm_observer_(this), port_(port) {}
+      : pm_observer_(this), port_(port), interstitial_frame_(nullptr) {}
   ~FrameTracker() override {}
 
   void TrackExtensionProcessFrames() {
     pm_observer_.Add(ProcessManager::Get(port_->browser_context_));
   }
 
   void TrackTabFrames(content::WebContents* tab) {
     Observe(tab);
   }
 
+  void TrackInterstitialFrame(content::WebContents* tab,
+                              content::RenderFrameHost* interstitial_frame) {
+    // |tab| should never be nullptr, because an interstitial's lifetime is
+    // tied to a tab. This is a CHECK, not a DCHECK because we really need an
+    // observer subject to detect frame removal (via DidDetachInterstitialPage).
+    CHECK(tab);
+    DCHECK(interstitial_frame);
+    interstitial_frame_ = interstitial_frame;
+    Observe(tab);
+  }
+
  private:
   // content::WebContentsObserver overrides:
   void RenderFrameDeleted(content::RenderFrameHost* render_frame_host)
       override {
     port_->UnregisterFrame(render_frame_host);
   }
 
-  // TODO(robwu): This should be superfluous with RenderFrameDeleted above, but
-  // we are not entirely sure.
-  void FrameDeleted(content::RenderFrameHost* render_frame_host) override {
-    port_->UnregisterFrame(render_frame_host);
-  }
-
   void DidNavigateAnyFrame(content::RenderFrameHost* render_frame_host,
                            const content::LoadCommittedDetails& details,
                            const content::FrameNavigateParams&) override {
     if (!details.is_in_page)
       port_->UnregisterFrame(render_frame_host);
   }
 
+  void DidDetachInterstitialPage() override {
+    if (interstitial_frame_)
+      port_->UnregisterFrame(interstitial_frame_);
+  }
+
   // extensions::ProcessManagerObserver overrides:
   void OnExtensionFrameUnregistered(
       const std::string& extension_id,
       content::RenderFrameHost* render_frame_host) override {
     if (extension_id == port_->extension_id_)
       port_->UnregisterFrame(render_frame_host);
   }
 
   ScopedObserver<ProcessManager, ProcessManagerObserver> pm_observer_;
   ExtensionMessagePort* port_;  // Owns this FrameTracker.
 
+  // Set to the main frame of an interstitial if we are tracking an interstitial
+  // page, because RenderFrameDeleted is never triggered for frames in an
+  // interstitial (and we only support tracking the interstitial's main frame).
+  content::RenderFrameHost* interstitial_frame_;
+
   DISALLOW_COPY_AND_ASSIGN(FrameTracker);
 };
 
 ExtensionMessagePort::ExtensionMessagePort(
     base::WeakPtr<MessageService> message_service,
     int port_id,
     const std::string& extension_id,
     content::RenderProcessHost* extension_process)
     : weak_message_service_(message_service),
       port_id_(port_id),
@@ skipping 19 matching lines @@
     bool include_child_frames)
     : weak_message_service_(message_service),
       port_id_(port_id),
       extension_id_(extension_id),
       browser_context_(rfh->GetProcess()->GetBrowserContext()),
       extension_process_(nullptr),
       did_create_port_(false),
       background_host_ptr_(nullptr),
       frame_tracker_(new FrameTracker(this)) {
   content::WebContents* tab = content::WebContents::FromRenderFrameHost(rfh);
-  CHECK(tab);
+  if (!tab) {
+    content::InterstitialPage* interstitial =
+        content::InterstitialPage::FromRenderFrameHost(rfh);
+    // A RenderFrameHost must be hosted in a WebContents or InterstitialPage.
+    CHECK(interstitial);
+
+    // Only the main frame of an interstitial is supported, because frames in
+    // the interstitial do not trigger RenderFrameCreated / RenderFrameDeleted
+    // on WebContentObservers. Consequently, (1) we cannot detect removal of
+    // RenderFrameHosts, and (2) even if the RenderFrameDeleted is propagated,
+    // then WebContentsObserverSanityChecker triggers a CHECK when it detects
+    // frame notifications without a corresponding RenderFrameCreated.
+    if (!rfh->GetParent()) {
+      // It is safe to pass the interstitial's WebContents here because we only
+      // use it to observe DidDetachInterstitialPage.
+      frame_tracker_->TrackInterstitialFrame(interstitial->GetWebContents(),
+                                             rfh);
+      RegisterFrame(rfh);
+    }
+    return;
+  }
+
   frame_tracker_->TrackTabFrames(tab);
   if (include_child_frames) {
     tab->ForEachFrame(base::Bind(&ExtensionMessagePort::RegisterFrame,
                                  base::Unretained(this)));
   } else {
     RegisterFrame(rfh);
   }
 }
 
 ExtensionMessagePort::~ExtensionMessagePort() {}
@@ skipping 129 matching lines @@
     return;
   }
   for (content::RenderFrameHost* rfh : frames_) {
     IPC::Message* msg_copy = new IPC::Message(*msg.get());
     msg_copy->set_routing_id(rfh->GetRoutingID());
     rfh->Send(msg_copy);
   }
 }
 
 }  // namespace extensions