Remove context-based dependencies on SyncerSession from ApplyUpdatesCommand....

chrome/browser/sync/engine/syncer_util.cc

 // Copyright (c) 2006-2008 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_util.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "chrome/browser/sync/engine/conflict_resolver.h"
 #include "chrome/browser/sync/engine/syncer_proto_util.h"
-#include "chrome/browser/sync/engine/syncer_session.h"
 #include "chrome/browser/sync/engine/syncer_types.h"
 #include "chrome/browser/sync/engine/syncproto.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/sync/syncable/syncable_changes_version.h"
 #include "chrome/browser/sync/util/character_set_converters.h"
 #include "chrome/browser/sync/util/path_helpers.h"
 #include "chrome/browser/sync/util/sync_types.h"
 
 using syncable::BASE_VERSION;
@@ skipping 189 matching lines @@
     // !local_entry.Good() means we don't have a left behind entry for this
     // ID. We successfully committed before. In the future we should get rid
     // of this system and just have client side generated IDs as a whole.
   }
 }
 
 // static
 UpdateAttemptResponse SyncerUtil::AttemptToUpdateEntry(
     syncable::WriteTransaction* const trans,
     syncable::MutableEntry* const entry,
-    SyncerSession* const session) {
+    ConflictResolver* resolver) {
 
   syncable::Id conflicting_id;
   UpdateAttemptResponse result =
-     AttemptToUpdateEntryWithoutMerge(trans, entry, session,
-                                      &conflicting_id);
+     AttemptToUpdateEntryWithoutMerge(trans, entry, &conflicting_id);
   if (result != NAME_CONFLICT) {
     return result;
   }
   syncable::MutableEntry same_path(trans, syncable::GET_BY_ID, conflicting_id);
   CHECK(same_path.good());
 
-  ConflictResolver* resolver = session->resolver();
-
   if (resolver &&
       resolver->AttemptItemMerge(trans, &same_path, entry)) {
     return SUCCESS;
   }
   LOG(INFO) << "Not updating item, path collision. Update:\n" << *entry
             << "\nSame Path:\n" << same_path;
   return CONFLICT;
 }
 
 // static
 UpdateAttemptResponse SyncerUtil::AttemptToUpdateEntryWithoutMerge(
     syncable::WriteTransaction* const trans,
     syncable::MutableEntry* const entry,
-    SyncerSession* const session, syncable::Id* const conflicting_id) {
+    syncable::Id* const conflicting_id) {
 
   CHECK(entry->good());
   if (!entry->Get(IS_UNAPPLIED_UPDATE))
     return SUCCESS;  // No work to do.
   syncable::Id id = entry->Get(ID);
 
   if (entry->Get(IS_UNSYNCED)) {
     LOG(INFO) << "Skipping update, returning conflict for: " << id
               << " ; it's unsynced.";
     return CONFLICT;
@@ skipping 572 matching lines @@
 
     // |update_entry| is considered to be somewhere after |candidate|, so store
     // it as the upper bound.
     closest_sibling = candidate.Get(ID);
   }
 
   return closest_sibling;
 }
 
 }  // namespace browser_sync