[Sync] Made some sync session member functions const

chrome/browser/sync/sessions/status_controller.h

 // 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.
 
 // StatusController handles all counter and status related number crunching and
 // state tracking on behalf of a SyncSession.  It 'controls' the model data
 // defined in session_state.h.  The most important feature of StatusController
 // is the ScopedModelSafetyRestriction. When one of these is active, the
 // underlying data set exposed via accessors is swapped out to the appropriate
 // set for the restricted ModelSafeGroup behind the scenes.  For example, if
@@ skipping 18 matching lines @@
 // so that various parts of the sync engine can avoid broadcasting
 // notifications if no changes occurred.
 
 #ifndef CHROME_BROWSER_SYNC_SESSIONS_STATUS_CONTROLLER_H_
 #define CHROME_BROWSER_SYNC_SESSIONS_STATUS_CONTROLLER_H_
 #pragma once
 
 #include <vector>
 #include <map>
 
+#include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/time.h"
 #include "chrome/browser/sync/sessions/ordered_commit_set.h"
 #include "chrome/browser/sync/sessions/session_state.h"
 
 namespace browser_sync {
 namespace sessions {
 
 class StatusController {
  public:
   explicit StatusController(const ModelSafeRoutingInfo& routes);
   ~StatusController();
 
   // Returns true if some portion of the session state has changed (is dirty)
   // since it was created or was last reset.
   bool TestAndClearIsDirty();
 
-  // Progress counters.
-  const ConflictProgress& conflict_progress() {
-    return GetOrCreateModelSafeGroupState(true,
-        group_restriction_)->conflict_progress;
-  }
-  ConflictProgress* mutable_conflict_progress() {
-    return &GetOrCreateModelSafeGroupState(true,
-        group_restriction_)->conflict_progress;
-  }
-  const UpdateProgress& update_progress() {
-    return GetOrCreateModelSafeGroupState(true,
-        group_restriction_)->update_progress;
-  }
-  UpdateProgress* mutable_update_progress() {
-    return &GetOrCreateModelSafeGroupState(true,
-        group_restriction_)->update_progress;
-  }
-  // Some unrestricted, non-ModelChangingSyncerCommand commands need to store
-  // meta information about updates.
-  UpdateProgress* GetUnrestrictedUpdateProgress(ModelSafeGroup group) {
-    return &GetOrCreateModelSafeGroupState(false, group)->update_progress;
-  }
+  // Progress counters.  All const methods may return NULL if the
+  // progress structure doesn't exist, but all non-const methods
+  // auto-create.
+  const ConflictProgress* conflict_progress() const;
+  ConflictProgress* mutable_conflict_progress();
+  const UpdateProgress* update_progress() const;
+  UpdateProgress* mutable_update_progress();
+  const ConflictProgress* GetUnrestrictedConflictProgress(
+      ModelSafeGroup group) const;
+  const UpdateProgress* GetUnrestrictedUpdateProgress(
+      ModelSafeGroup group) const;
 
   // ClientToServer messages.
   const ClientToServerMessage& commit_message() {
     return shared_.commit_message;
   }
   ClientToServerMessage* mutable_commit_message() {
     return &shared_.commit_message;
   }
   const ClientToServerResponse& commit_response() const {
     return shared_.commit_response;
@@ skipping 34 matching lines @@
   }
   const OrderedCommitSet::Projection& commit_id_projection() {
     DCHECK(group_restriction_in_effect_)
         << "No group restriction for projection.";
     return shared_.commit_set.GetCommitIdProjection(group_restriction_);
   }
   const syncable::Id& GetCommitIdAt(size_t index) {
     DCHECK(CurrentCommitIdProjectionHasIndex(index));
     return shared_.commit_set.GetCommitIdAt(index);
   }
-  syncable::ModelType GetCommitIdModelTypeAt(size_t index) {
+  syncable::ModelType GetCommitModelTypeAt(size_t index) {
     DCHECK(CurrentCommitIdProjectionHasIndex(index));
     return shared_.commit_set.GetModelTypeAt(index);
   }
+  syncable::ModelType GetUnrestrictedCommitModelTypeAt(size_t index) const {
+    DCHECK(!group_restriction_in_effect_) << "Group restriction in effect!";
+    return shared_.commit_set.GetModelTypeAt(index);
+  }
   const std::vector<int64>& unsynced_handles() const {
     DCHECK(!group_restriction_in_effect_)
         << "unsynced_handles is unrestricted.";
     return shared_.unsynced_handles.value();
   }
 
   // Control parameters for sync cycles.
   bool conflict_sets_built() const {
     return shared_.control_params.conflict_sets_built;
   }
@@ skipping 88 matching lines @@
   void set_commit_set(const OrderedCommitSet& commit_set);
   void update_conflict_sets_built(bool built);
   void update_conflicts_resolved(bool resolved);
   void reset_conflicts_resolved();
   void set_items_committed();
 
   void SetSyncInProgressAndUpdateStartTime(bool sync_in_progress);
 
   void set_debug_info_sent();
 
-  bool debug_info_sent();
+  bool debug_info_sent() const;
 
  private:
   friend class ScopedModelSafeGroupRestriction;
 
   // Returns true iff the commit id projection for |group_restriction_|
   // references position |index| into the full set of commit ids in play.
   bool CurrentCommitIdProjectionHasIndex(size_t index);
 
+  // Returns the state, if it exists, or NULL otherwise.
+  const PerModelSafeGroupState* GetModelSafeGroupState(
+      bool restrict, ModelSafeGroup group) const;
+
   // Helper to lazily create objects for per-ModelSafeGroup state.
-  PerModelSafeGroupState* GetOrCreateModelSafeGroupState(bool restrict,
-                                                         ModelSafeGroup group);
+  PerModelSafeGroupState* GetOrCreateModelSafeGroupState(
+      bool restrict, ModelSafeGroup group);
 
   AllModelTypeState shared_;
   std::map<ModelSafeGroup, PerModelSafeGroupState*> per_model_group_;
 
   STLValueDeleter<std::map<ModelSafeGroup, PerModelSafeGroupState*> >
       per_model_group_deleter_;
 
   // Set to true if any DirtyOnWrite pieces of state we maintain are changed.
   // Reset to false by TestAndClearIsDirty.
   bool is_dirty_;
@@ skipping 27 matching lines @@
   }
  private:
   StatusController* status_;
   DISALLOW_COPY_AND_ASSIGN(ScopedModelSafeGroupRestriction);
 };
 
 }
 }
 
 #endif  // CHROME_BROWSER_SYNC_SESSIONS_STATUS_CONTROLLER_H_