Implement newly designed sign-in related histograms for desktop platorms.

chrome/browser/ui/webui/signin/inline_login_handler_impl.cc

 // Copyright 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/ui/webui/signin/inline_login_handler_impl.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 56 matching lines @@
   UMA_HISTOGRAM_ENUMERATION("Signin.AllAccessPointActions", action,
                             signin_metrics::HISTOGRAM_MAX);
 }
 
 // Returns true if |profile| is a system profile or created from one.
 bool IsSystemProfile(Profile* profile) {
   return profile->GetOriginalProfile()->IsSystemProfile();
 }
 
 void RedirectToNtpOrAppsPage(content::WebContents* contents,
-                             signin_metrics::Source source) {
+                             signin_metrics::AccessPoint access_point) {
   // Do nothing if a navigation is pending, since this call can be triggered
   // from DidStartLoading. This avoids deleting the pending entry while we are
   // still navigating to it. See crbug/346632.
   if (contents->GetController().GetPendingEntry())
     return;
 
   VLOG(1) << "RedirectToNtpOrAppsPage";
   // Redirect to NTP/Apps page and display a confirmation bubble
-  GURL url(source == signin_metrics::SOURCE_APPS_PAGE_LINK ?
-           chrome::kChromeUIAppsURL : chrome::kChromeUINewTabURL);
+  GURL url(access_point == signin_metrics::ACCESS_POINT_APPS_PAGE_LINK
+               ? chrome::kChromeUIAppsURL
+               : chrome::kChromeUINewTabURL);
   content::OpenURLParams params(url,
                                 content::Referrer(),
                                 CURRENT_TAB,
                                 ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
                                 false);
   contents->OpenURL(params);
 }
 
