Remove port lifetime management from renderer

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/memory/ptr_util.h"
 #include "base/scoped_observer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/interstitial_page.h"
@@ skipping 81 matching lines @@
 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),
       extension_id_(extension_id),
       browser_context_(extension_process->GetBrowserContext()),
       extension_process_(extension_process),
+      opener_tab_id_(-1),
       did_create_port_(false),
       background_host_ptr_(nullptr),
       frame_tracker_(new FrameTracker(this)) {
   auto all_hosts = ProcessManager::Get(browser_context_)
                        ->GetRenderFrameHostsForExtension(extension_id);
   for (content::RenderFrameHost* rfh : all_hosts)
     RegisterFrame(rfh);
 
   frame_tracker_->TrackExtensionProcessFrames();
 }
 
 ExtensionMessagePort::ExtensionMessagePort(
     base::WeakPtr<MessageService> message_service,
     int port_id,
     const std::string& extension_id,
     content::RenderFrameHost* rfh,
     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),
+      opener_tab_id_(-1),
       did_create_port_(false),
       background_host_ptr_(nullptr),
       frame_tracker_(new FrameTracker(this)) {
   content::WebContents* tab = content::WebContents::FromRenderFrameHost(rfh);
   if (!tab) {
     content::InterstitialPage* interstitial =
         content::InterstitialPage::FromRenderFrameHost(rfh);
     // A RenderFrameHost must be hosted in a WebContents or InterstitialPage.
     CHECK(interstitial);
 
@@ skipping 17 matching lines @@
   if (include_child_frames) {
     tab->ForEachFrame(base::Bind(&ExtensionMessagePort::RegisterFrame,
                                  base::Unretained(this)));
   } else {
     RegisterFrame(rfh);
   }
 }
 
 ExtensionMessagePort::~ExtensionMessagePort() {}
 
+void ExtensionMessagePort::RevalidatePort() {
+  // Only opener ports need to be revalidated, because these are created in the
+  // renderer before the browser knows about them.
+  DCHECK(!extension_process_);
+  DCHECK_LE(frames_.size(), 1U);
+
+  SendToPort(base::WrapUnique(
+      new ExtensionMsg_CheckHasMessagePort(MSG_ROUTING_NONE, port_id_)));
+}
+
 void ExtensionMessagePort::RemoveCommonFrames(const MessagePort& port) {
   // Avoid overlap in the set of frames to make sure that it does not matter
   // when UnregisterFrame is called.
   for (std::set<content::RenderFrameHost*>::iterator it = frames_.begin();
        it != frames_.end(); ) {
     if (port.HasFrame(*it)) {
       frames_.erase(it++);
     } else {
       ++it;
     }
@@ skipping 12 matching lines @@
     const std::string& channel_name,
     std::unique_ptr<base::DictionaryValue> source_tab,
     int source_frame_id,
     int guest_process_id,
     int guest_render_frame_routing_id,
     const std::string& source_extension_id,
     const std::string& target_extension_id,
     const GURL& source_url,
     const std::string& tls_channel_id) {
   ExtensionMsg_TabConnectionInfo source;
-  if (source_tab)
+  if (source_tab) {
     source.tab.Swap(source_tab.get());
+    source.tab.GetInteger("id", &opener_tab_id_);
+  }
   source.frame_id = source_frame_id;
 
   ExtensionMsg_ExternalConnectionInfo info;
   info.target_id = target_extension_id;
   info.source_id = source_extension_id;
   info.source_url = source_url;
   info.guest_process_id = guest_process_id;
   info.guest_render_frame_routing_id = guest_render_frame_routing_id;
 
   SendToPort(base::WrapUnique(new ExtensionMsg_DispatchOnConnect(
       MSG_ROUTING_NONE, port_id_, channel_name, source, info, tls_channel_id)));
 }
 
 void ExtensionMessagePort::DispatchOnDisconnect(
     const std::string& error_message) {
   SendToPort(base::WrapUnique(new ExtensionMsg_DispatchOnDisconnect(
       MSG_ROUTING_NONE, port_id_, error_message)));
 }
 
 void ExtensionMessagePort::DispatchOnMessage(const Message& message) {
-  SendToPort(base::WrapUnique(
-      new ExtensionMsg_DeliverMessage(MSG_ROUTING_NONE, port_id_, message)));
+  SendToPort(base::WrapUnique(new ExtensionMsg_DeliverMessage(
+      MSG_ROUTING_NONE, port_id_, opener_tab_id_, message)));
 }
 
 void ExtensionMessagePort::IncrementLazyKeepaliveCount() {
   ProcessManager* pm = ProcessManager::Get(browser_context_);
   ExtensionHost* host = pm->GetBackgroundHostForExtension(extension_id_);
   if (host && BackgroundInfo::HasLazyBackgroundPage(host->extension()))
     pm->IncrementLazyKeepaliveCount(host->extension());
 
   // Keep track of the background host, so when we decrement, we only do so if
   // the host hasn't reloaded.
@@ skipping 62 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