Clean up straggler classes to use embedded signin in page in the new profiles world.

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 30 matching lines @@
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/signin/signin_names_io_thread.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/chrome_pages.h"
-#include "chrome/browser/ui/sync/one_click_signin_histogram.h"
 #include "chrome/browser/ui/sync/one_click_signin_sync_observer.h"
 #include "chrome/browser/ui/sync/one_click_signin_sync_starter.h"
-#include "chrome/browser/ui/sync/signin_histogram.h"
 #include "chrome/browser/ui/tab_modal_confirm_dialog.h"
 #include "chrome/browser/ui/tab_modal_confirm_dialog_delegate.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service_factory.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/net/url_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/google/core/browser/google_util.h"
 #include "components/password_manager/core/browser/password_manager.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_client.h"
 #include "components/signin/core/browser/signin_error_controller.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/browser/signin_manager_cookie_helper.h"
+#include "components/signin/core/browser/signin_metrics.h"
 #include "components/signin/core/common/profile_management_switches.h"
 #include "components/sync_driver/sync_prefs.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/page_navigator.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/frame_navigate_params.h"
@@ skipping 140 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) {
   ListPrefUpdate updater(profile->GetPrefs(),
                          prefs::kReverseAutologinRejectedEmailList);
   updater->AppendIfNotPresent(new base::StringValue(email));
 }
 
-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);
-}
-
 void RedirectToNtpOrAppsPageWithIds(int child_id,
                                     int route_id,
-                                    signin::Source source) {
+                                    signin_metrics::Source source) {
   content::WebContents* web_contents = tab_util::GetWebContentsByID(child_id,
                                                                     route_id);
   if (!web_contents)
     return;
 
   OneClickSigninHelper::RedirectToNtpOrAppsPage(web_contents, source);
 }
 
 // Start syncing with the given user information.
 void StartSync(const OneClickSigninHelper::StartSyncArgs& args,
                OneClickSigninSyncStarter::StartSyncMode start_mode) {
   if (start_mode == OneClickSigninSyncStarter::UNDO_SYNC) {
-    LogOneClickHistogramValue(one_click_signin::HISTOGRAM_UNDO);
+    OneClickSigninHelper::LogHistogramValue(signin_metrics::HISTOGRAM_UNDO);
     return;
   }
 
   // The wrapper deletes itself once it's done.
   OneClickSigninHelper::SyncStarterWrapper* wrapper =
       new OneClickSigninHelper::SyncStarterWrapper(args, start_mode);
   wrapper->Start();
 
-  int action = one_click_signin::HISTOGRAM_MAX;
+  int action = signin_metrics::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;
+              signin_metrics::HISTOGRAM_AUTO_WITH_DEFAULTS :
+              signin_metrics::HISTOGRAM_AUTO_WITH_ADVANCED;
       break;
     case OneClickSigninHelper::AUTO_ACCEPT_CONFIGURE:
       DCHECK(start_mode == OneClickSigninSyncStarter::CONFIGURE_SYNC_FIRST);
-      action = one_click_signin::HISTOGRAM_AUTO_WITH_ADVANCED;
+      action = signin_metrics::HISTOGRAM_AUTO_WITH_ADVANCED;
       break;
     default:
       NOTREACHED() << "Invalid auto_accept: " << args.auto_accept;
       break;
   }
