Rename InvalidationVersionTracker to InvalidationStateTracker in preparation

sync/notifier/chrome_invalidation_client.cc

 // Copyright (c) 2012 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 "sync/notifier/chrome_invalidation_client.h"
 
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
@@ skipping 30 matching lines @@
   DCHECK(non_thread_safe_.CalledOnValidThread());
   Stop();
   DCHECK(!listener_);
   DCHECK(!state_writer_);
 }
 
 void ChromeInvalidationClient::Start(
     const std::string& client_id, const std::string& client_info,
     const std::string& state,
     const InvalidationVersionMap& initial_max_invalidation_versions,
-    const browser_sync::WeakHandle<InvalidationVersionTracker>&
-        invalidation_version_tracker,
+    const browser_sync::WeakHandle<InvalidationStateTracker>&
+        invalidation_state_tracker,
     Listener* listener,
     StateWriter* state_writer,
     base::WeakPtr<buzz::XmppTaskParentInterface> base_task) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   Stop();
 
   chrome_system_resources_.set_platform(client_info);
   chrome_system_resources_.Start();
 
   // The Storage resource is implemented as a write-through cache.  We populate
   // it with the initial state on startup, so subsequent writes go to disk and
   // update the in-memory cache, while reads just return the cached state.
   chrome_system_resources_.storage()->SetInitialState(state);
 
   max_invalidation_versions_ = initial_max_invalidation_versions;
   if (max_invalidation_versions_.empty()) {
     DVLOG(2) << "No initial max invalidation versions for any type";
   } else {
     for (InvalidationVersionMap::const_iterator it =
              max_invalidation_versions_.begin();
          it != max_invalidation_versions_.end(); ++it) {
       DVLOG(2) << "Initial max invalidation version for "
                << syncable::ModelTypeToString(it->first) << " is "
                << it->second;
     }
   }
-  invalidation_version_tracker_ = invalidation_version_tracker;
-  DCHECK(invalidation_version_tracker_.IsInitialized());
+  invalidation_state_tracker_ = invalidation_state_tracker;
+  DCHECK(invalidation_state_tracker_.IsInitialized());
 
   DCHECK(!listener_);
   DCHECK(listener);
   listener_ = listener;
   DCHECK(!state_writer_);
   DCHECK(state_writer);
   state_writer_ = state_writer;
 
   int client_type = ipc::invalidation::ClientType::CHROME_SYNC;
   invalidation_client_.reset(
@@ skipping 26 matching lines @@
 
   registration_manager_.reset();
   cache_invalidation_packet_handler_.reset();
   chrome_system_resources_.Stop();
   invalidation_client_->Stop();
 
   invalidation_client_.reset();
   state_writer_ = NULL;
   listener_ = NULL;
 
-  invalidation_version_tracker_.Reset();
+  invalidation_state_tracker_.Reset();
   max_invalidation_versions_.clear();
 }
 
 void ChromeInvalidationClient::RegisterTypes(syncable::ModelTypeSet types) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   registered_types_ = types;
   if (ticl_ready_ && registration_manager_.get()) {
     registration_manager_->SetRegisteredTypes(registered_types_);
   }
   // TODO(akalin): Clear invalidation versions for unregistered types.
@@ skipping 33 matching lines @@
   if ((it != max_invalidation_versions_.end()) &&
       (invalidation.version() <= it->second)) {
     // Drop redundant invalidations.
     client->Acknowledge(ack_handle);
     return;
   }
   DVLOG(2) << "Setting max invalidation version for "
            << syncable::ModelTypeToString(model_type) << " to "
            << invalidation.version();
   max_invalidation_versions_[model_type] = invalidation.version();
-  invalidation_version_tracker_.Call(
+  invalidation_state_tracker_.Call(
       FROM_HERE,
-      &InvalidationVersionTracker::SetMaxVersion,
+      &InvalidationStateTracker::SetMaxVersion,
       model_type, invalidation.version());
 
   std::string payload;
   // payload() CHECK()'s has_payload(), so we must check it ourselves first.
   if (invalidation.has_payload())
     payload = invalidation.payload();
 
   EmitInvalidation(syncable::ModelTypeSet(model_type), payload);
   // TODO(akalin): We should really acknowledge only after we get the
   // updates from the sync server. (see http://crbug.com/78462).
@@ skipping 110 matching lines @@
   // TODO(ghc): handle the error.
 }
 
 void ChromeInvalidationClient::WriteState(const std::string& state) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(state_writer_);
   state_writer_->WriteState(state);
 }
 
 }  // namespace sync_notifier