Collects stats on how user interacts with the bubble.

chrome/browser/ui/views/session_crashed_bubble_view.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 "chrome/browser/ui/views/session_crashed_bubble_view.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
+#include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_list_observer.h"
 #include "chrome/browser/ui/options/options_util.h"
 #include "chrome/browser/ui/startup/session_crashed_bubble.h"
 #include "chrome/browser/ui/startup/startup_browser_creator_impl.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
@@ skipping 35 matching lines @@
 
 // The color of the text and background of the sub panel to offer UMA optin.
 // These values match the BookmarkSyncPromoView colors.
 const SkColor kBackgroundColor = SkColorSetRGB(245, 245, 245);
 const SkColor kTextColor = SkColorSetRGB(102, 102, 102);
 
 // The Finch study name and group name that enables session crashed bubble UI.
 const char kEnableBubbleUIFinchName[] = "EnableSessionCrashedBubbleUI";
 const char kEnableBubbleUIGroupEnabled[] = "Enabled";
 
+enum SessionCrashedBubbleHistogramValue {
+  SESSION_CRASHED_BUBBLE_SHOWN,
+  SESSION_CRASHED_BUBBLE_ERROR,
+  SESSION_CRASHED_BUBBLE_RESTORED,
+  SESSION_CRASHED_BUBBLE_ALREADY_UMA_OPTIN,
+  SESSION_CRASHED_BUBBLE_UMA_OPTIN,
+  SESSION_CRASHED_BUBBLE_HELP,
+  SESSION_CRASHED_BUBBLE_IGNORED,
+  SESSION_CRASHED_BUBBLE_MAX,
+};
+
+void RecordBubbleHistogramValue(SessionCrashedBubbleHistogramValue value) {
+  UMA_HISTOGRAM_ENUMERATION(
+      "SessionCrashed.Bubble", value, SESSION_CRASHED_BUBBLE_MAX);
+}
+
 // Whether or not the bubble UI should be used.
 bool IsBubbleUIEnabled() {
   const base::CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kDisableSessionCrashedBubble))
     return false;
   if (command_line.HasSwitch(switches::kEnableSessionCrashedBubble))
     return true;
   const std::string group_name = base::FieldTrialList::FindFullName(
       kEnableBubbleUIFinchName);
   return group_name == kEnableBubbleUIGroupEnabled;
@@ skipping 33 matching lines @@
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (browser->profile()->IsOffTheRecord())
     return;
 
   // Observes browser removal event and will be deallocated in ShowForReal.
   scoped_ptr<BrowserRemovalObserver> browser_observer(
       new BrowserRemovalObserver(browser));
 
 // Stats collection only applies to Google Chrome builds.
 #if defined(GOOGLE_CHROME_BUILD)
-  // Schedule a task to run ShouldOfferMetricsReporting() on FILE thread, since
-  // GoogleUpdateSettings::GetCollectStatsConsent() does IO. Then, call
+  // Schedule a task to run GoogleUpdateSettings::GetCollectStatsConsent() on
+  // FILE thread, since it does IO. Then, call
   // SessionCrashedBubbleView::ShowForReal with the result.
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&GoogleUpdateSettings::GetCollectStatsConsent),
       base::Bind(&SessionCrashedBubbleView::ShowForReal,
                  base::Passed(&browser_observer)));
 #else
   SessionCrashedBubbleView::ShowForReal(browser_observer.Pass(), false);
 #endif  // defined(GOOGLE_CHROME_BUILD)
 }
 
 // static
 void SessionCrashedBubbleView::ShowForReal(
     scoped_ptr<BrowserRemovalObserver> browser_observer,
     bool uma_opted_in_already) {
   // Determine whether or not the uma opt-in option should be offered. It is
   // offered only when it is a Google chrome build, user hasn't opted in yet,
   // and the preference is modifiable by the user.
   bool offer_uma_optin = false;
 
 #if defined(GOOGLE_CHROME_BUILD)
-  if (!uma_opted_in_already)
+  if (uma_opted_in_already) {
+    RecordBubbleHistogramValue(SESSION_CRASHED_BUBBLE_ALREADY_UMA_OPTIN);
+  } else {
     offer_uma_optin = g_browser_process->local_state()->FindPreference(
         prefs::kMetricsReportingEnabled)->IsUserModifiable();
+  }
 #endif  // defined(GOOGLE_CHROME_BUILD)
 
   Browser* browser = browser_observer->browser();
 
-  if (!browser)
+  if (!browser) {
+    RecordBubbleHistogramValue(SESSION_CRASHED_BUBBLE_ERROR);
     return;
+  }
 
   views::View* anchor_view =
       BrowserView::GetBrowserViewForBrowser(browser)->toolbar()->app_menu();
   content::WebContents* web_contents =
       browser->tab_strip_model()->GetActiveWebContents();
 
-  if (!web_contents)
+  if (!web_contents) {
+    RecordBubbleHistogramValue(SESSION_CRASHED_BUBBLE_ERROR);
     return;
+  }
 
   SessionCrashedBubbleView* crash_bubble =
       new SessionCrashedBubbleView(anchor_view, browser, web_contents,
                                    offer_uma_optin);
   views::BubbleDelegateView::CreateBubble(crash_bubble)->Show();
+  RecordBubbleHistogramValue(SESSION_CRASHED_BUBBLE_SHOWN);
 }
 
 SessionCrashedBubbleView::SessionCrashedBubbleView(
     views::View* anchor_view,
     Browser* browser,
     content::WebContents* web_contents,
     bool offer_uma_optin)
     : BubbleDelegateView(anchor_view, views::BubbleBorder::TOP_RIGHT),
       content::WebContentsObserver(web_contents),
       browser_(browser),
       web_contents_(web_contents),
       restore_button_(NULL),
       uma_option_(NULL),
       offer_uma_optin_(offer_uma_optin),
