Add startup metrics that measure the performance of the first web contents.

chrome/browser/metrics/chrome_browser_main_extra_parts_metrics.cc

 // Copyright (c) 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 "chrome/browser/metrics/chrome_browser_main_extra_parts_metrics.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/cpu.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
+#include "base/process/process_info.h"
 #include "base/sys_info.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "chrome/browser/about_flags.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_browser_main.h"
 #include "chrome/browser/mac/bluetooth_utility.h"
 #include "chrome/browser/pref_service_flags_storage.h"
 #include "chrome/browser/shell_integration.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_iterator.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/web_contents_observer.h"
 #include "ui/base/touch/touch_device.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/events/event_switches.h"
 #include "ui/gfx/screen.h"
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 #include <gnu/libc-version.h>
 
 #include "base/version.h"
 #if defined(USE_X11)
@@ skipping 181 matching lines @@
     NOTREACHED();
     return;
   }
 
   UMA_HISTOGRAM_ENUMERATION("Touchscreen.TouchEventsEnabled", state,
                             UMA_TOUCH_EVENTS_STATE_COUNT);
 }
 
 }  // namespace
 
+// Measures start up performance of the first active web contents.
+class ChromeBrowserMainExtraPartsMetrics::FirstWebContentsProfiler
+    : public content::WebContentsObserver {
+ public:
+  FirstWebContentsProfiler(content::WebContents* web_contents,
+                           ChromeBrowserMainExtraPartsMetrics* metrics)
+      : content::WebContentsObserver(web_contents),
+        recorded_paint_metric_(false),
+        recorded_load_metric_(false),
+        metrics_(metrics) {}
+
+ private:
+  void DidFirstVisuallyNonEmptyPaint() override {
+    if (recorded_paint_metric_)
+      return;
+    recorded_paint_metric_ = true;
+    const base::Time process_creation_time =
+        base::CurrentProcessInfo::CreationTime();
+    if (!process_creation_time.is_null()) {
+      base::TimeDelta elapsed = base::Time::Now() - process_creation_time;
+      UMA_HISTOGRAM_CUSTOM_TIMES("Startup.FirstWebContents.NonEmptyPaint",
+                                 elapsed,
+                                 base::TimeDelta::FromMilliseconds(100),
+                                 base::TimeDelta::FromMinutes(2), 300);

[Ilya Sherman, 2014/11/26 02:24:55]

Could you clarify why you need such fine granularity?  Jim tuned the default
numbers pretty carefully based on the needs of the networking team, and they're
pretty picky about their latency measurements.  What do you know that they
don't?

[erikchen, 2014/11/26 03:48:43]

I am basing these numbers on the histograms Startup.OSX.* that I added a couple
of months ago. Those use 100 buckets, with min=10ms and max=1 minute. That works
out to 12% increments for each bucket, which means that changes which improve
startup time by say, 5%, are incredibly hard to discern from the histograms.

With the numbers I listed here, the bucket increment is 3.4%. 

In my updated patch set, I've further reduced the min/max difference, as well as
increased the bucket count to 781 to get 1% bucket increments. This is necessary
since I expect most startup improvements to be incredibly incremental, so being
able to discern 1% improvements is quite important.

+    }
+
+    if (FinishedRecordingMetrics())
+      DestroySelf();
+  }
+
+  void DocumentOnLoadCompletedInMainFrame() override {
+    if (recorded_load_metric_)
+      return;
+    recorded_load_metric_ = true;
+    const base::Time process_creation_time =
+        base::CurrentProcessInfo::CreationTime();
+    if (!process_creation_time.is_null()) {
+      base::TimeDelta elapsed = base::Time::Now() - process_creation_time;
+      UMA_HISTOGRAM_CUSTOM_TIMES("Startup.FirstWebContents.MainFrameLoad",
+                                 elapsed,
+                                 base::TimeDelta::FromMilliseconds(100),
+                                 base::TimeDelta::FromMinutes(2), 300);
+    }
+
+    if (FinishedRecordingMetrics())
+      DestroySelf();
+  }
+
+  void WebContentsDestroyed() override { DestroySelf(); }
+
+  // Whether all metrics have been recorded.
+  bool FinishedRecordingMetrics() {
+    return recorded_paint_metric_ && recorded_load_metric_;
+  }
+
+  // Tells the owner of |this| to destroy |this|.
+  void DestroySelf() { metrics_->FirstWebContentsProfilerWantsDestruction(); }
+
+  // Whether the "NonEmptyPaint" metric has been recorded.
+  bool recorded_paint_metric_;
+
+  // Whether the "MainFrameLoad" metric has been recorded.
+  bool recorded_load_metric_;
+
+  // |metrics_| owns |this|.
+  ChromeBrowserMainExtraPartsMetrics* metrics_;
+
+  DISALLOW_COPY_AND_ASSIGN(FirstWebContentsProfiler);
+};

