[Extensions] Add metrics for asynchronous port creation

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 "base/timer/elapsed_timer.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"
 #include "extensions/renderer/script_context.h"
@@ skipping 55 matching lines @@
   // callbacks that are added during the iteration.
   std::vector<base::Closure> callbacks;
   callbacks_to_be_run_and_cleared->swap(callbacks);
   for (auto& callback : callbacks) {
     callback.Run();
     if (!frame_helper.get())
       return;  // Frame and ExtensionFrameHelper invalidated by callback.
   }
 }
 
+enum class PortType {
+  EXTENSION,
+  TAB,
+  NATIVE_APP,
+};
+
 }  // namespace
 
+struct ExtensionFrameHelper::PendingPortRequest {
+  PendingPortRequest(PortType type, const base::Callback<void(int)>& callback)
+      : type(type), callback(callback) {}
+  ~PendingPortRequest() {}
+
+  base::ElapsedTimer timer;
+  PortType type;
+  base::Callback<void(int)> callback;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PendingPortRequest);
+};
+
 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),
@@ skipping 77 matching lines @@
     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;
+  pending_port_requests_[port_request_id] =
+      base::MakeUnique<PendingPortRequest>(PortType::EXTENSION, 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::RequestTabPortId(
     const ExtensionMsg_TabTargetConnectionInfo& info,
     const std::string& extension_id,
     const std::string& channel_name,
     const base::Callback<void(int)>& callback) {
   int port_request_id = next_port_request_id_++;
-  pending_port_requests_[port_request_id] = callback;
+  pending_port_requests_[port_request_id] =
+      base::MakeUnique<PendingPortRequest>(PortType::TAB, callback);
   {
     SCOPED_UMA_HISTOGRAM_TIMER("Extensions.Messaging.GetPortIdSyncTime.Tab");
     render_frame()->Send(new ExtensionHostMsg_OpenChannelToTab(
         render_frame()->GetRoutingID(), info, extension_id, channel_name,
         port_request_id));
   }
 }
 
 void ExtensionFrameHelper::RequestNativeAppPortId(
     const std::string& native_app_name,
     const base::Callback<void(int)>& callback) {
   int port_request_id = next_port_request_id_++;
-  pending_port_requests_[port_request_id] = callback;
+  pending_port_requests_[port_request_id] =
+      base::MakeUnique<PendingPortRequest>(PortType::NATIVE_APP, callback);
   {
     SCOPED_UMA_HISTOGRAM_TIMER(
         "Extensions.Messaging.GetPortIdSyncTime.NativeApp");
     render_frame()->Send(new ExtensionHostMsg_OpenChannelToNativeApp(
         render_frame()->GetRoutingID(), native_app_name, port_request_id));
   }
 }
 
 void ExtensionFrameHelper::DidMatchCSS(
     const blink::WebVector<blink::WebString>& newly_matching_selectors,
@@ skipping 111 matching lines @@
     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);
+  PendingPortRequest& request = *iter->second;
+  switch (request.type) {
+    case PortType::EXTENSION: {
+      UMA_HISTOGRAM_TIMES("Extensions.Messaging.GetPortIdAsyncTime.Extension",
+                          request.timer.Elapsed());
+      break;
+    }
+    case PortType::TAB: {
+      UMA_HISTOGRAM_TIMES("Extensions.Messaging.GetPortIdAsyncTime.Tab",
+                          request.timer.Elapsed());
+      break;
+    }
+    case PortType::NATIVE_APP: {
+      UMA_HISTOGRAM_TIMES("Extensions.Messaging.GetPortIdAsyncTime.NativeApp",
+                          request.timer.Elapsed());
+      break;
+    }
+  }
+  request.callback.Run(port_id);
   pending_port_requests_.erase(iter);
 }
 
 void ExtensionFrameHelper::OnDestruct() {
   delete this;
 }
 
 }  // namespace extensions