[Extensions] Begin making Extension port initialization asynchronous

extensions/renderer/extension_frame_helper.cc

 // Copyright 2013 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/extension_frame_helper.h"
 
+#include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "content/public/renderer/render_frame.h"
 #include "extensions/common/api/messaging/message.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/renderer/console.h"
 #include "extensions/renderer/content_watcher.h"
 #include "extensions/renderer/dispatcher.h"
 #include "extensions/renderer/messaging_bindings.h"
@@ skipping 67 matching lines @@
 
 ExtensionFrameHelper::ExtensionFrameHelper(content::RenderFrame* render_frame,
                                            Dispatcher* extension_dispatcher)
     : content::RenderFrameObserver(render_frame),
       content::RenderFrameObserverTracker<ExtensionFrameHelper>(render_frame),
       view_type_(VIEW_TYPE_INVALID),
       tab_id_(-1),
       browser_window_id_(-1),
       extension_dispatcher_(extension_dispatcher),
       did_create_current_document_element_(false),
+      next_port_request_id_(0),
       weak_ptr_factory_(this) {
   g_frame_helpers.Get().insert(this);
 }
 
 ExtensionFrameHelper::~ExtensionFrameHelper() {
   g_frame_helpers.Get().erase(this);
 }
 
 // static
 std::vector<content::RenderFrame*> ExtensionFrameHelper::GetExtensionFrames(
@@ skipping 61 matching lines @@
 void ExtensionFrameHelper::ScheduleAtDocumentStart(
     const base::Closure& callback) {
   document_element_created_callbacks_.push_back(callback);
 }
 
 void ExtensionFrameHelper::ScheduleAtDocumentEnd(
     const base::Closure& callback) {
   document_load_finished_callbacks_.push_back(callback);
 }
 
+void ExtensionFrameHelper::RequestPortId(
+    const ExtensionMsg_ExternalConnectionInfo& info,
+    const std::string& channel_name,
+    bool include_tls_channel_id,
+    const base::Callback<void(int)>& callback) {
+  int port_request_id = next_port_request_id_++;
+  pending_port_requests_[port_request_id] = callback;
+  {
+    SCOPED_UMA_HISTOGRAM_TIMER(
+        "Extensions.Messaging.GetPortIdSyncTime.Extension");
+    render_frame()->Send(new ExtensionHostMsg_OpenChannelToExtension(
+        render_frame()->GetRoutingID(), info, channel_name,
+        include_tls_channel_id, port_request_id));
+  }
+}
+
 void ExtensionFrameHelper::DidMatchCSS(
     const blink::WebVector<blink::WebString>& newly_matching_selectors,
     const blink::WebVector<blink::WebString>& stopped_matching_selectors) {
   extension_dispatcher_->content_watcher()->DidMatchCSS(
       render_frame()->GetWebFrame(), newly_matching_selectors,
       stopped_matching_selectors);
 }
 
 void ExtensionFrameHelper::DidCreateScriptContext(
     v8::Local<v8::Context> context,
@@ skipping 20 matching lines @@
     IPC_MESSAGE_HANDLER(ExtensionMsg_DeliverMessage, OnExtensionDeliverMessage)
     IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchOnDisconnect,
                         OnExtensionDispatchOnDisconnect)
     IPC_MESSAGE_HANDLER(ExtensionMsg_SetTabId, OnExtensionSetTabId)
     IPC_MESSAGE_HANDLER(ExtensionMsg_UpdateBrowserWindowId,
                         OnUpdateBrowserWindowId)
     IPC_MESSAGE_HANDLER(ExtensionMsg_NotifyRenderViewType,
                         OnNotifyRendererViewType)
     IPC_MESSAGE_HANDLER(ExtensionMsg_Response, OnExtensionResponse)
     IPC_MESSAGE_HANDLER(ExtensionMsg_MessageInvoke, OnExtensionMessageInvoke)
+    IPC_MESSAGE_HANDLER(ExtensionMsg_AssignPortId, OnAssignPortId)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ExtensionFrameHelper::OnExtensionValidateMessagePort(int port_id) {
   MessagingBindings::ValidateMessagePort(
       extension_dispatcher_->script_context_set(), port_id, render_frame());
 }
 
@@ skipping 59 matching lines @@
     const std::string& extension_id,
     const std::string& module_name,
     const std::string& function_name,
     const base::ListValue& args,
     bool user_gesture) {
   extension_dispatcher_->InvokeModuleSystemMethod(render_frame(), extension_id,
                                                   module_name, function_name,
                                                   args, user_gesture);
 }
 
+void ExtensionFrameHelper::OnAssignPortId(int port_id, int request_id) {
+  auto iter = pending_port_requests_.find(request_id);
+  DCHECK(iter != pending_port_requests_.end());
+  iter->second.Run(port_id);
+  pending_port_requests_.erase(iter);
+}
+
 void ExtensionFrameHelper::OnDestruct() {
   delete this;
 }
 
 }  // namespace extensions