Take 2: sync changes to support encryption

chrome/browser/sync/engine/build_and_process_conflict_sets_command.cc

 // Copyright (c) 2006-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 file.
 
 #include "chrome/browser/sync/engine/build_and_process_conflict_sets_command.h"
 
 #include <string>
 #include <sstream>
 #include <vector>
 
@@ skipping 29 matching lines @@
   syncable::ScopedDirLookup dir(session->context()->directory_manager(),
                                 session->context()->account_name());
   if (!dir.good())
     return false;
   bool had_single_direction_sets = false;
   {  // Scope for transaction.
     syncable::WriteTransaction trans(dir, syncable::SYNCER, __FILE__, __LINE__);
     BuildConflictSets(&trans,
         session->status_controller()->mutable_conflict_progress());
     had_single_direction_sets = ProcessSingleDirectionConflictSets(&trans,
-        session->context()->resolver(), session->status_controller(),
-        session->routing_info());
+        session->context()->resolver(),
+        session->context()->directory_manager()->cryptographer(),
+        session->status_controller(), session->routing_info());
     // We applied some updates transactionally, lets try syncing again.
     if (had_single_direction_sets)
       return true;
   }
   return false;
 }
 
 bool BuildAndProcessConflictSetsCommand::ProcessSingleDirectionConflictSets(
     syncable::WriteTransaction* trans, ConflictResolver* resolver,
-    StatusController* status, const ModelSafeRoutingInfo& routes) {
+    Cryptographer* cryptographer, StatusController* status,
+    const ModelSafeRoutingInfo& routes) {
   bool rv = false;
   set<ConflictSet*>::const_iterator all_sets_iterator;
   for (all_sets_iterator = status->conflict_progress().ConflictSetsBegin();
        all_sets_iterator != status->conflict_progress().ConflictSetsEnd();) {
     const ConflictSet* conflict_set = *all_sets_iterator;
     CHECK(conflict_set->size() >= 2);
     // We scan the set to see if it consists of changes of only one type.
     ConflictSet::const_iterator i;
     size_t unsynced_count = 0, unapplied_count = 0;
     for (i = conflict_set->begin(); i != conflict_set->end(); ++i) {
       syncable::Entry entry(trans, syncable::GET_BY_ID, *i);
       CHECK(entry.good());
       if (entry.Get(syncable::IS_UNSYNCED))
         unsynced_count++;
       if (entry.Get(syncable::IS_UNAPPLIED_UPDATE))
         unapplied_count++;
     }
     if (conflict_set->size() == unsynced_count && 0 == unapplied_count) {
       LOG(INFO) << "Skipped transactional commit attempt.";
     } else if (conflict_set->size() == unapplied_count && 0 == unsynced_count &&
-          ApplyUpdatesTransactionally(trans, conflict_set, resolver, routes,
-                                      status)) {
+          ApplyUpdatesTransactionally(trans, conflict_set, resolver,
+                                      cryptographer, routes, status)) {
       rv = true;
     }
     ++all_sets_iterator;
   }
   return rv;
 }
 
 namespace {
 
 void StoreLocalDataForUpdateRollback(syncable::Entry* entry,
@@ skipping 45 matching lines @@
     entry.Put(syncable::PARENT_ID, trans->root_id());
     }
   }
 
 }  // namespace
 
 bool BuildAndProcessConflictSetsCommand::ApplyUpdatesTransactionally(
     syncable::WriteTransaction* trans,
     const vector<syncable::Id>* const update_set,
     ConflictResolver* resolver,
+    Cryptographer* cryptographer,
     const ModelSafeRoutingInfo& routes,
     StatusController* status) {
   // The handles in the |update_set| order.
   vector<int64> handles;
 
   // Holds the same Ids as update_set, but sorted so that runs of adjacent
   // nodes appear in order.
   vector<syncable::Id> rollback_ids;
   rollback_ids.reserve(update_set->size());
 
@@ skipping 26 matching lines @@
 
   // 4. Use the preparer to move things to an initial starting state where
   // nothing in the set is a child of anything else.  If
   // we've correctly calculated the set, the server tree is valid and no
   // changes have occurred locally we should be able to apply updates from this
   // state.
   PlaceEntriesAtRoot(trans, update_set);
 
   // 5. Use the usual apply updates from the special start state we've just
   // prepared.
-  UpdateApplicator applicator(resolver, handles.begin(), handles.end(),
-      routes, status->group_restriction());
+  UpdateApplicator applicator(resolver, cryptographer,
+                              handles.begin(), handles.end(),
+                              routes, status->group_restriction());
   while (applicator.AttemptOneApplication(trans)) {
     // Keep going till all updates are applied.
   }
   if (!applicator.AllUpdatesApplied()) {
     LOG(ERROR) << "Transactional Apply Failed, Rolling back.";
     // We have to move entries into the temp dir again. e.g. if a swap was in a
     // set with other failing updates, the swap may have gone through, meaning
     // the roll back needs to be transactional. But as we're going to a known
     // good state we should always succeed.
     PlaceEntriesAtRoot(trans, update_set);
@@ skipping 188 matching lines @@
     LocallyDeletedPathChecker checker;
     if (!checker.CausingConflict(parent, *entry))
       return;
     conflict_progress->MergeSets(entry->Get(syncable::ID),
                                  parent.Get(syncable::ID));
     CrawlDeletedTreeMergingSets(trans, parent, conflict_progress, checker);
   }
 }
 
 }  // namespace browser_sync