Add password sync for Android.

chrome/browser/sync/profile_sync_service.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/sync/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 56 matching lines @@
 #include "sync/internal_api/public/sync_encryption_handler.h"
 #include "sync/internal_api/public/util/experiments.h"
 #include "sync/internal_api/public/util/sync_string_conversions.h"
 #include "sync/js/js_arg_list.h"
 #include "sync/js/js_event_details.h"
 #include "sync/notifier/invalidator_registrar.h"
 #include "sync/notifier/invalidator_state.h"
 #include "sync/util/cryptographer.h"
 #include "ui/base/l10n/l10n_util.h"
 
+#if defined(OS_ANDROID)
+#include "sync/internal_api/public/read_transaction.h"
+#endif
+
 using browser_sync::ChangeProcessor;
 using browser_sync::DataTypeController;
 using browser_sync::DataTypeManager;
 using browser_sync::SyncBackendHost;
 using syncer::ModelType;
 using syncer::ModelTypeSet;
 using syncer::JsBackend;
 using syncer::JsController;
 using syncer::JsEventDetails;
 using syncer::JsEventHandler;
@@ skipping 93 matching lines @@
   // Sync is logged in if there is a non-empty authenticated username.
   return !signin_->GetAuthenticatedUsername().empty();
 }
 
 bool ProfileSyncService::IsSyncTokenAvailable() {
   TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
   if (!token_service)
     return false;
   return token_service->HasTokenForService(GaiaConstants::kSyncService);
 }
+#if defined(OS_ANDROID)
+bool ProfileSyncService::ShouldEnablePasswordSyncForAndroid() const {
+  const syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
+  const syncer::ModelTypeSet preferred_types =
+      sync_prefs_.GetPreferredDataTypes(registered_types);
+  if (!preferred_types.Has(syncer::PASSWORDS))
+    return false;
+  // On Android we do not want to prompt user to enter a passphrase. If
+  // passwords cannot be decrypted we just disable them.
+  syncer::ReadTransaction trans(FROM_HERE, GetUserShare());
+  return IsCryptographerReady(&trans);
+}
+#endif
 
 void ProfileSyncService::Initialize() {
   DCHECK(!invalidator_registrar_.get());
   invalidator_registrar_.reset(new syncer::InvalidatorRegistrar());
 
   InitSettings();
 
   // We clear this here (vs Shutdown) because we want to remember that an error
   // happened on shutdown so we can display details (message, location) about it
   // in about:sync.
@@ skipping 791 matching lines @@
   // consumed our cached passphrase. Clear it now.
   if (!cached_passphrase_.empty())
     cached_passphrase_.clear();
 
   // Reset passphrase_required_reason_ since we know we no longer require the
   // passphrase. We do this here rather than down in ResolvePassphraseRequired()
   // because that can be called by OnPassphraseRequired() if no encrypted data
   // types are enabled, and we don't want to clobber the true passphrase error.
   passphrase_required_reason_ = syncer::REASON_PASSPHRASE_NOT_REQUIRED;
 
+#if defined(OS_ANDROID)
+  // Re-enable passwords if we have disabled them.
+  if (failed_datatypes_handler_.GetFailedTypes().Has(syncer::PASSWORDS) &&
+      ShouldEnablePasswordSyncForAndroid()) {
+    // Clear the data type errors.
+    failed_datatypes_handler_.OnUserChoseDatatypes();
+  }
+#endif
+
   // Make sure the data types that depend on the passphrase are started at
   // this time.
   const syncer::ModelTypeSet types = GetPreferredDataTypes();
 
   if (data_type_manager_.get()) {
     // Unblock the data type manager if necessary.
     data_type_manager_->Configure(types,
                                   syncer::CONFIGURE_REASON_RECONFIGURATION);
   }
 
@@ skipping 446 matching lines @@
 
     // We create the migrator at the same time.
     migrator_.reset(
         new browser_sync::BackendMigrator(
             profile_->GetDebugName(), GetUserShare(),
             this, data_type_manager_.get(),
             base::Bind(&ProfileSyncService::StartSyncingWithServer,
                        base::Unretained(this))));
   }
 
+#if defined(OS_ANDROID)
+  if (GetPreferredDataTypes().Has(syncer::PASSWORDS) &&
+      !ShouldEnablePasswordSyncForAndroid()) {
+    DisableBrokenDatatype(syncer::PASSWORDS, FROM_HERE, "Not supported.");
+  }
+#endif
+
   const syncer::ModelTypeSet types = GetPreferredDataTypes();
   if (IsPassphraseRequiredForDecryption()) {
     // We need a passphrase still. We don't bother to attempt to configure
     // until we receive an OnPassphraseAccepted (which triggers a configure).
     DVLOG(1) << "ProfileSyncService::ConfigureDataTypeManager bailing out "
              << "because a passphrase required";
     NotifyObservers();
     return;
   }
   syncer::ConfigureReason reason = syncer::CONFIGURE_REASON_UNKNOWN;
@@ skipping 449 matching lines @@
   // See http://stackoverflow.com/questions/6224121/is-new-this-myclass-undefined-behaviour-after-directly-calling-the-destru.
   ProfileSyncService* old_this = this;
   this->~ProfileSyncService();
   new(old_this) ProfileSyncService(
       new ProfileSyncComponentsFactoryImpl(profile,
                                            CommandLine::ForCurrentProcess()),
       profile,
       signin,
       behavior);
 }