[Sync] Made some sync session member functions const

chrome/browser/sync/engine/build_and_process_conflict_sets_command.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/build_and_process_conflict_sets_command.h"
 
 #include <set>
 #include <string>
 #include <sstream>
 #include <vector>
@@ skipping 14 matching lines @@
 using sessions::UpdateProgress;
 using std::set;
 using std::string;
 using std::vector;
 
 BuildAndProcessConflictSetsCommand::BuildAndProcessConflictSetsCommand() {}
 BuildAndProcessConflictSetsCommand::~BuildAndProcessConflictSetsCommand() {}
 
 void BuildAndProcessConflictSetsCommand::ModelChangingExecuteImpl(
     SyncSession* session) {
-  session->status_controller()->update_conflict_sets_built(
+  session->mutable_status_controller()->update_conflict_sets_built(
       BuildAndProcessConflictSets(session));
 }
 
 bool BuildAndProcessConflictSetsCommand::BuildAndProcessConflictSets(
     SyncSession* session) {
   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(FROM_HERE, syncable::SYNCER, dir);
     BuildConflictSets(&trans,
-        session->status_controller()->mutable_conflict_progress());
+        session->mutable_status_controller()->mutable_conflict_progress());
     had_single_direction_sets = ProcessSingleDirectionConflictSets(&trans,
         session->context()->resolver(),
         session->context()->directory_manager()->GetCryptographer(&trans),
-        session->status_controller(), session->routing_info());
+        session->mutable_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,
     Cryptographer* cryptographer, StatusController* status,
     const ModelSafeRoutingInfo& routes) {
+  if (!status->conflict_progress())
+    return false;
   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();) {
+  for (all_sets_iterator = status->conflict_progress()->ConflictSetsBegin();
+       all_sets_iterator != status->conflict_progress()->ConflictSetsEnd();) {
     const ConflictSet* conflict_set = *all_sets_iterator;
     CHECK_GE(conflict_set->size(), 2U);
     // 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++;
@@ skipping 141 matching lines @@
   }
   applicator.SaveProgressIntoSessionState(status->mutable_conflict_progress(),
                                           status->mutable_update_progress());
   return true;
 }
 
 void BuildAndProcessConflictSetsCommand::BuildConflictSets(
     syncable::BaseTransaction* trans,
     ConflictProgress* conflict_progress) {
   conflict_progress->CleanupSets();
-  set<syncable::Id>::iterator i = conflict_progress->ConflictingItemsBegin();
+  set<syncable::Id>::const_iterator i =
+      conflict_progress->ConflictingItemsBegin();
   while (i != conflict_progress->ConflictingItemsEnd()) {
     syncable::Entry entry(trans, syncable::GET_BY_ID, *i);
     if (!entry.good() ||
         (!entry.Get(syncable::IS_UNSYNCED) &&
          !entry.Get(syncable::IS_UNAPPLIED_UPDATE))) {
       // This can happen very rarely. It means we had a simply conflicting item
       // that randomly committed; its ID could have changed during the commit.
       // We drop the entry as it's no longer conflicting.
       conflict_progress->EraseConflictingItemById(*(i++));
       continue;
@@ skipping 161 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