Revert 264226 "Reduce dependency of TiclInvalidationService on P..."

This caused a clang compile error:

../../sync/tools/sync_client.cc:278:43:error: no matching constructor for initialization of 'syncer::NonBlockingInvalidator'
  scoped_ptr<Invalidator> invalidator(new NonBlockingInvalidator(
 

> Reduce dependency of TiclInvalidationService on Profile
> 
> With this CL, a URLRequestContext and an InvalidationStateTracker are
> passed to TiclInvalidationService as explicit dependencies. This reduces
> the dependency of TiclInvalidationService on Profile, taking a step toward
> eventually removing the dependency altogether.
> 
> BUG=358696
> TEST=Updated unit tests
> 
> Review URL: https://codereview.chromium.org/221963003

TBR=bartfab@chromium.org

Review URL: https://codereview.chromium.org/240153005

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

16 files changed, 98 insertions, 177 deletions

diff --git a/chrome/browser/invalidation/invalidation_service_factory.cc b/chrome/browser/invalidation/invalidation_service_factory.cc
index 91ea1fd..ef34d2e 100644
--- a/chrome/browser/invalidation/invalidation_service_factory.cc
+++ b/chrome/browser/invalidation/invalidation_service_factory.cc
@@ -4,7 +4,6 @@
 
 #include "chrome/browser/invalidation/invalidation_service_factory.h"
 
-#include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_registry.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/invalidation/fake_invalidation_service.h"
@@ -23,8 +22,6 @@
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/user_prefs/pref_registry_syncable.h"
-#include "net/url_request/url_request_context_getter.h"
-#include "sync/notifier/invalidation_state_tracker.h"
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/invalidation/invalidation_controller_android.h"
@@ -118,12 +115,9 @@ KeyedService* InvalidationServiceFactory::BuildServiceInstanceFor(
         LoginUIServiceFactory::GetForProfile(profile)));
   }
 
-  TiclInvalidationService* service = new TiclInvalidationService(
-      auth_provider.Pass(),
-      profile->GetRequestContext(),
-      profile);
-  service->Init(scoped_ptr<syncer::InvalidationStateTracker>(
-      new InvalidatorStorage(profile->GetPrefs())));
+  TiclInvalidationService* service =
+      new TiclInvalidationService(auth_provider.Pass(), profile);
+  service->Init();
   return service;
 #endif
 }
diff --git a/chrome/browser/invalidation/invalidation_service_test_template.h b/chrome/browser/invalidation/invalidation_service_test_template.h
index 124e837..05e9928 100644
--- a/chrome/browser/invalidation/invalidation_service_test_template.h
+++ b/chrome/browser/invalidation/invalidation_service_test_template.h
@@ -74,7 +74,6 @@
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "chrome/browser/invalidation/invalidation_service.h"
-#include "content/public/test/test_browser_thread_bundle.h"
 #include "google/cacheinvalidation/include/types.h"
 #include "google/cacheinvalidation/types.pb.h"
 #include "sync/internal_api/public/base/ack_handle.h"
@@ -101,7 +100,6 @@ class InvalidationServiceTest : public testing::Test {
     return this->delegate_.GetInvalidationService();
   }
 
-  content::TestBrowserThreadBundle thread_bundle_;
   InvalidatorTestDelegate delegate_;
 
   const invalidation::ObjectId id1;
diff --git a/chrome/browser/invalidation/invalidator_storage.cc b/chrome/browser/invalidation/invalidator_storage.cc
index bc2cb74..39e32b6 100644
--- a/chrome/browser/invalidation/invalidator_storage.cc
+++ b/chrome/browser/invalidation/invalidator_storage.cc
@@ -82,7 +82,7 @@ InvalidatorStorage::InvalidatorStorage(PrefService* pref_service)
 InvalidatorStorage::~InvalidatorStorage() {
 }
 
