Control invalidations network channel 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 "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/invalidation/invalidation_service_util.h"
@@ skipping 63 matching lines @@
   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 (IsReadyToStart()) {
-    StartInvalidator();
+    StartInvalidator(PUSH_CLIENT_CHANNEL);
   }
 
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_GOOGLE_SIGNED_OUT,
                               content::Source<Profile>(profile_));
   oauth2_token_service_->AddObserver(this);
 }
 
 void TiclInvalidationService::InitForTest(syncer::Invalidator* invalidator) {
   // Here we perform the equivalent of Init() and StartInvalidator(), but with
@@ skipping 88 matching lines @@
 void TiclInvalidationService::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
   DCHECK_EQ(access_token_request_, request);
   access_token_request_.reset();
   // Reset backoff time after successful response.
   request_access_token_backoff_.Reset();
   access_token_ = access_token;
   if (!IsStarted() && IsReadyToStart()) {
-    StartInvalidator();
+    StartInvalidator(PUSH_CLIENT_CHANNEL);
   } else {
     UpdateInvalidatorCredentials();
   }
 }
 
 void TiclInvalidationService::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   DCHECK_EQ(access_token_request_, request);
   DCHECK_NE(error.state(), GoogleServiceAuthError::NONE);
@@ skipping 19 matching lines @@
     default: {
       // We have no way to notify the user of this.  Do nothing.
     }
   }
 }
 
 void TiclInvalidationService::OnRefreshTokenAvailable(
     const std::string& account_id) {
   if (oauth2_token_service_->GetPrimaryAccountId() == account_id) {
     if (!IsStarted() && IsReadyToStart()) {
-      StartInvalidator();
+      StartInvalidator(PUSH_CLIENT_CHANNEL);
     }
   }
 }
 
 void TiclInvalidationService::OnRefreshTokenRevoked(
     const std::string& account_id) {
   if (oauth2_token_service_->GetPrimaryAccountId() == account_id) {
     access_token_.clear();
     if (IsStarted()) {
       UpdateInvalidatorCredentials();
@@ skipping 62 matching lines @@
     return false;
   }
 
   return true;
 }
 
 bool TiclInvalidationService::IsStarted() {
   return invalidator_.get() != NULL;
 }
 
-void TiclInvalidationService::StartInvalidator() {
+void TiclInvalidationService::StartInvalidator(
+    InvalidationNetworkChannel network_channel) {
   DCHECK(CalledOnValidThread());
   DCHECK(!invalidator_);
   DCHECK(invalidator_storage_);
   DCHECK(!invalidator_storage_->GetInvalidatorClientId().empty());
 
   if (access_token_.empty()) {
     DVLOG(1)
         << "TiclInvalidationService: "
         << "Deferring start until we have an access token.";
     RequestAccessToken();
     return;
   }
 
-  notifier::NotifierOptions options =
-      ParseNotifierOptions(*CommandLine::ForCurrentProcess());
-  options.request_context_getter = profile_->GetRequestContext();
-  options.auth_mechanism = "X-OAUTH2";
+  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.auth_mechanism = "X-OAUTH2";
+      DCHECK_EQ(notifier::NOTIFICATION_SERVER, options.notification_method);
+      network_channel_creator =
+          syncer::NonBlockingInvalidator::MakePushClientChannelCreator(options);
+      break;
+    }
+    case GCM_NETWORK_CHANNEL: {
+      network_channel_creator =
+          syncer::NonBlockingInvalidator::MakeGCMNetworkChannelCreator();
+      break;
+    }
+    default: {
+      NOTREACHED();
+      return;
+    }
+  }
   invalidator_.reset(new syncer::NonBlockingInvalidator(
-          options,
+          network_channel_creator,
           invalidator_storage_->GetInvalidatorClientId(),
           invalidator_storage_->GetSavedInvalidations(),
           invalidator_storage_->GetBootstrapData(),
           syncer::WeakHandle<syncer::InvalidationStateTracker>(
               invalidator_storage_->AsWeakPtr()),
-          content::GetUserAgent(GURL())));
+          content::GetUserAgent(GURL()),
+          profile_->GetRequestContext()));
 
   UpdateInvalidatorCredentials();
 
   invalidator_->RegisterHandler(this);
   invalidator_->UpdateRegisteredIds(
       this,
       invalidator_registrar_->GetAllRegisteredIds());
 }
 
 void TiclInvalidationService::UpdateInvalidatorCredentials() {
@@ skipping 20 matching lines @@
   }
 
   // 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());
 }
 
 }  // namespace invalidation