[sync] Automatic bootstrapping of Sync on Win 8 from cached credentials

chrome/browser/signin/signin_manager.h

 // 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.
 //
 // The signin manager encapsulates some functionality tracking
 // which user is signed in. When a user is signed in, a ClientLogin
 // request is run on their behalf. Auth tokens are fetched from Google
 // and the results are stored in the TokenService.
 //
 // **NOTE** on semantics of SigninManager:
 //
 // Once a signin is successful, the username becomes "established" and will not
 // be cleared until a SignOut operation is performed (persists across
 // restarts). Until that happens, the signin manager can still be used to
 // refresh credentials, but changing the username is not permitted.
 
 #ifndef CHROME_BROWSER_SIGNIN_SIGNIN_MANAGER_H_
 #define CHROME_BROWSER_SIGNIN_SIGNIN_MANAGER_H_
 #pragma once
 
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/logging.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/prefs/pref_change_registrar.h"
 #include "chrome/browser/profiles/profile_keyed_service.h"
+#if defined(OS_WIN)
+#include "chrome/browser/sync/credential_cache_win.h"
+#endif
 #include "chrome/common/net/gaia/gaia_auth_consumer.h"
 #include "chrome/common/net/gaia/google_service_auth_error.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
 class GaiaAuthFetcher;
 class Profile;
 class PrefService;
 
 // Details for the Notification type GOOGLE_SIGNIN_SUCCESSFUL.
@@ skipping 59 matching lines @@
   virtual void StartSignInWithCredentials(const std::string& session_index,
                                           const std::string& username,
                                           const std::string& password);
 
   // Attempt to sign in this user with ClientOAuth. If successful, set a
   // preference indicating the signed in user and send out a notification,
   // then start fetching tokens for the user.
   virtual void StartSignInWithOAuth(const std::string& username,
                                     const std::string& password);
 
+#if defined(OS_WIN)
+  // Attempt to sign in using credentials cached by the alternate profile
+  // on Windows 8.
+  virtual void StartSignInWithCachedCredentials(
+      scoped_refptr<csync::CredentialCache> credentials);
+#endif

[Roger Tawa OOO till Jul 10th, 2012/06/27 21:23:28]

generally speaking there should be no #ifdef for platforms inside header files. 
I would not put the #ifdef here.  Put in the cc file, and for no-windows cases
use NOTREACHED().

[Raghu Simha, 2012/07/19 06:57:07]

Done.

+
   // Provide a challenge solution to a failed signin attempt with
   // StartSignInWithOAuth().  |type| and |token| come from the
   // GoogleServiceAuthError of the failed attempt.
   // |solution| is the answer typed by the user.
   void ProvideOAuthChallengeResponse(GoogleServiceAuthError::State type,
                                      const std::string& token,
                                      const std::string& solution);
 
   // Sign a user out, removing the preference, erasing all keys
   // associated with the user, and canceling all auth in progress.
@@ skipping 49 matching lines @@
   // Will clear in memory data but leaves the db as such so when the browser
   // restarts we can use the old token(which might throw a password error).
   void ClearTransientSigninData();
 
   // Called to handle an error from a GAIA auth fetch.  Sets the last error
   // to |error|, sends out a notification of login failure, and clears the
   // transient signin data if |clear_transient_data| is true.
   void HandleAuthError(const GoogleServiceAuthError& error,
                        bool clear_transient_data);
 
+  // Unsubscribes from notifications from the token service.
+  void CleanupNotificationRegistration();
+
+  // Sends out the NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL notification and starts
+  // fetching tokens. Called by OnGetUserInfoSuccess when the user manually
+  // signs in to sync, and by StartSignInWithCachedCredentials when sync is
+  // auto started on Windows 8 using cached credentials.
+  void ConsumeUserInfoAndFinishSignin();
+
+#if defined(OS_WIN)
+  // Persists the authenticated username and auth tokens (sid and lsid) to the
+  // sync credential cache when the user successfully signs in to sync on Win 8.
+  // These credentials may be used later by the alternate Metro / Desktop
+  // profile to automatically start up sync.

[Andrew T Wilson (Slow), 2012/06/26 23:26:13]

What happens if both are already running? Is there polling going on, or some
kind of notification to the other process when one process signs in?

[Raghu Simha, 2012/06/27 00:17:04]

I don't believe there is a mechanism within Chrome by which we can exchange 
messages between Desktop and Metro processes on Win 8. I chatted with Tim, and
it seemed reasonable to do nothing until the second process (that wasn't signed
in) is restarted. 

+  void PersistAuthTokensAsync();
+#endif
+
   Profile* profile_;
 
   // ClientLogin identity.
   std::string possibly_invalid_username_;
   std::string password_;  // This is kept empty whenever possible.
   bool had_two_factor_error_;
 
-  void CleanupNotificationRegistration();
-
   // Result of the last client login, kept pending the lookup of the
   // canonical email.
   ClientLoginResult last_result_;
 
   // Actual client login handler.
   scoped_ptr<GaiaAuthFetcher> client_login_;
 
   // Registrar for notifications from the TokenService.
   content::NotificationRegistrar registrar_;
 
   // Helper object to listen for changes to signin preferences stored in non-
   // profile-specific local prefs (like kGoogleServicesUsernamePattern).
   PrefChangeRegistrar local_state_pref_registrar_;
 
   // Actual username after successful authentication.
   std::string authenticated_username_;
 
   // The type of sign being performed.  This value is valid only between a call
   // to one of the StartSigninXXX methods and when the sign in is either
   // successful or not.
   SigninType type_;
 
   DISALLOW_COPY_AND_ASSIGN(SigninManager);
 };
 
 #endif  // CHROME_BROWSER_SIGNIN_SIGNIN_MANAGER_H_