sync: add a SyncSessionJobPurpose for clearing sync user data.

chrome/browser/sync/engine/syncer.cc

 // Copyright (c) 2010 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 "chrome/browser/sync/engine/apply_updates_command.h"
 #include "chrome/browser/sync/engine/build_and_process_conflict_sets_command.h"
@@ skipping 52 matching lines @@
 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;
 }
 
+// TODO(tim): Deprecated.
 void Syncer::SyncShare(sessions::SyncSession* session) {
   ScopedDirLookup dir(session->context()->directory_manager(),
                       session->context()->account_name());
   // The directory must be good here.
   CHECK(dir.good());
 
   const sessions::SyncSourceInfo& source(session->source());
   if (sync_pb::GetUpdatesCallerInfo::CLEAR_PRIVATE_DATA ==
       source.updates_source) {
     SyncShare(session, CLEAR_PRIVATE_DATA, SYNCER_END);
     return;
   } else {
-    // 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
-    // the commit request fails (e.g. due to lost connection), as we will
-    // fall all the way back to the syncer thread main loop in that case, and
-    // wind up creating a new session when a connection is established, losing
-    // the records set here on the original attempt.  This should provide us
-    // with the right data "most of the time", and we're only using this for
-    // analysis purposes, so Law of Large Numbers FTW.
-    session->context()->extensions_monitor()->GetAndClearRecords(
-        session->mutable_extensions_activity());
     SyncShare(session, SYNCER_BEGIN, SYNCER_END);
   }
 }
 
 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());
+
   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";
+        // 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
+        // the commit request fails (e.g. due to lost connection), as we will
+        // fall all the way back to the syncer thread main loop in that case,
+        // creating a new session when a connection is established, losing the
+        // records set here on the original attempt.  This should provide us
+        // with the right data "most of the time", and we're only using this
+        // for analysis purposes, so Law of Large Numbers FTW.
+        session->context()->extensions_monitor()->GetAndClearRecords(
+            session->mutable_extensions_activity());
         next_step = CLEANUP_DISABLED_TYPES;
         break;
       case CLEANUP_DISABLED_TYPES: {
         VLOG(1) << "Cleaning up disabled types";
         CleanupDisabledTypesCommand cleanup;
         cleanup.Execute(session);
         next_step = DOWNLOAD_UPDATES;
         break;
       }
       case DOWNLOAD_UPDATES: {
@@ skipping 201 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