[Ilya Sherman, 2014/11/26 02:24:55]

Please split this class out into its own implementation files.  Even better
would be not to dangle it off of ChromeBrowserMainExtraPartsMetrics at all --
I'd really prefer this file not to become too much of a dumping ground -- but if
there's not a better place to put it, that's okay.

[erikchen, 2014/11/26 03:48:43]

I split out the file into its own implementation. This class is still the
logical owner of the FirstWebContentsProfiler, but the new design only requires
7 additional lines in this .cc file.

+
 ChromeBrowserMainExtraPartsMetrics::ChromeBrowserMainExtraPartsMetrics()
     : display_count_(0), is_screen_observer_(false) {
 }
 
 ChromeBrowserMainExtraPartsMetrics::~ChromeBrowserMainExtraPartsMetrics() {
   if (is_screen_observer_)
     gfx::Screen::GetNativeScreen()->RemoveObserver(this);
 }
 
 void ChromeBrowserMainExtraPartsMetrics::PreProfileInit() {
@@ skipping 22 matching lines @@
   const int kStartupMetricsGatheringDelaySeconds = 45;
   content::BrowserThread::GetBlockingPool()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&RecordStartupMetricsOnBlockingPool),
       base::TimeDelta::FromSeconds(kStartupMetricsGatheringDelaySeconds));
 
   display_count_ = gfx::Screen::GetNativeScreen()->GetNumDisplays();
   UMA_HISTOGRAM_COUNTS_100("Hardware.Display.Count.OnStartup", display_count_);
   gfx::Screen::GetNativeScreen()->AddObserver(this);
   is_screen_observer_ = true;
+
+  // Record startup metrics for the active web contents. If there are multiple
+  // browsers, choose the first one.
+  for (chrome::BrowserIterator iterator; !iterator.done(); iterator.Next()) {
+    Browser* browser = *iterator;
+    content::WebContents* web_contents =
+        browser->tab_strip_model()->GetActiveWebContents();
+    if (web_contents) {
+      first_web_contents_profiler_.reset(
+          new FirstWebContentsProfiler(web_contents, this));
+      break;
+    }
+  }

[Ilya Sherman, 2014/11/26 02:24:55]

I think this logic could safely be internal to the FirstWebContentsProfiler
class.

[erikchen, 2014/11/26 03:48:43]

Done.

 }
 
 void ChromeBrowserMainExtraPartsMetrics::OnDisplayAdded(
     const gfx::Display& new_display) {
   EmitDisplaysChangedMetric();
 }
 
 void ChromeBrowserMainExtraPartsMetrics::OnDisplayRemoved(
     const gfx::Display& old_display) {
   EmitDisplaysChangedMetric();
 }
 
 void ChromeBrowserMainExtraPartsMetrics::OnDisplayMetricsChanged(
     const gfx::Display& display,
     uint32_t changed_metrics) {
 }
 
 void ChromeBrowserMainExtraPartsMetrics::EmitDisplaysChangedMetric() {
   int display_count = gfx::Screen::GetNativeScreen()->GetNumDisplays();
   if (display_count != display_count_) {
     display_count_ = display_count;
     UMA_HISTOGRAM_COUNTS_100("Hardware.Display.Count.OnChange", display_count_);
   }
 }
 
+void ChromeBrowserMainExtraPartsMetrics::
+    FirstWebContentsProfilerWantsDestruction() {
+  first_web_contents_profiler_.reset();
+}
+
 namespace chrome {
 
 void AddMetricsExtraParts(ChromeBrowserMainParts* main_parts) {
   main_parts->AddParts(new ChromeBrowserMainExtraPartsMetrics());
 }
 
 }  // namespace chrome