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

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

16 files changed, 177 insertions, 98 deletions

diff --git a/chrome/browser/invalidation/invalidation_service_factory.cc b/chrome/browser/invalidation/invalidation_service_factory.cc
index ef34d2e..91ea1fd 100644
--- a/chrome/browser/invalidation/invalidation_service_factory.cc
+++ b/chrome/browser/invalidation/invalidation_service_factory.cc
@@ -4,6 +4,7 @@
 
 #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"
@@ -22,6 +23,8 @@
 #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"
@@ -115,9 +118,12 @@ KeyedService* InvalidationServiceFactory::BuildServiceInstanceFor(
         LoginUIServiceFactory::GetForProfile(profile)));
   }
 
-  TiclInvalidationService* service =
-      new TiclInvalidationService(auth_provider.Pass(), profile);
-  service->Init();
+  TiclInvalidationService* service = new TiclInvalidationService(
+      auth_provider.Pass(),
+      profile->GetRequestContext(),
+      profile);
+  service->Init(scoped_ptr<syncer::InvalidationStateTracker>(
+      new InvalidatorStorage(profile->GetPrefs())));
   return service;
 #endif
 }
diff --git a/chrome/browser/invalidation/invalidation_service_test_template.h b/chrome/browser/invalidation/invalidation_service_test_template.h
index 05e9928..124e837 100644
--- a/chrome/browser/invalidation/invalidation_service_test_template.h
+++ b/chrome/browser/invalidation/invalidation_service_test_template.h
@@ -74,6 +74,7 @@
 #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"
