src/chrome/browser/sync/glue/sync_backend_host_impl.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/sync/glue/sync_backend_host_impl.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/logging.h"
   9 #include "chrome/browser/browser_process.h"
  10 #include "chrome/browser/chrome_notification_types.h"
  11 #include "chrome/browser/profiles/profile.h"
  12 #include "chrome/browser/signin/chrome_signin_client_factory.h"
  13 #include "chrome/browser/sync/glue/invalidation_helper.h"
  14 #include "chrome/browser/sync/glue/sync_backend_host_core.h"
  15 #include "chrome/browser/sync/glue/sync_backend_registrar.h"
  16 #include "chrome/common/chrome_switches.h"
  17 #include "components/invalidation/invalidation_service.h"
  18 #include "components/invalidation/object_id_invalidation_map.h"
  19 #include "components/network_time/network_time_tracker.h"
  20 #include "components/signin/core/browser/signin_client.h"
  21 #include "components/sync_driver/sync_frontend.h"
  22 #include "components/sync_driver/sync_prefs.h"
  23 #include "content/public/browser/browser_thread.h"
  24 #include "content/public/browser/notification_details.h"
  25 #include "content/public/browser/notification_source.h"
  26 #include "sync/internal_api/public/base_transaction.h"
  27 #include "sync/internal_api/public/events/protocol_event.h"
  28 #include "sync/internal_api/public/http_bridge.h"
  29 #include "sync/internal_api/public/internal_components_factory.h"
  30 #include "sync/internal_api/public/internal_components_factory_impl.h"
  31 #include "sync/internal_api/public/network_resources.h"
  32 #include "sync/internal_api/public/sync_manager.h"
  33 #include "sync/internal_api/public/sync_manager_factory.h"
  34 #include "sync/internal_api/public/util/experiments.h"
  35 #include "sync/internal_api/public/util/sync_string_conversions.h"
  36
  37 // Helper macros to log with the syncer thread name; useful when there
  38 // are multiple syncers involved.
  39
  40 #define SLOG(severity) LOG(severity) << name_ << ": "
  41
  42 #define SDVLOG(verbose_level) DVLOG(verbose_level) << name_ << ": "
  43
  44 using syncer::InternalComponentsFactory;
  45
  46 namespace browser_sync {
  47
  48 namespace {
  49
  50 void UpdateNetworkTimeOnUIThread(base::Time network_time,
  51                                  base::TimeDelta resolution,
  52                                  base::TimeDelta latency,
  53                                  base::TimeTicks post_time) {
  54   g_browser_process->network_time_tracker()->UpdateNetworkTime(
  55       network_time, resolution, latency, post_time);
  56 }
  57
  58 void UpdateNetworkTime(const base::Time& network_time,
  59                        const base::TimeDelta& resolution,
  60                        const base::TimeDelta& latency) {
  61   content::BrowserThread::PostTask(
  62       content::BrowserThread::UI,
  63       FROM_HERE,
  64       base::Bind(&UpdateNetworkTimeOnUIThread,
  65                  network_time, resolution, latency, base::TimeTicks::Now()));
  66 }
  67
  68 }  // namespace
  69
  70 SyncBackendHostImpl::SyncBackendHostImpl(
  71     const std::string& name,
  72     Profile* profile,
  73     invalidation::InvalidationService* invalidator,
  74     const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs,
  75     const base::FilePath& sync_folder)
  76     : frontend_loop_(base::MessageLoop::current()),
  77       profile_(profile),
  78       name_(name),
  79       initialized_(false),
  80       sync_prefs_(sync_prefs),
  81       frontend_(NULL),
  82       cached_passphrase_type_(syncer::IMPLICIT_PASSPHRASE),
  83       invalidator_(invalidator),
  84       invalidation_handler_registered_(false),
  85       weak_ptr_factory_(this) {
  86   core_ = new SyncBackendHostCore(
  87       name_,
  88       profile_->GetPath().Append(sync_folder),
  89       sync_prefs_->HasSyncSetupCompleted(),
  90       weak_ptr_factory_.GetWeakPtr());
  91 }
  92
  93 SyncBackendHostImpl::~SyncBackendHostImpl() {
  94   DCHECK(!core_.get() && !frontend_) << "Must call Shutdown before destructor.";
  95   DCHECK(!registrar_.get());
  96 }
  97
  98 void SyncBackendHostImpl::Initialize(
  99     sync_driver::SyncFrontend* frontend,
 100     scoped_ptr<base::Thread> sync_thread,
 101     const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
 102     const GURL& sync_service_url,
 103     const syncer::SyncCredentials& credentials,
 104     bool delete_sync_data_folder,
 105     scoped_ptr<syncer::SyncManagerFactory> sync_manager_factory,
 106     scoped_ptr<syncer::UnrecoverableErrorHandler> unrecoverable_error_handler,
 107     syncer::ReportUnrecoverableErrorFunction
 108         report_unrecoverable_error_function,
 109     syncer::NetworkResources* network_resources) {
 110   registrar_.reset(new browser_sync::SyncBackendRegistrar(name_,
 111                                             profile_,
 112                                             sync_thread.Pass()));
 113   CHECK(registrar_->sync_thread());
 114
 115   frontend_ = frontend;
 116   DCHECK(frontend);
 117
 118   syncer::ModelSafeRoutingInfo routing_info;
 119   std::vector<scoped_refptr<syncer::ModelSafeWorker> > workers;
 120   registrar_->GetModelSafeRoutingInfo(&routing_info);
 121   registrar_->GetWorkers(&workers);
 122
 123   InternalComponentsFactory::Switches factory_switches = {
 124     InternalComponentsFactory::ENCRYPTION_KEYSTORE,
 125     InternalComponentsFactory::BACKOFF_NORMAL
 126   };
 127
 128   CommandLine* cl = CommandLine::ForCurrentProcess();
 129   if (cl->HasSwitch(switches::kSyncShortInitialRetryOverride)) {
 130     factory_switches.backoff_override =
 131         InternalComponentsFactory::BACKOFF_SHORT_INITIAL_RETRY_OVERRIDE;
 132   }
 133   if (cl->HasSwitch(switches::kSyncEnableGetUpdateAvoidance)) {
 134     factory_switches.pre_commit_updates_policy =
 135         InternalComponentsFactory::FORCE_ENABLE_PRE_COMMIT_UPDATE_AVOIDANCE;
 136   }
 137
 138   scoped_ptr<DoInitializeOptions> init_opts(new DoInitializeOptions(
 139       registrar_->sync_thread()->message_loop(),
 140       registrar_.get(),
 141       routing_info,
 142       workers,
 143       extensions_activity_monitor_.GetExtensionsActivity(),
 144       event_handler,
 145       sync_service_url,
 146       network_resources->GetHttpPostProviderFactory(
 147           make_scoped_refptr(profile_->GetRequestContext()),
 148           base::Bind(&UpdateNetworkTime),
 149           core_->GetRequestContextCancelationSignal()),
 150       credentials,
 151       invalidator_ ? invalidator_->GetInvalidatorClientId() : "",
 152       sync_manager_factory.Pass(),
 153       delete_sync_data_folder,
 154       sync_prefs_->GetEncryptionBootstrapToken(),
 155       sync_prefs_->GetKeystoreEncryptionBootstrapToken(),
 156       scoped_ptr<InternalComponentsFactory>(
 157           new syncer::InternalComponentsFactoryImpl(factory_switches)).Pass(),
 158       unrecoverable_error_handler.Pass(),
 159       report_unrecoverable_error_function));
 160   InitCore(init_opts.Pass());
 161 }
 162
 163 void SyncBackendHostImpl::UpdateCredentials(
 164     const syncer::SyncCredentials& credentials) {
 165   DCHECK(registrar_->sync_thread()->IsRunning());
 166   registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
 167       base::Bind(&SyncBackendHostCore::DoUpdateCredentials,
 168                  core_.get(),
 169                  credentials));
 170 }
 171
 172 void SyncBackendHostImpl::StartSyncingWithServer() {
 173   SDVLOG(1) << "SyncBackendHostImpl::StartSyncingWithServer called.";
 174
 175   syncer::ModelSafeRoutingInfo routing_info;
 176   registrar_->GetModelSafeRoutingInfo(&routing_info);
 177
 178   registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
 179       base::Bind(&SyncBackendHostCore::DoStartSyncing,
 180                  core_.get(), routing_info));
 181 }
 182
 183 void SyncBackendHostImpl::SetEncryptionPassphrase(const std::string& passphrase,
 184                                                   bool is_explicit) {
 185   DCHECK(registrar_->sync_thread()->IsRunning());
 186   if (!IsNigoriEnabled()) {
 187     NOTREACHED() << "SetEncryptionPassphrase must never be called when nigori"
 188                     " is disabled.";
 189     return;
 190   }
 191
 192   // We should never be called with an empty passphrase.
 193   DCHECK(!passphrase.empty());
 194
 195   // This should only be called by the frontend.
 196   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 197
 198   // SetEncryptionPassphrase should never be called if we are currently
 199   // encrypted with an explicit passphrase.
 200   DCHECK(cached_passphrase_type_ == syncer::KEYSTORE_PASSPHRASE ||
 201          cached_passphrase_type_ == syncer::IMPLICIT_PASSPHRASE);
 202
 203   // Post an encryption task on the syncer thread.
 204   registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
 205       base::Bind(&SyncBackendHostCore::DoSetEncryptionPassphrase,
 206                  core_.get(),
 207                  passphrase, is_explicit));
 208 }
 209
 210 bool SyncBackendHostImpl::SetDecryptionPassphrase(
 211     const std::string& passphrase) {
 212   if (!IsNigoriEnabled()) {
 213     NOTREACHED() << "SetDecryptionPassphrase must never be called when nigori"
 214                     " is disabled.";
 215     return false;
 216   }
 217
 218   // We should never be called with an empty passphrase.
 219   DCHECK(!passphrase.empty());
 220
 221   // This should only be called by the frontend.
 222   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 223
 224   // This should only be called when we have cached pending keys.
 225   DCHECK(cached_pending_keys_.has_blob());
 226
 227   // Check the passphrase that was provided against our local cache of the
 228   // cryptographer's pending keys. If this was unsuccessful, the UI layer can
 229   // immediately call OnPassphraseRequired without showing the user a spinner.
 230   if (!CheckPassphraseAgainstCachedPendingKeys(passphrase))
 231     return false;
 232
 233   // Post a decryption task on the syncer thread.
 234   registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
 235       base::Bind(&SyncBackendHostCore::DoSetDecryptionPassphrase,
 236                  core_.get(),
 237                  passphrase));
 238
 239   // Since we were able to decrypt the cached pending keys with the passphrase
 240   // provided, we immediately alert the UI layer that the passphrase was
 241   // accepted. This will avoid the situation where a user enters a passphrase,
 242   // clicks OK, immediately reopens the advanced settings dialog, and gets an
 243   // unnecessary prompt for a passphrase.
 244   // Note: It is not guaranteed that the passphrase will be accepted by the
 245   // syncer thread, since we could receive a new nigori node while the task is
 246   // pending. This scenario is a valid race, and SetDecryptionPassphrase can
 247   // trigger a new OnPassphraseRequired if it needs to.
 248   NotifyPassphraseAccepted();
 249   return true;
 250 }
 251
 252 void SyncBackendHostImpl::StopSyncingForShutdown() {
 253   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 254
 255   // Immediately stop sending messages to the frontend.
 256   frontend_ = NULL;
 257
 258   // Stop listening for and forwarding locally-triggered sync refresh requests.
 259   notification_registrar_.RemoveAll();
 260
 261   // Stop non-blocking sync types from sending any more requests to the syncer.
 262   sync_context_proxy_.reset();
 263
 264   DCHECK(registrar_->sync_thread()->IsRunning());
 265
 266   registrar_->RequestWorkerStopOnUIThread();
 267
 268   core_->ShutdownOnUIThread();
 269 }
 270
 271 scoped_ptr<base::Thread> SyncBackendHostImpl::Shutdown(
 272     syncer::ShutdownReason reason) {
 273   // StopSyncingForShutdown() (which nulls out |frontend_|) should be
 274   // called first.
 275   DCHECK(!frontend_);
 276   DCHECK(registrar_->sync_thread()->IsRunning());
 277
 278   bool sync_thread_claimed = (reason != syncer::BROWSER_SHUTDOWN);
 279
 280   if (invalidation_handler_registered_) {
 281     if (reason == syncer::DISABLE_SYNC) {
 282       UnregisterInvalidationIds();
 283     }
 284     invalidator_->UnregisterInvalidationHandler(this);
 285     invalidator_ = NULL;
 286   }
 287   invalidation_handler_registered_ = false;
 288
 289   // Shut down and destroy sync manager.
 290   registrar_->sync_thread()->message_loop()->PostTask(
 291       FROM_HERE,
 292       base::Bind(&SyncBackendHostCore::DoShutdown,
 293                  core_.get(), reason));
 294   core_ = NULL;
 295
 296   // Worker cleanup.
 297   SyncBackendRegistrar* detached_registrar = registrar_.release();
 298   detached_registrar->sync_thread()->message_loop()->PostTask(
 299       FROM_HERE,
 300       base::Bind(&SyncBackendRegistrar::Shutdown,
 301                  base::Unretained(detached_registrar)));
 302
 303   if (sync_thread_claimed)
 304     return detached_registrar->ReleaseSyncThread();
 305   else
 306     return scoped_ptr<base::Thread>();
 307 }
 308
 309 void SyncBackendHostImpl::UnregisterInvalidationIds() {
 310   if (invalidation_handler_registered_) {
 311     invalidator_->UpdateRegisteredInvalidationIds(
 312         this,
 313         syncer::ObjectIdSet());
 314   }
 315 }
 316
 317 void SyncBackendHostImpl::ConfigureDataTypes(
 318     syncer::ConfigureReason reason,
 319     const DataTypeConfigStateMap& config_state_map,
 320     const base::Callback<void(syncer::ModelTypeSet,
 321                               syncer::ModelTypeSet)>& ready_task,
 322     const base::Callback<void()>& retry_callback) {
 323   // Only one configure is allowed at a time.  This is guaranteed by our
 324   // callers.  The SyncBackendHostImpl requests one configure as the backend is
 325   // initializing and waits for it to complete.  After initialization, all
 326   // configurations will pass through the DataTypeManager, which is careful to
 327   // never send a new configure request until the current request succeeds.
 328
 329   // The SyncBackendRegistrar's routing info will be updated by adding the
 330   // types_to_add to the list then removing types_to_remove.  Any types which
 331   // are not in either of those sets will remain untouched.
 332   //
 333   // Types which were not in the list previously are not fully downloaded, so we
 334   // must ask the syncer to download them.  Any newly supported datatypes will
 335   // not have been in that routing info list, so they will be among the types
 336   // downloaded if they are enabled.
 337   //
 338   // The SyncBackendRegistrar's state was initially derived from the types
 339   // detected to have been downloaded in the database.  Afterwards it is
 340   // modified only by this function.  We expect it to remain in sync with the
 341   // backend because configuration requests are never aborted; they are retried
 342   // until they succeed or the backend is shut down.
 343
 344   syncer::ModelTypeSet disabled_types =
 345       GetDataTypesInState(DISABLED, config_state_map);
 346   syncer::ModelTypeSet fatal_types =
 347       GetDataTypesInState(FATAL, config_state_map);
 348   syncer::ModelTypeSet crypto_types =
 349       GetDataTypesInState(CRYPTO, config_state_map);
 350   syncer::ModelTypeSet unready_types =
 351       GetDataTypesInState(UNREADY, config_state_map);
 352
 353   disabled_types.PutAll(fatal_types);
 354   disabled_types.PutAll(crypto_types);
 355   disabled_types.PutAll(unready_types);
 356
 357   syncer::ModelTypeSet active_types =
 358       GetDataTypesInState(CONFIGURE_ACTIVE, config_state_map);
 359   syncer::ModelTypeSet clean_first_types =
 360       GetDataTypesInState(CONFIGURE_CLEAN, config_state_map);
 361   syncer::ModelTypeSet types_to_download = registrar_->ConfigureDataTypes(
 362       syncer::Union(active_types, clean_first_types),
 363       disabled_types);
 364   types_to_download.PutAll(clean_first_types);
 365   types_to_download.RemoveAll(syncer::ProxyTypes());
 366   if (!types_to_download.Empty())
 367     types_to_download.Put(syncer::NIGORI);
 368
 369   // TODO(sync): crbug.com/137550.
 370   // It's dangerous to configure types that have progress markers.  Types with
 371   // progress markers can trigger a MIGRATION_DONE response.  We are not
 372   // prepared to handle a migration during a configure, so we must ensure that
 373   // all our types_to_download actually contain no data before we sync them.
 374   //
 375   // One common way to end up in this situation used to be types which
 376   // downloaded some or all of their data but have not applied it yet.  We avoid
 377   // problems with those types by purging the data of any such partially synced
 378   // types soon after we load the directory.
 379   //
 380   // Another possible scenario is that we have newly supported or newly enabled
 381   // data types being downloaded here but the nigori type, which is always
 382   // included in any GetUpdates request, requires migration.  The server has
 383   // code to detect this scenario based on the configure reason, the fact that
 384   // the nigori type is the only requested type which requires migration, and
 385   // that the requested types list includes at least one non-nigori type.  It
 386   // will not send a MIGRATION_DONE response in that case.  We still need to be
 387   // careful to not send progress markers for non-nigori types, though.  If a
 388   // non-nigori type in the request requires migration, a MIGRATION_DONE
 389   // response will be sent.
 390
 391   syncer::ModelSafeRoutingInfo routing_info;
 392   registrar_->GetModelSafeRoutingInfo(&routing_info);
 393
 394   syncer::ModelTypeSet current_types = registrar_->GetLastConfiguredTypes();
 395   syncer::ModelTypeSet types_to_purge =
 396       syncer::Difference(syncer::ModelTypeSet::All(), current_types);
 397   syncer::ModelTypeSet inactive_types =
 398       GetDataTypesInState(CONFIGURE_INACTIVE, config_state_map);
 399   types_to_purge.RemoveAll(inactive_types);
 400   types_to_purge.RemoveAll(unready_types);
 401
 402   // If a type has already been disabled and unapplied or journaled, it will
 403   // not be part of the |types_to_purge| set, and therefore does not need
 404   // to be acted on again.
 405   fatal_types.RetainAll(types_to_purge);
 406   syncer::ModelTypeSet unapply_types =
 407       syncer::Union(crypto_types, clean_first_types);
 408   unapply_types.RetainAll(types_to_purge);
 409
 410   DCHECK(syncer::Intersection(current_types, fatal_types).Empty());
 411   DCHECK(syncer::Intersection(current_types, crypto_types).Empty());
 412   DCHECK(current_types.HasAll(types_to_download));
 413
 414   SDVLOG(1) << "Types "
 415             << syncer::ModelTypeSetToString(types_to_download)
 416             << " added; calling DoConfigureSyncer";
 417   // Divide up the types into their corresponding actions (each is mutually
 418   // exclusive):
 419   // - Types which have just been added to the routing info (types_to_download):
 420   //   are downloaded.
 421   // - Types which have encountered a fatal error (fatal_types) are deleted
 422   //   from the directory and journaled in the delete journal.
 423   // - Types which have encountered a cryptographer error (crypto_types) are
 424   //   unapplied (local state is purged but sync state is not).
 425   // - All other types not in the routing info (types just disabled) are deleted
 426   //   from the directory.
 427   // - Everything else (enabled types and already disabled types) is not
 428   //   touched.
 429   RequestConfigureSyncer(reason,
 430                          types_to_download,
 431                          types_to_purge,
 432                          fatal_types,
 433                          unapply_types,
 434                          inactive_types,
 435                          routing_info,
 436                          ready_task,
 437                          retry_callback);
 438 }
 439
 440 void SyncBackendHostImpl::EnableEncryptEverything() {
 441   registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
 442      base::Bind(&SyncBackendHostCore::DoEnableEncryptEverything,
 443                 core_.get()));
 444 }
 445
 446 void SyncBackendHostImpl::ActivateDataType(
 447     syncer::ModelType type, syncer::ModelSafeGroup group,
 448     sync_driver::ChangeProcessor* change_processor) {
 449   registrar_->ActivateDataType(type, group, change_processor, GetUserShare());
 450 }
 451
 452 void SyncBackendHostImpl::DeactivateDataType(syncer::ModelType type) {
 453   registrar_->DeactivateDataType(type);
 454 }
 455
 456 syncer::UserShare* SyncBackendHostImpl::GetUserShare() const {
 457   return core_->sync_manager()->GetUserShare();
 458 }
 459
 460 scoped_ptr<syncer::SyncContextProxy>
 461 SyncBackendHostImpl::GetSyncContextProxy() {
 462   return sync_context_proxy_.get() ? scoped_ptr<syncer::SyncContextProxy>(
 463                                          sync_context_proxy_->Clone())
 464                                    : scoped_ptr<syncer::SyncContextProxy>();
 465 }
 466
 467 SyncBackendHostImpl::Status SyncBackendHostImpl::GetDetailedStatus() {
 468   DCHECK(initialized());
 469   return core_->sync_manager()->GetDetailedStatus();
 470 }
 471
 472 syncer::sessions::SyncSessionSnapshot
 473 SyncBackendHostImpl::GetLastSessionSnapshot() const {
 474   return last_snapshot_;
 475 }
 476
 477 bool SyncBackendHostImpl::HasUnsyncedItems() const {
 478   DCHECK(initialized());
 479   return core_->sync_manager()->HasUnsyncedItems();
 480 }
 481
 482 bool SyncBackendHostImpl::IsNigoriEnabled() const {
 483   return registrar_.get() && registrar_->IsNigoriEnabled();
 484 }
 485
 486 syncer::PassphraseType SyncBackendHostImpl::GetPassphraseType() const {
 487   return cached_passphrase_type_;
 488 }
 489
 490 base::Time SyncBackendHostImpl::GetExplicitPassphraseTime() const {
 491   return cached_explicit_passphrase_time_;
 492 }
 493
 494 bool SyncBackendHostImpl::IsCryptographerReady(
 495     const syncer::BaseTransaction* trans) const {
 496   return initialized() && trans->GetCryptographer() &&
 497       trans->GetCryptographer()->is_ready();
 498 }
 499
 500 void SyncBackendHostImpl::GetModelSafeRoutingInfo(
 501     syncer::ModelSafeRoutingInfo* out) const {
 502   if (initialized()) {
 503     CHECK(registrar_.get());
 504     registrar_->GetModelSafeRoutingInfo(out);
 505   } else {
 506     NOTREACHED();
 507   }
 508 }
 509
 510 void SyncBackendHostImpl::RequestBufferedProtocolEventsAndEnableForwarding() {
 511   registrar_->sync_thread()->message_loop()->PostTask(
 512       FROM_HERE,
 513       base::Bind(
 514           &SyncBackendHostCore::SendBufferedProtocolEventsAndEnableForwarding,
 515           core_));
 516 }
 517
 518 void SyncBackendHostImpl::DisableProtocolEventForwarding() {
 519   registrar_->sync_thread()->message_loop()->PostTask(
 520       FROM_HERE,
 521       base::Bind(
 522           &SyncBackendHostCore::DisableProtocolEventForwarding,
 523           core_));
 524 }
 525
 526 void SyncBackendHostImpl::EnableDirectoryTypeDebugInfoForwarding() {
 527   DCHECK(initialized());
 528   registrar_->sync_thread()->message_loop()->PostTask(
 529       FROM_HERE,
 530       base::Bind(
 531           &SyncBackendHostCore::EnableDirectoryTypeDebugInfoForwarding,
 532           core_));
 533 }
 534
 535 void SyncBackendHostImpl::DisableDirectoryTypeDebugInfoForwarding() {
 536   DCHECK(initialized());
 537   registrar_->sync_thread()->message_loop()->PostTask(
 538       FROM_HERE,
 539       base::Bind(
 540           &SyncBackendHostCore::DisableDirectoryTypeDebugInfoForwarding,
 541           core_));
 542 }
 543
 544 void SyncBackendHostImpl::GetAllNodesForTypes(
 545     syncer::ModelTypeSet types,
 546     base::Callback<void(const std::vector<syncer::ModelType>&,
 547                         ScopedVector<base::ListValue>)> callback) {
 548   DCHECK(initialized());
 549   registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
 550        base::Bind(
 551            &SyncBackendHostCore::GetAllNodesForTypes,
 552            core_,
 553            types,
 554            frontend_loop_->message_loop_proxy(),
 555            callback));
 556 }
 557
 558 void SyncBackendHostImpl::InitCore(scoped_ptr<DoInitializeOptions> options) {
 559   registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
 560       base::Bind(&SyncBackendHostCore::DoInitialize,
 561                  core_.get(), base::Passed(&options)));
 562 }
 563
 564 void SyncBackendHostImpl::RequestConfigureSyncer(
 565     syncer::ConfigureReason reason,
 566     syncer::ModelTypeSet to_download,
 567     syncer::ModelTypeSet to_purge,
 568     syncer::ModelTypeSet to_journal,
 569     syncer::ModelTypeSet to_unapply,
 570     syncer::ModelTypeSet to_ignore,
 571     const syncer::ModelSafeRoutingInfo& routing_info,
 572     const base::Callback<void(syncer::ModelTypeSet,
 573                               syncer::ModelTypeSet)>& ready_task,
 574     const base::Closure& retry_callback) {
 575   DoConfigureSyncerTypes config_types;
 576   config_types.to_download = to_download;
 577   config_types.to_purge = to_purge;
 578   config_types.to_journal = to_journal;
 579   config_types.to_unapply = to_unapply;
 580   registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
 581        base::Bind(&SyncBackendHostCore::DoConfigureSyncer,
 582                   core_.get(),
 583                   reason,
 584                   config_types,
 585                   routing_info,
 586                   ready_task,
 587                   retry_callback));
 588 }
 589
 590 void SyncBackendHostImpl::FinishConfigureDataTypesOnFrontendLoop(
 591     const syncer::ModelTypeSet enabled_types,
 592     const syncer::ModelTypeSet succeeded_configuration_types,
 593     const syncer::ModelTypeSet failed_configuration_types,
 594     const base::Callback<void(syncer::ModelTypeSet,
 595                               syncer::ModelTypeSet)>& ready_task) {
 596   if (!frontend_)
 597     return;
 598
 599   if (invalidator_) {
 600     invalidator_->UpdateRegisteredInvalidationIds(
 601         this,
 602         ModelTypeSetToObjectIdSet(enabled_types));
 603   }
 604
 605   if (!ready_task.is_null())
 606     ready_task.Run(succeeded_configuration_types, failed_configuration_types);
 607 }
 608
 609 void SyncBackendHostImpl::Observe(
 610     int type,
 611     const content::NotificationSource& source,
 612     const content::NotificationDetails& details) {
 613   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 614   DCHECK_EQ(type, chrome::NOTIFICATION_SYNC_REFRESH_LOCAL);
 615
 616   content::Details<const syncer::ModelTypeSet> state_details(details);
 617   const syncer::ModelTypeSet& types = *(state_details.ptr());
 618   registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
 619       base::Bind(&SyncBackendHostCore::DoRefreshTypes, core_.get(), types));
 620 }
 621
 622 void SyncBackendHostImpl::AddExperimentalTypes() {
 623   CHECK(initialized());
 624   syncer::Experiments experiments;
 625   if (core_->sync_manager()->ReceivedExperiment(&experiments))
 626     frontend_->OnExperimentsChanged(experiments);
 627 }
 628
 629 void SyncBackendHostImpl::HandleControlTypesDownloadRetry() {
 630   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 631   if (!frontend_)
 632     return;
 633
 634   frontend_->OnSyncConfigureRetry();
 635 }
 636
 637 void SyncBackendHostImpl::HandleInitializationSuccessOnFrontendLoop(
 638     const syncer::WeakHandle<syncer::JsBackend> js_backend,
 639     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>
 640         debug_info_listener,
 641     syncer::SyncContextProxy* sync_context_proxy,
 642     const std::string& cache_guid) {
 643   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 644
 645   if (sync_context_proxy)
 646     sync_context_proxy_ = sync_context_proxy->Clone();
 647
 648   if (!frontend_)
 649     return;
 650
 651   initialized_ = true;
 652
 653   if (invalidator_) {
 654     invalidator_->RegisterInvalidationHandler(this);
 655     invalidation_handler_registered_ = true;
 656
 657     // Fake a state change to initialize the SyncManager's cached invalidator
 658     // state.
 659     OnInvalidatorStateChange(invalidator_->GetInvalidatorState());
 660   }
 661
 662   // Start forwarding refresh requests to the SyncManager
 663   notification_registrar_.Add(this, chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
 664                               content::Source<Profile>(profile_));
 665
 666   // Now that we've downloaded the control types, we can see if there are any
 667   // experimental types to enable. This should be done before we inform
 668   // the frontend to ensure they're visible in the customize screen.
 669   AddExperimentalTypes();
 670   frontend_->OnBackendInitialized(js_backend,
 671                                   debug_info_listener,
 672                                   cache_guid,
 673                                   true);
 674 }
 675
 676 void SyncBackendHostImpl::HandleInitializationFailureOnFrontendLoop() {
 677   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 678   if (!frontend_)
 679     return;
 680
 681   frontend_->OnBackendInitialized(
 682       syncer::WeakHandle<syncer::JsBackend>(),
 683       syncer::WeakHandle<syncer::DataTypeDebugInfoListener>(),
 684       "",
 685       false);
 686 }
 687
 688 void SyncBackendHostImpl::HandleSyncCycleCompletedOnFrontendLoop(
 689     const syncer::sessions::SyncSessionSnapshot& snapshot) {
 690   if (!frontend_)
 691     return;
 692   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 693
 694   last_snapshot_ = snapshot;
 695
 696   SDVLOG(1) << "Got snapshot " << snapshot.ToString();
 697
 698   // Process any changes to the datatypes we're syncing.
 699   // TODO(sync): add support for removing types.
 700   if (initialized())
 701     AddExperimentalTypes();
 702
 703   if (initialized())
 704     frontend_->OnSyncCycleCompleted();
 705 }
 706
 707 void SyncBackendHostImpl::RetryConfigurationOnFrontendLoop(
 708     const base::Closure& retry_callback) {
 709   SDVLOG(1) << "Failed to complete configuration, informing of retry.";
 710   retry_callback.Run();
 711 }
 712
 713 void SyncBackendHostImpl::PersistEncryptionBootstrapToken(
 714     const std::string& token,
 715     syncer::BootstrapTokenType token_type) {
 716   CHECK(sync_prefs_.get());
 717   DCHECK(!token.empty());
 718   if (token_type == syncer::PASSPHRASE_BOOTSTRAP_TOKEN)
 719     sync_prefs_->SetEncryptionBootstrapToken(token);
 720   else
 721     sync_prefs_->SetKeystoreEncryptionBootstrapToken(token);
 722 }
 723
 724 void SyncBackendHostImpl::HandleActionableErrorEventOnFrontendLoop(
 725     const syncer::SyncProtocolError& sync_error) {
 726   if (!frontend_)
 727     return;
 728   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 729   frontend_->OnActionableError(sync_error);
 730 }
 731
 732 void SyncBackendHostImpl::HandleMigrationRequestedOnFrontendLoop(
 733     syncer::ModelTypeSet types) {
 734   if (!frontend_)
 735     return;
 736   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 737   frontend_->OnMigrationNeededForTypes(types);
 738 }
 739
 740 void SyncBackendHostImpl::OnInvalidatorStateChange(
 741     syncer::InvalidatorState state) {
 742   registrar_->sync_thread()->message_loop()->PostTask(
 743       FROM_HERE,
 744       base::Bind(&SyncBackendHostCore::DoOnInvalidatorStateChange,
 745                  core_.get(),
 746                  state));
 747 }
 748
 749 void SyncBackendHostImpl::OnIncomingInvalidation(
 750     const syncer::ObjectIdInvalidationMap& invalidation_map) {
 751   registrar_->sync_thread()->message_loop()->PostTask(
 752       FROM_HERE,
 753       base::Bind(&SyncBackendHostCore::DoOnIncomingInvalidation,
 754                  core_.get(),
 755                  invalidation_map));
 756 }
 757
 758 std::string SyncBackendHostImpl::GetOwnerName() const {
 759   return "SyncBackendHostImpl";
 760 }
 761
 762 bool SyncBackendHostImpl::CheckPassphraseAgainstCachedPendingKeys(
 763     const std::string& passphrase) const {
 764   DCHECK(cached_pending_keys_.has_blob());
 765   DCHECK(!passphrase.empty());
 766   syncer::Nigori nigori;
 767   nigori.InitByDerivation("localhost", "dummy", passphrase);
 768   std::string plaintext;
 769   bool result = nigori.Decrypt(cached_pending_keys_.blob(), &plaintext);
 770   DVLOG_IF(1, result) << "Passphrase failed to decrypt pending keys.";
 771   return result;
 772 }
 773
 774 void SyncBackendHostImpl::NotifyPassphraseRequired(
 775     syncer::PassphraseRequiredReason reason,
 776     sync_pb::EncryptedData pending_keys) {
 777   if (!frontend_)
 778     return;
 779
 780   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 781
 782   // Update our cache of the cryptographer's pending keys.
 783   cached_pending_keys_ = pending_keys;
 784
 785   frontend_->OnPassphraseRequired(reason, pending_keys);
 786 }
 787
 788 void SyncBackendHostImpl::NotifyPassphraseAccepted() {
 789   if (!frontend_)
 790     return;
 791
 792   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 793
 794   // Clear our cache of the cryptographer's pending keys.
 795   cached_pending_keys_.clear_blob();
 796   frontend_->OnPassphraseAccepted();
 797 }
 798
 799 void SyncBackendHostImpl::NotifyEncryptedTypesChanged(
 800     syncer::ModelTypeSet encrypted_types,
 801     bool encrypt_everything) {
 802   if (!frontend_)
 803     return;
 804
 805   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 806   frontend_->OnEncryptedTypesChanged(
 807       encrypted_types, encrypt_everything);
 808 }
 809
 810 void SyncBackendHostImpl::NotifyEncryptionComplete() {
 811   if (!frontend_)
 812     return;
 813
 814   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 815   frontend_->OnEncryptionComplete();
 816 }
 817
 818 void SyncBackendHostImpl::HandlePassphraseTypeChangedOnFrontendLoop(
 819     syncer::PassphraseType type,
 820     base::Time explicit_passphrase_time) {
 821   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 822   DVLOG(1) << "Passphrase type changed to "
 823            << syncer::PassphraseTypeToString(type);
 824   cached_passphrase_type_ = type;
 825   cached_explicit_passphrase_time_ = explicit_passphrase_time;
 826 }
 827
 828 void SyncBackendHostImpl::HandleConnectionStatusChangeOnFrontendLoop(
 829     syncer::ConnectionStatus status) {
 830   if (!frontend_)
 831     return;
 832
 833   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 834
 835   DVLOG(1) << "Connection status changed: "
 836            << syncer::ConnectionStatusToString(status);
 837   frontend_->OnConnectionStatusChange(status);
 838 }
 839
 840 void SyncBackendHostImpl::HandleProtocolEventOnFrontendLoop(
 841     syncer::ProtocolEvent* event) {
 842   scoped_ptr<syncer::ProtocolEvent> scoped_event(event);
 843   if (!frontend_)
 844     return;
 845   frontend_->OnProtocolEvent(*scoped_event);
 846 }
 847
 848 void SyncBackendHostImpl::HandleDirectoryCommitCountersUpdatedOnFrontendLoop(
 849     syncer::ModelType type,
 850     const syncer::CommitCounters& counters) {
 851   if (!frontend_)
 852     return;
 853   frontend_->OnDirectoryTypeCommitCounterUpdated(type, counters);
 854 }
 855
 856 void SyncBackendHostImpl::HandleDirectoryUpdateCountersUpdatedOnFrontendLoop(
 857     syncer::ModelType type,
 858     const syncer::UpdateCounters& counters) {
 859   if (!frontend_)
 860     return;
 861   frontend_->OnDirectoryTypeUpdateCounterUpdated(type, counters);
 862 }
 863
 864 void SyncBackendHostImpl::HandleDirectoryStatusCountersUpdatedOnFrontendLoop(
 865     syncer::ModelType type,
 866     const syncer::StatusCounters& counters) {
 867   if (!frontend_)
 868     return;
 869   frontend_->OnDirectoryTypeStatusCounterUpdated(type, counters);
 870 }
 871
 872 base::MessageLoop* SyncBackendHostImpl::GetSyncLoopForTesting() {
 873   return registrar_->sync_thread()->message_loop();
 874 }
 875
 876 }  // namespace browser_sync
 877
 878 #undef SDVLOG
 879
 880 #undef SLOG