Report InvalidatorState correctly from GCMNetworkChannel

components/invalidation/gcm_network_channel.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/base64.h"
 #include "base/i18n/time_formatting.h"
 #include "base/metrics/histogram.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 89 matching lines @@
 }
 
 }  // namespace
 
 GCMNetworkChannel::GCMNetworkChannel(
     scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     scoped_ptr<GCMNetworkChannelDelegate> delegate)
     : request_context_getter_(request_context_getter),
       delegate_(delegate.Pass()),
       register_backoff_entry_(new net::BackoffEntry(&kRegisterBackoffPolicy)),
+      gcm_channel_online_(false),
+      http_channel_online_(false),
       diagnostic_info_(this),
       weak_factory_(this) {
   net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
   delegate_->Initialize(base::Bind(&GCMNetworkChannel::OnConnectionStateChanged,
                                    weak_factory_.GetWeakPtr()));
   Register();
 }
 
 GCMNetworkChannel::~GCMNetworkChannel() {
   net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
@@ skipping 68 matching lines @@
     // Nothing to do.
     return;
   }
 
   if (error.state() != GoogleServiceAuthError::NONE) {
     // Requesting access token failed. Persistent errors will be reported by
     // token service. Just drop this request, cacheinvalidations will retry
     // sending message and at that time we'll retry requesting access token.
     DVLOG(1) << "RequestAccessToken failed: " << error.ToString();
     RecordOutgoingMessageStatus(ACCESS_TOKEN_FAILURE);
-    // Message won't get sent because of connection failure. Let's retry once
-    // connection is restored.
-    if (error.state() == GoogleServiceAuthError::CONNECTION_FAILED)
-      NotifyStateChange(TRANSIENT_INVALIDATION_ERROR);
+    // Message won't get sent. Notify that http channel doesn't work.
+    UpdateHttpChannelState(false);
     cached_message_.clear();
     return;
   }
   DCHECK(!token.empty());
   // Save access token in case POST fails and we need to invalidate it.
   access_token_ = token;
 
   DVLOG(2) << "Got access token, sending message";
   fetcher_.reset(net::URLFetcher::Create(
       BuildUrl(registration_id_), net::URLFetcher::POST, this));
@@ skipping 24 matching lines @@
       fetcher->GetResponseCode() == net::HTTP_UNAUTHORIZED) {
     DVLOG(1) << "URLFetcher failure: HTTP_UNAUTHORIZED";
     delegate_->InvalidateToken(access_token_);
   }
 
   if (!status.is_success() ||
       (fetcher->GetResponseCode() != net::HTTP_OK &&
        fetcher->GetResponseCode() != net::HTTP_NO_CONTENT)) {
     DVLOG(1) << "URLFetcher failure";
     RecordOutgoingMessageStatus(POST_FAILURE);
-    NotifyStateChange(TRANSIENT_INVALIDATION_ERROR);
+    // POST failed. Notify that http channel doesn't work.
+    UpdateHttpChannelState(false);
     return;
   }
 
   RecordOutgoingMessageStatus(OUTGOING_MESSAGE_SUCCESS);
-  NotifyStateChange(INVALIDATIONS_ENABLED);
+  // Successfully sent message. Http channel works.
+  UpdateHttpChannelState(true);
   DVLOG(2) << "URLFetcher success";
 }
 
 void GCMNetworkChannel::OnIncomingMessage(const std::string& message,
                                           const std::string& echo_token) {
 #if !defined(OS_ANDROID)
   if (!echo_token.empty())
     echo_token_ = echo_token;
   diagnostic_info_.last_message_empty_echo_token_ = echo_token.empty();
   diagnostic_info_.last_message_received_time_ = base::Time::Now();
 
   if (message.empty()) {
     RecordIncomingMessageStatus(MESSAGE_EMPTY);
     return;
   }
   std::string data;
   if (!Base64DecodeURLSafe(message, &data)) {
     RecordIncomingMessageStatus(INVALID_ENCODING);
     return;
   }
   ipc::invalidation::AddressedAndroidMessage android_message;
   if (!android_message.ParseFromString(data) ||
       !android_message.has_message()) {
     RecordIncomingMessageStatus(INVALID_PROTO);
     return;
   }
   DVLOG(2) << "Deliver incoming message";
   RecordIncomingMessageStatus(INCOMING_MESSAGE_SUCCESS);
+  UpdateGcmChannelState(true);
   DeliverIncomingMessage(android_message.message());
 #else
   // This code shouldn't be invoked on Android.
   NOTREACHED();
 #endif
 }
 
-void GCMNetworkChannel::OnConnectionStateChanged(
-    GCMNetworkChannelDelegate::ConnectionState connection_state) {
-  switch (connection_state) {
-    case GCMNetworkChannelDelegate::CONNECTION_STATE_OFFLINE: {
-      NotifyStateChange(TRANSIENT_INVALIDATION_ERROR);
-      break;
-    }
-    case GCMNetworkChannelDelegate::CONNECTION_STATE_ONLINE: {
-      NotifyStateChange(INVALIDATIONS_ENABLED);
-      break;
-    }
-    default: {
-      NOTREACHED();
-      break;
-    }
-  }
+void GCMNetworkChannel::OnConnectionStateChanged(bool online) {
+  UpdateGcmChannelState(online);
 }
 
 void GCMNetworkChannel::OnNetworkChanged(
     net::NetworkChangeNotifier::ConnectionType connection_type) {
   // Network connection is restored. Let's notify cacheinvalidations so it has
   // chance to retry.
-  if (connection_type != net::NetworkChangeNotifier::CONNECTION_NONE)
-    NotifyStateChange(INVALIDATIONS_ENABLED);
+  NotifyNetworkStatusChange(
+      connection_type != net::NetworkChangeNotifier::CONNECTION_NONE);
+}
+
+void GCMNetworkChannel::UpdateGcmChannelState(bool online) {
+  if (gcm_channel_online_ == online)
+    return;
+  gcm_channel_online_ = online;
+  InvalidatorState channel_state = TRANSIENT_INVALIDATION_ERROR;
+  if (gcm_channel_online_ && http_channel_online_)
+    channel_state = INVALIDATIONS_ENABLED;
+  NotifyChannelStateChange(channel_state);
+}
+
+void GCMNetworkChannel::UpdateHttpChannelState(bool online) {
+  if (http_channel_online_ == online)
+    return;
+  http_channel_online_ = online;
+  InvalidatorState channel_state = TRANSIENT_INVALIDATION_ERROR;
+  if (gcm_channel_online_ && http_channel_online_)
+    channel_state = INVALIDATIONS_ENABLED;
+  NotifyChannelStateChange(channel_state);
 }
 
 GURL GCMNetworkChannel::BuildUrl(const std::string& registration_id) {
   DCHECK(!registration_id.empty());
 
 #if !defined(OS_ANDROID)
   ipc::invalidation::EndpointId endpoint_id;
   endpoint_id.set_c2dm_registration_id(registration_id);
   endpoint_id.set_client_key(std::string());
   endpoint_id.set_package_name(kCacheInvalidationPackageName);
@@ skipping 119 matching lines @@
     ENUM_CASE(gcm::GCMClient::NOT_SIGNED_IN);
     ENUM_CASE(gcm::GCMClient::INVALID_PARAMETER);
     ENUM_CASE(gcm::GCMClient::ASYNC_OPERATION_PENDING);
     ENUM_CASE(gcm::GCMClient::GCM_DISABLED);
   }
   NOTREACHED();
   return "";
 }
 
 }  // namespace syncer