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::Reason reason =
+      signin::GetSigninReasonForPromoURL(current_url_);
 
   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) {
       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,
+      CreateSyncStarter(browser, contents, current_url_,
                         signin::GetNextPageURLForPromoURL(current_url_),
-                        result.refresh_token,
-                        start_mode,
+                        result.refresh_token, start_mode,
                         confirmation_required);
       base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
     }
   }
 }
 
 void InlineSigninHelper::CreateSyncStarter(
     Browser* browser,
     content::WebContents* contents,
-    const GURL& url,
+    const GURL& current_url,
+    const GURL& continue_url,
     const std::string& refresh_token,
     OneClickSigninSyncStarter::StartSyncMode start_mode,
     OneClickSigninSyncStarter::ConfirmationRequired confirmation_required) {
   // OneClickSigninSyncStarter will delete itself once the job is done.
   new OneClickSigninSyncStarter(
-      profile_, browser,
-      gaia_id_, email_, password_, refresh_token,
-      start_mode,
-      contents,
-      confirmation_required,
-      url,
+      profile_, browser, gaia_id_, email_, password_, refresh_token, start_mode,
+      contents, confirmation_required, current_url, continue_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);
       }
       chrome::ShowSettingsSubPage(browser,
                                   std::string(chrome::kCreateProfileSubPage));
       break;
     case InlineSigninHelper::START_SYNC:
-      CreateSyncStarter(browser, web_contents, GURL(), refresh_token,
-          start_mode, confirmation_required);
+      CreateSyncStarter(browser, web_contents, current_url_, GURL(),
+                        refresh_token, start_mode, confirmation_required);
       break;
     case InlineSigninHelper::CLOSE:
       if (handler_) {
         handler_->SyncStarterCallback(
             OneClickSigninSyncStarter::SYNC_SETUP_FAILURE);
       }
       break;
     default:
       DCHECK(false) << "Invalid action";
   }
@@ skipping 132 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 138 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);
     }
   }
 }