@@ -100,6 +101,7 @@ 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 39e32b6..bc2cb74 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::SetInvalidatorClientId(const std::string& client_id) {
+void InvalidatorStorage::ClearAndSetNewClientId(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 75c3f90..37ef025 100644
--- a/chrome/browser/invalidation/invalidator_storage.h
+++ b/chrome/browser/invalidation/invalidator_storage.h
@@ -11,7 +11,6 @@
 
 #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"
@@ -29,8 +28,7 @@ class PrefRegistrySyncable;
 
 namespace invalidation {
 
-class InvalidatorStorage : public base::SupportsWeakPtr<InvalidatorStorage>,
-                           public syncer::InvalidationStateTracker {
+class InvalidatorStorage : public syncer::InvalidationStateTracker {
  public:
   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
 
@@ -39,7 +37,7 @@ class InvalidatorStorage : public base::SupportsWeakPtr<InvalidatorStorage>,
   virtual ~InvalidatorStorage();
 
   // InvalidationStateTracker implementation.
-  virtual void SetInvalidatorClientId(const std::string& client_id) OVERRIDE;
+  virtual void ClearAndSetNewClientId(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 b09d8d5..b587997 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.SetInvalidatorClientId("fake_id");
+  storage.ClearAndSetNewClientId("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.SetInvalidatorClientId(client_id);
+  storage.ClearAndSetNewClientId(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 536d965..2f0569b 100644
--- a/chrome/browser/invalidation/ticl_invalidation_service.cc
+++ b/chrome/browser/invalidation/ticl_invalidation_service.cc
@@ -19,6 +19,7 @@
 #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"
@@ -62,6 +63,7 @@ namespace invalidation {
 
 TiclInvalidationService::TiclInvalidationService(
     scoped_ptr<InvalidationAuthProvider> auth_provider,
+    const scoped_refptr<net::URLRequestContextGetter>& request_context,
     Profile* profile)
     : OAuth2TokenService::Consumer("ticl_invalidation"),
       profile_(profile),
@@ -69,20 +71,21 @@ 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() {
+void TiclInvalidationService::Init(
+    scoped_ptr<syncer::InvalidationStateTracker> invalidation_state_tracker) {
   DCHECK(CalledOnValidThread());
+  invalidation_state_tracker_ = invalidation_state_tracker.Pass();
 
-  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());
+  if (invalidation_state_tracker_->GetInvalidatorClientId().empty()) {
+    invalidation_state_tracker_->ClearAndSetNewClientId(
+        GenerateInvalidatorClientId());
   }
 
   pref_change_registrar_.Init(profile_->GetPrefs());
@@ -108,10 +111,13 @@ void TiclInvalidationService::Init() {
   auth_provider_->GetTokenService()->AddObserver(this);
 }
 
-void TiclInvalidationService::InitForTest(syncer::Invalidator* invalidator) {
+void TiclInvalidationService::InitForTest(
+    scoped_ptr<syncer::InvalidationStateTracker> invalidation_state_tracker,
+    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);
@@ -169,7 +175,7 @@ syncer::InvalidatorState TiclInvalidationService::GetInvalidatorState() const {
 
 std::string TiclInvalidationService::GetInvalidatorClientId() const {
   DCHECK(CalledOnValidThread());
-  return invalidator_storage_->GetInvalidatorClientId();
+  return invalidation_state_tracker_->GetInvalidatorClientId();
 }
 
 InvalidationLogger* TiclInvalidationService::GetInvalidationLogger() {
@@ -280,11 +286,11 @@ void TiclInvalidationService::OnInvalidationAuthLogout() {
     StopInvalidator();
   }
 
-  // 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());
+  // 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());
 }
 
 void TiclInvalidationService::OnInvalidatorStateChange(
@@ -325,7 +331,7 @@ void TiclInvalidationService::Shutdown() {
   if (IsStarted()) {
     StopInvalidator();
   }
-  invalidator_storage_.reset();
+  invalidation_state_tracker_.reset();
   invalidator_registrar_.reset();
 }
 
@@ -365,8 +371,8 @@ void TiclInvalidationService::StartInvalidator(
     InvalidationNetworkChannel network_channel) {
   DCHECK(CalledOnValidThread());
   DCHECK(!invalidator_);
-  DCHECK(invalidator_storage_);
-  DCHECK(!invalidator_storage_->GetInvalidatorClientId().empty());
+  DCHECK(invalidation_state_tracker_);
+  DCHECK(!invalidation_state_tracker_->GetInvalidatorClientId().empty());
 
   // Request access token for PushClientChannel. GCMNetworkChannel will request
   // access token before sending message to server.
@@ -384,7 +390,7 @@ void TiclInvalidationService::StartInvalidator(
     case PUSH_CLIENT_CHANNEL: {
       notifier::NotifierOptions options =
           ParseNotifierOptions(*CommandLine::ForCurrentProcess());
-      options.request_context_getter = profile_->GetRequestContext();
+      options.request_context_getter = request_context_;
       options.auth_mechanism = "X-OAUTH2";
       network_channel_options_.SetString("Options.HostPort",
                                          options.xmpp_host_port.ToString());
@@ -402,7 +408,7 @@ void TiclInvalidationService::StartInvalidator(
           new GCMInvalidationBridge(gcm_profile_service, auth_provider_.get()));
       network_channel_creator =
           syncer::NonBlockingInvalidator::MakeGCMNetworkChannelCreator(
-              profile_->GetRequestContext(),
+              request_context_,
               gcm_invalidation_bridge_->CreateDelegate().Pass());
       break;
     }
@@ -413,13 +419,12 @@ void TiclInvalidationService::StartInvalidator(
   }
   invalidator_.reset(new syncer::NonBlockingInvalidator(
           network_channel_creator,
-          invalidator_storage_->GetInvalidatorClientId(),
-          invalidator_storage_->GetSavedInvalidations(),
-          invalidator_storage_->GetBootstrapData(),
-          syncer::WeakHandle<syncer::InvalidationStateTracker>(
-              invalidator_storage_->AsWeakPtr()),
+          invalidation_state_tracker_->GetInvalidatorClientId(),
+          invalidation_state_tracker_->GetSavedInvalidations(),
+          invalidation_state_tracker_->GetBootstrapData(),
+          invalidation_state_tracker_.get(),
           GetUserAgent(),
-          profile_->GetRequestContext()));
+          request_context_));
 
   UpdateInvalidatorCredentials();
 
diff --git a/chrome/browser/invalidation/ticl_invalidation_service.h b/chrome/browser/invalidation/ticl_invalidation_service.h
index 684ed2a..290e749 100644
--- a/chrome/browser/invalidation/ticl_invalidation_service.h
+++ b/chrome/browser/invalidation/ticl_invalidation_service.h
@@ -7,14 +7,15 @@
 
 #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"
@@ -24,7 +25,12 @@
 
 class Profile;
 
+namespace net {
+class URLRequestContextGetter;
+}
+
 namespace syncer {
+class InvalidationStateTracker;
 class Invalidator;
 }
 
@@ -49,11 +55,14 @@ class TiclInvalidationService : public base::NonThreadSafe,
     NETWORK_CHANNELS_COUNT = 2
   };
 
-  TiclInvalidationService(scoped_ptr<InvalidationAuthProvider> auth_provider,
-                          Profile* profile);
+  TiclInvalidationService(
+      scoped_ptr<InvalidationAuthProvider> auth_provider,
+      const scoped_refptr<net::URLRequestContextGetter>& request_context,
+      Profile* profile);
   virtual ~TiclInvalidationService();
 
-  void Init();
+  void Init(
+      scoped_ptr<syncer::InvalidationStateTracker> invalidation_state_tracker);
 
   // InvalidationService implementation.
   // It is an error to have registered handlers when Shutdown() is called.
@@ -101,7 +110,9 @@ class TiclInvalidationService : public base::NonThreadSafe,
 
  protected:
   // Initializes with an injected invalidator.
-  void InitForTest(syncer::Invalidator* invalidator);
+  void InitForTest(
+      scoped_ptr<syncer::InvalidationStateTracker> invalidation_state_tracker,
+      syncer::Invalidator* invalidator);
 
   friend class TiclInvalidationServiceTestDelegate;
   friend class TiclInvalidationServiceChannelTest;
@@ -119,7 +130,7 @@ class TiclInvalidationService : public base::NonThreadSafe,
   scoped_ptr<InvalidationAuthProvider> auth_provider_;
 
   scoped_ptr<syncer::InvalidatorRegistrar> invalidator_registrar_;
-  scoped_ptr<InvalidatorStorage> invalidator_storage_;
+  scoped_ptr<syncer::InvalidationStateTracker> invalidation_state_tracker_;
   scoped_ptr<syncer::Invalidator> invalidator_;
 
   // TiclInvalidationService needs to remember access token in order to
@@ -135,6 +146,7 @@ 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 9c90df7..0c89554 100644
--- a/chrome/browser/invalidation/ticl_invalidation_service_unittest.cc
+++ b/chrome/browser/invalidation/ticl_invalidation_service_unittest.cc
@@ -7,6 +7,7 @@
 #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"
@@ -14,8 +15,11 @@
 #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"
 
@@ -43,12 +47,16 @@ class TiclInvalidationServiceTestDelegate {
                 SigninManagerFactory::GetForProfile(profile_.get()),
                 token_service_.get(),
                 NULL)),
+        profile_->GetRequestContext(),
         profile_.get()));
   }
 
   void InitializeInvalidationService() {
     fake_invalidator_ = new syncer::FakeInvalidator();
-    invalidation_service_->InitForTest(fake_invalidator_);
+    invalidation_service_->InitForTest(
+        scoped_ptr<syncer::InvalidationStateTracker>(
+            new InvalidatorStorage(profile_->GetPrefs())),
+        fake_invalidator_);
   }
 
   InvalidationService* GetInvalidationService() {
@@ -95,9 +103,12 @@ 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_.get()));
-    invalidation_service_->Init();
+    invalidation_service_.reset(new TiclInvalidationService(
+        auth_provider.Pass(),
+        profile_->GetRequestContext(),
+        profile_.get()));
+    invalidation_service_->Init(scoped_ptr<syncer::InvalidationStateTracker>(
+        new InvalidatorStorage(profile_->GetPrefs())));
   }
 
   virtual void TearDown() OVERRIDE {
@@ -109,6 +120,7 @@ class TiclInvalidationServiceChannelTest : public ::testing::Test {
   }
 
  protected:
+  content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<TestingProfile> profile_;
   SigninManagerBase* fake_signin_manager_;
   scoped_ptr<FakeProfileOAuth2TokenService> token_service_;
@@ -174,6 +186,8 @@ 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 47e2f0f..ccef53e 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::SetInvalidatorClientId(
+void FakeInvalidationStateTracker::ClearAndSetNewClientId(
     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 d1daaba..eb62256 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 SetInvalidatorClientId(const std::string& client_id) OVERRIDE;
+  virtual void ClearAndSetNewClientId(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 81a07ea..22e3e6f 100644
--- a/sync/notifier/invalidation_state_tracker.h
+++ b/sync/notifier/invalidation_state_tracker.h
@@ -30,14 +30,16 @@ class TaskRunner;
 
 namespace syncer {
 
-class InvalidationStateTracker {
+class SYNC_EXPORT 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.
-  virtual void SetInvalidatorClientId(const std::string& data) = 0;
+  // from changes made by this client.  Setting the client ID clears all other
+  // state.
+  virtual void ClearAndSetNewClientId(const std::string& data) = 0;
   virtual std::string GetInvalidatorClientId() const = 0;
 
   // Used by invalidation::InvalidationClient for persistence. |data| is an
@@ -55,9 +57,6 @@ class 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 db8d018..df40477 100644
--- a/sync/notifier/non_blocking_invalidator.cc
+++ b/sync/notifier/non_blocking_invalidator.cc
@@ -13,7 +13,9 @@
 #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"
@@ -95,10 +97,9 @@ 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<InvalidationHandler>& delegate_observer);
+      const WeakHandle<NonBlockingInvalidator>& delegate_observer);
 
   // Helpers called on I/O thread.
   void Initialize(
@@ -123,7 +124,7 @@ class NonBlockingInvalidator::Core
   virtual ~Core();
 
   // The variables below should be used only on the I/O thread.
-  const WeakHandle<InvalidationHandler> delegate_observer_;
+  const WeakHandle<NonBlockingInvalidator> delegate_observer_;
   scoped_ptr<InvalidationNotifier> invalidation_notifier_;
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
 
@@ -131,7 +132,7 @@ class NonBlockingInvalidator::Core
 };
 
 NonBlockingInvalidator::Core::Core(
-    const WeakHandle<InvalidationHandler>& delegate_observer)
+    const WeakHandle<NonBlockingInvalidator>& delegate_observer)
     : delegate_observer_(delegate_observer) {
   DCHECK(delegate_observer_.IsInitialized());
 }
@@ -185,15 +186,16 @@ void NonBlockingInvalidator::Core::RequestDetailedStatus(
 void NonBlockingInvalidator::Core::OnInvalidatorStateChange(
     InvalidatorState reason) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
-  delegate_observer_.Call(
-      FROM_HERE, &InvalidationHandler::OnInvalidatorStateChange, reason);
+  delegate_observer_.Call(FROM_HERE,
+                          &NonBlockingInvalidator::OnInvalidatorStateChange,
+                          reason);
 }
 
 void NonBlockingInvalidator::Core::OnIncomingInvalidation(
     const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   delegate_observer_.Call(FROM_HERE,
-                          &InvalidationHandler::OnIncomingInvalidation,
+                          &NonBlockingInvalidator::OnIncomingInvalidation,
                           invalidation_map);
 }
 
@@ -206,11 +208,11 @@ NonBlockingInvalidator::NonBlockingInvalidator(
     const std::string& invalidator_client_id,
     const UnackedInvalidationsMap& saved_invalidations,
     const std::string& invalidation_bootstrap_data,
-    const WeakHandle<InvalidationStateTracker>&
-        invalidation_state_tracker,
+    InvalidationStateTracker* invalidation_state_tracker,
     const std::string& client_info,
     const scoped_refptr<net::URLRequestContextGetter>& request_context_getter)
-    : parent_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+    : invalidation_state_tracker_(invalidation_state_tracker),
+      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()));
@@ -220,7 +222,7 @@ NonBlockingInvalidator::NonBlockingInvalidator(
       invalidator_client_id,
       saved_invalidations,
       invalidation_bootstrap_data,
-      invalidation_state_tracker,
+      MakeWeakHandle(weak_ptr_factory_.GetWeakPtr()),
       client_info,
       request_context_getter);
 
@@ -298,19 +300,6 @@ 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) {
@@ -326,4 +315,53 @@ 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 47bd216..efdf89d 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,17 +38,15 @@ typedef base::Callback<scoped_ptr<SyncNetworkChannel>(void)>
 
 class SYNC_EXPORT_PRIVATE NonBlockingInvalidator
     : public Invalidator,
-      // InvalidationHandler to "observe" our Core via WeakHandle.
-      public InvalidationHandler {
+      public InvalidationStateTracker {
  public:
-  // |invalidation_state_tracker| must be initialized.
+  // |invalidation_state_tracker| must be initialized and must outlive |this|.
   NonBlockingInvalidator(
       NetworkChannelCreator network_channel_creator,
       const std::string& invalidator_client_id,
       const UnackedInvalidationsMap& saved_invalidations,
       const std::string& invalidation_bootstrap_data,
-      const WeakHandle<InvalidationStateTracker>&
-          invalidation_state_tracker,
+      InvalidationStateTracker* invalidation_state_tracker,
       const std::string& client_info,
       const scoped_refptr<net::URLRequestContextGetter>&
           request_context_getter);
@@ -67,12 +65,6 @@ 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
@@ -82,11 +74,29 @@ 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 3dd2dbb..07700a5 100644
--- a/sync/notifier/non_blocking_invalidator_unittest.cc
+++ b/sync/notifier/non_blocking_invalidator_unittest.cc
@@ -13,7 +13,6 @@
 #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"
@@ -21,8 +20,6 @@
 
 namespace syncer {
 
-namespace {
-
 class NonBlockingInvalidatorTestDelegate {
  public:
   NonBlockingInvalidatorTestDelegate() : io_thread_("IO thread") {}
@@ -52,7 +49,7 @@ class NonBlockingInvalidatorTestDelegate {
             invalidator_client_id,
             UnackedInvalidationsMap(),
             initial_state,
-            MakeWeakHandle(invalidation_state_tracker),
+            invalidation_state_tracker.get(),
             "fake_client_info",
             request_context_getter_));
   }
@@ -98,6 +95,4 @@ 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 6823759..d7f949f 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::SetInvalidatorClientId(
+void NullInvalidationStateTracker::ClearAndSetNewClientId(
     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 a12844c..a08fe7d 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 SetInvalidatorClientId(const std::string& data) OVERRIDE;
+  virtual void ClearAndSetNewClientId(const std::string& data) OVERRIDE;
   virtual std::string GetInvalidatorClientId() const OVERRIDE;
 
   virtual std::string GetBootstrapData() const OVERRIDE;