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.
-// Otherwise returns empty string.
-std::string GetSigninScopedDeviceId(Profile* profile) {
+// If profile is valid then generates new signin scoped device id from signin
+// client. Otherwise returns empty string.
+std::string GenerateNewSigninScopedDeviceId(Profile* profile) {
   std::string signin_scoped_device_id;
   SigninClient* signin_client =
       profile ? ChromeSigninClientFactory::GetForProfile(profile) : NULL;
   if (signin_client) {
+    signin_client->ClearSigninScopedDeviceId();
     signin_scoped_device_id = signin_client->GetSigninScopedDeviceId();
   }
   return signin_scoped_device_id;
 }
 
 // CurrentHistoryCleaner ------------------------------------------------------
 
 // Watch a webcontents and remove URL from the history once loading is complete.
 // We have to delay the cleaning until the new URL has finished loading because
 // we're not allowed to remove the last-loaded URL from the history.  Objects
@@ skipping 75 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 =
+      GenerateNewSigninScopedDeviceId(args_.profile);

[pavely, 2014/06/30 23:31:09]

This is where new id generated before signing in.

[Roger Tawa OOO till Jul 10th, 2014/07/01 13:42:54]

For mirror, sign in occurs in inline_login_handler_impl.cc.  Should't we call
ClearSigninScopedDeviceId() there when the source !=
signin::SOURCE_AVATAR_BUBBLE_ADD_ACCOUNT && source != signin::SOURCE_REAUTH?

How about cros?  Will you handle that is a separate CL?

[pavely, 2014/07/01 21:41:47]

Ok, it seems like there are multiple codepaths that request refresh token and no
future-proof way to tell if particular call is new signin or reauth. I'll remove
call to clear device id from here and only leave one in signout codepath.

We'll see, maybe I'll find a better place to clear device_id on signin when i
know more details about how signin/signout works on chromeOS.

BTW, Where signin starts in case of mirror? Where should I start tracing code?

Yes, I'll handle CrOS in separate change.

On 2014/07/01 13:42:54, Roger Tawa wrote:

[Roger Tawa OOO till Jul 10th, 2014/07/03 15:07:41]

In mirror, start tracing from  InlineLoginHandlerImpl::CompleteLogin(),
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/ui/....

   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_));
     }
   }
 }