-  if (action != one_click_signin::HISTOGRAM_MAX)
-    LogOneClickHistogramValue(action);
+  if (action != signin_metrics::HISTOGRAM_MAX)
+    OneClickSigninHelper::LogHistogramValue(action);
 }
 
 void StartExplicitSync(const OneClickSigninHelper::StartSyncArgs& args,
                        content::WebContents* contents,
                        OneClickSigninSyncStarter::StartSyncMode start_mode,
                        ConfirmEmailDialogDelegate::Action action) {
   bool enable_inline = !switches::IsEnableWebBasedSignin();
   if (action == ConfirmEmailDialogDelegate::START_SYNC) {
     StartSync(args, start_mode);
     if (!enable_inline) {
@@ skipping 30 matching lines @@
 void ClearPendingEmailOnIOThread(content::ResourceContext* context) {
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
   DCHECK(io_data);
   io_data->set_reverse_autologin_pending_email(std::string());
 }
 
 // Determines the source of the sign in and the continue URL.  It's either one
 // of the known sign-in access points (first run, NTP, Apps page, menu, or
 // settings) or it's an implicit sign in via another Google property.  In the
 // former case, "service" is also checked to make sure its "chromiumsync".
-signin::Source GetSigninSource(const GURL& url, GURL* continue_url) {
+signin_metrics::Source GetSigninSource(const GURL& url, GURL* continue_url) {
   DCHECK(url.is_valid());
   std::string value;
   net::GetValueForKeyInQuery(url, "service", &value);
   bool possibly_an_explicit_signin = value == "chromiumsync";
 
   // Find the final continue URL for this sign in.  In some cases, Gaia can
   // continue to itself, with the original continue URL buried under a couple
   // of layers of indirection.  Peel those layers away.  The final destination
   // can also be "IsGaiaSignonRealm" so stop if we get to the end (but be sure
   // we always extract at least one "continue" value).
   GURL local_continue_url = signin::GetNextPageURLForPromoURL(url);
   while (gaia::IsGaiaSignonRealm(local_continue_url.GetOrigin())) {
     GURL next_continue_url =
         signin::GetNextPageURLForPromoURL(local_continue_url);
     if (!next_continue_url.is_valid())
       break;
     local_continue_url = next_continue_url;
   }
 
   if (continue_url && local_continue_url.is_valid()) {
     DCHECK(!continue_url->is_valid() || *continue_url == local_continue_url);
     *continue_url = local_continue_url;
   }
 
   return possibly_an_explicit_signin ?
       signin::GetSourceForPromoURL(local_continue_url) :
-      signin::SOURCE_UNKNOWN;
+      signin_metrics::SOURCE_UNKNOWN;
 }
 
 // Returns true if |url| is a valid URL that can occur during the sign in
 // process.  Valid URLs are of the form:
 //
 //    https://accounts.google.{TLD}/...
 //    https://accounts.youtube.com/...
 //    https://accounts.blogger.com/...
 //
 // All special headers used by one click sign in occur on
@@ skipping 16 matching lines @@
       origin == GURL("https://accounts.blogger.com"))
     return true;
 
   return false;
 }
 
 // Tells when we are in the process of showing either the signin to chrome page
 // or the one click sign in to chrome page.
 // NOTE: This should only be used for logging purposes since it relies on hard
 // coded URLs that could change.
-bool AreWeShowingSignin(GURL url, signin::Source source, std::string email) {
+bool AreWeShowingSignin(GURL url,
+                        signin_metrics::Source source,
+                        std::string email) {
   GURL::Replacements replacements;
   replacements.ClearQuery();
   GURL clean_login_url =
       GaiaUrls::GetInstance()->service_login_url().ReplaceComponents(
           replacements);
 
   return (url.ReplaceComponents(replacements) == clean_login_url &&
-          source != signin::SOURCE_UNKNOWN) ||
+          source != signin_metrics::SOURCE_UNKNOWN) ||
       (IsValidGaiaSigninRedirectOrResponseURL(url) &&
        url.spec().find("ChromeLoginPrompt") != std::string::npos &&
        !email.empty());
 }
 
 // If profile is valid then get signin scoped device id from signin client.
 // Otherwise returns empty string.
 std::string GetSigninScopedDeviceId(Profile* profile) {
   std::string signin_scoped_device_id;
   SigninClient* signin_client =
@@ skipping 71 matching lines @@
 
 
 // StartSyncArgs --------------------------------------------------------------
 
 OneClickSigninHelper::StartSyncArgs::StartSyncArgs()
     : profile(NULL),
       browser(NULL),
       auto_accept(AUTO_ACCEPT_NONE),
       web_contents(NULL),
       confirmation_required(OneClickSigninSyncStarter::NO_CONFIRMATION),
-      source(signin::SOURCE_UNKNOWN) {}
+      source(signin_metrics::SOURCE_UNKNOWN) {}
 
 OneClickSigninHelper::StartSyncArgs::StartSyncArgs(
     Profile* profile,
     Browser* browser,
     OneClickSigninHelper::AutoAccept auto_accept,
     const std::string& session_index,
     const std::string& email,
     const std::string& password,
     const std::string& refresh_token,
     content::WebContents* web_contents,
     bool untrusted_confirmation_required,
-    signin::Source source,
+    signin_metrics::Source source,
     OneClickSigninSyncStarter::Callback callback)
     : profile(profile),
       browser(browser),
       auto_accept(auto_accept),
       session_index(session_index),
       email(email),
       password(password),
       refresh_token(refresh_token),
       web_contents(web_contents),
       source(source),
       callback(callback) {
   DCHECK(session_index.empty() != refresh_token.empty());
   if (untrusted_confirmation_required) {
     confirmation_required = OneClickSigninSyncStarter::CONFIRM_UNTRUSTED_SIGNIN;
-  } else if (source == signin::SOURCE_SETTINGS) {
+  } else if (source == signin_metrics::SOURCE_SETTINGS) {
     // Do not display a status confirmation for re-auth.
     confirmation_required = OneClickSigninSyncStarter::NO_CONFIRMATION;
   } else {
     confirmation_required = OneClickSigninSyncStarter::CONFIRM_AFTER_SIGNIN;
   }
 }
 
 OneClickSigninHelper::StartSyncArgs::~StartSyncArgs() {}
 
 // SyncStarterWrapper ---------------------------------------------------------
@@ skipping 134 matching lines @@
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(OneClickSigninHelper);
 
 // static
 const int OneClickSigninHelper::kMaxNavigationsSince = 10;
 
 OneClickSigninHelper::OneClickSigninHelper(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       showing_signin_(false),
       auto_accept_(AUTO_ACCEPT_NONE),
-      source_(signin::SOURCE_UNKNOWN),
+      source_(signin_metrics::SOURCE_UNKNOWN),
       switched_to_advanced_(false),
       untrusted_navigations_since_signin_visit_(0),
       untrusted_confirmation_required_(false),
       do_not_clear_pending_email_(false),
       do_not_start_sync_for_testing_(false),
       weak_pointer_factory_(this) {
   ChromePasswordManagerClient* client =
       ChromePasswordManagerClient::FromWebContents(web_contents);
   // May be NULL during testing.
   if (client) {
     client->GetPasswordManager()->AddSubmissionCallback(
         base::Bind(&OneClickSigninHelper::PasswordSubmitted,
                    weak_pointer_factory_.GetWeakPtr()));
   }
 }
 
 OneClickSigninHelper::~OneClickSigninHelper() {}
 
 // static
-void OneClickSigninHelper::LogHistogramValue(
-    signin::Source source, int action) {
-  switch (source) {
-    case signin::SOURCE_START_PAGE:
-      UMA_HISTOGRAM_ENUMERATION("Signin.StartPageActions", action,
-                                one_click_signin::HISTOGRAM_MAX);
-      break;
-    case signin::SOURCE_NTP_LINK:
-      UMA_HISTOGRAM_ENUMERATION("Signin.NTPLinkActions", action,
-                                one_click_signin::HISTOGRAM_MAX);
-      break;
-    case signin::SOURCE_MENU:
-      UMA_HISTOGRAM_ENUMERATION("Signin.MenuActions", action,
-                                one_click_signin::HISTOGRAM_MAX);
-      break;
-    case signin::SOURCE_SETTINGS:
-      UMA_HISTOGRAM_ENUMERATION("Signin.SettingsActions", action,
-                                one_click_signin::HISTOGRAM_MAX);
-      break;
-    case signin::SOURCE_EXTENSION_INSTALL_BUBBLE:
-      UMA_HISTOGRAM_ENUMERATION("Signin.ExtensionInstallBubbleActions", action,
-                                one_click_signin::HISTOGRAM_MAX);
-      break;
-    case signin::SOURCE_APP_LAUNCHER:
-      UMA_HISTOGRAM_ENUMERATION("Signin.AppLauncherActions", action,
-                                one_click_signin::HISTOGRAM_MAX);
-      break;
-    case signin::SOURCE_APPS_PAGE_LINK:
-      UMA_HISTOGRAM_ENUMERATION("Signin.AppsPageLinkActions", action,
-                                one_click_signin::HISTOGRAM_MAX);
-      break;
-    case signin::SOURCE_BOOKMARK_BUBBLE:
-      UMA_HISTOGRAM_ENUMERATION("Signin.BookmarkBubbleActions", action,
-                                one_click_signin::HISTOGRAM_MAX);
-      break;
-    case signin::SOURCE_AVATAR_BUBBLE_SIGN_IN:
-      UMA_HISTOGRAM_ENUMERATION("Signin.AvatarBubbleActions", action,
-                                one_click_signin::HISTOGRAM_MAX);
-      break;
-    case signin::SOURCE_AVATAR_BUBBLE_ADD_ACCOUNT:
-      UMA_HISTOGRAM_ENUMERATION("Signin.AvatarBubbleActions", action,
-                                one_click_signin::HISTOGRAM_MAX);
-      break;
-    case signin::SOURCE_DEVICES_PAGE:
-      UMA_HISTOGRAM_ENUMERATION("Signin.DevicesPageActions", action,
-                                one_click_signin::HISTOGRAM_MAX);
-      break;
-    case signin::SOURCE_REAUTH:
-      UMA_HISTOGRAM_ENUMERATION("Signin.ReauthActions", action,
-                                one_click_signin::HISTOGRAM_MAX);
-      break;
-    default:
-      // This switch statement needs to be updated when the enum Source changes.
-      COMPILE_ASSERT(signin::SOURCE_UNKNOWN == 12,
-                     kSourceEnumHasChangedButNotThisSwitchStatement);
-      UMA_HISTOGRAM_ENUMERATION("Signin.UnknownActions", action,
-                                one_click_signin::HISTOGRAM_MAX);
-  }
+void OneClickSigninHelper::LogHistogramValue(int action) {
   UMA_HISTOGRAM_ENUMERATION("Signin.AllAccessPointActions", action,
-                            one_click_signin::HISTOGRAM_MAX);
+                            signin_metrics::HISTOGRAM_MAX);
 }
 
 // static
 bool OneClickSigninHelper::CanOffer(content::WebContents* web_contents,
                                     CanOfferFor can_offer_for,
                                     const std::string& email,
                                     std::string* error_message) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     VLOG(1) << "OneClickSigninHelper::CanOffer";
 
@@ skipping 37 matching lines @@
     }
 
     if (can_offer_for != CAN_OFFER_FOR_SECONDARY_ACCOUNT) {
       // If the signin manager already has an authenticated name, then this is a
       // re-auth scenario.  Make sure the email just signed in corresponds to
       // the one sign in manager expects.
       std::string current_email = manager->GetAuthenticatedUsername();
       const bool same_email = gaia::AreEmailsSame(current_email, email);
       if (!current_email.empty() && !same_email) {
         UMA_HISTOGRAM_ENUMERATION("Signin.Reauth",
-                                  signin::HISTOGRAM_ACCOUNT_MISSMATCH,
-                                  signin::HISTOGRAM_MAX);
+                                  signin_metrics::HISTOGRAM_ACCOUNT_MISSMATCH,
+                                  signin_metrics::HISTOGRAM_MAX);
         if (error_message) {
           error_message->assign(
               l10n_util::GetStringFUTF8(IDS_SYNC_WRONG_EMAIL,
                                         base::UTF8ToUTF16(current_email)));
         }
         return false;
       }
 
       // If some profile, not just the current one, is already connected to this
       // account, don't show the infobar.
@@ skipping 145 matching lines @@
     io_data->set_reverse_autologin_pending_email(email);
 
   if (!email.empty() || !session_index.empty()) {
     VLOG(1) << "OneClickSigninHelper::ShowInfoBarIfPossible:"
             << " email=" << email
             << " sessionindex=" << session_index;
   }
 
   // Parse Google-Chrome-SignIn.
   AutoAccept auto_accept = AUTO_ACCEPT_NONE;
-  signin::Source source = signin::SOURCE_UNKNOWN;
+  signin_metrics::Source source = signin_metrics::SOURCE_UNKNOWN;
   GURL continue_url;
   std::vector<std::string> tokens;
   base::SplitString(google_chrome_signin_value, ',', &tokens);
   for (size_t i = 0; i < tokens.size(); ++i) {
     const std::string& token = tokens[i];
     if (token == "accepted") {
       auto_accept = AUTO_ACCEPT_ACCEPTED;
     } else if (token == "configure") {
       auto_accept = AUTO_ACCEPT_CONFIGURE;
     } else if (token == "rejected-for-profile") {
       auto_accept = AUTO_ACCEPT_REJECTED_FOR_PROFILE;
     }
   }
 
   // If this is an explicit sign in (i.e., first run, NTP, Apps page, menu,
   // settings) then force the auto accept type to explicit.
   source = GetSigninSource(request->url(), &continue_url);
-  if (source != signin::SOURCE_UNKNOWN)
+  if (source != signin_metrics::SOURCE_UNKNOWN)
     auto_accept = AUTO_ACCEPT_EXPLICIT;
 
   if (auto_accept != AUTO_ACCEPT_NONE) {
     VLOG(1) << "OneClickSigninHelper::ShowInfoBarIfPossible:"
             << " auto_accept=" << auto_accept;
   }
 
   // If |session_index|, |email|, |auto_accept|, and |continue_url| all have
   // their default value, don't bother posting a task to the UI thread.
   // It will be a noop anyway.
   //
   // The two headers above may (but not always) come in different http requests
   // so a post to the UI thread is still needed if |auto_accept| is not its
   // default value, but |email| and |session_index| are.
   if (session_index.empty() && email.empty() &&
       auto_accept == AUTO_ACCEPT_NONE && !continue_url.is_valid()) {
     return;
   }
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(&OneClickSigninHelper::ShowInfoBarUIThread, session_index,
                  email, auto_accept, source, continue_url, child_id, route_id));
 }
 
 // static
 void OneClickSigninHelper::LogConfirmHistogramValue(int action) {
   UMA_HISTOGRAM_ENUMERATION("Signin.OneClickConfirmation", action,
-                            one_click_signin::HISTOGRAM_CONFIRM_MAX);
+                            signin_metrics::HISTOGRAM_CONFIRM_MAX);
 }
 // static
 void OneClickSigninHelper::ShowInfoBarUIThread(
     const std::string& session_index,
     const std::string& email,
     AutoAccept auto_accept,
-    signin::Source source,
+    signin_metrics::Source source,
     const GURL& continue_url,
     int child_id,
     int route_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   content::WebContents* web_contents = tab_util::GetWebContentsByID(child_id,
                                                                     route_id);
   if (!web_contents)
     return;
 
   // TODO(mathp): The appearance of this infobar should be tested using a
   // browser_test.
   OneClickSigninHelper* helper =
       OneClickSigninHelper::FromWebContents(web_contents);
   if (!helper)
     return;
 
   if (auto_accept != AUTO_ACCEPT_NONE)
     helper->auto_accept_ = auto_accept;
 
-  if (source != signin::SOURCE_UNKNOWN &&
-      helper->source_ == signin::SOURCE_UNKNOWN) {
+  if (source != signin_metrics::SOURCE_UNKNOWN &&
+      helper->source_ == signin_metrics::SOURCE_UNKNOWN) {
     helper->source_ = source;
   }
 
   // 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())
@@ skipping 50 matching lines @@
 }
 
 // static
 bool OneClickSigninHelper::HandleCrossAccountError(
     Profile* profile,
     const std::string& session_index,
     const std::string& email,
     const std::string& password,
     const std::string& refresh_token,
     OneClickSigninHelper::AutoAccept auto_accept,
-    signin::Source source,
+    signin_metrics::Source source,
     OneClickSigninSyncStarter::StartSyncMode start_mode,
     OneClickSigninSyncStarter::Callback sync_callback) {
   std::string last_email =
       profile->GetPrefs()->GetString(prefs::kGoogleServicesLastUsername);
 
   if (!last_email.empty() && !gaia::AreEmailsSame(last_email, email)) {
     // If the new email address is different from the email address that
     // just signed in, show a confirmation dialog on top of the current active
     // tab.
 
@@ skipping 20 matching lines @@
             contents,
             start_mode));
     return true;
   }
 
   return false;
 }
 
 // static
 void OneClickSigninHelper::RedirectToNtpOrAppsPage(
-    content::WebContents* contents, signin::Source source) {
+    content::WebContents* contents, signin_metrics::Source source) {
   // 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::SOURCE_APPS_PAGE_LINK ?
+  GURL url(source == signin_metrics::SOURCE_APPS_PAGE_LINK ?
            chrome::kChromeUIAppsURL : chrome::kChromeUINewTabURL);
   content::OpenURLParams params(url,
                                 content::Referrer(),
                                 CURRENT_TAB,
                                 ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
                                 false);
   contents->OpenURL(params);
 }
 
 // static
 void OneClickSigninHelper::RedirectToNtpOrAppsPageIfNecessary(
-    content::WebContents* contents, signin::Source source) {
-  if (source != signin::SOURCE_SETTINGS) {
+    content::WebContents* contents, signin_metrics::Source source) {
+  if (source != signin_metrics::SOURCE_SETTINGS) {
     RedirectToNtpOrAppsPage(contents, source);
   }
 }
 
 void OneClickSigninHelper::RedirectToSignin() {
   VLOG(1) << "OneClickSigninHelper::RedirectToSignin";
 
   // Extract the existing sounce=X value.  Default to "2" if missing.
-  signin::Source source = signin::GetSourceForPromoURL(continue_url_);
-  if (source == signin::SOURCE_UNKNOWN)
-    source = signin::SOURCE_MENU;
+  signin_metrics::Source source = signin::GetSourceForPromoURL(continue_url_);
+  if (source == signin_metrics::SOURCE_UNKNOWN)
+    source = signin_metrics::SOURCE_MENU;
   GURL page = signin::GetPromoURL(source, false);
 
   content::WebContents* contents = web_contents();
   contents->GetController().LoadURL(page,
                                     content::Referrer(),
                                     ui::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_ = signin::SOURCE_UNKNOWN;
+  source_ = signin_metrics::SOURCE_UNKNOWN;
   switched_to_advanced_ = false;
   continue_url_ = GURL();
   untrusted_navigations_since_signin_visit_ = 0;
   untrusted_confirmation_required_ = false;
   error_message_.clear();
 
   // Post to IO thread to clear pending email.
   if (!do_not_clear_pending_email_) {
     Profile* profile =
         Profile::FromBrowserContext(web_contents()->GetBrowserContext());
@@ skipping 100 matching lines @@
 
     // Redirect to the landing page and display an error popup.
     RedirectToNtpOrAppsPage(web_contents(), source_);
     LoginUIServiceFactory::GetForProfile(profile)->
         DisplayLoginResult(browser, base::UTF8ToUTF16(error_message_));
     CleanTransientState();
     return;
   }
 
   if (AreWeShowingSignin(url, source_, email_)) {
-    if (!showing_signin_) {
-      if (source_ == signin::SOURCE_UNKNOWN)
-        LogOneClickHistogramValue(one_click_signin::HISTOGRAM_SHOWN);
-      else
-        LogHistogramValue(source_, one_click_signin::HISTOGRAM_SHOWN);
-    }
+    if (!showing_signin_)
+      LogHistogramValue(signin_metrics::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.  Sometimes locales will redirect to a country-
   // specific TLD so just make sure it's a valid domain instead of comparing
   // for an exact match.
   GURL::Replacements replacements;
   replacements.ClearQuery();
@@ skipping 47 matching lines @@
   // During an explicit sign in, if the user has not yet reached the final
   // continue URL, wait for it to arrive. Note that Gaia will add some extra
   // query parameters to the continue URL.  Ignore them when checking to
   // see if the user has continued.
   //
   // If this is not an explicit sign in, we don't need to check if we landed
   // on the right continue URL.  This is important because the continue URL
   // may itself lead to a redirect, which means this function will never see
   // the continue URL go by.
   if (auto_accept_ == AUTO_ACCEPT_EXPLICIT) {
-    DCHECK(source_ != signin::SOURCE_UNKNOWN);
+    DCHECK(source_ != signin_metrics::SOURCE_UNKNOWN);
     if (!continue_url_match) {
       VLOG(1) << "OneClickSigninHelper::DidStopLoading: invalid url='"
               << url.spec()
               << "' expected continue url=" << continue_url_;
       CleanTransientState();
       return;
     }
 
     // In explicit sign ins, the user may have changed the box
     // "Let me choose what to sync".  This is reflected as a change in the
     // 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.
-    signin::Source source = signin::GetSourceForPromoURL(url);
+    signin_metrics::Source source = signin::GetSourceForPromoURL(url);
     if (source != source_) {
       source_ = source;
-      switched_to_advanced_ = source == signin::SOURCE_SETTINGS;
+      switched_to_advanced_ = source == signin_metrics::SOURCE_SETTINGS;
     }
   }
 
   Browser* browser = chrome::FindBrowserWithWebContents(contents);
 
   VLOG(1) << "OneClickSigninHelper::DidStopLoading: signin is go."
           << " auto_accept=" << auto_accept_
           << " source=" << source_;
 
   switch (auto_accept_) {
     case AUTO_ACCEPT_NONE:
       if (showing_signin_)
-        LogOneClickHistogramValue(one_click_signin::HISTOGRAM_DISMISSED);
+        LogHistogramValue(signin_metrics::HISTOGRAM_DISMISSED);
       break;
     case AUTO_ACCEPT_ACCEPTED:
-      LogOneClickHistogramValue(one_click_signin::HISTOGRAM_ACCEPTED);
-      LogOneClickHistogramValue(one_click_signin::HISTOGRAM_WITH_DEFAULTS);
+      LogHistogramValue(signin_metrics::HISTOGRAM_ACCEPTED);
+      LogHistogramValue(signin_metrics::HISTOGRAM_WITH_DEFAULTS);
       SigninManager::DisableOneClickSignIn(profile->GetPrefs());
       // Start syncing with the default settings - prompt the user to sign in
       // first.
       if (!do_not_start_sync_for_testing_) {
         StartSync(
             StartSyncArgs(profile, browser, auto_accept_,
                           session_index_, email_, password_, "",
                           NULL  /* don't force sync setup in same tab */,
                           true  /* confirmation_required */, source_,
                           CreateSyncStarterCallback()),
             OneClickSigninSyncStarter::SYNC_WITH_DEFAULT_SETTINGS);
       }
       break;
     case AUTO_ACCEPT_CONFIGURE:
-      LogOneClickHistogramValue(one_click_signin::HISTOGRAM_ACCEPTED);
-      LogOneClickHistogramValue(one_click_signin::HISTOGRAM_WITH_ADVANCED);
+      LogHistogramValue(signin_metrics::HISTOGRAM_ACCEPTED);
+      LogHistogramValue(signin_metrics::HISTOGRAM_WITH_ADVANCED);
       SigninManager::DisableOneClickSignIn(profile->GetPrefs());
       // Display the extra confirmation (even in the SAML case) in case this
       // was an untrusted renderer.
       if (!do_not_start_sync_for_testing_) {
         StartSync(
             StartSyncArgs(profile, browser, auto_accept_,
                           session_index_, email_, password_, "",
                           NULL  /* don't force sync setup in same tab */,
                           true  /* confirmation_required */, source_,
                           CreateSyncStarterCallback()),
             OneClickSigninSyncStarter::CONFIGURE_SYNC_FIRST);
       }
       break;
     case AUTO_ACCEPT_EXPLICIT: {
-      signin::Source original_source =
+      signin_metrics::Source original_source =
           signin::GetSourceForPromoURL(original_continue_url_);
       if (switched_to_advanced_) {
-        LogHistogramValue(original_source,
-                          one_click_signin::HISTOGRAM_WITH_ADVANCED);
-        LogHistogramValue(original_source,
-                          one_click_signin::HISTOGRAM_ACCEPTED);
+        LogHistogramValue(signin_metrics::HISTOGRAM_WITH_ADVANCED);
+        LogHistogramValue(signin_metrics::HISTOGRAM_ACCEPTED);
       } else {
-        LogHistogramValue(source_, one_click_signin::HISTOGRAM_ACCEPTED);
-        LogHistogramValue(source_, one_click_signin::HISTOGRAM_WITH_DEFAULTS);
+        LogHistogramValue(signin_metrics::HISTOGRAM_ACCEPTED);
+        LogHistogramValue(signin_metrics::HISTOGRAM_WITH_DEFAULTS);
       }
 
       // - If sign in was initiated from the NTP or the hotdog menu, sync with
       //   default settings.
       // - If sign in was initiated from the settings page for first time sync
       //   set up, show the advanced sync settings dialog.
       // - If sign in was initiated from the settings page due to a re-auth when
       //   sync was already setup, simply navigate back to the settings page.
       ProfileSyncService* sync_service =
           ProfileSyncServiceFactory::GetForProfile(profile);
       SigninErrorController* error_controller =
           ProfileOAuth2TokenServiceFactory::GetForProfile(profile)->
               signin_error_controller();
 
       OneClickSigninSyncStarter::StartSyncMode start_mode =
-          source_ == signin::SOURCE_SETTINGS ?
+          source_ == signin_metrics::SOURCE_SETTINGS ?
               (error_controller->HasError() &&
                sync_service && sync_service->HasSyncSetupCompleted()) ?
                   OneClickSigninSyncStarter::SHOW_SETTINGS_WITHOUT_CONFIGURE :
                   OneClickSigninSyncStarter::CONFIGURE_SYNC_FIRST :
               OneClickSigninSyncStarter::SYNC_WITH_DEFAULT_SETTINGS;
 
       if (!HandleCrossAccountError(profile, session_index_, email_, password_,
               "", auto_accept_, source_, start_mode,
               CreateSyncStarterCallback())) {
         if (!do_not_start_sync_for_testing_) {
           StartSync(
               StartSyncArgs(profile, browser, auto_accept_,
                             session_index_, email_, password_, "",
                             contents,
                             untrusted_confirmation_required_, source_,
                             CreateSyncStarterCallback()),
               start_mode);
         }
 
         // If this explicit sign in is not from settings page/webstore, show
         // the NTP/Apps page after sign in completes. In the case of the
         // settings page, it will get auto-closed after sync setup. In the case
         // of webstore, it will redirect back to webstore.
         RedirectToNtpOrAppsPageIfNecessary(web_contents(), source_);
       }
 
       // Observe the sync service if the settings tab requested a gaia sign in,
       // so that when sign in and sync setup are successful, we can redirect to
       // the correct URL, or auto-close the gaia sign in tab.
-      if (original_source == signin::SOURCE_SETTINGS) {
+      if (original_source == signin_metrics::SOURCE_SETTINGS) {
         // The observer deletes itself once it's done.
         new OneClickSigninSyncObserver(contents, original_continue_url_);
       }
       break;
     }
     case AUTO_ACCEPT_REJECTED_FOR_PROFILE:
       AddEmailToOneClickRejectedList(profile, email_);
-      LogOneClickHistogramValue(one_click_signin::HISTOGRAM_REJECTED);
+      LogHistogramValue(signin_metrics::HISTOGRAM_REJECTED);
       break;
     default:
       NOTREACHED() << "Invalid auto_accept=" << auto_accept_;
       break;
   }
 
   CleanTransientState();
 }
 
 OneClickSigninSyncStarter::Callback
@@ skipping 14 matching lines @@
     // If the web contents is showing a blank page and not about to be closed,
     // redirect to the NTP or apps page.
     if (signin::IsContinueUrlForWebBasedSigninFlow(current_url) &&
         !signin::IsAutoCloseEnabledInURL(original_continue_url_)) {
       RedirectToNtpOrAppsPage(
           web_contents(),
           signin::GetSourceForPromoURL(original_continue_url_));
     }
   }
 }