-      started_navigation_(false) {
+      started_navigation_(false),
+      restored_(false) {
   set_close_on_deactivate(false);
   registrar_.Add(
       this,
       chrome::NOTIFICATION_TAB_CLOSING,
       content::Source<content::NavigationController>(&(
           web_contents->GetController())));
   browser->tab_strip_model()->AddObserver(this);
 }
 
 SessionCrashedBubbleView::~SessionCrashedBubbleView() {
   browser_->tab_strip_model()->RemoveObserver(this);
 }
 
 views::View* SessionCrashedBubbleView::GetInitiallyFocusedView() {
   return restore_button_;
 }
 
 base::string16 SessionCrashedBubbleView::GetWindowTitle() const {
   return l10n_util::GetStringUTF16(IDS_SESSION_CRASHED_BUBBLE_TITLE);
 }
 
 bool SessionCrashedBubbleView::ShouldShowWindowTitle() const {
   return true;
 }
 
 bool SessionCrashedBubbleView::ShouldShowCloseButton() const {
   return true;
 }
 
+void SessionCrashedBubbleView::OnWidgetDestroying(views::Widget* widget) {
+  if (!restored_)
+    RecordBubbleHistogramValue(SESSION_CRASHED_BUBBLE_IGNORED);
+  BubbleDelegateView::OnWidgetDestroying(widget);
+}
+
 void SessionCrashedBubbleView::Init() {
   // Description text label.
   views::Label* text_label = new views::Label(
       l10n_util::GetStringUTF16(IDS_SESSION_CRASHED_VIEW_MESSAGE));
   text_label->SetMultiLine(true);
   text_label->SetLineHeight(20);
   text_label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   text_label->SizeToFit(kWidthOfDescriptionText);
 
   // Restore button.
@@ skipping 99 matching lines @@
   layout->AddView(new views::Separator(views::Separator::HORIZONTAL));
   layout->StartRow(0, kReportColumnSetId);
   layout->AddView(uma_option_);
   layout->AddView(uma_label);
 }
 
 void SessionCrashedBubbleView::ButtonPressed(views::Button* sender,
                                              const ui::Event& event) {
   DCHECK_EQ(sender, restore_button_);
   RestorePreviousSession(sender);
+  RecordBubbleHistogramValue(SESSION_CRASHED_BUBBLE_RESTORED);
+  restored_ = true;

[msw, 2014/07/10 19:58:37]

nit: you should probably record the histogram value and set this flag in
RestorePreviousSession, just in case there are (or will eventually be) other
ways to invoke that.

[yao, 2014/07/10 20:19:12]

Done.

 }
 
 void SessionCrashedBubbleView::StyledLabelLinkClicked(const gfx::Range& range,
                                                       int event_flags) {
   browser_->OpenURL(content::OpenURLParams(
       GURL("https://support.google.com/chrome/answer/96817"),
       content::Referrer(),
       NEW_FOREGROUND_TAB,
       content::PAGE_TRANSITION_LINK,
       false));
+  RecordBubbleHistogramValue(SESSION_CRASHED_BUBBLE_HELP);
 }
 
 void SessionCrashedBubbleView::DidStartNavigationToPendingEntry(
       const GURL& url,
       content::NavigationController::ReloadType reload_type) {
   started_navigation_ = true;
 }
 
 void SessionCrashedBubbleView::DidFinishLoad(
       int64 frame_id,
       const GURL& validated_url,
       bool is_main_frame,
       content::RenderViewHost* render_view_host) {
   if (started_navigation_)
     CloseBubble();
-}
+  }

[msw, 2014/07/10 19:58:37]

nit: revert this (indent was correct).

[yao, 2014/07/10 20:19:12]

Done.

 
 void SessionCrashedBubbleView::WasShown() {
   GetWidget()->Show();
 }
 
 void SessionCrashedBubbleView::WasHidden() {
   GetWidget()->Hide();
 }
 
 void SessionCrashedBubbleView::Observe(
@@ skipping 14 matching lines @@
   SessionRestore::RestoreSessionAfterCrash(browser_);
 
   // Record user's choice for opting in to UMA.
   // There's no opting-out choice in the crash restore bubble.
   if (uma_option_ && uma_option_->checked()) {
     // TODO: Clean up function ResolveMetricsReportingEnabled so that user pref
     // is stored automatically.
     OptionsUtil::ResolveMetricsReportingEnabled(true);
     g_browser_process->local_state()->SetBoolean(
         prefs::kMetricsReportingEnabled, true);
+    RecordBubbleHistogramValue(SESSION_CRASHED_BUBBLE_UMA_OPTIN);
   }
   CloseBubble();
 }
 
 void SessionCrashedBubbleView::CloseBubble() {
   GetWidget()->Close();
 }
 
 bool ShowSessionCrashedBubble(Browser* browser) {
   if (IsBubbleUIEnabled()) {
     SessionCrashedBubbleView::Show(browser);
     return true;
   }
   return false;
 }