Implementation of SigninClient::GetSigninScopedDeviceId

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 396 matching lines @@
       GaiaUrls::GetInstance()->service_login_url().ReplaceComponents(
           replacements);
 
   return (url.ReplaceComponents(replacements) == clean_login_url &&
           source != signin::SOURCE_UNKNOWN) ||
       (IsValidGaiaSigninRedirectOrResponseURL(url) &&
        url.spec().find("ChromeLoginPrompt") != std::string::npos &&
        !email.empty());
 }
 
-// Gets signin scoped device id from signin client if profile is valid.
+// 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 =
       profile ? ChromeSigninClientFactory::GetForProfile(profile) : NULL;
   if (signin_client) {
     signin_scoped_device_id = signin_client->GetSigninScopedDeviceId();
   }
   return signin_scoped_device_id;
 }
@@ skipping 81 matching lines @@
       source(signin::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,
-    const std::string& signin_scoped_device_id,
     content::WebContents* web_contents,
     bool untrusted_confirmation_required,
     signin::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),
-      signin_scoped_device_id(signin_scoped_device_id),
       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 ||
              source == signin::SOURCE_WEBSTORE_INSTALL) {
     // Do not display a status confirmation for webstore installs or re-auth.
     confirmation_required = OneClickSigninSyncStarter::NO_CONFIRMATION;
@@ skipping 112 matching lines @@
       args_.browser, args_.profile, desktop_type_);
   args_.browser->window()->ShowOneClickSigninBubble(
       BrowserWindow::ONE_CLICK_SIGNIN_BUBBLE_TYPE_BUBBLE,
       base::string16(),  // No email required - this is not a SAML confirmation.
       base::UTF8ToUTF16(error_message),
       // Callback is ignored.
       BrowserWindow::StartSyncCallback());
 }
 
 void OneClickSigninHelper::SyncStarterWrapper::StartSigninOAuthHelper() {
+  std::string signin_scoped_device_id = GetSigninScopedDeviceId(args_.profile);
   signin_oauth_helper_.reset(
       new SigninOAuthHelper(args_.profile->GetRequestContext(),
                             args_.session_index,
-                            args_.signin_scoped_device_id,
+                            signin_scoped_device_id,
                             this));
 }
 
 void
 OneClickSigninHelper::SyncStarterWrapper::StartOneClickSigninSyncStarter(
     const std::string& email,
     const std::string& refresh_token) {
   // The starter deletes itself once it's done.
   new OneClickSigninSyncStarter(args_.profile, args_.browser,
                                 email, args_.password,
@@ skipping 496 matching lines @@
     const std::string& password,
     const std::string& refresh_token,
     OneClickSigninHelper::AutoAccept auto_accept,
     signin::Source source,
     OneClickSigninSyncStarter::StartSyncMode start_mode,
     OneClickSigninSyncStarter::Callback sync_callback) {
   Profile* profile =
       Profile::FromBrowserContext(contents->GetBrowserContext());
   std::string last_email =
       profile->GetPrefs()->GetString(prefs::kGoogleServicesLastUsername);
-  std::string signin_scoped_device_id = GetSigninScopedDeviceId(profile);
 
   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.
 
     // No need to display a second confirmation so pass false below.
     // TODO(atwilson): Move this into OneClickSigninSyncStarter.
     // The tab modal dialog always executes its callback before |contents|
     // is deleted.
     Browser* browser = chrome::FindBrowserWithWebContents(contents);
     ConfirmEmailDialogDelegate::AskForConfirmation(
         contents,
         last_email,
         email,
         base::Bind(
             &StartExplicitSync,
             StartSyncArgs(profile, browser, auto_accept,
                           session_index, email, password,
-                          refresh_token, signin_scoped_device_id,
+                          refresh_token,
                           contents, false /* confirmation_required */, source,
                           sync_callback),
             contents,
             start_mode));
     return true;
   }
 
   return false;
 }
 
@@ skipping 266 matching lines @@
       switched_to_advanced_ = source == signin::SOURCE_SETTINGS;
     }
   }
 
   Browser* browser = chrome::FindBrowserWithWebContents(contents);
 
   VLOG(1) << "OneClickSigninHelper::DidStopLoading: signin is go."
           << " auto_accept=" << auto_accept_
           << " source=" << source_;
 
-  std::string signin_scoped_device_id = GetSigninScopedDeviceId(profile);
   switch (auto_accept_) {
     case AUTO_ACCEPT_NONE:
       if (showing_signin_)
         LogOneClickHistogramValue(one_click_signin::HISTOGRAM_DISMISSED);
       break;
     case AUTO_ACCEPT_ACCEPTED:
       LogOneClickHistogramValue(one_click_signin::HISTOGRAM_ACCEPTED);
       LogOneClickHistogramValue(one_click_signin::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_,
-                          "", signin_scoped_device_id,
+                          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);
       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_,
-                          "", signin_scoped_device_id,
+                          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::GetSourceForPromoURL(original_continue_url_);
       if (switched_to_advanced_) {
@@ skipping 25 matching lines @@
                   OneClickSigninSyncStarter::SHOW_SETTINGS_WITHOUT_CONFIGURE :
                   OneClickSigninSyncStarter::CONFIGURE_SYNC_FIRST :
               OneClickSigninSyncStarter::SYNC_WITH_DEFAULT_SETTINGS;
 
       if (!HandleCrossAccountError(contents, 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_,
-                            "", signin_scoped_device_id,
+                            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.
@@ skipping 42 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_));
     }
   }
 }