Reduce dependency of TiclInvalidationService on Profile

chrome/browser/invalidation/ticl_invalidation_service.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/invalidation/ticl_invalidation_service.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/invalidation/gcm_invalidation_bridge.h"
 #include "chrome/browser/invalidation/invalidation_auth_provider.h"
 #include "chrome/browser/invalidation/invalidation_logger.h"
 #include "chrome/browser/invalidation/invalidation_service_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/services/gcm/gcm_profile_service.h"
 #include "chrome/browser/services/gcm/gcm_profile_service_factory.h"
 #include "chrome/common/chrome_content_client.h"
 #include "chrome/common/chrome_switches.h"
 #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"
 #include "sync/notifier/invalidator_state.h"
 #include "sync/notifier/non_blocking_invalidator.h"
 #include "sync/notifier/object_id_invalidation_map.h"
 
 static const char* kOAuth2Scopes[] = {
   GaiaConstants::kGoogleTalkOAuth2Scope
 };
@@ skipping 23 matching lines @@
   -1,
 
   // Don't use initial delay unless the last request was an error.
   false,
 };
 
 namespace invalidation {
 
 TiclInvalidationService::TiclInvalidationService(
     scoped_ptr<InvalidationAuthProvider> auth_provider,
+    const scoped_refptr<net::URLRequestContextGetter>& request_context,
+    scoped_ptr<syncer::InvalidationStateTracker> invalidation_state_tracker,
     Profile* profile)
     : OAuth2TokenService::Consumer("ticl_invalidation"),
       profile_(profile),
       auth_provider_(auth_provider.Pass()),
       invalidator_registrar_(new syncer::InvalidatorRegistrar()),
+      invalidation_state_tracker_(invalidation_state_tracker.Pass()),
       request_access_token_backoff_(&kRequestAccessTokenBackoffPolicy),
       network_channel_type_(PUSH_CLIENT_CHANNEL),
+      request_context_(request_context),
       logger_() {}
 
 TiclInvalidationService::~TiclInvalidationService() {
   DCHECK(CalledOnValidThread());
 }
 
 void TiclInvalidationService::Init() {
   DCHECK(CalledOnValidThread());
 
-  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());
   pref_change_registrar_.Add(
       prefs::kInvalidationServiceUseGCMChannel,
       base::Bind(&TiclInvalidationService::UpdateInvalidationNetworkChannel,
                  base::Unretained(this)));
   pref_change_registrar_.Add(
       prefs::kGCMChannelEnabled,
       base::Bind(&TiclInvalidationService::UpdateInvalidationNetworkChannel,
@@ skipping 66 matching lines @@
         << invalidator_->GetInvalidatorState();
     return invalidator_->GetInvalidatorState();
   } else {
     DVLOG(2) << "Invalidator currently stopped";
     return syncer::TRANSIENT_INVALIDATION_ERROR;
   }
 }
 
 std::string TiclInvalidationService::GetInvalidatorClientId() const {
   DCHECK(CalledOnValidThread());
-  return invalidator_storage_->GetInvalidatorClientId();
+  return invalidation_state_tracker_->GetInvalidatorClientId();
 }
 
 InvalidationLogger* TiclInvalidationService::GetInvalidationLogger() {
   return &logger_;
 }
 
 InvalidationAuthProvider*
 TiclInvalidationService::GetInvalidationAuthProvider() {
   return auth_provider_.get();
 }
@@ skipping 90 matching lines @@
 }
 
 void TiclInvalidationService::OnInvalidationAuthLogout() {
   access_token_request_.reset();
   request_access_token_retry_timer_.Stop();
 
   if (IsStarted()) {
     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(
     syncer::InvalidatorState state) {
   if (state == syncer::INVALIDATION_CREDENTIALS_REJECTED) {
     // This may be due to normal OAuth access token expiration.  If so, we must
     // fetch a new one using our refresh token.  Resetting the invalidator's
     // access token will not reset the invalidator's exponential backoff, so
     // it's safe to try to update the token every time we receive this signal.
     //
@@ skipping 20 matching lines @@
 
 std::string TiclInvalidationService::GetOwnerName() const { return "TICL"; }
 
 void TiclInvalidationService::Shutdown() {
   DCHECK(CalledOnValidThread());
   auth_provider_->GetTokenService()->RemoveObserver(this);
   auth_provider_->RemoveObserver(this);
   if (IsStarted()) {
     StopInvalidator();
   }
-  invalidator_storage_.reset();
+  invalidation_state_tracker_.reset();
   invalidator_registrar_.reset();
 }
 
 bool TiclInvalidationService::IsReadyToStart() {
   if (profile_->IsManaged()) {
     DVLOG(2) << "Not starting TiclInvalidationService: User is managed.";
     return false;
   }
 
   if (auth_provider_->GetAccountId().empty()) {
@@ skipping 19 matching lines @@
 }
 
 bool TiclInvalidationService::IsStarted() const {
   return invalidator_.get() != NULL;
 }
 
 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.
   if (network_channel == PUSH_CLIENT_CHANNEL && access_token_.empty()) {
     DVLOG(1)
         << "TiclInvalidationService: "
         << "Deferring start until we have an access token.";
     RequestAccessToken();
     return;
   }
 
   syncer::NetworkChannelCreator network_channel_creator;
 
   switch (network_channel) {
     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());
       network_channel_options_.SetString("Options.AuthMechanism",
                                          options.auth_mechanism);
       DCHECK_EQ(notifier::NOTIFICATION_SERVER, options.notification_method);
       network_channel_creator =
           syncer::NonBlockingInvalidator::MakePushClientChannelCreator(options);
       break;
     }
     case GCM_NETWORK_CHANNEL: {
       gcm::GCMProfileService* gcm_profile_service =
           gcm::GCMProfileServiceFactory::GetForProfile(profile_);
       gcm_invalidation_bridge_.reset(
           new GCMInvalidationBridge(gcm_profile_service, auth_provider_.get()));
       network_channel_creator =
           syncer::NonBlockingInvalidator::MakeGCMNetworkChannelCreator(
-              profile_->GetRequestContext(),
+              request_context_,
               gcm_invalidation_bridge_->CreateDelegate().Pass());
       break;
     }
     default: {
       NOTREACHED();
       return;
     }
   }
   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();
 
   invalidator_->RegisterHandler(this);
   invalidator_->UpdateRegisteredIds(
       this,
       invalidator_registrar_->GetAllRegisteredIds());
 }
 
 void TiclInvalidationService::UpdateInvalidationNetworkChannel() {
@@ skipping 25 matching lines @@
 }
 
 void TiclInvalidationService::StopInvalidator() {
   DCHECK(invalidator_);
   gcm_invalidation_bridge_.reset();
   invalidator_->UnregisterHandler(this);
   invalidator_.reset();
 }
 
 }  // namespace invalidation