Control invalidations network channel from TiclInvalidationService

sync/notifier/non_blocking_invalidator.cc

Index: sync/notifier/non_blocking_invalidator.cc
diff --git a/sync/notifier/non_blocking_invalidator.cc b/sync/notifier/non_blocking_invalidator.cc
index bd0596722b0e155b7edf6e2bbac20924c1f1e1d0..5ec17586c4f324a96925dca378f1d90baa2c1366 100644
--- a/sync/notifier/non_blocking_invalidator.cc
+++ b/sync/notifier/non_blocking_invalidator.cc
@@ -15,9 +15,39 @@
 #include "jingle/notifier/listener/push_client.h"
 #include "sync/notifier/invalidation_notifier.h"
 #include "sync/notifier/object_id_invalidation_map.h"
+#include "sync/notifier/sync_system_resources.h"
 
 namespace syncer {
 
+struct NonBlockingInvalidator::InitializeOptions {
+  InitializeOptions(
+      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,
+      const std::string& client_info,
+      scoped_refptr<net::URLRequestContextGetter> request_context_getter)
+      : network_channel_creator(network_channel_creator),
+        invalidator_client_id(invalidator_client_id),
+        saved_invalidations(saved_invalidations),
+        invalidation_bootstrap_data(invalidation_bootstrap_data),
+        invalidation_state_tracker(invalidation_state_tracker),
+        client_info(client_info),
+        request_context_getter(request_context_getter) {
+  }
+
+  NetworkChannelCreator network_channel_creator;
+  std::string invalidator_client_id;
+  UnackedInvalidationsMap saved_invalidations;
+  std::string invalidation_bootstrap_data;
+  WeakHandle<InvalidationStateTracker> invalidation_state_tracker;
+  std::string client_info;
+  scoped_refptr<net::URLRequestContextGetter> request_context_getter;
+};
+
+
 class NonBlockingInvalidator::Core
     : public base::RefCountedThreadSafe<NonBlockingInvalidator::Core>,
       // InvalidationHandler to observe the InvalidationNotifier we create.
@@ -30,12 +60,7 @@ class NonBlockingInvalidator::Core
 
   // Helpers called on I/O thread.
   void Initialize(
-      const notifier::NotifierOptions& notifier_options,
-      const std::string& invalidator_client_id,
-      const UnackedInvalidationsMap& saved_invalidations,
-      const std::string& invalidation_bootstrap_data,
-      const WeakHandle<InvalidationStateTracker>& invalidation_state_tracker,
-      const std::string& client_info);
+      const NonBlockingInvalidator::InitializeOptions& initialize_options);
   void Teardown();
   void UpdateRegisteredIds(const ObjectIdSet& ids);
   void UpdateCredentials(const std::string& email, const std::string& token);
@@ -70,26 +95,21 @@ NonBlockingInvalidator::Core::~Core() {
 }
 
 void NonBlockingInvalidator::Core::Initialize(
-    const notifier::NotifierOptions& notifier_options,
-    const std::string& invalidator_client_id,
-    const UnackedInvalidationsMap& saved_invalidations,
-    const std::string& invalidation_bootstrap_data,
-    const WeakHandle<InvalidationStateTracker>& invalidation_state_tracker,
-    const std::string& client_info) {
-  DCHECK(notifier_options.request_context_getter.get());
-  DCHECK_EQ(notifier::NOTIFICATION_SERVER,
-            notifier_options.notification_method);
-  network_task_runner_ = notifier_options.request_context_getter->
-      GetNetworkTaskRunner();
+    const NonBlockingInvalidator::InitializeOptions& initialize_options) {
+  DCHECK(initialize_options.request_context_getter.get());
+  network_task_runner_ =
+      initialize_options.request_context_getter->GetNetworkTaskRunner();
   DCHECK(network_task_runner_->BelongsToCurrentThread());
+  scoped_ptr<SyncNetworkChannel> network_channel =
+      initialize_options.network_channel_creator.Run();
   invalidation_notifier_.reset(
       new InvalidationNotifier(
-          notifier::PushClient::CreateDefaultOnIOThread(notifier_options),
-          invalidator_client_id,
-          saved_invalidations,
-          invalidation_bootstrap_data,
-          invalidation_state_tracker,
-          client_info));
+          network_channel.Pass(),
+          initialize_options.invalidator_client_id,
+          initialize_options.saved_invalidations,
+          initialize_options.invalidation_bootstrap_data,
+          initialize_options.invalidation_state_tracker,
+          initialize_options.client_info));
   invalidation_notifier_->RegisterHandler(this);
 }
 
@@ -127,30 +147,34 @@ void NonBlockingInvalidator::Core::OnIncomingInvalidation(
 }
 
 NonBlockingInvalidator::NonBlockingInvalidator(
-    const notifier::NotifierOptions& notifier_options,
+    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,
-    const std::string& client_info)
+    const std::string& client_info,
+    const scoped_refptr<net::URLRequestContextGetter>& request_context_getter)
     : parent_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      network_task_runner_(
-          notifier_options.request_context_getter->GetNetworkTaskRunner()),
+      network_task_runner_(request_context_getter->GetNetworkTaskRunner()),
       weak_ptr_factory_(this) {
   core_ = new Core(MakeWeakHandle(weak_ptr_factory_.GetWeakPtr()));
 
+  InitializeOptions initialize_options(
+      network_channel_creator,
+      invalidator_client_id,
+      saved_invalidations,
+      invalidation_bootstrap_data,
+      invalidation_state_tracker,
+      client_info,
+      request_context_getter);
+
   if (!network_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(
               &NonBlockingInvalidator::Core::Initialize,
               core_.get(),
-              notifier_options,
-              invalidator_client_id,
-              saved_invalidations,
-              invalidation_bootstrap_data,
-              invalidation_state_tracker,
-              client_info))) {
+              initialize_options))) {
     NOTREACHED();
   }
 }
@@ -216,4 +240,16 @@ void NonBlockingInvalidator::OnIncomingInvalidation(
   registrar_.DispatchInvalidationsToHandlers(invalidation_map);
 }
 
+NetworkChannelCreator
+    NonBlockingInvalidator::MakePushClientChannelCreator(
+        const notifier::NotifierOptions& notifier_options) {
+  return base::Bind(SyncNetworkChannel::CreatePushClientChannel,
+      notifier_options);
+}
+
+NetworkChannelCreator
+    NonBlockingInvalidator::MakeGCMNetworkChannelCreator() {
+  return base::Bind(SyncNetworkChannel::CreateGCMNetworkChannel);
+}
+
 }  // namespace syncer