-void RedirectToNtpOrAppsPageIfNecessary(content::WebContents* contents,
-                                        signin_metrics::Source source) {
-  if (source != signin_metrics::SOURCE_SETTINGS)
-    RedirectToNtpOrAppsPage(contents, source);
+void RedirectToNtpOrAppsPageIfNecessary(
+    content::WebContents* contents,
+    signin_metrics::AccessPoint access_point) {
+  if (access_point != signin_metrics::ACCESS_POINT_SETTINGS)
+    RedirectToNtpOrAppsPage(contents, access_point);
 }
 
 class ConfirmEmailDialogDelegate : public TabModalConfirmDialogDelegate {
  public:
   // Callback indicating action performed by the user.
   typedef base::Callback<void(InlineSigninHelper::Action)> Callback;
 
   // Ask the user for confirmation before starting to sync.
   static void AskForConfirmation(content::WebContents* contents,
                                  const std::string& last_email,
@@ skipping 155 matching lines @@
 
   AboutSigninInternals* about_signin_internals =
       AboutSigninInternalsFactory::GetForProfile(profile_);
   about_signin_internals->OnRefreshTokenReceived("Successful");
 
   // Prime the account tracker with this combination of gaia id/display email.
   std::string account_id =
       AccountTrackerServiceFactory::GetForProfile(profile_)
           ->SeedAccountInfo(gaia_id_, email_);
 
-  signin_metrics::Source source = signin::GetSourceForPromoURL(current_url_);
+  signin_metrics::AccessPoint access_point =
+      signin::GetAccessPointForPromoURL(current_url_);
+  signin_metrics::LogSigninAccessPoint(access_point, true);
+
+  signin_metrics::Reason reason =
+      signin::GetSigninReasonForPromoURL(current_url_);
+  signin_metrics::LogSigninReason(reason);

[Roger Tawa OOO till Jul 10th, 2015/12/02 20:33:49]

By this point, gaia sign in completed successfully, but chrome is not quite
signed in yet.  For example, for an enterprise sign in, the user could still
choose to abort sign in.

I wonder if it is better to log this in SigninManager::OnSignedIn().

[gogerald1, 2015/12/03 17:49:03]

Do it in one_click_signin_sync_starter

 
   SigninManager* signin_manager = SigninManagerFactory::GetForProfile(profile_);
   std::string primary_email =
       signin_manager->GetAuthenticatedAccountInfo().email;
   if (gaia::AreEmailsSame(email_, primary_email) &&
-      source == signin_metrics::SOURCE_REAUTH &&
-      switches::IsNewProfileManagement() &&
-      !password_.empty() &&
+      (reason == signin_metrics::REASON_REAUTHENTICATION ||
+       reason == signin_metrics::REASON_UNLOCK) &&
+      switches::IsNewProfileManagement() && !password_.empty() &&
       profiles::IsLockAvailable(profile_)) {
     LocalAuth::SetLocalAuthCredentials(profile_, password_);
   }
 
-  if (source == signin_metrics::SOURCE_AVATAR_BUBBLE_ADD_ACCOUNT ||
-      source == signin_metrics::SOURCE_REAUTH) {
+  if (reason == signin_metrics::REASON_REAUTHENTICATION ||
+      reason == signin_metrics::REASON_UNLOCK ||
+      reason == signin_metrics::REASON_ADD_SECONDARY_ACCOUNT) {
     ProfileOAuth2TokenServiceFactory::GetForProfile(profile_)->
         UpdateCredentials(account_id, result.refresh_token);
 
     if (signin::IsAutoCloseEnabledInURL(current_url_)) {
       // Close the gaia sign in tab via a task to make sure we aren't in the
       // middle of any webui handler code.
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(&InlineLoginHandlerImpl::CloseTab, handler_,
                      signin::ShouldShowAccountManagement(current_url_)));
     }
 
-    if (source == signin_metrics::SOURCE_REAUTH)
+    if (reason == signin_metrics::REASON_REAUTHENTICATION ||
+        reason == signin_metrics::REASON_UNLOCK)

[Roger Tawa OOO till Jul 10th, 2015/12/02 20:33:48]

Need { and } for if.

[gogerald1, 2015/12/03 17:49:03]

Done.

       signin_manager->MergeSigninCredentialIntoCookieJar();
   } else {
     ProfileSyncService* sync_service =
         ProfileSyncServiceFactory::GetForProfile(profile_);
     SigninErrorController* error_controller =
         SigninErrorControllerFactory::GetForProfile(profile_);
 
     OneClickSigninSyncStarter::StartSyncMode start_mode =
         OneClickSigninSyncStarter::CONFIRM_SYNC_SETTINGS_FIRST;
-    if (source == signin_metrics::SOURCE_SETTINGS || choose_what_to_sync_) {
+    if (access_point == signin_metrics::ACCESS_POINT_SETTINGS ||
+        choose_what_to_sync_) {
       bool show_settings_without_configure =
           error_controller->HasError() &&
           sync_service &&
           sync_service->HasSyncSetupCompleted();
       start_mode = show_settings_without_configure ?
           OneClickSigninSyncStarter::SHOW_SETTINGS_WITHOUT_CONFIGURE :
           OneClickSigninSyncStarter::CONFIGURE_SYNC_FIRST;
     }
 
     OneClickSigninSyncStarter::ConfirmationRequired confirmation_required =
         confirm_untrusted_signin_ ?
             OneClickSigninSyncStarter::CONFIRM_UNTRUSTED_SIGNIN :
             OneClickSigninSyncStarter::CONFIRM_AFTER_SIGNIN;
 
-    bool start_signin = !HandleCrossAccountError(result.refresh_token, source,
-        confirmation_required, start_mode);
+    bool start_signin = !HandleCrossAccountError(
+        result.refresh_token, confirmation_required, start_mode);
     if (start_signin) {
       CreateSyncStarter(browser,
                         contents,
                         signin::GetNextPageURLForPromoURL(current_url_),
                         result.refresh_token,
                         start_mode,
                         confirmation_required);
       base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
     }
   }
@@ skipping 12 matching lines @@
       gaia_id_, email_, password_, refresh_token,
       start_mode,
       contents,
       confirmation_required,
       url,
       base::Bind(&InlineLoginHandlerImpl::SyncStarterCallback, handler_));
 }
 
 bool InlineSigninHelper::HandleCrossAccountError(
     const std::string& refresh_token,
-    signin_metrics::Source source,
     OneClickSigninSyncStarter::ConfirmationRequired confirmation_required,
     OneClickSigninSyncStarter::StartSyncMode start_mode) {
   std::string last_email =
       profile_->GetPrefs()->GetString(prefs::kGoogleServicesLastUsername);
 
   if (last_email.empty() || gaia::AreEmailsSame(last_email, email_))
     return false;
 
   Browser* browser = chrome::FindLastActiveWithProfile(
       profile_, chrome::GetActiveDesktop());
   content::WebContents* web_contents =
       browser->tab_strip_model()->GetActiveWebContents();
 
   ConfirmEmailDialogDelegate::AskForConfirmation(
       web_contents,
       last_email,
       email_,
       base::Bind(&InlineSigninHelper::ConfirmEmailAction,
                  base::Unretained(this),
                  web_contents,
                  refresh_token,
-                 source,
                  confirmation_required,
                  start_mode));
   return true;
 }
 
 void InlineSigninHelper::ConfirmEmailAction(
     content::WebContents* web_contents,
     const std::string& refresh_token,
-    signin_metrics::Source source,
     OneClickSigninSyncStarter::ConfirmationRequired confirmation_required,
     OneClickSigninSyncStarter::StartSyncMode start_mode,
     InlineSigninHelper::Action action) {
   Browser* browser = chrome::FindLastActiveWithProfile(
       profile_, chrome::GetActiveDesktop());
   switch (action) {
     case InlineSigninHelper::CREATE_NEW_USER:
       if (handler_) {
         handler_->SyncStarterCallback(
             OneClickSigninSyncStarter::SYNC_SETUP_FAILURE);
@@ skipping 149 matching lines @@
   params.SetString("service", "chromiumsync");
 
   // If this was called from the user manager to reauthenticate the profile,
   // make sure the webui is aware.
   Profile* profile = Profile::FromWebUI(web_ui());
   if (IsSystemProfile(profile))
     params.SetBoolean("dontResizeNonEmbeddedPages", true);
 
   content::WebContents* contents = web_ui()->GetWebContents();
   const GURL& current_url = contents->GetURL();
-  signin_metrics::Source source = signin::GetSourceForPromoURL(current_url);
+  signin_metrics::Reason reason =
+      signin::GetSigninReasonForPromoURL(current_url);
 
   std::string is_constrained;
   net::GetValueForKeyInQuery(current_url, "constrained", &is_constrained);
 
   // Use new embedded flow if in constrained window.
   if (is_constrained == "1") {
     const bool is_new_gaia_flow = switches::UsePasswordSeparatedSigninFlow();
     const GURL& url = is_new_gaia_flow
             ? GaiaUrls::GetInstance()->embedded_signin_url()
             : GaiaUrls::GetInstance()->password_combined_embedded_signin_url();
     params.SetBoolean("isNewGaiaFlow", is_new_gaia_flow);
     params.SetString("clientId",
                      GaiaUrls::GetInstance()->oauth2_chrome_client_id());
     params.SetString("gaiaPath", url.path().substr(1));
 
     std::string flow;
-    switch (source) {
-      case signin_metrics::SOURCE_AVATAR_BUBBLE_ADD_ACCOUNT:
+    switch (reason) {
+      case signin_metrics::REASON_ADD_SECONDARY_ACCOUNT:
         flow = "addaccount";
         break;
-      case signin_metrics::SOURCE_REAUTH:
+      case signin_metrics::REASON_REAUTHENTICATION:
+      case signin_metrics::REASON_UNLOCK:
         flow = "reauth";
         break;
       default:
         flow = "signin";
         break;
     }
     params.SetString("flow", flow);
   }
 
   content::WebContentsObserver::Observe(contents);
@@ skipping 132 matching lines @@
     if (!gaia::AreEmailsSame(params.email, default_email)) {
       if (params.handler) {
         params.handler->HandleLoginError(
             l10n_util::GetStringFUTF8(IDS_SYNC_WRONG_EMAIL,
                                       base::UTF8ToUTF16(default_email)));
       }
       return;
     }
   }
 
-  signin_metrics::Source source = signin::GetSourceForPromoURL(params.url);
+  signin_metrics::AccessPoint access_point =
+      signin::GetAccessPointForPromoURL(params.url);
+  signin_metrics::Reason reason =
+      signin::GetSigninReasonForPromoURL(params.url);
   LogHistogramValue(signin_metrics::HISTOGRAM_ACCEPTED);
   bool switch_to_advanced =
-      params.choose_what_to_sync && (source != signin_metrics::SOURCE_SETTINGS);
+      params.choose_what_to_sync &&
+      (access_point != signin_metrics::ACCESS_POINT_SETTINGS);
   LogHistogramValue(
       switch_to_advanced ? signin_metrics::HISTOGRAM_WITH_ADVANCED :
                            signin_metrics::HISTOGRAM_WITH_DEFAULTS);
 
   CanOfferFor can_offer_for = CAN_OFFER_FOR_ALL;
-  switch (source) {
-    case signin_metrics::SOURCE_AVATAR_BUBBLE_ADD_ACCOUNT:
+  switch (reason) {
+    case signin_metrics::REASON_ADD_SECONDARY_ACCOUNT:
       can_offer_for = CAN_OFFER_FOR_SECONDARY_ACCOUNT;
       break;
-    case signin_metrics::SOURCE_REAUTH: {
+    case signin_metrics::REASON_REAUTHENTICATION:
+    case signin_metrics::REASON_UNLOCK: {
       std::string primary_username =
           SigninManagerFactory::GetForProfile(profile)
               ->GetAuthenticatedAccountInfo()
               .email;
       if (!gaia::AreEmailsSame(default_email, primary_username))
         can_offer_for = CAN_OFFER_FOR_SECONDARY_ACCOUNT;
       break;
     }
     default:
       // No need to change |can_offer_for|.
@@ skipping 75 matching lines @@
   content::WebContents* contents = web_ui()->GetWebContents();
 
   if (contents->GetController().GetPendingEntry()) {
     // Do nothing if a navigation is pending, since this call can be triggered
     // from DidStartLoading. This avoids deleting the pending entry while we are
     // still navigating to it. See crbug/346632.
     return;
   }
 
   const GURL& current_url = contents->GetLastCommittedURL();
-  signin_metrics::Source source = signin::GetSourceForPromoURL(current_url);
+  signin_metrics::AccessPoint access_point =
+      signin::GetAccessPointForPromoURL(current_url);
   bool auto_close = signin::IsAutoCloseEnabledInURL(current_url);
 
   if (result == OneClickSigninSyncStarter::SYNC_SETUP_FAILURE) {
-    RedirectToNtpOrAppsPage(contents, source);
+    RedirectToNtpOrAppsPage(contents, access_point);
   } else if (auto_close) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&InlineLoginHandlerImpl::CloseTab,
                    weak_factory_.GetWeakPtr(),
                    signin::ShouldShowAccountManagement(current_url)));
   } else {
-     RedirectToNtpOrAppsPageIfNecessary(contents, source);
+    RedirectToNtpOrAppsPageIfNecessary(contents, access_point);
   }
 }
 
 void InlineLoginHandlerImpl::CloseTab(bool show_account_management) {
   content::WebContents* tab = web_ui()->GetWebContents();
   Browser* browser = chrome::FindBrowserWithWebContents(tab);
   if (browser) {
     TabStripModel* tab_strip_model = browser->tab_strip_model();
     if (tab_strip_model) {
       int index = tab_strip_model->GetIndexOfWebContents(tab);
       if (index != TabStripModel::kNoTab) {
         tab_strip_model->ExecuteContextMenuCommand(
             index, TabStripModel::CommandCloseTab);
       }
     }
 
     if (show_account_management) {
       browser->window()->ShowAvatarBubbleFromAvatarButton(
-            BrowserWindow::AVATAR_BUBBLE_MODE_ACCOUNT_MANAGEMENT,
-            signin::ManageAccountsParams());
+          BrowserWindow::AVATAR_BUBBLE_MODE_ACCOUNT_MANAGEMENT,
+          signin::ManageAccountsParams(),
+          signin_metrics::ACCESS_POINT_AVATAR_BUBBLE_SIGN_IN);
     }
   }
 }