Notify SyncNetworkChannel about GCM connection state

components/invalidation/gcm_invalidation_bridge.cc

 // Copyright 2014 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 "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/gcm_driver/gcm_driver.h"
 #include "components/invalidation/gcm_invalidation_bridge.h"
@@ skipping 23 matching lines @@
 // and passes all calls to GCMInvalidationBridge. All calls should be serialized
 // through GCMInvalidationBridge to avoid race conditions.
 class GCMInvalidationBridge::Core : public syncer::GCMNetworkChannelDelegate,
                                     public base::NonThreadSafe {
  public:
   Core(base::WeakPtr<GCMInvalidationBridge> bridge,
        scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner);
   virtual ~Core();
 
   // syncer::GCMNetworkChannelDelegate implementation.
-  virtual void Initialize() OVERRIDE;
+  virtual void Initialize(ConnectionStateCallback callback) OVERRIDE;
   virtual void RequestToken(RequestTokenCallback callback) OVERRIDE;
   virtual void InvalidateToken(const std::string& token) OVERRIDE;
   virtual void Register(RegisterCallback callback) OVERRIDE;
   virtual void SetMessageReceiver(MessageCallback callback) OVERRIDE;
 
   void RequestTokenFinished(RequestTokenCallback callback,
                             const GoogleServiceAuthError& error,
                             const std::string& token);
 
   void RegisterFinished(RegisterCallback callback,
                         const std::string& registration_id,
                         gcm::GCMClient::Result result);
 
   void OnIncomingMessage(const std::string& message,
                          const std::string& echo_token);
 
+  void OnConnectionStateChanged(ConnectionState connection_state);
+
  private:
   base::WeakPtr<GCMInvalidationBridge> bridge_;
   scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner_;
 
   MessageCallback message_callback_;
+  ConnectionStateCallback connection_state_callback_;
 
   base::WeakPtrFactory<Core> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 GCMInvalidationBridge::Core::Core(
     base::WeakPtr<GCMInvalidationBridge> bridge,
     scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner)
     : bridge_(bridge),
       ui_thread_task_runner_(ui_thread_task_runner),
       weak_factory_(this) {
   // Core is created on UI thread but all calls happen on IO thread.
   DetachFromThread();
 }
 
 GCMInvalidationBridge::Core::~Core() {}
 
-void GCMInvalidationBridge::Core::Initialize() {
+void GCMInvalidationBridge::Core::Initialize(ConnectionStateCallback callback) {
   DCHECK(CalledOnValidThread());
+  connection_state_callback_ = callback;
   // Pass core WeapPtr and TaskRunner to GCMInvalidationBridge for it to be able
   // to post back.
   ui_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::CoreInitializationDone,
                  bridge_,
                  weak_factory_.GetWeakPtr(),
                  base::ThreadTaskRunnerHandle::Get()));
 }
 
@@ skipping 42 matching lines @@
   callback.Run(registration_id, result);
 }
 
 void GCMInvalidationBridge::Core::OnIncomingMessage(
     const std::string& message,
     const std::string& echo_token) {
   DCHECK(!message_callback_.is_null());
   message_callback_.Run(message, echo_token);
 }
 
+void GCMInvalidationBridge::Core::OnConnectionStateChanged(
+    ConnectionState connection_state) {
+  if (!connection_state_callback_.is_null()) {
+    connection_state_callback_.Run(connection_state);
+  }
+}
+
 GCMInvalidationBridge::GCMInvalidationBridge(
     gcm::GCMDriver* gcm_driver,
     IdentityProvider* identity_provider)
     : OAuth2TokenService::Consumer("gcm_network_channel"),
       gcm_driver_(gcm_driver),
       identity_provider_(identity_provider),
       subscribed_for_incoming_messages_(false),
       weak_factory_(this) {}
 
 GCMInvalidationBridge::~GCMInvalidationBridge() {
@@ skipping 152 matching lines @@
 }
 
 void GCMInvalidationBridge::OnSendError(
     const std::string& app_id,
     const gcm::GCMClient::SendErrorDetails& send_error_details) {
   // cacheinvalidation doesn't send messages over GCM.
   NOTREACHED();
 }
 
 void GCMInvalidationBridge::OnConnected(const net::IPEndPoint& ip_endpoint) {
-  // TODO(pavely): update invalidator state.
+  core_thread_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMInvalidationBridge::Core::OnConnectionStateChanged,
+                 core_,
+                 syncer::GCMNetworkChannelDelegate::CONNECTION_STATE_ONLINE));
 }
 
 void GCMInvalidationBridge::OnDisconnected() {
-  // TODO(pavely): update invalidator state.
+  core_thread_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMInvalidationBridge::Core::OnConnectionStateChanged,
+                 core_,
+                 syncer::GCMNetworkChannelDelegate::CONNECTION_STATE_OFFLINE));
 }
 
 
 }  // namespace invalidation