[Sync] Refactoring polling to be reliable.

sync/engine/syncer.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/engine/syncer.h"
 
+#include "base/auto_reset.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "sync/engine/apply_control_data_updates.h"
 #include "sync/engine/commit.h"
 #include "sync/engine/commit_processor.h"
 #include "sync/engine/conflict_resolver.h"
@@ skipping 21 matching lines @@
 static const bool kCreateMobileBookmarksFolder = true;
 #else
 static const bool kCreateMobileBookmarksFolder = false;
 #endif
 
 using sessions::StatusController;
 using sessions::SyncSession;
 using sessions::NudgeTracker;
 
 Syncer::Syncer(syncer::CancelationSignal* cancelation_signal)
-    : cancelation_signal_(cancelation_signal) {
+    : cancelation_signal_(cancelation_signal),
+      is_syncing_(false) {
 }
 
 Syncer::~Syncer() {}
 
 bool Syncer::ExitRequested() {
   return cancelation_signal_->IsSignalled();
 }
 
+bool Syncer::IsSyncing() const {
+  return is_syncing_;
+}
+
 bool Syncer::NormalSyncShare(ModelTypeSet request_types,
                              NudgeTracker* nudge_tracker,
                              SyncSession* session) {
+  base::AutoReset<bool> is_syncing(&is_syncing_, true);
   HandleCycleBegin(session);
   if (nudge_tracker->IsGetUpdatesRequired() ||
       session->context()->ShouldFetchUpdatesBeforeCommit()) {
     VLOG(1) << "Downloading types " << ModelTypeSetToString(request_types);
     NormalGetUpdatesDelegate normal_delegate(*nudge_tracker);
     GetUpdatesProcessor get_updates_processor(
         session->context()->model_type_registry()->update_handler_map(),
         normal_delegate);
     if (!DownloadAndApplyUpdates(
             &request_types,
@@ skipping 11 matching lines @@
                                                   session, &commit_processor);
   session->mutable_status_controller()->set_commit_result(commit_result);
 
   return HandleCycleEnd(session, nudge_tracker->GetLegacySource());
 }
 
 bool Syncer::ConfigureSyncShare(
     ModelTypeSet request_types,
     sync_pb::GetUpdatesCallerInfo::GetUpdatesSource source,
     SyncSession* session) {
+  base::AutoReset<bool> is_syncing(&is_syncing_, true);
   VLOG(1) << "Configuring types " << ModelTypeSetToString(request_types);
   HandleCycleBegin(session);
   ConfigureGetUpdatesDelegate configure_delegate(source);
   GetUpdatesProcessor get_updates_processor(
       session->context()->model_type_registry()->update_handler_map(),
       configure_delegate);
   DownloadAndApplyUpdates(
       &request_types,
       session,
       &get_updates_processor,
       kCreateMobileBookmarksFolder);
   return HandleCycleEnd(session, source);
 }
 
 bool Syncer::PollSyncShare(ModelTypeSet request_types,
                            SyncSession* session) {
+  base::AutoReset<bool> is_syncing(&is_syncing_, true);
   VLOG(1) << "Polling types " << ModelTypeSetToString(request_types);
   HandleCycleBegin(session);
   PollGetUpdatesDelegate poll_delegate;
   GetUpdatesProcessor get_updates_processor(
       session->context()->model_type_registry()->update_handler_map(),
       poll_delegate);
   DownloadAndApplyUpdates(
       &request_types,
       session,
       &get_updates_processor,
@@ skipping 78 matching lines @@
 void Syncer::HandleCycleBegin(SyncSession* session) {
   session->mutable_status_controller()->UpdateStartTime();
   session->SendEventNotification(SyncCycleEvent::SYNC_CYCLE_BEGIN);
 }
 
 bool Syncer::HandleCycleEnd(
     SyncSession* session,
     sync_pb::GetUpdatesCallerInfo::GetUpdatesSource source) {
   if (!ExitRequested()) {
     session->SendSyncCycleEndEventNotification(source);
-    return true;
+
+    bool success = !sessions::HasSyncerError(
+          session->status_controller().model_neutral_state());
+    if (success && source == sync_pb::GetUpdatesCallerInfo::PERIODIC)
+      session->mutable_status_controller()->UpdatePollTime();
+    return success;
   } else {
     return false;
   }
 }
 
 }  // namespace syncer