Remove unique naming.

chrome/browser/sync/engine/syncer.cc

 // Copyright (c) 2009 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 entry.
 
 #include "chrome/browser/sync/engine/syncer.h"
 
 #include "base/format_macros.h"
 #include "base/message_loop.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/sync/engine/apply_updates_command.h"
 #include "chrome/browser/sync/engine/build_and_process_conflict_sets_command.h"
 #include "chrome/browser/sync/engine/build_commit_command.h"
 #include "chrome/browser/sync/engine/conflict_resolver.h"
 #include "chrome/browser/sync/engine/download_updates_command.h"
 #include "chrome/browser/sync/engine/get_commit_ids_command.h"
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/post_commit_message_command.h"
 #include "chrome/browser/sync/engine/process_commit_response_command.h"
 #include "chrome/browser/sync/engine/process_updates_command.h"
 #include "chrome/browser/sync/engine/resolve_conflicts_command.h"
 #include "chrome/browser/sync/engine/syncer_end_command.h"
 #include "chrome/browser/sync/engine/syncer_types.h"
 #include "chrome/browser/sync/engine/syncer_util.h"
 #include "chrome/browser/sync/engine/syncproto.h"
 #include "chrome/browser/sync/engine/verify_updates_command.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/syncable-inl.h"
 #include "chrome/browser/sync/syncable/syncable.h"
+#include "chrome/browser/sync/util/closure.h"
 
 using sync_pb::ClientCommand;
 using syncable::Blob;
 using syncable::IS_UNAPPLIED_UPDATE;
 using syncable::SERVER_BOOKMARK_FAVICON;
 using syncable::SERVER_BOOKMARK_URL;
 using syncable::SERVER_CTIME;
 using syncable::SERVER_IS_BOOKMARK_OBJECT;
 using syncable::SERVER_IS_DEL;
 using syncable::SERVER_IS_DIR;
 using syncable::SERVER_MTIME;