-void InvalidatorStorage::ClearAndSetNewClientId(const std::string& client_id) {
+void InvalidatorStorage::SetInvalidatorClientId(const std::string& client_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   Clear();  // We can't reuse our old invalidation state if the ID changes.
   pref_service_->SetString(prefs::kInvalidatorClientId, client_id);
diff --git a/chrome/browser/invalidation/invalidator_storage.h b/chrome/browser/invalidation/invalidator_storage.h
index 37ef025..75c3f90 100644
--- a/chrome/browser/invalidation/invalidator_storage.h
+++ b/chrome/browser/invalidation/invalidator_storage.h
@@ -11,6 +11,7 @@
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
+#include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/notifier/unacked_invalidation_set.h"
@@ -28,7 +29,8 @@ class PrefRegistrySyncable;
 
 namespace invalidation {
 
-class InvalidatorStorage : public syncer::InvalidationStateTracker {
+class InvalidatorStorage : public base::SupportsWeakPtr<InvalidatorStorage>,
+                           public syncer::InvalidationStateTracker {
  public:
   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
 
@@ -37,7 +39,7 @@ class InvalidatorStorage : public syncer::InvalidationStateTracker {
   virtual ~InvalidatorStorage();
 
   // InvalidationStateTracker implementation.
-  virtual void ClearAndSetNewClientId(const std::string& client_id) OVERRIDE;
+  virtual void SetInvalidatorClientId(const std::string& client_id) OVERRIDE;
   virtual std::string GetInvalidatorClientId() const OVERRIDE;
   virtual void SetBootstrapData(const std::string& data) OVERRIDE;
   virtual std::string GetBootstrapData() const OVERRIDE;
diff --git a/chrome/browser/invalidation/invalidator_storage_unittest.cc b/chrome/browser/invalidation/invalidator_storage_unittest.cc
index b587997..b09d8d5 100644
--- a/chrome/browser/invalidation/invalidator_storage_unittest.cc
+++ b/chrome/browser/invalidation/invalidator_storage_unittest.cc
@@ -32,7 +32,7 @@ TEST_F(InvalidatorStorageTest, Clear) {
   EXPECT_TRUE(storage.GetBootstrapData().empty());
   EXPECT_TRUE(storage.GetInvalidatorClientId().empty());
 
-  storage.ClearAndSetNewClientId("fake_id");
+  storage.SetInvalidatorClientId("fake_id");
   EXPECT_EQ("fake_id", storage.GetInvalidatorClientId());
 
   storage.SetBootstrapData("test");
@@ -48,7 +48,7 @@ TEST_F(InvalidatorStorageTest, SetGetNotifierClientId) {
   InvalidatorStorage storage(&pref_service_);
   const std::string client_id("fK6eDzAIuKqx9A4+93bljg==");
 
-  storage.ClearAndSetNewClientId(client_id);
+  storage.SetInvalidatorClientId(client_id);
   EXPECT_EQ(client_id, storage.GetInvalidatorClientId());
 }
 
diff --git a/chrome/browser/invalidation/ticl_invalidation_service.cc b/chrome/browser/invalidation/ticl_invalidation_service.cc
index 2f0569b..536d965 100644
--- a/chrome/browser/invalidation/ticl_invalidation_service.cc
+++ b/chrome/browser/invalidation/ticl_invalidation_service.cc
@@ -19,7 +19,6 @@
 #include "chrome/common/pref_names.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "google_apis/gaia/gaia_constants.h"
-#include "net/url_request/url_request_context_getter.h"
 #include "sync/notifier/gcm_network_channel_delegate.h"
 #include "sync/notifier/invalidation_util.h"
 #include "sync/notifier/invalidator.h"
@@ -63,7 +62,6 @@ namespace invalidation {
 
 TiclInvalidationService::TiclInvalidationService(
     scoped_ptr<InvalidationAuthProvider> auth_provider,
-    const scoped_refptr<net::URLRequestContextGetter>& request_context,
     Profile* profile)
     : OAuth2TokenService::Consumer("ticl_invalidation"),
       profile_(profile),
@@ -71,21 +69,20 @@ TiclInvalidationService::TiclInvalidationService(
       invalidator_registrar_(new syncer::InvalidatorRegistrar()),
       request_access_token_backoff_(&kRequestAccessTokenBackoffPolicy),
       network_channel_type_(PUSH_CLIENT_CHANNEL),
-      request_context_(request_context),
       logger_() {}
 
 TiclInvalidationService::~TiclInvalidationService() {
   DCHECK(CalledOnValidThread());
 }
 
-void TiclInvalidationService::Init(
-    scoped_ptr<syncer::InvalidationStateTracker> invalidation_state_tracker) {
+void TiclInvalidationService::Init() {
   DCHECK(CalledOnValidThread());
-  invalidation_state_tracker_ = invalidation_state_tracker.Pass();
 
-  if (invalidation_state_tracker_->GetInvalidatorClientId().empty()) {
-    invalidation_state_tracker_->ClearAndSetNewClientId(
-        GenerateInvalidatorClientId());
+  invalidator_storage_.reset(new InvalidatorStorage(profile_->GetPrefs()));
+  if (invalidator_storage_->GetInvalidatorClientId().empty()) {
+    // This also clears any existing state.  We can't reuse old invalidator
+    // state with the new ID anyway.
+    invalidator_storage_->SetInvalidatorClientId(GenerateInvalidatorClientId());
   }
 
   pref_change_registrar_.Init(profile_->GetPrefs());
@@ -111,13 +108,10 @@ void TiclInvalidationService::Init(
   auth_provider_->GetTokenService()->AddObserver(this);
 }
 
-void TiclInvalidationService::InitForTest(
-    scoped_ptr<syncer::InvalidationStateTracker> invalidation_state_tracker,
-    syncer::Invalidator* invalidator) {
+void TiclInvalidationService::InitForTest(syncer::Invalidator* invalidator) {
   // Here we perform the equivalent of Init() and StartInvalidator(), but with
   // some minor changes to account for the fact that we're injecting the
   // invalidator.
-  invalidation_state_tracker_ = invalidation_state_tracker.Pass();
   invalidator_.reset(invalidator);
 
   invalidator_->RegisterHandler(this);
@@ -175,7 +169,7 @@ syncer::InvalidatorState TiclInvalidationService::GetInvalidatorState() const {
 
 std::string TiclInvalidationService::GetInvalidatorClientId() const {
   DCHECK(CalledOnValidThread());
-  return invalidation_state_tracker_->GetInvalidatorClientId();
+  return invalidator_storage_->GetInvalidatorClientId();
 }
 
 InvalidationLogger* TiclInvalidationService::GetInvalidationLogger() {
@@ -286,11 +280,11 @@ void TiclInvalidationService::OnInvalidationAuthLogout() {
     StopInvalidator();
   }
 
-  // This service always expects to have a valid invalidation state. Thus, we
-  // must generate a new client ID to replace the existing one. Setting a new
-  // client ID also clears all other state.
-  invalidation_state_tracker_->
-      ClearAndSetNewClientId(GenerateInvalidatorClientId());
+  // This service always expects to have a valid invalidator storage.
+  // So we must not only clear the old one, but also start a new one.
+  invalidator_storage_->Clear();
+  invalidator_storage_.reset(new InvalidatorStorage(profile_->GetPrefs()));
+  invalidator_storage_->SetInvalidatorClientId(GenerateInvalidatorClientId());
 }
 
 void TiclInvalidationService::OnInvalidatorStateChange(
@@ -331,7 +325,7 @@ void TiclInvalidationService::Shutdown() {
   if (IsStarted()) {
     StopInvalidator();
   }
-  invalidation_state_tracker_.reset();
+  invalidator_storage_.reset();
   invalidator_registrar_.reset();
 }
 
@@ -371,8 +365,8 @@ void TiclInvalidationService::StartInvalidator(
     InvalidationNetworkChannel network_channel) {
   DCHECK(CalledOnValidThread());
   DCHECK(!invalidator_);
-  DCHECK(invalidation_state_tracker_);
-  DCHECK(!invalidation_state_tracker_->GetInvalidatorClientId().empty());
+  DCHECK(invalidator_storage_);
+  DCHECK(!invalidator_storage_->GetInvalidatorClientId().empty());
 
   // Request access token for PushClientChannel. GCMNetworkChannel will request
   // access token before sending message to server.
@@ -390,7 +384,7 @@ void TiclInvalidationService::StartInvalidator(
     case PUSH_CLIENT_CHANNEL: {
       notifier::NotifierOptions options =
           ParseNotifierOptions(*CommandLine::ForCurrentProcess());
-      options.request_context_getter = request_context_;
+      options.request_context_getter = profile_->GetRequestContext();
       options.auth_mechanism = "X-OAUTH2";
       network_channel_options_.SetString("Options.HostPort",
                                          options.xmpp_host_port.ToString());
@@ -408,7 +402,7 @@ void TiclInvalidationService::StartInvalidator(
           new GCMInvalidationBridge(gcm_profile_service, auth_provider_.get()));
       network_channel_creator =
           syncer::NonBlockingInvalidator::MakeGCMNetworkChannelCreator(
-              request_context_,
+              profile_->GetRequestContext(),
               gcm_invalidation_bridge_->CreateDelegate().Pass());
       break;
     }
@@ -419,12 +413,13 @@ void TiclInvalidationService::StartInvalidator(
   }
   invalidator_.reset(new syncer::NonBlockingInvalidator(
           network_channel_creator,
-          invalidation_state_tracker_->GetInvalidatorClientId(),
-          invalidation_state_tracker_->GetSavedInvalidations(),
-          invalidation_state_tracker_->GetBootstrapData(),
-          invalidation_state_tracker_.get(),
+          invalidator_storage_->GetInvalidatorClientId(),
+          invalidator_storage_->GetSavedInvalidations(),
+          invalidator_storage_->GetBootstrapData(),
+          syncer::WeakHandle<syncer::InvalidationStateTracker>(
+              invalidator_storage_->AsWeakPtr()),
           GetUserAgent(),
-          request_context_));
+          profile_->GetRequestContext()));
 
   UpdateInvalidatorCredentials();
 
diff --git a/chrome/browser/invalidation/ticl_invalidation_service.h b/chrome/browser/invalidation/ticl_invalidation_service.h
index 290e749..684ed2a 100644
--- a/chrome/browser/invalidation/ticl_invalidation_service.h
+++ b/chrome/browser/invalidation/ticl_invalidation_service.h
@@ -7,15 +7,14 @@
 
 #include <string>
 
-#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/timer/timer.h"
-#include "base/values.h"
 #include "chrome/browser/invalidation/invalidation_auth_provider.h"
 #include "chrome/browser/invalidation/invalidation_logger.h"
 #include "chrome/browser/invalidation/invalidation_service.h"
+#include "chrome/browser/invalidation/invalidator_storage.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "google_apis/gaia/oauth2_token_service.h"
@@ -25,12 +24,7 @@
 
 class Profile;
 
-namespace net {
-class URLRequestContextGetter;
-}
-
 namespace syncer {
-class InvalidationStateTracker;
 class Invalidator;
 }
 
@@ -55,14 +49,11 @@ class TiclInvalidationService : public base::NonThreadSafe,
     NETWORK_CHANNELS_COUNT = 2
   };
 
-  TiclInvalidationService(
-      scoped_ptr<InvalidationAuthProvider> auth_provider,
-      const scoped_refptr<net::URLRequestContextGetter>& request_context,
-      Profile* profile);
+  TiclInvalidationService(scoped_ptr<InvalidationAuthProvider> auth_provider,
+                          Profile* profile);
   virtual ~TiclInvalidationService();
 
-  void Init(
-      scoped_ptr<syncer::InvalidationStateTracker> invalidation_state_tracker);
+  void Init();
 
   // InvalidationService implementation.
   // It is an error to have registered handlers when Shutdown() is called.
@@ -110,9 +101,7 @@ class TiclInvalidationService : public base::NonThreadSafe,
 
  protected:
   // Initializes with an injected invalidator.
-  void InitForTest(
-      scoped_ptr<syncer::InvalidationStateTracker> invalidation_state_tracker,
-      syncer::Invalidator* invalidator);
+  void InitForTest(syncer::Invalidator* invalidator);
 
   friend class TiclInvalidationServiceTestDelegate;
   friend class TiclInvalidationServiceChannelTest;
@@ -130,7 +119,7 @@ class TiclInvalidationService : public base::NonThreadSafe,
   scoped_ptr<InvalidationAuthProvider> auth_provider_;
 
   scoped_ptr<syncer::InvalidatorRegistrar> invalidator_registrar_;
-  scoped_ptr<syncer::InvalidationStateTracker> invalidation_state_tracker_;
+  scoped_ptr<InvalidatorStorage> invalidator_storage_;
   scoped_ptr<syncer::Invalidator> invalidator_;
 
   // TiclInvalidationService needs to remember access token in order to
@@ -146,7 +135,6 @@ class TiclInvalidationService : public base::NonThreadSafe,
   PrefChangeRegistrar pref_change_registrar_;
   InvalidationNetworkChannel network_channel_type_;
   scoped_ptr<GCMInvalidationBridge> gcm_invalidation_bridge_;
-  scoped_refptr<net::URLRequestContextGetter> request_context_;
 
   // The invalidation logger object we use to record state changes
   // and invalidations.
diff --git a/chrome/browser/invalidation/ticl_invalidation_service_unittest.cc b/chrome/browser/invalidation/ticl_invalidation_service_unittest.cc
index 0c89554..9c90df7 100644
--- a/chrome/browser/invalidation/ticl_invalidation_service_unittest.cc
+++ b/chrome/browser/invalidation/ticl_invalidation_service_unittest.cc
@@ -7,7 +7,6 @@
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/invalidation/invalidation_service_factory.h"
 #include "chrome/browser/invalidation/invalidation_service_test_template.h"
-#include "chrome/browser/invalidation/invalidator_storage.h"
 #include "chrome/browser/invalidation/profile_invalidation_auth_provider.h"
 #include "chrome/browser/signin/fake_profile_oauth2_token_service.h"
 #include "chrome/browser/signin/fake_signin_manager.h"
@@ -15,11 +14,8 @@
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/signin/core/browser/signin_manager.h"
-#include "content/public/test/test_browser_thread_bundle.h"
-#include "net/url_request/url_request_context_getter.h"
 #include "sync/notifier/fake_invalidation_handler.h"
 #include "sync/notifier/fake_invalidator.h"
-#include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/notifier/invalidation_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -47,16 +43,12 @@ class TiclInvalidationServiceTestDelegate {
                 SigninManagerFactory::GetForProfile(profile_.get()),
                 token_service_.get(),
                 NULL)),
-        profile_->GetRequestContext(),
         profile_.get()));
   }
 
   void InitializeInvalidationService() {
     fake_invalidator_ = new syncer::FakeInvalidator();
-    invalidation_service_->InitForTest(
-        scoped_ptr<syncer::InvalidationStateTracker>(
-            new InvalidatorStorage(profile_->GetPrefs())),
-        fake_invalidator_);
+    invalidation_service_->InitForTest(fake_invalidator_);
   }
 
   InvalidationService* GetInvalidationService() {
@@ -103,12 +95,9 @@ class TiclInvalidationServiceChannelTest : public ::testing::Test {
     scoped_ptr<InvalidationAuthProvider> auth_provider(
         new ProfileInvalidationAuthProvider(
             fake_signin_manager_, token_service_.get(), NULL));
-    invalidation_service_.reset(new TiclInvalidationService(
-        auth_provider.Pass(),
-        profile_->GetRequestContext(),
-        profile_.get()));
-    invalidation_service_->Init(scoped_ptr<syncer::InvalidationStateTracker>(
-        new InvalidatorStorage(profile_->GetPrefs())));
+    invalidation_service_.reset(
+        new TiclInvalidationService(auth_provider.Pass(), profile_.get()));
+    invalidation_service_->Init();
   }
 
   virtual void TearDown() OVERRIDE {
@@ -120,7 +109,6 @@ class TiclInvalidationServiceChannelTest : public ::testing::Test {
   }
 
  protected:
-  content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<TestingProfile> profile_;
   SigninManagerBase* fake_signin_manager_;
   scoped_ptr<FakeProfileOAuth2TokenService> token_service_;
@@ -186,8 +174,6 @@ class FakeCallbackContainer {
 // Test that requesting for detailed status doesn't crash even if the
 // underlying invalidator is not initialized.
 TEST(TiclInvalidationServiceLoggingTest, DetailedStatusCallbacksWork) {
-  content::TestBrowserThreadBundle thread_bundle;
-
   scoped_ptr<TiclInvalidationServiceTestDelegate> delegate (
       new TiclInvalidationServiceTestDelegate());
 
diff --git a/sync/notifier/fake_invalidation_state_tracker.cc b/sync/notifier/fake_invalidation_state_tracker.cc
index ccef53e..47e2f0f 100644
--- a/sync/notifier/fake_invalidation_state_tracker.cc
+++ b/sync/notifier/fake_invalidation_state_tracker.cc
@@ -18,7 +18,7 @@ FakeInvalidationStateTracker::FakeInvalidationStateTracker() {}
 
 FakeInvalidationStateTracker::~FakeInvalidationStateTracker() {}
 
-void FakeInvalidationStateTracker::ClearAndSetNewClientId(
+void FakeInvalidationStateTracker::SetInvalidatorClientId(
     const std::string& client_id) {
   Clear();
   invalidator_client_id_ = client_id;
diff --git a/sync/notifier/fake_invalidation_state_tracker.h b/sync/notifier/fake_invalidation_state_tracker.h
index eb62256..d1daaba 100644
--- a/sync/notifier/fake_invalidation_state_tracker.h
+++ b/sync/notifier/fake_invalidation_state_tracker.h
@@ -20,7 +20,7 @@ class FakeInvalidationStateTracker
   virtual ~FakeInvalidationStateTracker();
 
   // InvalidationStateTracker implementation.
-  virtual void ClearAndSetNewClientId(const std::string& client_id) OVERRIDE;
+  virtual void SetInvalidatorClientId(const std::string& client_id) OVERRIDE;
   virtual std::string GetInvalidatorClientId() const OVERRIDE;
   virtual void SetBootstrapData(const std::string& data) OVERRIDE;
   virtual std::string GetBootstrapData() const OVERRIDE;
diff --git a/sync/notifier/invalidation_state_tracker.h b/sync/notifier/invalidation_state_tracker.h
index 22e3e6f..81a07ea 100644
--- a/sync/notifier/invalidation_state_tracker.h
+++ b/sync/notifier/invalidation_state_tracker.h
@@ -30,16 +30,14 @@ class TaskRunner;
 
 namespace syncer {
 
-class SYNC_EXPORT InvalidationStateTracker {
+class InvalidationStateTracker {
  public:
   InvalidationStateTracker() {}
-  virtual ~InvalidationStateTracker() {}
 
   // The per-client unique ID used to register the invalidation client with the
   // server.  This is used to squelch invalidation notifications that originate
-  // from changes made by this client.  Setting the client ID clears all other
-  // state.
-  virtual void ClearAndSetNewClientId(const std::string& data) = 0;
+  // from changes made by this client.
+  virtual void SetInvalidatorClientId(const std::string& data) = 0;
   virtual std::string GetInvalidatorClientId() const = 0;
 
   // Used by invalidation::InvalidationClient for persistence. |data| is an
@@ -57,6 +55,9 @@ class SYNC_EXPORT InvalidationStateTracker {
 
   // Erases invalidation versions, client ID, and state stored on disk.
   virtual void Clear() = 0;
+
+ protected:
+  virtual ~InvalidationStateTracker() {}
 };
 
 }  // namespace syncer
diff --git a/sync/notifier/non_blocking_invalidator.cc b/sync/notifier/non_blocking_invalidator.cc
index df40477..db8d018 100644
--- a/sync/notifier/non_blocking_invalidator.cc
+++ b/sync/notifier/non_blocking_invalidator.cc
@@ -13,9 +13,7 @@
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "jingle/notifier/listener/push_client.h"
-#include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/notifier/gcm_network_channel_delegate.h"
-#include "sync/notifier/invalidation_handler.h"
 #include "sync/notifier/invalidation_notifier.h"
 #include "sync/notifier/object_id_invalidation_map.h"
 #include "sync/notifier/sync_system_resources.h"
@@ -97,9 +95,10 @@ class NonBlockingInvalidator::Core
       // InvalidationHandler to observe the InvalidationNotifier we create.
       public InvalidationHandler {
  public:
-  // Called on parent thread.  |delegate_observer| should be initialized.
+  // Called on parent thread.  |delegate_observer| should be
+  // initialized.
   explicit Core(
-      const WeakHandle<NonBlockingInvalidator>& delegate_observer);
+      const WeakHandle<InvalidationHandler>& delegate_observer);
 
   // Helpers called on I/O thread.
   void Initialize(
@@ -124,7 +123,7 @@ class NonBlockingInvalidator::Core
   virtual ~Core();
 
   // The variables below should be used only on the I/O thread.
-  const WeakHandle<NonBlockingInvalidator> delegate_observer_;
+  const WeakHandle<InvalidationHandler> delegate_observer_;
   scoped_ptr<InvalidationNotifier> invalidation_notifier_;
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
 
@@ -132,7 +131,7 @@ class NonBlockingInvalidator::Core
 };
 
 NonBlockingInvalidator::Core::Core(
-    const WeakHandle<NonBlockingInvalidator>& delegate_observer)
+    const WeakHandle<InvalidationHandler>& delegate_observer)
     : delegate_observer_(delegate_observer) {
   DCHECK(delegate_observer_.IsInitialized());
 }
@@ -186,16 +185,15 @@ void NonBlockingInvalidator::Core::RequestDetailedStatus(
 void NonBlockingInvalidator::Core::OnInvalidatorStateChange(
     InvalidatorState reason) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
-  delegate_observer_.Call(FROM_HERE,
-                          &NonBlockingInvalidator::OnInvalidatorStateChange,
-                          reason);
+  delegate_observer_.Call(
+      FROM_HERE, &InvalidationHandler::OnInvalidatorStateChange, reason);
 }
 
 void NonBlockingInvalidator::Core::OnIncomingInvalidation(
     const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   delegate_observer_.Call(FROM_HERE,
-                          &NonBlockingInvalidator::OnIncomingInvalidation,
+                          &InvalidationHandler::OnIncomingInvalidation,
                           invalidation_map);
 }
 
@@ -208,11 +206,11 @@ NonBlockingInvalidator::NonBlockingInvalidator(
     const std::string& invalidator_client_id,
     const UnackedInvalidationsMap& saved_invalidations,
     const std::string& invalidation_bootstrap_data,
-    InvalidationStateTracker* invalidation_state_tracker,
+    const WeakHandle<InvalidationStateTracker>&
+        invalidation_state_tracker,
     const std::string& client_info,
     const scoped_refptr<net::URLRequestContextGetter>& request_context_getter)
-    : invalidation_state_tracker_(invalidation_state_tracker),
-      parent_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+    : parent_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       network_task_runner_(request_context_getter->GetNetworkTaskRunner()),
       weak_ptr_factory_(this) {
   core_ = new Core(MakeWeakHandle(weak_ptr_factory_.GetWeakPtr()));
@@ -222,7 +220,7 @@ NonBlockingInvalidator::NonBlockingInvalidator(
       invalidator_client_id,
       saved_invalidations,
       invalidation_bootstrap_data,
-      MakeWeakHandle(weak_ptr_factory_.GetWeakPtr()),
+      invalidation_state_tracker,
       client_info,
       request_context_getter);
 
@@ -300,6 +298,19 @@ void NonBlockingInvalidator::RequestDetailedStatus(
   }
 }
 
+void NonBlockingInvalidator::OnInvalidatorStateChange(InvalidatorState state) {
+  DCHECK(parent_task_runner_->BelongsToCurrentThread());
+  registrar_.UpdateInvalidatorState(state);
+}
+
+void NonBlockingInvalidator::OnIncomingInvalidation(
+        const ObjectIdInvalidationMap& invalidation_map) {
+  DCHECK(parent_task_runner_->BelongsToCurrentThread());
+  registrar_.DispatchInvalidationsToHandlers(invalidation_map);
+}
+
+std::string NonBlockingInvalidator::GetOwnerName() const { return "Sync"; }
+
 NetworkChannelCreator
     NonBlockingInvalidator::MakePushClientChannelCreator(
         const notifier::NotifierOptions& notifier_options) {
@@ -315,53 +326,4 @@ NetworkChannelCreator NonBlockingInvalidator::MakeGCMNetworkChannelCreator(
                     base::Passed(&delegate));
 }
 
-void NonBlockingInvalidator::ClearAndSetNewClientId(const std::string& data) {
-  DCHECK(parent_task_runner_->BelongsToCurrentThread());
-  invalidation_state_tracker_->ClearAndSetNewClientId(data);
-}
-
-std::string NonBlockingInvalidator::GetInvalidatorClientId() const {
-  DCHECK(parent_task_runner_->BelongsToCurrentThread());
-  return invalidation_state_tracker_->GetInvalidatorClientId();
-}
-
-void NonBlockingInvalidator::SetBootstrapData(const std::string& data) {
-  DCHECK(parent_task_runner_->BelongsToCurrentThread());
-  invalidation_state_tracker_->SetBootstrapData(data);
-}
-
-std::string NonBlockingInvalidator::GetBootstrapData() const {
-  DCHECK(parent_task_runner_->BelongsToCurrentThread());
-  return invalidation_state_tracker_->GetBootstrapData();
-}
-
-void NonBlockingInvalidator::SetSavedInvalidations(
-      const UnackedInvalidationsMap& states) {
-  DCHECK(parent_task_runner_->BelongsToCurrentThread());
-  invalidation_state_tracker_->SetSavedInvalidations(states);
-}
-
-UnackedInvalidationsMap NonBlockingInvalidator::GetSavedInvalidations() const {
-  DCHECK(parent_task_runner_->BelongsToCurrentThread());
-  return invalidation_state_tracker_->GetSavedInvalidations();
-}
-
-void NonBlockingInvalidator::Clear() {
-  DCHECK(parent_task_runner_->BelongsToCurrentThread());
-  invalidation_state_tracker_->Clear();
-}
-
-void NonBlockingInvalidator::OnInvalidatorStateChange(InvalidatorState state) {
-  DCHECK(parent_task_runner_->BelongsToCurrentThread());
-  registrar_.UpdateInvalidatorState(state);
-}
-
-void NonBlockingInvalidator::OnIncomingInvalidation(
-        const ObjectIdInvalidationMap& invalidation_map) {
-  DCHECK(parent_task_runner_->BelongsToCurrentThread());
-  registrar_.DispatchInvalidationsToHandlers(invalidation_map);
-}
-
-std::string NonBlockingInvalidator::GetOwnerName() const { return "Sync"; }
-
 }  // namespace syncer
diff --git a/sync/notifier/non_blocking_invalidator.h b/sync/notifier/non_blocking_invalidator.h
index efdf89d..47bd216 100644
--- a/sync/notifier/non_blocking_invalidator.h
+++ b/sync/notifier/non_blocking_invalidator.h
@@ -17,11 +17,11 @@
 #include "base/memory/weak_ptr.h"
 #include "jingle/notifier/base/notifier_options.h"
 #include "sync/base/sync_export.h"
+#include "sync/internal_api/public/util/weak_handle.h"
+#include "sync/notifier/invalidation_handler.h"
 #include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/notifier/invalidator.h"
 #include "sync/notifier/invalidator_registrar.h"
-#include "sync/notifier/invalidator_state.h"
-#include "sync/notifier/unacked_invalidation_set.h"
 
 namespace base {
 class SingleThreadTaskRunner;
@@ -38,15 +38,17 @@ typedef base::Callback<scoped_ptr<SyncNetworkChannel>(void)>
 
 class SYNC_EXPORT_PRIVATE NonBlockingInvalidator
     : public Invalidator,
-      public InvalidationStateTracker {
+      // InvalidationHandler to "observe" our Core via WeakHandle.
+      public InvalidationHandler {
  public:
-  // |invalidation_state_tracker| must be initialized and must outlive |this|.
+  // |invalidation_state_tracker| must be initialized.
   NonBlockingInvalidator(
       NetworkChannelCreator network_channel_creator,
       const std::string& invalidator_client_id,
       const UnackedInvalidationsMap& saved_invalidations,
       const std::string& invalidation_bootstrap_data,
-      InvalidationStateTracker* invalidation_state_tracker,
+      const WeakHandle<InvalidationStateTracker>&
+          invalidation_state_tracker,
       const std::string& client_info,
       const scoped_refptr<net::URLRequestContextGetter>&
           request_context_getter);
@@ -65,6 +67,12 @@ class SYNC_EXPORT_PRIVATE NonBlockingInvalidator
       base::Callback<void(const base::DictionaryValue&)> callback) const
       OVERRIDE;
 
+  // InvalidationHandler implementation.
+  virtual void OnInvalidatorStateChange(InvalidatorState state) OVERRIDE;
+  virtual void OnIncomingInvalidation(
+      const ObjectIdInvalidationMap& invalidation_map) OVERRIDE;
+  virtual std::string GetOwnerName() const OVERRIDE;
+
   // Static functions to construct callback that creates network channel for
   // SyncSystemResources. The goal is to pass network channel to invalidator at
   // the same time not exposing channel specific parameters to invalidator and
@@ -74,29 +82,11 @@ class SYNC_EXPORT_PRIVATE NonBlockingInvalidator
   static NetworkChannelCreator MakeGCMNetworkChannelCreator(
       scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       scoped_ptr<GCMNetworkChannelDelegate> delegate);
-
-  // These methods are forwarded to the invalidation_state_tracker_.
-  virtual void ClearAndSetNewClientId(const std::string& data) OVERRIDE;
-  virtual std::string GetInvalidatorClientId() const OVERRIDE;
-  virtual void SetBootstrapData(const std::string& data) OVERRIDE;
-  virtual std::string GetBootstrapData() const OVERRIDE;
-  virtual void SetSavedInvalidations(
-      const UnackedInvalidationsMap& states) OVERRIDE;
-  virtual UnackedInvalidationsMap GetSavedInvalidations() const OVERRIDE;
-  virtual void Clear() OVERRIDE;
-
  private:
-  void OnInvalidatorStateChange(InvalidatorState state);
-  void OnIncomingInvalidation(const ObjectIdInvalidationMap& invalidation_map);
-  std::string GetOwnerName() const;
-
-  friend class NonBlockingInvalidatorTestDelegate;
-
   struct InitializeOptions;
   class Core;
 
   InvalidatorRegistrar registrar_;
-  InvalidationStateTracker* invalidation_state_tracker_;
 
   // The real guts of NonBlockingInvalidator, which allows this class to live
   // completely on the parent thread.
diff --git a/sync/notifier/non_blocking_invalidator_unittest.cc b/sync/notifier/non_blocking_invalidator_unittest.cc
index 07700a5..3dd2dbb 100644
--- a/sync/notifier/non_blocking_invalidator_unittest.cc
+++ b/sync/notifier/non_blocking_invalidator_unittest.cc
@@ -13,6 +13,7 @@
 #include "google/cacheinvalidation/types.pb.h"
 #include "jingle/notifier/base/fake_base_task.h"
 #include "net/url_request/url_request_test_util.h"
+#include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/notifier/fake_invalidation_handler.h"
 #include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/notifier/invalidator_test_template.h"
@@ -20,6 +21,8 @@
 
 namespace syncer {
 
+namespace {
+
 class NonBlockingInvalidatorTestDelegate {
  public:
   NonBlockingInvalidatorTestDelegate() : io_thread_("IO thread") {}
@@ -49,7 +52,7 @@ class NonBlockingInvalidatorTestDelegate {
             invalidator_client_id,
             UnackedInvalidationsMap(),
             initial_state,
-            invalidation_state_tracker.get(),
+            MakeWeakHandle(invalidation_state_tracker),
             "fake_client_info",
             request_context_getter_));
   }
@@ -95,4 +98,6 @@ INSTANTIATE_TYPED_TEST_CASE_P(
     NonBlockingInvalidatorTest, InvalidatorTest,
     NonBlockingInvalidatorTestDelegate);
 
+}  // namespace
+
 }  // namespace syncer
diff --git a/sync/tools/null_invalidation_state_tracker.cc b/sync/tools/null_invalidation_state_tracker.cc
index d7f949f..6823759 100644
--- a/sync/tools/null_invalidation_state_tracker.cc
+++ b/sync/tools/null_invalidation_state_tracker.cc
@@ -17,7 +17,7 @@ namespace syncer {
 NullInvalidationStateTracker::NullInvalidationStateTracker() {}
 NullInvalidationStateTracker::~NullInvalidationStateTracker() {}
 
-void NullInvalidationStateTracker::ClearAndSetNewClientId(
+void NullInvalidationStateTracker::SetInvalidatorClientId(
     const std::string& data) {
   LOG(INFO) << "Setting invalidator client ID to: " << data;
 }
diff --git a/sync/tools/null_invalidation_state_tracker.h b/sync/tools/null_invalidation_state_tracker.h
index a08fe7d..a12844c 100644
--- a/sync/tools/null_invalidation_state_tracker.h
+++ b/sync/tools/null_invalidation_state_tracker.h
@@ -18,7 +18,7 @@ class NullInvalidationStateTracker
   NullInvalidationStateTracker();
   virtual ~NullInvalidationStateTracker();
 
-  virtual void ClearAndSetNewClientId(const std::string& data) OVERRIDE;
+  virtual void SetInvalidatorClientId(const std::string& data) OVERRIDE;
   virtual std::string GetInvalidatorClientId() const OVERRIDE;
 
   virtual std::string GetBootstrapData() const OVERRIDE;