Simulate transient error and verify exponential backoff.

chrome/browser/sync/engine/syncer.cc

 // Copyright (c) 2011 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/engine/syncer.h"
 
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "base/tracked.h"
 #include "chrome/browser/sync/engine/apply_updates_command.h"
@@ skipping 36 matching lines @@
 using syncable::ScopedDirLookup;
 using syncable::WriteTransaction;
 
 namespace browser_sync {
 
 using sessions::ScopedSessionContextConflictResolver;
 using sessions::StatusController;
 using sessions::SyncSession;
 using sessions::ConflictProgress;
 
+Syncer::ScopedSyncStartStopTracker::ScopedSyncStartStopTracker(
+    sessions::SyncSession* session) : session_(session) {
+  session_->status_controller()->SetSyncInProgressAndUpdateStartTime(true);
+}
+
+Syncer::ScopedSyncStartStopTracker::~ScopedSyncStartStopTracker() {
+  session_->status_controller()->SetSyncInProgressAndUpdateStartTime(false);
+}
+
 Syncer::Syncer()
     : early_exit_requested_(false),
       pre_conflict_resolution_closure_(NULL) {
 }
 
 Syncer::~Syncer() {}
 
 bool Syncer::ExitRequested() {
   base::AutoLock lock(early_exit_requested_lock_);
   return early_exit_requested_;
 }
 
 void Syncer::RequestEarlyExit() {
   base::AutoLock lock(early_exit_requested_lock_);
   early_exit_requested_ = true;
 }
 
 void Syncer::SyncShare(sessions::SyncSession* session,
                        SyncerStep first_step,
                        SyncerStep last_step) {
   {
     ScopedDirLookup dir(session->context()->directory_manager(),
                         session->context()->account_name());
     // The directory must be good here.
     CHECK(dir.good());
   }
 
   ScopedSessionContextConflictResolver scoped(session->context(),
                                               &resolver_);
+
+  ScopedSyncStartStopTracker start_stop_tracker(session);
   SyncerStep current_step = first_step;
 
   SyncerStep next_step = current_step;
   while (!ExitRequested()) {
     switch (current_step) {
       case SYNCER_BEGIN:
         VLOG(1) << "Syncer Begin";
         // This isn't perfect, as we can end up bundling extensions activity
         // intended for the next session into the current one.  We could do a
         // test-and-reset as with the source, but note that also falls short if
@@ skipping 65 matching lines @@
           last_step = SYNCER_END;
           next_step = SYNCER_END;
         } else {
           next_step = BUILD_COMMIT_REQUEST;
         }
         break;
       }
       // These two steps are combined since they are executed within the same
       // write transaction.
       case BUILD_COMMIT_REQUEST: {
-        session->status_controller()->set_syncing(true);
-
         VLOG(1) << "Processing Commit Request";
         ScopedDirLookup dir(session->context()->directory_manager(),
                             session->context()->account_name());
         if (!dir.good()) {
           LOG(ERROR) << "Scoped dir lookup failed!";
           return;
         }
         WriteTransaction trans(FROM_HERE, SYNCER, dir);
         sessions::ScopedSetSessionWriteTransaction set_trans(session, &trans);
 
@@ skipping 151 matching lines @@
   entry->Put(SERVER_CTIME, 0);
   entry->Put(SERVER_VERSION, 0);
   entry->Put(SERVER_IS_DIR, false);
   entry->Put(SERVER_IS_DEL, false);
   entry->Put(IS_UNAPPLIED_UPDATE, false);
   entry->Put(SERVER_SPECIFICS, sync_pb::EntitySpecifics::default_instance());
   entry->Put(SERVER_POSITION_IN_PARENT, 0);
 }
 
 }  // namespace browser_sync