[Sync] Made some sync session member functions const

chrome/browser/sync/engine/syncer.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/syncer.h"
 
 #include "base/debug/trace_event.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 66 matching lines @@
     ENUM_CASE(CLEAR_PRIVATE_DATA);
     ENUM_CASE(SYNCER_END);
   }
   NOTREACHED();
   return "";
 }
 #undef ENUM_CASE
 
 Syncer::ScopedSyncStartStopTracker::ScopedSyncStartStopTracker(
     sessions::SyncSession* session) : session_(session) {
-  session_->status_controller()->SetSyncInProgressAndUpdateStartTime(true);
+  session_->mutable_status_controller()->
+      SetSyncInProgressAndUpdateStartTime(true);
 }
 
 Syncer::ScopedSyncStartStopTracker::~ScopedSyncStartStopTracker() {
-  session_->status_controller()->SetSyncInProgressAndUpdateStartTime(false);
+  session_->mutable_status_controller()->
+      SetSyncInProgressAndUpdateStartTime(false);
 }
 
 Syncer::Syncer()
     : early_exit_requested_(false),
       pre_conflict_resolution_closure_(NULL) {
 }
 
 Syncer::~Syncer() {}
 
 bool Syncer::ExitRequested() {
@@ skipping 70 matching lines @@
         ProcessUpdatesCommand process_updates;
         process_updates.Execute(session);
         next_step = STORE_TIMESTAMPS;
         break;
       }
       case STORE_TIMESTAMPS: {
         StoreTimestampsCommand store_timestamps;
         store_timestamps.Execute(session);
         // We should download all of the updates before attempting to process
         // them.
-        if (session->status_controller()->ServerSaysNothingMoreToDownload() ||
-            !session->status_controller()->download_updates_succeeded()) {
+        if (session->status_controller().ServerSaysNothingMoreToDownload() ||
+            !session->status_controller().download_updates_succeeded()) {
           next_step = APPLY_UPDATES;
         } else {
           next_step = DOWNLOAD_UPDATES;
         }
         break;
       }
       case APPLY_UPDATES: {
         ApplyUpdatesCommand apply_updates;
         apply_updates.Execute(session);
         if (last_step == APPLY_UPDATES) {
@@ skipping 16 matching lines @@
           return;
         }
         WriteTransaction trans(FROM_HERE, SYNCER, dir);
         sessions::ScopedSetSessionWriteTransaction set_trans(session, &trans);
 
         VLOG(1) << "Getting the Commit IDs";
         GetCommitIdsCommand get_commit_ids_command(
             session->context()->max_commit_batch_size());
         get_commit_ids_command.Execute(session);
 
-        if (!session->status_controller()->commit_ids().empty()) {
+        if (!session->status_controller().commit_ids().empty()) {
           VLOG(1) << "Building a commit message";
           BuildCommitCommand build_commit_command;
           build_commit_command.Execute(session);
 
           next_step = POST_COMMIT_MESSAGE;
         } else {
           next_step = BUILD_AND_PROCESS_CONFLICT_SETS;
         }
 
         break;
       }
       case POST_COMMIT_MESSAGE: {
         PostCommitMessageCommand post_commit_command;
         post_commit_command.Execute(session);
         next_step = PROCESS_COMMIT_RESPONSE;
         break;
       }
       case PROCESS_COMMIT_RESPONSE: {
-        session->status_controller()->reset_num_conflicting_commits();
+        session->mutable_status_controller()->reset_num_conflicting_commits();
         ProcessCommitResponseCommand process_response_command;
         process_response_command.Execute(session);
         next_step = BUILD_AND_PROCESS_CONFLICT_SETS;
         break;
       }
       case BUILD_AND_PROCESS_CONFLICT_SETS: {
         BuildAndProcessConflictSetsCommand build_process_conflict_sets;
         build_process_conflict_sets.Execute(session);
-        if (session->status_controller()->conflict_sets_built())
+        if (session->status_controller().conflict_sets_built())
           next_step = SYNCER_END;
         else
           next_step = RESOLVE_CONFLICTS;
         break;
       }
       case RESOLVE_CONFLICTS: {
 
         // Trigger the pre_conflict_resolution_closure_, which is a testing
         // hook for the unit tests, if it is non-NULL.
         if (pre_conflict_resolution_closure_) {
           pre_conflict_resolution_closure_->Run();
         }
 
-        StatusController* status = session->status_controller();
+        StatusController* status = session->mutable_status_controller();
         status->reset_conflicts_resolved();
         ResolveConflictsCommand resolve_conflicts_command;
         resolve_conflicts_command.Execute(session);
 
         // Has ConflictingUpdates includes both blocking and non-blocking
         // conflicts. If we have either, we want to attempt to reapply.
         if (status->HasConflictingUpdates())
           next_step = APPLY_UPDATES_TO_RESOLVE_CONFLICTS;
         else
           next_step = SYNCER_END;
         break;
       }
       case APPLY_UPDATES_TO_RESOLVE_CONFLICTS: {
-        StatusController* status = session->status_controller();
+        StatusController* status = session->mutable_status_controller();
         VLOG(1) << "Applying updates to resolve conflicts";
         ApplyUpdatesCommand apply_updates;
 
         // We only care to resolve conflicts again if we made progress on the
         // blocking conflicts. Whether or not we made progress on the
         // non-blocking doesn't matter.
         int before_blocking_conflicting_updates =
             status->TotalNumBlockingConflictingItems();
         apply_updates.Execute(session);
         int after_blocking_conflicting_updates =
@@ skipping 26 matching lines @@
         << "next step: " << SyncerStepToString(next_step) << ", "
         << "snapshot: " << session->TakeSnapshot().ToString();
     if (last_step == current_step)
       break;
     current_step = next_step;
   }
 }
 
 void Syncer::ProcessClientCommand(sessions::SyncSession* session) {
   const ClientToServerResponse& response =
-      session->status_controller()->updates_response();
+      session->status_controller().updates_response();
   if (!response.has_client_command())
     return;
   const ClientCommand& command = response.client_command();
 
   // The server limits the number of items a client can commit in one batch.
   if (command.has_max_commit_batch_size()) {
     session->context()->set_max_commit_batch_size(
         command.max_commit_batch_size());
   }
   if (command.has_set_sync_long_poll_interval()) {
@@ skipping 31 matching lines @@
   entry->Put(SERVER_CTIME, Time());
   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