Expanding signin histogram coverage.

chrome/browser/ui/sync/one_click_signin_helper.cc

 // Copyright (c) 2012 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/sync/one_click_signin_helper.h"
 
 #include <algorithm>
 #include <functional>
 #include <utility>
 #include <vector>
@@ skipping 73 matching lines @@
 // Add a specific email to the list of emails rejected for one-click
 // sign-in, for this profile.
 void AddEmailToOneClickRejectedList(Profile* profile,
                                     const std::string& email) {
   PrefService* pref_service = profile->GetPrefs();
   ListPrefUpdate updater(pref_service,
                          prefs::kReverseAutologinRejectedEmailList);
   updater->AppendIfNotPresent(new base::StringValue(email));
 }
 
+void LogHistogramValue(SyncPromoUI::Source source, int action) {
+  switch (source) {
+    case SyncPromoUI::SOURCE_START_PAGE:
+      UMA_HISTOGRAM_ENUMERATION("Signin.StartPageActions", action,
+                                one_click_signin::HISTOGRAM_MAX);
+      break;
+    case SyncPromoUI::SOURCE_NTP_LINK:
+      UMA_HISTOGRAM_ENUMERATION("Signin.NTPLinkActions", action,
+                                one_click_signin::HISTOGRAM_MAX);
+      break;
+    case SyncPromoUI::SOURCE_MENU:
+      UMA_HISTOGRAM_ENUMERATION("Signin.MenuActions", action,
+                                one_click_signin::HISTOGRAM_MAX);
+      break;
+    case SyncPromoUI::SOURCE_SETTINGS:
+      UMA_HISTOGRAM_ENUMERATION("Signin.SettingsActions", action,
+                                one_click_signin::HISTOGRAM_MAX);
+      break;
+    case SyncPromoUI::SOURCE_EXTENSION_INSTALL_BUBBLE:
+      UMA_HISTOGRAM_ENUMERATION("Signin.ExtensionInstallBubbleActions", action,
+                                one_click_signin::HISTOGRAM_MAX);
+      break;
+    case SyncPromoUI::SOURCE_WEBSTORE_INSTALL:
+      UMA_HISTOGRAM_ENUMERATION("Signin.WebstoreInstallActions", action,
+                                one_click_signin::HISTOGRAM_MAX);
+      break;
+    case SyncPromoUI::SOURCE_APP_LAUNCHER:
+      UMA_HISTOGRAM_ENUMERATION("Signin.AppLauncherActions", action,
+                                one_click_signin::HISTOGRAM_MAX);
+      break;
+    default:
+      NOTREACHED() << "Invalid Source";
+      return;
+  }
+  UMA_HISTOGRAM_ENUMERATION("Signin.AllAccessPointActions", action,
+                            one_click_signin::HISTOGRAM_MAX);
+}
+
+void LogOneClickHistogramValue(int action) {
+  UMA_HISTOGRAM_ENUMERATION("Signin.OneClickActions", action,
+                            one_click_signin::HISTOGRAM_MAX);
+  UMA_HISTOGRAM_ENUMERATION("Signin.AllAccessPointActions", action,
+                            one_click_signin::HISTOGRAM_MAX);
+}
+
 // Arguments used with StartSync function.  base::Bind() cannot support too
 // many args for performance reasons, so they are packaged up into a struct.
 struct StartSyncArgs {
   StartSyncArgs(Profile* profile,
                 Browser* browser,
                 OneClickSigninHelper::AutoAccept auto_accept,
                 const std::string& session_index,
                 const std::string& email,
                 const std::string& password,
                 bool force_same_tab_navigation)
@@ skipping 12 matching lines @@
   std::string session_index;
   std::string email;
   std::string password;
   bool force_same_tab_navigation;
 };
 
 // Start syncing with the given user information.
 void StartSync(const StartSyncArgs& args,
                OneClickSigninSyncStarter::StartSyncMode start_mode) {
   if (start_mode == OneClickSigninSyncStarter::UNDO_SYNC) {
-    UMA_HISTOGRAM_ENUMERATION("AutoLogin.Reverse",
-                              one_click_signin::HISTOGRAM_UNDO,
-                              one_click_signin::HISTOGRAM_MAX);
+    LogOneClickHistogramValue(one_click_signin::HISTOGRAM_UNDO);
     return;
   }
   // The starter deletes itself once its done.
   new OneClickSigninSyncStarter(args.profile, args.browser, args.session_index,
                                 args.email, args.password, start_mode,
                                 args.force_same_tab_navigation);
 
   int action = one_click_signin::HISTOGRAM_MAX;
   switch (args.auto_accept) {
     case OneClickSigninHelper::AUTO_ACCEPT_EXPLICIT:
+      break;
+    case OneClickSigninHelper::AUTO_ACCEPT_ACCEPTED:
       action =
           start_mode == OneClickSigninSyncStarter::SYNC_WITH_DEFAULT_SETTINGS ?
               one_click_signin::HISTOGRAM_AUTO_WITH_DEFAULTS :
               one_click_signin::HISTOGRAM_AUTO_WITH_ADVANCED;
       break;
-    case OneClickSigninHelper::AUTO_ACCEPT_ACCEPTED:
       action = one_click_signin::HISTOGRAM_AUTO_WITH_DEFAULTS;
       break;
-    case OneClickSigninHelper::AUTO_ACCEPT_NONE:
-      action =
-          start_mode == OneClickSigninSyncStarter::SYNC_WITH_DEFAULT_SETTINGS ?
-              one_click_signin::HISTOGRAM_WITH_DEFAULTS :
-              one_click_signin::HISTOGRAM_WITH_ADVANCED;
-      break;
     case OneClickSigninHelper::AUTO_ACCEPT_CONFIGURE:
       DCHECK(start_mode == OneClickSigninSyncStarter::CONFIGURE_SYNC_FIRST);
       action = one_click_signin::HISTOGRAM_AUTO_WITH_ADVANCED;
       break;
     default:
       NOTREACHED() << "Invalid auto_accept: " << args.auto_accept;
       break;
   }
-
-  UMA_HISTOGRAM_ENUMERATION("AutoLogin.Reverse", action,
-                            one_click_signin::HISTOGRAM_MAX);
+  if (action != one_click_signin::HISTOGRAM_MAX)
+    LogOneClickHistogramValue(action);
 }
 
 void StartExplicitSync(const StartSyncArgs& args,
                        content::WebContents* contents,
                        OneClickSigninSyncStarter::StartSyncMode start_mode,
                        int button) {
   if (button == IDS_ONE_CLICK_SIGNIN_CONFIRM_EMAIL_DIALOG_OK_BUTTON) {
     contents->GetController().LoadURL(
         GURL(chrome::kChromeUINewTabURL), content::Referrer(),
         content::PAGE_TRANSITION_AUTO_TOPLEVEL, std::string());
@@ skipping 146 matching lines @@
     content::WebContents* contents,
     const std::string& last_email,
     const std::string& email,
     Callback callback)
   : TabModalConfirmDialogDelegate(contents),
     last_email_(last_email),
     email_(email),
     callback_(callback) {
 }
 
+// Tells when we are in the process of showing either the signin to chrome page
+// or the one click sign in to chrome page.
+bool AreWeShowingSignin(GURL url, SyncPromoUI::Source source,
+                        std::string email) {
+  GURL::Replacements replacements;
+  replacements.ClearQuery();
+  GURL clean_login_url =
+      GURL(GaiaUrls::GetInstance()->service_login_url()).ReplaceComponents(
+          replacements);
+
+  return (url.ReplaceComponents(replacements) == clean_login_url &&
+          source != SyncPromoUI::SOURCE_UNKNOWN) || !email.empty();
+}
+
 }  // namespace
 
 // The infobar asking the user if they want to use one-click sign in.
 // TODO(rogerta): once we move to a web-based sign in flow, we can get rid
 // of this infobar.
 class OneClickInfoBarDelegateImpl : public OneClickSigninInfoBarDelegate {
  public:
   // Creates a one click signin delegate and adds it to |infobar_service|.
   static void Create(InfoBarService* infobar_service,
                      const std::string& session_index,
@@ skipping 155 matching lines @@
   return OneClickSigninInfoBarDelegate::GetAlternateColors(alt_colors);
 }
 
 void OneClickInfoBarDelegateImpl::RecordHistogramAction(int action) {
   UMA_HISTOGRAM_ENUMERATION("AutoLogin.Reverse", action,
                             one_click_signin::HISTOGRAM_MAX);
 }
 
 OneClickSigninHelper::OneClickSigninHelper(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
+      showing_signin_(false),
       auto_accept_(AUTO_ACCEPT_NONE),
-      source_(SyncPromoUI::SOURCE_UNKNOWN) {
+      source_(SyncPromoUI::SOURCE_UNKNOWN),
+      switched_to_advanced_(false),
+      original_source_(SyncPromoUI::SOURCE_UNKNOWN) {
 }
 
 OneClickSigninHelper::~OneClickSigninHelper() {
   content::WebContents* contents = web_contents();
   if (contents) {
     Profile* profile =
         Profile::FromBrowserContext(contents->GetBrowserContext());
     ProfileSyncService* sync_service =
         ProfileSyncServiceFactory::GetForProfile(profile);
     if (sync_service && sync_service->HasObserver(this))
@@ skipping 316 matching lines @@
   content::WebContents* web_contents = tab_util::GetWebContentsByID(child_id,
                                                                     route_id);
 
   // TODO(mathp): The appearance of this infobar should be tested using a
   // browser_test.
   OneClickSigninHelper* helper =
       OneClickSigninHelper::FromWebContents(web_contents);
   if (!helper)
     return;
 
-  // Save the email in the one-click signin manager.  The manager may
-  // not exist if the contents is incognito or if the profile is already
-  // connected to a Google account.
-  if (!session_index.empty())
-    helper->session_index_ = session_index;
-
-  if (!email.empty())
-    helper->email_ = email;
-
   if (auto_accept != AUTO_ACCEPT_NONE) {
     helper->auto_accept_ = auto_accept;
     helper->source_ = source;
   }
 
   CanOfferFor can_offer_for =
       (auto_accept != AUTO_ACCEPT_EXPLICIT &&
           helper->auto_accept_ != AUTO_ACCEPT_EXPLICIT) ?
           CAN_OFFER_FOR_INTERSTITAL_ONLY : CAN_OFFER_FOR_ALL;
   std::string error_message;
 
   if (!web_contents || !CanOffer(web_contents, can_offer_for, email,
                                  &error_message)) {
     VLOG(1) << "OneClickSigninHelper::ShowInfoBarUIThread: not offering";
     if (helper && helper->error_message_.empty() && !error_message.empty())
       helper->error_message_ = error_message;
 
     return;
   }
 
+  // Save the email in the one-click signin manager.  The manager may
+  // not exist if the contents is incognito or if the profile is already
+  // connected to a Google account.
+  if (!session_index.empty())
+    helper->session_index_ = session_index;
+
+  if (!email.empty())
+    helper->email_ = email;
+
   if (continue_url.is_valid())
     helper->continue_url_ = continue_url;
 }
 
 void OneClickSigninHelper::RedirectToNTP(bool show_bubble) {
   VLOG(1) << "OneClickSigninHelper::RedirectToNTP";
 
   // Redirect to NTP with sign in bubble visible.
   content::WebContents* contents = web_contents();
   Profile* profile =
@@ skipping 27 matching lines @@
 
   content::WebContents* contents = web_contents();
   contents->GetController().LoadURL(page,
                                     content::Referrer(),
                                     content::PAGE_TRANSITION_AUTO_TOPLEVEL,
                                     std::string());
 }
 
 void OneClickSigninHelper::CleanTransientState() {
   VLOG(1) << "OneClickSigninHelper::CleanTransientState";
+  showing_signin_ = false;
   email_.clear();
   password_.clear();
   auto_accept_ = AUTO_ACCEPT_NONE;
   source_ = SyncPromoUI::SOURCE_UNKNOWN;
+  switched_to_advanced_ = false;
+  original_source_ = SyncPromoUI::SOURCE_UNKNOWN;
   continue_url_ = GURL();
 
   // Post to IO thread to clear pending email.
   Profile* profile =
       Profile::FromBrowserContext(web_contents()->GetBrowserContext());
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&ClearPendingEmailOnIOThread,
                  base::Unretained(profile->GetResourceContext())));
 }
@@ skipping 33 matching lines @@
 
   // If an error has already occured during the sign in flow, make sure to
   // display it to the user and abort the process.  Do this only for
   // explicit sign ins.
   if (!error_message_.empty() && auto_accept_ == AUTO_ACCEPT_EXPLICIT) {
     VLOG(1) << "OneClickSigninHelper::DidStopLoading: error=" << error_message_;
     RedirectToNTP(true);
     return;
   }
 
+  if (AreWeShowingSignin(url, source_, email_)) {
+    if (!showing_signin_) {
+      if (source_ == SyncPromoUI::SOURCE_UNKNOWN)
+        LogOneClickHistogramValue(one_click_signin::HISTOGRAM_SHOWN);
+      else
+        LogHistogramValue(source_, one_click_signin::HISTOGRAM_SHOWN);
+    }
+    showing_signin_ = true;
+  }
+
   // When Gaia finally redirects to the continue URL, Gaia will add some
   // extra query parameters.  So ignore the parameters when checking to see
   // if the user has continued.
   GURL::Replacements replacements;
   replacements.ClearQuery();
   const bool continue_url_match_accept = (
       auto_accept_ == AUTO_ACCEPT_EXPLICIT &&
       continue_url_.is_valid() &&
       url.ReplaceComponents(replacements) ==
         continue_url_.ReplaceComponents(replacements));
 
   // If there is no valid email or password yet, there is nothing to do.
   if (email_.empty() || password_.empty()) {
+    VLOG(1) << "OneClickSigninHelper::DidStopLoading: nothing to do";
     if (continue_url_match_accept)
       RedirectToSignin();
     std::string unused_value;
     if (net::GetValueForKeyInQuery(url, "ntp", &unused_value))
       RedirectToNTP(false);
     return;
   }
 
   // When the user uses the first-run, ntp, or hotdog menu to sign in, then have
   // the option of checking the the box "Let me choose what to sync".  When the
@@ skipping 33 matching lines @@
       // source of the continue URL.  Make one last check of the current URL
       // to see if there is a valid source.  If so, it overrides the
       // current source.
       //
       // If the source was changed to SOURCE_SETTINGS, we want
       // OneClickSigninSyncStarter to reuse the current tab to display the
       // advanced configuration.
       SyncPromoUI::Source source =
           SyncPromoUI::GetSourceForSyncPromoURL(url);
       if (source != source_) {
+        original_source_ = source_;
         source_ = source;
-        force_same_tab_navigation = source_ == SyncPromoUI::SOURCE_SETTINGS;
+        force_same_tab_navigation = source == SyncPromoUI::SOURCE_SETTINGS;
+        switched_to_advanced_ = source == SyncPromoUI::SOURCE_SETTINGS;
       }
     }
   }
 
   Browser* browser = chrome::FindBrowserWithWebContents(contents);
   Profile* profile =
       Profile::FromBrowserContext(contents->GetBrowserContext());
 
   VLOG(1) << "OneClickSigninHelper::DidStopLoading: signin is go."
           << " auto_accept=" << auto_accept_
           << " source=" << source_;
 
   BrowserWindow::OneClickSigninBubbleType bubble_type;
   if (base::FieldTrialList::FindFullName(kSignInToChromeDialogFieldTrialName) ==
       kSignInConfirmBubbleGroupName)
     bubble_type = BrowserWindow::ONE_CLICK_SIGNIN_BUBBLE_TYPE_BUBBLE;
   else
     bubble_type = BrowserWindow::ONE_CLICK_SIGNIN_BUBBLE_TYPE_MODAL_DIALOG;
 
   switch (auto_accept_) {
     case AUTO_ACCEPT_NONE:
       if (SyncPromoUI::UseWebBasedSigninFlow()) {
-        UMA_HISTOGRAM_ENUMERATION("AutoLogin.Reverse",
-                                  one_click_signin::HISTOGRAM_DISMISSED,
-                                  one_click_signin::HISTOGRAM_MAX);
+        LogOneClickHistogramValue(one_click_signin::HISTOGRAM_DISMISSED);
       } else {
         OneClickInfoBarDelegateImpl::Create(
             InfoBarService::FromWebContents(contents), session_index_, email_,
             password_);
       }
       break;
     case AUTO_ACCEPT_ACCEPTED:
+      LogOneClickHistogramValue(one_click_signin::HISTOGRAM_ACCEPTED);
+      LogOneClickHistogramValue(one_click_signin::HISTOGRAM_WITH_DEFAULTS);
       SigninManager::DisableOneClickSignIn(profile);
       browser->window()->ShowOneClickSigninBubble(
           bubble_type,
           base::Bind(&StartSync,
                      StartSyncArgs(profile, browser, auto_accept_,
                                    session_index_, email_, password_,
                                    false /* force_same_tab_navigation */)));
       break;
     case AUTO_ACCEPT_CONFIGURE:
+      LogOneClickHistogramValue(one_click_signin::HISTOGRAM_ACCEPTED);
+      LogOneClickHistogramValue(one_click_signin::HISTOGRAM_WITH_ADVANCED);
       SigninManager::DisableOneClickSignIn(profile);
       StartSync(
           StartSyncArgs(profile, browser, auto_accept_, session_index_, email_,
                         password_, false /* force_same_tab_navigation */),
           OneClickSigninSyncStarter::CONFIGURE_SYNC_FIRST);
       break;
     case AUTO_ACCEPT_EXPLICIT: {
+      if (switched_to_advanced_) {
+        LogHistogramValue(original_source_,
+                          one_click_signin::HISTOGRAM_WITH_ADVANCED);
+        LogHistogramValue(original_source_,
+                          one_click_signin::HISTOGRAM_ACCEPTED);
+      } else {
+        LogHistogramValue(source_, one_click_signin::HISTOGRAM_ACCEPTED);
+        LogHistogramValue(source_, one_click_signin::HISTOGRAM_WITH_DEFAULTS);
+      }
       OneClickSigninSyncStarter::StartSyncMode start_mode =
           source_ == SyncPromoUI::SOURCE_SETTINGS ?
               OneClickSigninSyncStarter::CONFIGURE_SYNC_FIRST :
               OneClickSigninSyncStarter::SYNC_WITH_DEFAULT_SETTINGS;
 
       // If the new email address is different from the email address that
       // just signed in, show a confirmation dialog.
       std::string last_email =
           profile->GetPrefs()->GetString(prefs::kGoogleServicesLastUsername);
       if (!last_email.empty() && last_email != email_) {
@@ skipping 33 matching lines @@
       // redirect back to webstore.
       if (source_ != SyncPromoUI::SOURCE_SETTINGS &&
           source_ != SyncPromoUI::SOURCE_WEBSTORE_INSTALL) {
         signin_tracker_.reset(new SigninTracker(profile, this));
         RedirectToNTP(true);
       }
       break;
     }
     case AUTO_ACCEPT_REJECTED_FOR_PROFILE:
       AddEmailToOneClickRejectedList(profile, email_);
-      UMA_HISTOGRAM_ENUMERATION("AutoLogin.Reverse",
-                                one_click_signin::HISTOGRAM_REJECTED,
-                                one_click_signin::HISTOGRAM_MAX);
+      LogOneClickHistogramValue(one_click_signin::HISTOGRAM_REJECTED);
       break;
     default:
       NOTREACHED() << "Invalid auto_accept=" << auto_accept_;
       break;
   }
 
   CleanTransientState();
 }
 
 void OneClickSigninHelper::GaiaCredentialsValid() {
@@ skipping 45 matching lines @@
     }
   }
 
   RedirectToNTP(true);
   signin_tracker_.reset();
 }
 
 void OneClickSigninHelper::SigninSuccess() {
   signin_tracker_.reset();
 }