[Sync] Made some sync session member functions const

chrome/browser/sync/sessions/status_controller.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/sessions/status_controller.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "chrome/browser/sync/protocol/sync_protocol_error.h"
@@ skipping 15 matching lines @@
 }
 
 StatusController::~StatusController() {}
 
 bool StatusController::TestAndClearIsDirty() {
   bool is_dirty = is_dirty_;
   is_dirty_ = false;
   return is_dirty;
 }
 
+const UpdateProgress* StatusController::update_progress() const {
+  const PerModelSafeGroupState* state =
+      GetModelSafeGroupState(true, group_restriction_);
+  return state ? &state->update_progress : NULL;
+}
+
+UpdateProgress* StatusController::mutable_update_progress() {
+  return &GetOrCreateModelSafeGroupState(
+      true, group_restriction_)->update_progress;
+}
+
+const ConflictProgress* StatusController::conflict_progress() const {
+  const PerModelSafeGroupState* state =
+      GetModelSafeGroupState(true, group_restriction_);
+  return state ? &state->conflict_progress : NULL;
+}
+
+ConflictProgress* StatusController::mutable_conflict_progress() {
+  return &GetOrCreateModelSafeGroupState(
+      true, group_restriction_)->conflict_progress;
+}
+
+const ConflictProgress* StatusController::GetUnrestrictedConflictProgress(
+    ModelSafeGroup group) const {
+  const PerModelSafeGroupState* state =
+      GetModelSafeGroupState(false, group);
+  return state ? &state->conflict_progress : NULL;
+}
+
+const UpdateProgress* StatusController::GetUnrestrictedUpdateProgress(
+    ModelSafeGroup group) const {
+  const PerModelSafeGroupState* state =
+      GetModelSafeGroupState(false, group);
+  return state ? &state->update_progress : NULL;
+}
+
+const PerModelSafeGroupState* StatusController::GetModelSafeGroupState(
+    bool restrict, ModelSafeGroup group) const {
+  DCHECK_EQ(restrict, group_restriction_in_effect_);
+  std::map<ModelSafeGroup, PerModelSafeGroupState*>::const_iterator it =
+      per_model_group_.find(group);
+  return (it == per_model_group_.end()) ? NULL : it->second;
+}
+
 PerModelSafeGroupState* StatusController::GetOrCreateModelSafeGroupState(
     bool restrict, ModelSafeGroup group) {
-  DCHECK(restrict == group_restriction_in_effect_) << "Group violation!";
-  if (per_model_group_.find(group) == per_model_group_.end()) {
+  DCHECK_EQ(restrict, group_restriction_in_effect_);
+  std::map<ModelSafeGroup, PerModelSafeGroupState*>::iterator it =
+      per_model_group_.find(group);
+  if (it == per_model_group_.end()) {
     PerModelSafeGroupState* state = new PerModelSafeGroupState(&is_dirty_);
-    per_model_group_[group] = state;
-    return state;
+    it = per_model_group_.insert(std::make_pair(group, state)).first;
   }
-  return per_model_group_[group];
+  return it->second;
 }
 
 void StatusController::increment_num_conflicting_commits_by(int value) {
   if (value == 0)
     return;
   shared_.error.mutate()->num_conflicting_commits += value;
 }
 
 void StatusController::increment_num_updates_downloaded_by(int value) {
   shared_.syncer_status.mutate()->num_updates_downloaded_total += value;
@@ skipping 184 matching lines @@
   }
   // Changes remaining is an estimate, but if it's estimated to be
   // zero, that's firm and we don't have to ask again.
   return updates_response().get_updates().changes_remaining() == 0;
 }
 
 void StatusController::set_debug_info_sent() {
   shared_.control_params.debug_info_sent = true;
 }
 
-bool StatusController::debug_info_sent() {
+bool StatusController::debug_info_sent() const {
   return shared_.control_params.debug_info_sent;
 }
 
 }  // namespace sessions
 }  // namespace browser_sync