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 94 matching lines @@
         break;
       case CLEANUP_DISABLED_TYPES: {
         VLOG(1) << "Cleaning up disabled types";
         CleanupDisabledTypesCommand cleanup;
         cleanup.Execute(session);
         next_step = DOWNLOAD_UPDATES;
         break;
       }
       case DOWNLOAD_UPDATES: {
         VLOG(1) << "Downloading Updates";
+
+        // We would call set_syncing(false) at the SYNCER_END step. Note if
+        // we are on DOWNLOAD_UPDATES state we would not exit without
+        // going to SYNCER_END because of various cleanup steps.
+        session->status_controller()->set_syncing(true);

[tim (not reviewing), 2011/08/09 19:57:47]

Why are we making this change?  What do you mean by "would call
set_syncing(false)"?  We don't always go through to SYNCER_END from
DOWNLOAD_UPDATES (e.g. config) and probably shouldn't make assumptions like that
given that callers can invoke SyncShare with arbitrary start/stop states.

[lipalani1, 2011/08/09 20:36:48]

hey even in that case we would always call syncer_end. otherwise the snapshot
wont be send. Thats why I thought it was safe to put it. But now you bring it up
I am going with my original idea which is to make it a scoped variable so sync
end and start would be called correctly.
Earlier sync start and sync end was kind of broken. we would call
set_syncing(true) when processing updates and again in upload commits. and call
stop syncing in syncerend. 
With this change whenever we are in syncer we would call set_syncing(true) and
when we exit we would call set_syncing(false). this includes clearing of
disabled types.
On 2011/08/09 19:57:47, timsteele wrote:

         DownloadUpdatesCommand download_updates;
         download_updates.Execute(session);
         next_step = PROCESS_CLIENT_COMMAND;
         break;
       }
       case PROCESS_CLIENT_COMMAND: {
         VLOG(1) << "Processing Client Command";
         ProcessClientCommand(session);
         next_step = VERIFY_UPDATES;
         break;
@@ skipping 36 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