[Sync] Refactoring polling to be reliable.

sync/internal_api/sync_manager_impl.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 "sync/internal_api/sync_manager_impl.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 200 matching lines @@
     ready_task.Run();
     return;
   }
 
   ConfigurationParams params(GetSourceFromReason(reason),
                              to_download,
                              new_routing_info,
                              ready_task,
                              retry_task);
 
-  scheduler_->Start(SyncScheduler::CONFIGURATION_MODE);
+  scheduler_->Start(SyncScheduler::CONFIGURATION_MODE, base::Time());
   scheduler_->ScheduleConfiguration(params);
 }
 
 void SyncManagerImpl::Init(InitArgs* args) {
   CHECK(!initialized_);
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(args->post_factory.get());
   DCHECK(!args->credentials.email.empty());
   DCHECK(!args->credentials.sync_token.empty());
   DCHECK(!args->credentials.scope_set.empty());
@@ skipping 96 matching lines @@
                                              args->extensions_activity,
                                              listeners,
                                              &debug_info_event_listener_,
                                              model_type_registry_.get(),
                                              args->invalidator_client_id)
           .Pass();
   session_context_->set_account_name(args->credentials.email);
   scheduler_ = args->internal_components_factory->BuildScheduler(
       name_, session_context_.get(), args->cancelation_signal).Pass();
 
-  scheduler_->Start(SyncScheduler::CONFIGURATION_MODE);
+  scheduler_->Start(SyncScheduler::CONFIGURATION_MODE, base::Time());
 
   initialized_ = true;
 
   net::NetworkChangeNotifier::AddIPAddressObserver(this);
   net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
   observing_network_connectivity_changes_ = true;
 
   UpdateCredentials(args->credentials);
 
   NotifyInitializationSuccess();
@@ skipping 51 matching lines @@
 
 void SyncManagerImpl::OnPassphraseTypeChanged(
     PassphraseType type,
     base::Time explicit_passphrase_time) {
   allstatus_.SetPassphraseType(type);
   allstatus_.SetKeystoreMigrationTime(
       sync_encryption_handler_->migration_time());
 }
 
 void SyncManagerImpl::StartSyncingNormally(
-    const ModelSafeRoutingInfo& routing_info) {
+    const ModelSafeRoutingInfo& routing_info,
+    base::Time last_poll_time) {
   // Start the sync scheduler.
   // TODO(sync): We always want the newest set of routes when we switch back
   // to normal mode. Figure out how to enforce set_routing_info is always
   // appropriately set and that it's only modified when switching to normal
   // mode.
   DCHECK(thread_checker_.CalledOnValidThread());
   session_context_->SetRoutingInfo(routing_info);
-  scheduler_->Start(SyncScheduler::NORMAL_MODE);
+  scheduler_->Start(SyncScheduler::NORMAL_MODE,
+                    last_poll_time);
 }
 
 syncable::Directory* SyncManagerImpl::directory() {
   return share_.directory.get();
 }
 
 const SyncScheduler* SyncManagerImpl::scheduler() const {
   return scheduler_.get();
 }
 
@@ skipping 595 matching lines @@
 bool SyncManagerImpl::HasDirectoryTypeDebugInfoObserver(
     syncer::TypeDebugInfoObserver* observer) {
   return model_type_registry_->HasDirectoryTypeDebugInfoObserver(observer);
 }
 
 void SyncManagerImpl::RequestEmitDebugInfo() {
   model_type_registry_->RequestEmitDebugInfo();
 }
 
 }  // namespace syncer