Rename InvalidationVersionTracker to InvalidationStateTracker in preparation

to add more methods to that class.

BUG=124140
Review URL: https://chromiumcodereview.appspot.com/10407014

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@137685 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/sync/glue/sync_backend_host.cc

@@ -312,7 +312,7 @@ SyncBackendHost::SyncBackendHost(Profile* profile)
           ParseNotifierOptions(*CommandLine::ForCurrentProcess(),
                                profile_->GetRequestContext()),
           content::GetUserAgent(GURL()),
-          base::WeakPtr<sync_notifier::InvalidationVersionTracker>()),
+          base::WeakPtr<sync_notifier::InvalidationStateTracker>()),
       frontend_(NULL) {
 }
 

chrome/browser/sync/sync_prefs.h

@@ -14,7 +14,7 @@
 #include "base/time.h"
 #include "chrome/browser/prefs/pref_member.h"
 #include "content/public/browser/notification_observer.h"
-#include "sync/notifier/invalidation_version_tracker.h"
+#include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/syncable/model_type.h"
 
 class PrefService;
@@ -45,7 +45,7 @@ class SyncPrefObserver {
 //   sync_setup_wizard_unittest.cc
 //   two_client_preferences_sync_test.cc
 class SyncPrefs : public base::SupportsWeakPtr<SyncPrefs>,
-                  public sync_notifier::InvalidationVersionTracker,
+                  public sync_notifier::InvalidationStateTracker,
                   public content::NotificationObserver {
  public:
   // |pref_service| may be NULL (for unit tests), but in that case no
@@ -106,7 +106,7 @@ class SyncPrefs : public base::SupportsWeakPtr<SyncPrefs>,
   void SetSpareBootstrapToken(const std::string& token);
 #endif
 
-  // InvalidationVersionTracker implementation.
+  // InvalidationStateTracker implementation.
   virtual sync_notifier::InvalidationVersionMap
       GetAllMaxVersions() const OVERRIDE;
   virtual void SetMaxVersion(syncable::ModelType model_type,

sync/notifier/chrome_invalidation_client.cc

@@ -48,8 +48,8 @@ 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) {
@@ -76,8 +76,8 @@ void ChromeInvalidationClient::Start(
                << 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);
@@ -124,7 +124,7 @@ void ChromeInvalidationClient::Stop() {
   state_writer_ = NULL;
   listener_ = NULL;
 
-  invalidation_version_tracker_.Reset();
+  invalidation_state_tracker_.Reset();
   max_invalidation_versions_.clear();
 }
 
@@ -178,9 +178,9 @@ void ChromeInvalidationClient::Invalidate(
            << 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;

sync/notifier/chrome_invalidation_client.h

@@ -18,7 +18,7 @@
 #include "base/threading/non_thread_safe.h"
 #include "google/cacheinvalidation/include/invalidation-listener.h"
 #include "sync/notifier/chrome_system_resources.h"
-#include "sync/notifier/invalidation_version_tracker.h"
+#include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/notifier/state_writer.h"
 #include "sync/syncable/model_type.h"
 #include "sync/syncable/model_type_payload_map.h"
@@ -57,14 +57,14 @@ class ChromeInvalidationClient
   virtual ~ChromeInvalidationClient();
 
   // Does not take ownership of |listener| or |state_writer|.
-  // |invalidation_version_tracker| must be initialized.
+  // |invalidation_state_tracker| must be initialized.
   // |base_task| must still be non-NULL.
   void 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);
@@ -122,8 +122,8 @@ class ChromeInvalidationClient
   base::NonThreadSafe non_thread_safe_;
   ChromeSystemResources chrome_system_resources_;
   InvalidationVersionMap max_invalidation_versions_;
-  browser_sync::WeakHandle<InvalidationVersionTracker>
-      invalidation_version_tracker_;
+  browser_sync::WeakHandle<InvalidationStateTracker>
+      invalidation_state_tracker_;
   Listener* listener_;
   StateWriter* state_writer_;
   scoped_ptr<invalidation::InvalidationClient> invalidation_client_;

sync/notifier/chrome_invalidation_client_unittest.cc

@@ -46,9 +46,9 @@ class MockListener : public ChromeInvalidationClient::Listener {
   MOCK_METHOD1(OnSessionStatusChanged, void(bool));
 };
 
-class MockInvalidationVersionTracker
-    : public InvalidationVersionTracker,
-      public base::SupportsWeakPtr<MockInvalidationVersionTracker> {
+class MockInvalidationStateTracker
+    : public InvalidationStateTracker,
+      public base::SupportsWeakPtr<MockInvalidationStateTracker> {
  public:
   MOCK_CONST_METHOD0(GetAllMaxVersions, InvalidationVersionMap());
   MOCK_METHOD2(SetMaxVersion, void(syncable::ModelType, int64));
@@ -67,7 +67,7 @@ class ChromeInvalidationClientTest : public testing::Test {
     client_.Start(kClientId, kClientInfo, kState,
                   InvalidationVersionMap(),
                   browser_sync::MakeWeakHandle(
-                      mock_invalidation_version_tracker_.AsWeakPtr()),
+                      mock_invalidation_state_tracker_.AsWeakPtr()),
                   &mock_listener_, &mock_state_writer_,
                   fake_base_task_.AsWeakPtr());
   }
@@ -98,7 +98,7 @@ class ChromeInvalidationClientTest : public testing::Test {
     EXPECT_CALL(mock_invalidation_client_, Acknowledge(ack_handle));
     client_.Invalidate(&mock_invalidation_client_, inv, ack_handle);
     // Pump message loop to trigger
-    // InvalidationVersionTracker::SetMaxVersion().
+    // InvalidationStateTracker::SetMaxVersion().
     message_loop_.RunAllPending();
   }
 
@@ -121,8 +121,8 @@ class ChromeInvalidationClientTest : public testing::Test {
 
   MessageLoop message_loop_;
   StrictMock<MockListener> mock_listener_;
-  StrictMock<MockInvalidationVersionTracker>
-      mock_invalidation_version_tracker_;
+  StrictMock<MockInvalidationStateTracker>
+      mock_invalidation_state_tracker_;
   StrictMock<MockStateWriter> mock_state_writer_;
   StrictMock<MockInvalidationClient> mock_invalidation_client_;
   notifier::FakeBaseTask fake_base_task_;
@@ -156,7 +156,7 @@ TEST_F(ChromeInvalidationClientTest, InvalidateBadObjectId) {
 TEST_F(ChromeInvalidationClientTest, InvalidateNoPayload) {
   EXPECT_CALL(mock_listener_,
               OnInvalidate(MakeMap(syncable::BOOKMARKS, "")));
-  EXPECT_CALL(mock_invalidation_version_tracker_,
+  EXPECT_CALL(mock_invalidation_state_tracker_,
               SetMaxVersion(syncable::BOOKMARKS, 1));
   FireInvalidate("BOOKMARK", 1, NULL);
 }
@@ -164,7 +164,7 @@ TEST_F(ChromeInvalidationClientTest, InvalidateNoPayload) {
 TEST_F(ChromeInvalidationClientTest, InvalidateWithPayload) {
   EXPECT_CALL(mock_listener_,
               OnInvalidate(MakeMap(syncable::PREFERENCES, "payload")));
-  EXPECT_CALL(mock_invalidation_version_tracker_,
+  EXPECT_CALL(mock_invalidation_state_tracker_,
               SetMaxVersion(syncable::PREFERENCES, 1));
   FireInvalidate("PREFERENCE", 1, "payload");
 }
@@ -174,7 +174,7 @@ TEST_F(ChromeInvalidationClientTest, InvalidateVersion) {
 
   EXPECT_CALL(mock_listener_,
               OnInvalidate(MakeMap(syncable::APPS, "")));
-  EXPECT_CALL(mock_invalidation_version_tracker_,
+  EXPECT_CALL(mock_invalidation_state_tracker_,
               SetMaxVersion(syncable::APPS, 1));
 
   // Should trigger.
@@ -207,9 +207,9 @@ TEST_F(ChromeInvalidationClientTest, InvalidateVersionMultipleTypes) {
   EXPECT_CALL(mock_listener_,
               OnInvalidate(MakeMap(syncable::EXTENSIONS, "")));
 
-  EXPECT_CALL(mock_invalidation_version_tracker_,
+  EXPECT_CALL(mock_invalidation_state_tracker_,
               SetMaxVersion(syncable::APPS, 3));
-  EXPECT_CALL(mock_invalidation_version_tracker_,
+  EXPECT_CALL(mock_invalidation_state_tracker_,
               SetMaxVersion(syncable::EXTENSIONS, 2));
 
   // Should trigger both.
@@ -217,21 +217,21 @@ TEST_F(ChromeInvalidationClientTest, InvalidateVersionMultipleTypes) {
   FireInvalidate("EXTENSION", 2, NULL);
 
   Mock::VerifyAndClearExpectations(&mock_listener_);
-  Mock::VerifyAndClearExpectations(&mock_invalidation_version_tracker_);
+  Mock::VerifyAndClearExpectations(&mock_invalidation_state_tracker_);
 
   // Should both be dropped.
   FireInvalidate("APP", 1, NULL);
   FireInvalidate("EXTENSION", 1, NULL);
 
   Mock::VerifyAndClearExpectations(&mock_listener_);
-  Mock::VerifyAndClearExpectations(&mock_invalidation_version_tracker_);
+  Mock::VerifyAndClearExpectations(&mock_invalidation_state_tracker_);
 
   // InvalidateAll shouldn't change any version state.
   EXPECT_CALL(mock_listener_, OnInvalidate(MakeMapFromSet(types, "")));
   FireInvalidateAll();
 
   Mock::VerifyAndClearExpectations(&mock_listener_);
-  Mock::VerifyAndClearExpectations(&mock_invalidation_version_tracker_);
+  Mock::VerifyAndClearExpectations(&mock_invalidation_state_tracker_);
 
   EXPECT_CALL(mock_listener_,
               OnInvalidate(MakeMap(syncable::PREFERENCES, "")));
@@ -240,11 +240,11 @@ TEST_F(ChromeInvalidationClientTest, InvalidateVersionMultipleTypes) {
   EXPECT_CALL(mock_listener_,
               OnInvalidate(MakeMap(syncable::APPS, "")));
 
-  EXPECT_CALL(mock_invalidation_version_tracker_,
+  EXPECT_CALL(mock_invalidation_state_tracker_,
               SetMaxVersion(syncable::PREFERENCES, 5));
-  EXPECT_CALL(mock_invalidation_version_tracker_,
+  EXPECT_CALL(mock_invalidation_state_tracker_,
               SetMaxVersion(syncable::EXTENSIONS, 3));
-  EXPECT_CALL(mock_invalidation_version_tracker_,
+  EXPECT_CALL(mock_invalidation_state_tracker_,
               SetMaxVersion(syncable::APPS, 4));
 
   // Should trigger all three.

sync/notifier/invalidation_notifier.cc

@@ -19,13 +19,13 @@ namespace sync_notifier {
 InvalidationNotifier::InvalidationNotifier(
     const notifier::NotifierOptions& notifier_options,
     const InvalidationVersionMap& initial_max_invalidation_versions,
-    const browser_sync::WeakHandle<InvalidationVersionTracker>&
-        invalidation_version_tracker,
+    const browser_sync::WeakHandle<InvalidationStateTracker>&
+        invalidation_state_tracker,
     const std::string& client_info)
     : state_(STOPPED),
       notifier_options_(notifier_options),
       initial_max_invalidation_versions_(initial_max_invalidation_versions),
-      invalidation_version_tracker_(invalidation_version_tracker),
+      invalidation_state_tracker_(invalidation_state_tracker),
       client_info_(client_info) {
   DCHECK_EQ(notifier::NOTIFICATION_SERVER,
             notifier_options.notification_method);
@@ -111,7 +111,7 @@ void InvalidationNotifier::OnConnect(
     invalidation_client_.Start(
         invalidation_client_id_, client_info_, invalidation_state_,
         initial_max_invalidation_versions_,
-        invalidation_version_tracker_,
+        invalidation_state_tracker_,
         this, this, base_task);
     invalidation_state_.clear();
     state_ = STARTED;

sync/notifier/invalidation_notifier.h

@@ -23,7 +23,7 @@
 #include "jingle/notifier/base/notifier_options.h"
 #include "jingle/notifier/communicator/login.h"
 #include "sync/notifier/chrome_invalidation_client.h"
-#include "sync/notifier/invalidation_version_tracker.h"
+#include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/notifier/state_writer.h"
 #include "sync/notifier/sync_notifier.h"
 #include "sync/syncable/model_type.h"
@@ -38,12 +38,12 @@ class InvalidationNotifier
       public ChromeInvalidationClient::Listener,
       public StateWriter {
  public:
-  // |invalidation_version_tracker| must be initialized.
+  // |invalidation_state_tracker| must be initialized.
   InvalidationNotifier(
       const notifier::NotifierOptions& notifier_options,
       const InvalidationVersionMap& initial_max_invalidation_versions,
-      const browser_sync::WeakHandle<InvalidationVersionTracker>&
-          invalidation_version_tracker,
+      const browser_sync::WeakHandle<InvalidationStateTracker>&
+          invalidation_state_tracker,
       const std::string& client_info);
 
   virtual ~InvalidationNotifier();
@@ -94,8 +94,8 @@ class InvalidationNotifier
   const InvalidationVersionMap initial_max_invalidation_versions_;
 
   // Passed to |invalidation_client_|.
-  const browser_sync::WeakHandle<InvalidationVersionTracker>
-      invalidation_version_tracker_;
+  const browser_sync::WeakHandle<InvalidationStateTracker>
+      invalidation_state_tracker_;
 
   // Passed to |invalidation_client_|.
   const std::string client_info_;

sync/notifier/invalidation_notifier_unittest.cc

@@ -9,7 +9,7 @@
 #include "jingle/notifier/base/fake_base_task.h"
 #include "jingle/notifier/base/notifier_options.h"
 #include "net/url_request/url_request_test_util.h"
-#include "sync/notifier/invalidation_version_tracker.h"
+#include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/notifier/mock_sync_notifier_observer.h"
 #include "sync/syncable/model_type.h"
 #include "sync/syncable/model_type_payload_map.h"
@@ -36,7 +36,7 @@ class InvalidationNotifierTest : public testing::Test {
             notifier_options,
             InvalidationVersionMap(),
             browser_sync::MakeWeakHandle(
-                base::WeakPtr<InvalidationVersionTracker>()),
+                base::WeakPtr<InvalidationStateTracker>()),
             "fake_client_info"));
     invalidation_notifier_->AddObserver(&mock_observer_);
   }

sync/notifier/invalidation_version_tracker.h → sync/notifier/invalidation_state_tracker.h

@@ -5,8 +5,8 @@
 // An InvalidationVersionTracker is an interface that handles getting
 // and setting (persisting) max invalidation versions.
 
-#ifndef SYNC_NOTIFIER_INVALIDATION_VERSION_TRACKER_H_
-#define SYNC_NOTIFIER_INVALIDATION_VERSION_TRACKER_H_
+#ifndef SYNC_NOTIFIER_INVALIDATION_STATE_TRACKER_H_
+#define SYNC_NOTIFIER_INVALIDATION_STATE_TRACKER_H_
 
 #include <map>
 
@@ -17,9 +17,9 @@ namespace sync_notifier {
 
 typedef std::map<syncable::ModelType, int64> InvalidationVersionMap;
 
-class InvalidationVersionTracker {
+class InvalidationStateTracker {
  public:
-  InvalidationVersionTracker() {}
+  InvalidationStateTracker() {}
 
   virtual InvalidationVersionMap GetAllMaxVersions() const = 0;
 
@@ -29,10 +29,9 @@ class InvalidationVersionTracker {
                              int64 max_version) = 0;
 
  protected:
-  virtual ~InvalidationVersionTracker() {}
+  virtual ~InvalidationStateTracker() {}
 };
 
 }  // namespace sync_notifier
 
-#endif  // SYNC_NOTIFIER_INVALIDATION_VERSION_TRACKER_H_
-
+#endif  // SYNC_NOTIFIER_INVALIDATION_STATE_TRACKER_H_

sync/notifier/non_blocking_invalidation_notifier.cc

@@ -26,8 +26,8 @@ class NonBlockingInvalidationNotifier::Core
   void Initialize(
       const notifier::NotifierOptions& notifier_options,
       const InvalidationVersionMap& initial_max_invalidation_versions,
-      const browser_sync::WeakHandle<InvalidationVersionTracker>&
-          invalidation_version_tracker,
+      const browser_sync::WeakHandle<InvalidationStateTracker>&
+          invalidation_state_tracker,
       const std::string& client_info);
   void Teardown();
   void SetUniqueId(const std::string& unique_id);
@@ -69,8 +69,8 @@ NonBlockingInvalidationNotifier::Core::~Core() {
 void NonBlockingInvalidationNotifier::Core::Initialize(
     const notifier::NotifierOptions& notifier_options,
     const InvalidationVersionMap& initial_max_invalidation_versions,
-    const browser_sync::WeakHandle<InvalidationVersionTracker>&
-        invalidation_version_tracker,
+    const browser_sync::WeakHandle<InvalidationStateTracker>&
+        invalidation_state_tracker,
     const std::string& client_info) {
   DCHECK(notifier_options.request_context_getter);
   DCHECK_EQ(notifier::NOTIFICATION_SERVER,
@@ -82,7 +82,7 @@ void NonBlockingInvalidationNotifier::Core::Initialize(
       new InvalidationNotifier(
           notifier_options,
           initial_max_invalidation_versions,
-          invalidation_version_tracker,
+          invalidation_state_tracker,
           client_info));
   invalidation_notifier_->AddObserver(this);
 }
@@ -147,8 +147,8 @@ void NonBlockingInvalidationNotifier::Core::StoreState(
 NonBlockingInvalidationNotifier::NonBlockingInvalidationNotifier(
     const notifier::NotifierOptions& notifier_options,
     const InvalidationVersionMap& initial_max_invalidation_versions,
-    const browser_sync::WeakHandle<InvalidationVersionTracker>&
-        invalidation_version_tracker,
+    const browser_sync::WeakHandle<InvalidationStateTracker>&
+        invalidation_state_tracker,
     const std::string& client_info)
         : weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
           core_(
@@ -165,7 +165,7 @@ NonBlockingInvalidationNotifier::NonBlockingInvalidationNotifier(
               core_.get(),
               notifier_options,
               initial_max_invalidation_versions,
-              invalidation_version_tracker,
+              invalidation_state_tracker,
               client_info))) {
     NOTREACHED();
   }

sync/notifier/non_blocking_invalidation_notifier.h

@@ -17,7 +17,7 @@
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "jingle/notifier/base/notifier_options.h"
-#include "sync/notifier/invalidation_version_tracker.h"
+#include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/notifier/sync_notifier.h"
 #include "sync/notifier/sync_notifier_observer.h"
 #include "sync/util/weak_handle.h"
@@ -32,12 +32,12 @@ class NonBlockingInvalidationNotifier
     : public SyncNotifier,
       public SyncNotifierObserver {
  public:
-  // |invalidation_version_tracker| must be initialized.
+  // |invalidation_state_tracker| must be initialized.
   NonBlockingInvalidationNotifier(
       const notifier::NotifierOptions& notifier_options,
       const InvalidationVersionMap& initial_max_invalidation_versions,
-      const browser_sync::WeakHandle<InvalidationVersionTracker>&
-          invalidation_version_tracker,
+      const browser_sync::WeakHandle<InvalidationStateTracker>&
+          invalidation_state_tracker,
       const std::string& client_info);
 
   virtual ~NonBlockingInvalidationNotifier();

sync/notifier/non_blocking_invalidation_notifier_unittest.cc

@@ -10,7 +10,7 @@
 #include "base/threading/thread.h"
 #include "jingle/notifier/base/fake_base_task.h"
 #include "net/url_request/url_request_test_util.h"
-#include "sync/notifier/invalidation_version_tracker.h"
+#include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/notifier/mock_sync_notifier_observer.h"
 #include "sync/syncable/model_type.h"
 #include "sync/syncable/model_type_payload_map.h"
@@ -43,7 +43,7 @@ class NonBlockingInvalidationNotifierTest : public testing::Test {
             notifier_options,
             InvalidationVersionMap(),
             browser_sync::MakeWeakHandle(
-                base::WeakPtr<sync_notifier::InvalidationVersionTracker>()),
+                base::WeakPtr<sync_notifier::InvalidationStateTracker>()),
             "fake_client_info"));
     invalidation_notifier_->AddObserver(&mock_observer_);
   }

sync/notifier/sync_notifier_factory.cc

@@ -17,8 +17,8 @@ namespace {
 SyncNotifier* CreateDefaultSyncNotifier(
     const notifier::NotifierOptions& notifier_options,
     const InvalidationVersionMap& initial_max_invalidation_versions,
-    const browser_sync::WeakHandle<InvalidationVersionTracker>&
-        invalidation_version_tracker,
+    const browser_sync::WeakHandle<InvalidationStateTracker>&
+        invalidation_state_tracker,
     const std::string& client_info) {
   if (notifier_options.notification_method == notifier::NOTIFICATION_P2P) {
     // TODO(rlarocque): Ideally, the notification target would be
@@ -30,7 +30,7 @@ SyncNotifier* CreateDefaultSyncNotifier(
 
   return new NonBlockingInvalidationNotifier(
       notifier_options, initial_max_invalidation_versions,
-      invalidation_version_tracker, client_info);
+      invalidation_state_tracker, client_info);
 }
 
 }  // namespace
@@ -39,15 +39,15 @@ SyncNotifier* CreateDefaultSyncNotifier(
 SyncNotifierFactory::SyncNotifierFactory(
     const notifier::NotifierOptions& notifier_options,
     const std::string& client_info,
-    const base::WeakPtr<InvalidationVersionTracker>&
-        invalidation_version_tracker)
+    const base::WeakPtr<InvalidationStateTracker>&
+        invalidation_state_tracker)
     : notifier_options_(notifier_options),
       client_info_(client_info),
       initial_max_invalidation_versions_(
-          invalidation_version_tracker.get() ?
-          invalidation_version_tracker->GetAllMaxVersions() :
+          invalidation_state_tracker.get() ?
+          invalidation_state_tracker->GetAllMaxVersions() :
           InvalidationVersionMap()),
-      invalidation_version_tracker_(invalidation_version_tracker) {
+      invalidation_state_tracker_(invalidation_state_tracker) {
 }
 
 SyncNotifierFactory::~SyncNotifierFactory() {
@@ -60,7 +60,7 @@ SyncNotifier* SyncNotifierFactory::CreateSyncNotifier() {
 #else
   return CreateDefaultSyncNotifier(notifier_options_,
                                    initial_max_invalidation_versions_,
-                                   invalidation_version_tracker_,
+                                   invalidation_state_tracker_,
                                    client_info_);
 #endif
 }

sync/notifier/sync_notifier_factory.h

@@ -9,7 +9,7 @@
 
 #include "base/memory/weak_ptr.h"
 #include "jingle/notifier/base/notifier_options.h"
-#include "sync/notifier/invalidation_version_tracker.h"
+#include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/util/weak_handle.h"
 
 namespace sync_notifier {
@@ -21,13 +21,13 @@ class SyncNotifier;
 class SyncNotifierFactory {
  public:
   // |client_info| is a string identifying the client, e.g. a user
-  // agent string.  |invalidation_version_tracker| may be NULL (for
+  // agent string.  |invalidation_state_tracker| may be NULL (for
   // tests).
   SyncNotifierFactory(
       const notifier::NotifierOptions& notifier_options,
       const std::string& client_info,
-      const base::WeakPtr<InvalidationVersionTracker>&
-          invalidation_version_tracker);
+      const base::WeakPtr<InvalidationStateTracker>&
+          invalidation_state_tracker);
   ~SyncNotifierFactory();
 
   // Creates a sync notifier. Caller takes ownership of the returned
@@ -39,8 +39,8 @@ class SyncNotifierFactory {
   const notifier::NotifierOptions notifier_options_;
   const std::string client_info_;
   const InvalidationVersionMap initial_max_invalidation_versions_;
-  const browser_sync::WeakHandle<InvalidationVersionTracker>
-      invalidation_version_tracker_;
+  const browser_sync::WeakHandle<InvalidationStateTracker>
+      invalidation_state_tracker_;
 };
 
 }  // namespace sync_notifier

sync/notifier/sync_notifier_factory_unittest.cc

@@ -14,7 +14,7 @@
 #include "jingle/notifier/base/notification_method.h"
 #include "jingle/notifier/base/notifier_options.h"
 #include "net/url_request/url_request_test_util.h"
-#include "sync/notifier/invalidation_version_tracker.h"
+#include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/notifier/mock_sync_notifier_observer.h"
 #include "sync/notifier/sync_notifier.h"
 #include "sync/syncable/model_type.h"
@@ -54,7 +54,7 @@ TEST_F(SyncNotifierFactoryTest, Basic) {
   SyncNotifierFactory factory(
       notifier_options_,
       "test client info",
-      base::WeakPtr<sync_notifier::InvalidationVersionTracker>());
+      base::WeakPtr<sync_notifier::InvalidationStateTracker>());
   scoped_ptr<SyncNotifier> notifier(factory.CreateSyncNotifier());
 #if defined(OS_ANDROID)
   ASSERT_FALSE(notifier.get());
@@ -71,7 +71,7 @@ TEST_F(SyncNotifierFactoryTest, Basic_P2P) {
   SyncNotifierFactory factory(
       notifier_options_,
       "test client info",
-      base::WeakPtr<sync_notifier::InvalidationVersionTracker>());
+      base::WeakPtr<sync_notifier::InvalidationStateTracker>());
   scoped_ptr<SyncNotifier> notifier(factory.CreateSyncNotifier());
 #if defined(OS_ANDROID)
   ASSERT_FALSE(notifier.get());

sync/sync.gyp

@@ -223,7 +223,7 @@
             'notifier/invalidation_notifier.cc',
             'notifier/invalidation_util.cc',
             'notifier/invalidation_util.h',
-            'notifier/invalidation_version_tracker.h',
+            'notifier/invalidation_state_tracker.h',
             'notifier/non_blocking_invalidation_notifier.h',
             'notifier/non_blocking_invalidation_notifier.cc',
             'notifier/p2p_notifier.h',

sync/tools/sync_listen_notifications.cc

@@ -19,7 +19,7 @@
 #include "jingle/notifier/base/notifier_options.h"
 #include "net/base/host_port_pair.h"
 #include "net/url_request/url_request_test_util.h"
-#include "sync/notifier/invalidation_version_tracker.h"
+#include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/notifier/sync_notifier.h"
 #include "sync/notifier/sync_notifier_factory.h"
 #include "sync/notifier/sync_notifier_observer.h"
@@ -65,12 +65,12 @@ class NotificationPrinter : public sync_notifier::SyncNotifierObserver {
   DISALLOW_COPY_AND_ASSIGN(NotificationPrinter);
 };
 
-class NullInvalidationVersionTracker
-    : public base::SupportsWeakPtr<NullInvalidationVersionTracker>,
-      public sync_notifier::InvalidationVersionTracker {
+class NullInvalidationStateTracker
+    : public base::SupportsWeakPtr<NullInvalidationStateTracker>,
+      public sync_notifier::InvalidationStateTracker {
  public:
-  NullInvalidationVersionTracker() {}
-  virtual ~NullInvalidationVersionTracker() {}
+  NullInvalidationStateTracker() {}
+  virtual ~NullInvalidationStateTracker() {}
 
   virtual sync_notifier::InvalidationVersionMap
       GetAllMaxVersions() const OVERRIDE {
@@ -171,10 +171,10 @@ int main(int argc, char* argv[]) {
           command_line,
           new TestURLRequestContextGetter(io_thread.message_loop_proxy()));
   const char kClientInfo[] = "sync_listen_notifications";
-  NullInvalidationVersionTracker null_invalidation_version_tracker;
+  NullInvalidationStateTracker null_invalidation_state_tracker;
   sync_notifier::SyncNotifierFactory sync_notifier_factory(
       notifier_options, kClientInfo,
-      null_invalidation_version_tracker.AsWeakPtr());
+      null_invalidation_state_tracker.AsWeakPtr());
   scoped_ptr<sync_notifier::SyncNotifier> sync_notifier(
       sync_notifier_factory.CreateSyncNotifier());
   NotificationPrinter notification_printer;