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,

[jwd, 2014/07/09 15:37:52]

Is this being used anywhere anymore?

[yao, 2014/07/09 15:47:03]

Done.

+  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;
 }
 
+// Will be passed in as a callback function to BubbleFrameView. Before the
+// bubble is closed (by the close button), collect the usage stats.
+void BubbleToBeClosed() {
+  RecordBubbleHistogramValue(SESSION_CRASHED_BUBBLE_IGNORED);
+}
+
 }  // namespace
 
 // A helper class that listens to browser removal event.
 class SessionCrashedBubbleView::BrowserRemovalObserver
     : public chrome::BrowserListObserver {
  public:
   explicit BrowserRemovalObserver(Browser* browser) : browser_(browser) {
     DCHECK(browser_);
     BrowserList::AddObserver(this);
   }
@@ skipping 21 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)
     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();
+  views::BubbleFrameView* frame_view = crash_bubble->GetBubbleFrameView();
+  if (frame_view) {
+    frame_view->set_before_close_callback(base::Bind(&BubbleToBeClosed));
+  }
+  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),
@@ skipping 143 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);
 }
 
 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_)
+  if (started_navigation_) {
+    RecordBubbleHistogramValue(SESSION_CRASHED_BUBBLE_IGNORED);
     CloseBubble();
+  }
 }
 
 void SessionCrashedBubbleView::WasShown() {
   GetWidget()->Show();
 }
 
 void SessionCrashedBubbleView::WasHidden() {
   GetWidget()->Hide();
 }
 
 void SessionCrashedBubbleView::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  if (type == chrome::NOTIFICATION_TAB_CLOSING)
+  if (type == chrome::NOTIFICATION_TAB_CLOSING) {
+    RecordBubbleHistogramValue(SESSION_CRASHED_BUBBLE_IGNORED);
     CloseBubble();
+  }
 }
 
 void SessionCrashedBubbleView::TabDetachedAt(content::WebContents* contents,
                                              int index) {
-  if (web_contents_ == contents)
+  if (web_contents_ == contents) {
+    RecordBubbleHistogramValue(SESSION_CRASHED_BUBBLE_IGNORED);
     CloseBubble();
+  }
 }
 
 void SessionCrashedBubbleView::RestorePreviousSession(views::Button* sender) {
   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;
 }