Replace the ExtensionHost load UMAs (Extensions.BackgroundPageLoadTime and friends)

extensions/browser/extension_host.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_host.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
-#include "base/metrics/histogram.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
@@ skipping 119 matching lines @@
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
                  content::Source<BrowserContext>(browser_context_));
 
   // Set up web contents observers and pref observers.
   delegate_->OnExtensionHostCreated(host_contents());
 }
 
 ExtensionHost::~ExtensionHost() {
   if (extension_host_type_ == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE &&
-      extension_ && BackgroundInfo::HasLazyBackgroundPage(extension_)) {
-    UMA_HISTOGRAM_LONG_TIMES("Extensions.EventPageActiveTime",
-                             since_created_.Elapsed());
+      extension_ && BackgroundInfo::HasLazyBackgroundPage(extension_) &&
+      load_start_.get()) {
+    UMA_HISTOGRAM_LONG_TIMES("Extensions.EventPageActiveTime2",
+                             load_start_->Elapsed());
   }
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
       content::Source<BrowserContext>(browser_context_),
       content::Details<ExtensionHost>(this));
   FOR_EACH_OBSERVER(ExtensionHostObserver, observer_list_,
                     OnExtensionHostDestroyed(this));
   ProcessCreationQueue::GetInstance()->Remove(this);
 }
 
 content::RenderProcessHost* ExtensionHost::render_process_host() const {
   return render_view_host()->GetProcess();
 }
 
 RenderViewHost* ExtensionHost::render_view_host() const {
   // TODO(mpcomplete): This can be NULL. How do we handle that?
   return render_view_host_;
 }
 
 bool ExtensionHost::IsRenderViewLive() const {
   return render_view_host()->IsRenderViewLive();
 }
 
 void ExtensionHost::CreateRenderViewSoon() {
-  if ((render_process_host() && render_process_host()->HasConnection())) {
+  if (render_process_host() && render_process_host()->HasConnection()) {
     // If the process is already started, go ahead and initialize the RenderView
     // synchronously. The process creation is the real meaty part that we want
     // to defer.
     CreateRenderViewNow();
   } else {
     ProcessCreationQueue::GetInstance()->CreateSoon(this);
   }
 }
 
 void ExtensionHost::CreateRenderViewNow() {
@@ skipping 38 matching lines @@
 void ExtensionHost::OnNetworkRequestDone(uint64 request_id) {
   FOR_EACH_OBSERVER(ExtensionHostObserver, observer_list_,
                     OnNetworkRequestDone(this, request_id));
 }
 
 const GURL& ExtensionHost::GetURL() const {
   return host_contents()->GetURL();
 }
 
 void ExtensionHost::LoadInitialURL() {
+  load_start_.reset(new base::ElapsedTimer());
   host_contents_->GetController().LoadURL(
       initial_url_, content::Referrer(), ui::PAGE_TRANSITION_LINK,
       std::string());
 }
 
 bool ExtensionHost::IsBackgroundPage() const {
   DCHECK(extension_host_type_ == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
   return true;
 }
 
@@ skipping 48 matching lines @@
       extensions::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
       content::Source<BrowserContext>(browser_context_),
       content::Details<ExtensionHost>(this));
 }
 
 void ExtensionHost::DidStopLoading(content::RenderViewHost* render_view_host) {
   bool notify = !did_stop_loading_;
   did_stop_loading_ = true;
   OnDidStopLoading();
   if (notify) {
+    CHECK(load_start_.get());
     if (extension_host_type_ == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
       if (extension_ && BackgroundInfo::HasLazyBackgroundPage(extension_)) {
-        UMA_HISTOGRAM_TIMES("Extensions.EventPageLoadTime",
-                            since_created_.Elapsed());
+        UMA_HISTOGRAM_MEDIUM_TIMES("Extensions.EventPageLoadTime2",
+                                   load_start_->Elapsed());
       } else {
-        UMA_HISTOGRAM_TIMES("Extensions.BackgroundPageLoadTime",
-                            since_created_.Elapsed());
+        UMA_HISTOGRAM_MEDIUM_TIMES("Extensions.BackgroundPageLoadTime2",
+                                   load_start_->Elapsed());
       }
-    } else if (extension_host_type_ == VIEW_TYPE_EXTENSION_DIALOG) {
-      UMA_HISTOGRAM_TIMES("Extensions.DialogLoadTime",
-                          since_created_.Elapsed());
     } else if (extension_host_type_ == VIEW_TYPE_EXTENSION_POPUP) {
-      UMA_HISTOGRAM_TIMES("Extensions.PopupLoadTime",
-                          since_created_.Elapsed());
-    } else if (extension_host_type_ == VIEW_TYPE_EXTENSION_INFOBAR) {
-      UMA_HISTOGRAM_TIMES("Extensions.InfobarLoadTime",
-        since_created_.Elapsed());
+      UMA_HISTOGRAM_MEDIUM_TIMES("Extensions.PopupLoadTime2",
+                                 load_start_->Elapsed());
     }
 
     // Send the notification last, because it might result in this being
     // deleted.
     content::NotificationService::current()->Notify(
         extensions::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
         content::Source<BrowserContext>(browser_context_),
         content::Details<ExtensionHost>(this));
   }
 }
@@ skipping 150 matching lines @@
   return delegate_->CheckMediaAccessPermission(
       web_contents, security_origin, type, extension());
 }
 
 bool ExtensionHost::IsNeverVisible(content::WebContents* web_contents) {
   ViewType view_type = extensions::GetViewType(web_contents);
   return view_type == extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE;
 }
 
 }  // namespace extensions