Report InvalidatorState correctly from GCMNetworkChannel

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 40 matching lines @@
                             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);
+  void OnConnectionStateChanged(bool online);
 
  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_;
 
@@ skipping 70 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) {
+void GCMInvalidationBridge::Core::OnConnectionStateChanged(bool online) {
   if (!connection_state_callback_.is_null()) {
-    connection_state_callback_.Run(connection_state);
+    connection_state_callback_.Run(online);
   }
 }
 
 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),
@@ skipping 113 matching lines @@
                  result));
 }
 
 void GCMInvalidationBridge::SubscribeForIncomingMessages() {
   // No-op if GCMClient is disabled.
   if (gcm_driver_ == NULL)
     return;
 
   DCHECK(!subscribed_for_incoming_messages_);
   gcm_driver_->AddAppHandler(kInvalidationsAppId, this);
+  core_thread_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMInvalidationBridge::Core::OnConnectionStateChanged,
+                 core_,
+                 gcm_driver_->IsConnected()));
+
   subscribed_for_incoming_messages_ = true;
 }
 
 void GCMInvalidationBridge::ShutdownHandler() {
   // Nothing to do.
 }
 
 void GCMInvalidationBridge::OnMessage(
     const std::string& app_id,
     const gcm::GCMClient::IncomingMessage& message) {
@@ skipping 24 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) {
   core_thread_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&GCMInvalidationBridge::Core::OnConnectionStateChanged,
-                 core_,
-                 syncer::GCMNetworkChannelDelegate::CONNECTION_STATE_ONLINE));
+      base::Bind(
+          &GCMInvalidationBridge::Core::OnConnectionStateChanged, core_, true));
 }
 
 void GCMInvalidationBridge::OnDisconnected() {
   core_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::Core::OnConnectionStateChanged,
                  core_,
-                 syncer::GCMNetworkChannelDelegate::CONNECTION_STATE_OFFLINE));
+                 false));
 }
 
 
 }  // namespace invalidation