-using syncable::SERVER_NAME;
 using syncable::SERVER_NON_UNIQUE_NAME;
 using syncable::SERVER_PARENT_ID;
 using syncable::SERVER_POSITION_IN_PARENT;
 using syncable::SERVER_VERSION;
 using syncable::SYNCER;
 using syncable::ScopedDirLookup;
 using syncable::WriteTransaction;
 
 namespace browser_sync {
 
 Syncer::Syncer(
     syncable::DirectoryManager* dirman,
     const PathString& account_name,
     ServerConnectionManager* connection_manager,
     ModelSafeWorker* model_safe_worker)
     : account_name_(account_name),
       early_exit_requested_(false),
       max_commit_batch_size_(kDefaultMaxCommitBatchSize),
       connection_manager_(connection_manager),
       dirman_(dirman),
       command_channel_(NULL),
       model_safe_worker_(model_safe_worker),
       updates_source_(sync_pb::GetUpdatesCallerInfo::UNKNOWN),
       notifications_enabled_(false),
-      pre_conflict_resolution_function_(NULL) {
+      pre_conflict_resolution_closure_(NULL) {
   SyncerEvent shutdown = { SyncerEvent::SHUTDOWN_USE_WITH_CARE };
   syncer_event_channel_.reset(new SyncerEventChannel(shutdown));
   shutdown_channel_.reset(new ShutdownChannel(this));
 
   extensions_monitor_ = new ExtensionsActivityMonitor();
 
   ScopedDirLookup dir(dirman_, account_name_);
   // The directory must be good here.
   CHECK(dir.good());
 }
@@ skipping 162 matching lines @@
         build_process_conflict_sets.Execute(session);
         if (session->conflict_sets_built())
           next_step = SYNCER_END;
         else
           next_step = RESOLVE_CONFLICTS;
         break;
       }
       case RESOLVE_CONFLICTS: {
         LOG(INFO) << "Resolving Conflicts";
 
-        // Trigger the pre_conflict_resolution_function_, which is a testing
+        // Trigger the pre_conflict_resolution_closure_, which is a testing
         // hook for the unit tests, if it is non-NULL.
-        if (pre_conflict_resolution_function_) {
-          ScopedDirLookup dir(dirman_, account_name_);
-          if (!dir.good()) {
-            LOG(ERROR) << "Bad dir lookup in syncer loop";
-            return;
-          }
-          pre_conflict_resolution_function_(dir);
+        if (pre_conflict_resolution_closure_) {
+          pre_conflict_resolution_closure_->Run();
         }
 
         ResolveConflictsCommand resolve_conflicts_command;
         resolve_conflicts_command.Execute(session);
         if (session->HasConflictingUpdates())
           next_step = APPLY_UPDATES_TO_RESOLVE_CONFLICTS;
         else
           next_step = SYNCER_END;
         break;
       }
@@ skipping 38 matching lines @@
   const ClientCommand command = session->update_response().client_command();
   if (command_channel_)
     command_channel_->NotifyListeners(&command);
 
   // The server limits the number of items a client can commit in one batch.
   if (command.has_max_commit_batch_size())
     max_commit_batch_size_ = command.max_commit_batch_size();
 }
 
 void CopyServerFields(syncable::Entry* src, syncable::MutableEntry* dest) {
-  dest->Put(SERVER_NAME, src->Get(SERVER_NAME));
   dest->Put(SERVER_NON_UNIQUE_NAME, src->Get(SERVER_NON_UNIQUE_NAME));
   dest->Put(SERVER_PARENT_ID, src->Get(SERVER_PARENT_ID));
   dest->Put(SERVER_MTIME, src->Get(SERVER_MTIME));
   dest->Put(SERVER_CTIME, src->Get(SERVER_CTIME));
   dest->Put(SERVER_VERSION, src->Get(SERVER_VERSION));
   dest->Put(SERVER_IS_DIR, src->Get(SERVER_IS_DIR));
   dest->Put(SERVER_IS_DEL, src->Get(SERVER_IS_DEL));
   dest->Put(SERVER_IS_BOOKMARK_OBJECT, src->Get(SERVER_IS_BOOKMARK_OBJECT));
   dest->Put(IS_UNAPPLIED_UPDATE, src->Get(IS_UNAPPLIED_UPDATE));
   dest->Put(SERVER_BOOKMARK_URL, src->Get(SERVER_BOOKMARK_URL));
   dest->Put(SERVER_BOOKMARK_FAVICON, src->Get(SERVER_BOOKMARK_FAVICON));
   dest->Put(SERVER_POSITION_IN_PARENT, src->Get(SERVER_POSITION_IN_PARENT));
 }
 
 void ClearServerData(syncable::MutableEntry* entry) {
-  entry->Put(SERVER_NAME, PSTR(""));
   entry->Put(SERVER_NON_UNIQUE_NAME, PSTR(""));
   entry->Put(SERVER_PARENT_ID, syncable::kNullId);
   entry->Put(SERVER_MTIME, 0);
   entry->Put(SERVER_CTIME, 0);
   entry->Put(SERVER_VERSION, 0);
   entry->Put(SERVER_IS_DIR, false);
   entry->Put(SERVER_IS_DEL, false);
   entry->Put(SERVER_IS_BOOKMARK_OBJECT, false);
   entry->Put(IS_UNAPPLIED_UPDATE, false);
   entry->Put(SERVER_BOOKMARK_URL, PSTR(""));
@@ skipping 11 matching lines @@
                       entry.id_string().c_str(),
                       entry.parent_id_string().c_str(),
                       entry.version(),
                       entry.mtime(), ServerTimeToClientTime(entry.mtime()),
                       entry.ctime(), ServerTimeToClientTime(entry.ctime()),
                       entry.name().c_str(), entry.sync_timestamp(),
                       entry.deleted() ? "deleted, ":"");
 }
 
 }  // namespace browser_sync