Remove Profile dependency from TiclInvalidationService

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_service_util.h"
-#include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/services/gcm/gcm_profile_service.h"
 #include "chrome/browser/services/gcm/gcm_service.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[] = {
@@ skipping 25 matching lines @@
   -1,
 
   // Don't use initial delay unless the last request was an error.
   false,
 };
 
 namespace invalidation {
 
 TiclInvalidationService::TiclInvalidationService(
     scoped_ptr<IdentityProvider> identity_provider,
+    scoped_ptr<TiclSettingsProvider> settings_provider,
     gcm::GCMService* gcm_service,
-    const scoped_refptr<net::URLRequestContextGetter>& request_context,
-    Profile* profile)
+    const scoped_refptr<net::URLRequestContextGetter>& request_context)
     : OAuth2TokenService::Consumer("ticl_invalidation"),
-      profile_(profile),
       identity_provider_(identity_provider.Pass()),
+      settings_provider_(settings_provider.Pass()),
       invalidator_registrar_(new syncer::InvalidatorRegistrar()),
       request_access_token_backoff_(&kRequestAccessTokenBackoffPolicy),
       network_channel_type_(PUSH_CLIENT_CHANNEL),
       gcm_service_(gcm_service),
       request_context_(request_context),
       logger_() {}
 
 TiclInvalidationService::~TiclInvalidationService() {
   DCHECK(CalledOnValidThread());
 }
 
 void TiclInvalidationService::Init(
     scoped_ptr<syncer::InvalidationStateTracker> invalidation_state_tracker) {
   DCHECK(CalledOnValidThread());
   invalidation_state_tracker_ = invalidation_state_tracker.Pass();
 
   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,
-                 base::Unretained(this)));
-
   UpdateInvalidationNetworkChannel();
   UMA_HISTOGRAM_ENUMERATION("Invalidations.NetworkChannel",
                             network_channel_type_,
                             NETWORK_CHANNELS_COUNT);
 
   if (IsReadyToStart()) {
     StartInvalidator(network_channel_type_);
   }
 
   identity_provider_->AddObserver(this);
   identity_provider_->AddActiveAccountRefreshTokenObserver(this);
+  settings_provider_->AddObserver(this);
 }
 
 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);
@@ skipping 157 matching lines @@
     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());
 }
 
+void TiclInvalidationService::OnUseGCMChannelChanged() {
+  UpdateInvalidationNetworkChannel();
+}
+
 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.
     //
     // We won't be receiving any invalidations while the refresh is in progress,
     // we set our state to TRANSIENT_INVALIDATION_ERROR.  If the credentials
@@ skipping 13 matching lines @@
     const syncer::ObjectIdInvalidationMap& invalidation_map) {
   invalidator_registrar_->DispatchInvalidationsToHandlers(invalidation_map);
 
   logger_.OnInvalidation(invalidation_map);
 }
 
 std::string TiclInvalidationService::GetOwnerName() const { return "TICL"; }
 
 void TiclInvalidationService::Shutdown() {
   DCHECK(CalledOnValidThread());
+  settings_provider_->RemoveObserver(this);
   identity_provider_->RemoveActiveAccountRefreshTokenObserver(this);
   identity_provider_->RemoveObserver(this);
   if (IsStarted()) {
     StopInvalidator();
   }
   invalidation_state_tracker_.reset();
   invalidator_registrar_.reset();
 }
 
 bool TiclInvalidationService::IsReadyToStart() {
@@ skipping 83 matching lines @@
 
   UpdateInvalidatorCredentials();
 
   invalidator_->RegisterHandler(this);
   invalidator_->UpdateRegisteredIds(
       this,
       invalidator_registrar_->GetAllRegisteredIds());
 }
 
 void TiclInvalidationService::UpdateInvalidationNetworkChannel() {
-  InvalidationNetworkChannel network_channel_type = PUSH_CLIENT_CHANNEL;
-  if (gcm::GCMProfileService::GetGCMEnabledState(profile_) ==
-          gcm::GCMProfileService::ALWAYS_ENABLED &&
-      (profile_->GetPrefs()->GetBoolean(
-           prefs::kInvalidationServiceUseGCMChannel) ||
-       CommandLine::ForCurrentProcess()->HasSwitch(
-           switches::kInvalidationUseGCMChannel))) {
-    network_channel_type = GCM_NETWORK_CHANNEL;
-  }
+  const InvalidationNetworkChannel network_channel_type =
+      settings_provider_->UseGCMChannel() ? GCM_NETWORK_CHANNEL
+                                          : PUSH_CLIENT_CHANNEL;
   if (network_channel_type_ == network_channel_type)
     return;
   network_channel_type_ = network_channel_type;
   if (IsStarted()) {
     StopInvalidator();
     StartInvalidator(network_channel_type_);
   }
 }
 
 void TiclInvalidationService::UpdateInvalidatorCredentials() {
   std::string email = identity_provider_->GetActiveAccountId();
 
   DCHECK(!email.empty()) << "Expected user to be signed in.";
 
   DVLOG(2) << "UpdateCredentials: " << email;
   invalidator_->UpdateCredentials(email, access_token_);
 }
 
 void TiclInvalidationService::StopInvalidator() {
   DCHECK(invalidator_);
   gcm_invalidation_bridge_.reset();
   invalidator_->UnregisterHandler(this);
   invalidator_.reset();
 }
 
 }  // namespace invalidation