Re-land 151364 - [sync] Auto-create credential cache for users who are already signe…

chrome/browser/sync/credential_cache_service_win.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.
 
 #ifndef CHROME_BROWSER_SYNC_CREDENTIAL_CACHE_SERVICE_WIN_H_
 #define CHROME_BROWSER_SYNC_CREDENTIAL_CACHE_SERVICE_WIN_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 21 matching lines @@
 // Desktop modes. When the user signs in to sync in one of the modes, we would
 // like to automatically start sync in the other mode.
 //
 // This class implements a caching service for sync credentials. It listens for
 // updates to the PrefService and TokenService that pertain to the user
 // signing in and out of sync, and persists the credentials to a separate file
 // in the default profile directory. It also contains functionality to bootstrap
 // sync using credentials that were cached due to signing in on the other
 // (alternate) mode.
 class CredentialCacheService : public ProfileKeyedService,
-                               public content::NotificationObserver,
-                               public PrefStore::Observer {
+                               public content::NotificationObserver {
  public:
   explicit CredentialCacheService(Profile* profile);
   virtual ~CredentialCacheService();
 
   // ProfileKeyedService implementation.
   virtual void Shutdown() OVERRIDE;
 
-  // PrefStore::Observer implementation.
-  virtual void OnInitializationCompleted(bool succeeded) OVERRIDE;
-  virtual void OnPrefValueChanged(const std::string& key) OVERRIDE;
-
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
+  // Loads cached sync credentials from the alternate profile and applies them
+  // to the local profile if the load was successful.
+  void ReadCachedCredentialsFromAlternateProfile();
+
+  // Populates a new local credential cache file if the user is already signed
+  // in to the local profile, and there is no existing local credential cache.
+  // Used in scenarios where a user upgraded from an older version of Chrome
+  // that didn't support credential caching. This method is a no-op if local
+  // sync prefs have already been written to the local cache.
+  void WriteExistingSyncPrefsToLocalCache();
+
+  // Resets |alternate_store_| and schedules the next read from the alternate
+  // credential cache.
+  void ScheduleNextReadFromAlternateCredentialCache();
+
  protected:
   // Returns true if the credential cache represented by |store| contains a
   // value for |pref_name|.
   bool HasPref(scoped_refptr<JsonPrefStore> store,
                const std::string& pref_name);
 
   // Encrypts and base 64 encodes |credential|, converts the result to a
   // StringValue, and returns the result. Caller owns the StringValue returned.
   static base::StringValue* PackCredential(const std::string& credential);
 
@@ skipping 34 matching lines @@
   const scoped_refptr<JsonPrefStore>& local_store() const {
     return local_store_;
   }
 
   // Setter for unit tests
   void set_local_store(JsonPrefStore* new_local_store) {
     local_store_ = new_local_store;
   }
 
  private:
+  // Used to track the initialization of the local credential cache.
+  class LocalStoreObserver
+      : public base::RefCounted<LocalStoreObserver>,
+        public PrefStore::Observer {
+   public:
+    LocalStoreObserver(CredentialCacheService* service,
+                       scoped_refptr<JsonPrefStore> local_store);
+    virtual ~LocalStoreObserver();
+
+    // PrefStore::Observer implementation.
+    virtual void OnInitializationCompleted(bool succeeded) OVERRIDE;
+    virtual void OnPrefValueChanged(const std::string& key) OVERRIDE;
+
+   protected:
+    friend class base::RefCounted<LocalStoreObserver>;
+
+   private:
+    CredentialCacheService* service_;
+    scoped_refptr<JsonPrefStore> local_store_;
+    DISALLOW_COPY_AND_ASSIGN(LocalStoreObserver);
+  };
+
+  // Used to track the initialization of the alternate credential cache.
+  class AlternateStoreObserver
+      : public base::RefCounted<AlternateStoreObserver>,
+        public PrefStore::Observer  {
+   public:
+    AlternateStoreObserver(CredentialCacheService* service,
+                           scoped_refptr<JsonPrefStore> alternate_store);
+    virtual ~AlternateStoreObserver();
+
+    // PrefStore::Observer implementation.
+    virtual void OnInitializationCompleted(bool succeeded) OVERRIDE;
+    virtual void OnPrefValueChanged(const std::string& key) OVERRIDE;
+
+   protected:
+    friend class base::RefCounted<AlternateStoreObserver>;
+
+   private:
+    CredentialCacheService* service_;
+    scoped_refptr<JsonPrefStore> alternate_store_;
+    DISALLOW_COPY_AND_ASSIGN(AlternateStoreObserver);
+  };
+
   // Returns the path to the sync credentials file in the current profile
   // directory.
   FilePath GetCredentialPathInCurrentProfile() const;
 
   // Returns the path to the sync credentials file in the default Desktop
   // profile directory if we are running in Metro mode, and vice versa.
   FilePath GetCredentialPathInAlternateProfile() const;
 
   // Determines if the local credential cache writer should be initialized,
   // based on the OS version and relevant sync preferences. Returns true if the
   // writer must be initialized, and false if not.
   bool ShouldInitializeLocalCredentialCacheWriter() const;
 
-  // Determines if we must look for credentials in the alternate profile, based
-  // on relevant sync preferences, in addition the to conditions in
-  // ShouldInitializeLocalCredentialCacheWriter(). Returns true if we must look
-  // for cached credentials, and false if not.
-  bool ShouldLookForCachedCredentialsInAlternateProfile() const;
-
   // Initializes the JsonPrefStore object for the local profile directory.
   void InitializeLocalCredentialCacheWriter();
 
-  // Initializes the JsonPrefStore object for the alternate profile directory
-  // if |should_initialize| is true. We take a bool* instead of a bool since
-  // this is a callback, and base::Owned needs to clean up the flag.
-  void InitializeAlternateCredentialCacheReader(bool* should_initialize);
-
   // Returns true if there is an empty value for kGoogleServicesUsername in the
   // credential cache for the local profile (indicating that the user first
   // signed in and then signed out). Returns false if there's no value at all
   // (indicating that the user has never signed in) or if there's a non-empty
   // value (indicating that the user is currently signed in).
   bool HasUserSignedOut();
 
   // Asynchronously looks for a cached credential file in the alternate profile
   // and initiates start up using cached credentials if the file was found.
   // Called by ProfileSyncService when it tries to start up on Windows 8 and
   // cannot auto-start.
   void LookForCachedCredentialsInAlternateProfile();
 
-  // Loads cached sync credentials from the alternate profile and calls
-  // ApplyCachedCredentials if the load was successful.
-  void ReadCachedCredentialsFromAlternateProfile();
-
   // Initiates sync sign in using credentials read from the alternate profile by
   // persisting |google_services_username|, |encryption_bootstrap_token|,
   // |keep_everything_synced| and |preferred_types| to the local pref store, and
   // preparing ProfileSyncService for sign in.
   void InitiateSignInWithCachedCredentials(
       const std::string& google_services_username,
       const std::string& encryption_bootstrap_token,
       bool keep_everything_synced,
       ModelTypeSet preferred_types);
 
@@ skipping 36 matching lines @@
   // Determines if the user must be signed in to the local profile or not.
   // Called when updated settings are noticed in the alternate credential cache
   // for |google_services_username|, with new values for |lsid|, |sid| and
   // |encryption_bootstrap_token|. Returns true if we should sign in, and
   // false if not.
   bool ShouldSignInToSync(const std::string& google_services_username,
                           const std::string& lsid,
                           const std::string& sid,
                           const std::string& encryption_bootstrap_token);
 
-  // Resets |alternate_store_| and schedules the next read from the alternate
-  // credential cache.
-  void ScheduleNextReadFromAlternateCredentialCache();
-
   // Profile for which credentials are being cached.
   Profile* profile_;
 
   // Used to access sync specific preferences in the PrefStore of |profile_|.
   browser_sync::SyncPrefs sync_prefs_;
 
   // Used for write operations to the credential cache file in the local profile
   // directory. This is separate from the chrome pref store. Protected so that
   // it can be accessed by unit tests.
   scoped_refptr<JsonPrefStore> local_store_;
 
+  // Used to respond to the initialization of |local_store_|.
+  scoped_refptr<LocalStoreObserver> local_store_observer_;
+
   // Used for read operations on the credential cache file in the alternate
   // profile directory. This is separate from the chrome pref store.
   scoped_refptr<JsonPrefStore> alternate_store_;
 
+  // Used to respond to the initialization of |alternate_store_|.
+  scoped_refptr<AlternateStoreObserver> alternate_store_observer_;
+
   // Registrar for notifications from the PrefService.
   PrefChangeRegistrar pref_registrar_;
 
   // Registrar for notifications from the TokenService.
   content::NotificationRegistrar registrar_;
 
   // WeakPtr implementation.
   base::WeakPtrFactory<CredentialCacheService> weak_factory_;
 
   // Used to make sure that there is always at most one future read scheduled
   // on the alternate credential cache.
   base::CancelableClosure next_read_;
 
   DISALLOW_COPY_AND_ASSIGN(CredentialCacheService);
 };
 
 }  // namespace syncer
 
 #endif  // CHROME_BROWSER_SYNC_CREDENTIAL_CACHE_SERVICE_WIN_H_