[Sync] Add RequestCleanupDisabledTypes() method to SyncManager

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 54 matching lines @@
   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,
-                       const SyncerStep first_step,
-                       const SyncerStep last_step) {
-  ScopedDirLookup dir(session->context()->directory_manager(),
-                      session->context()->account_name());
-  // The directory must be good here.
-  CHECK(dir.good());
+                       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_);
   SyncerStep current_step = first_step;
 
   SyncerStep next_step = current_step;
   while (!ExitRequested()) {
     switch (current_step) {
       case SYNCER_BEGIN:
         VLOG(1) << "Syncer Begin";
@@ skipping 55 matching lines @@
           next_step = APPLY_UPDATES;
         } else {
           next_step = DOWNLOAD_UPDATES;
         }
         break;
       }
       case APPLY_UPDATES: {
         VLOG(1) << "Applying Updates";
         ApplyUpdatesCommand apply_updates;
         apply_updates.Execute(session);
-        next_step = BUILD_COMMIT_REQUEST;
+        if (last_step == APPLY_UPDATES) {
+          // We're in configuration mode, but we still need to run the
+          // SYNCER_END step.
+          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());
@@ skipping 90 matching lines @@
         break;
       }
       case CLEAR_PRIVATE_DATA: {
         VLOG(1) << "Clear Private Data";
         ClearDataCommand clear_data_command;
         clear_data_command.Execute(session);
         next_step = SYNCER_END;
         break;
       }
       case SYNCER_END: {
+        VLOG(1) << "Syncer End";
+        SyncerEndCommand syncer_end_command;
+        syncer_end_command.Execute(session);
+        next_step = SYNCER_END;
         break;
       }
       default:
         LOG(ERROR) << "Unknown command: " << current_step;
     }
     VLOG(2) << "last step: " << last_step << ", current step: "
             << current_step << ", next step: "
             << next_step << ", snapshot: "
             << session->TakeSnapshot().ToString();
     if (last_step == current_step)
       break;
     current_step = next_step;
   }
-
-  VLOG(1) << "Syncer End";
-  VLOG(2) << "last step: " << last_step << ", current step: "
-          << current_step << ", next step: "
-          << next_step << ", snapshot: "
-          << session->TakeSnapshot().ToString();
-  SyncerEndCommand syncer_end_command;
-  syncer_end_command.Execute(session);
-  return;
 }
 
 void Syncer::ProcessClientCommand(sessions::SyncSession* session) {
   const ClientToServerResponse& response =
       session->status_controller()->updates_response();
   if (!response.has_client_command())
     return;
   const ClientCommand& command = response.client_command();
 
   // The server limits the number of items a client can commit in one batch.
@@ skipping 31 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