Notify cacheinvalidations about network status

sync/notifier/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 137 matching lines @@
 }
 
 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)),
       diagnostic_info_(this),
       weak_factory_(this) {
+  net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
   delegate_->Initialize();
   Register();
 }
 
 GCMNetworkChannel::~GCMNetworkChannel() {
+  net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
 }
 
 void GCMNetworkChannel::UpdateCredentials(
     const std::string& email,
     const std::string& token) {
   // Do nothing. We get access token by requesting it for every message.
 }
 
 void GCMNetworkChannel::RequestDetailedStatus(
     base::Callback<void(const base::DictionaryValue&)> callback) {
@@ skipping 81 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);
     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 56 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);
     return;
   }
 
   RecordOutgoingMessageStatus(OUTGOING_MESSAGE_SUCCESS);
+  NotifyStateChange(INVALIDATIONS_ENABLED);
   DVLOG(2) << "URLFetcher success";
 }
 
+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);
+}
+
 GURL GCMNetworkChannel::BuildUrl(const std::string& registration_id) {
   DCHECK(!registration_id.empty());
 
 #if !defined(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);
   endpoint_id.mutable_channel_version()->set_major_version(
       ipc::invalidation::INITIAL);
@@ skipping 39 matching lines @@
   size_t padded_size = (input.size() + 3) - (input.size() + 3) % 4;
   std::string padded_input(input);
   padded_input.resize(padded_size, '=');
   // Convert to standard base64 alphabet.
   base::ReplaceChars(padded_input, "-", "+", &padded_input);
   base::ReplaceChars(padded_input, "_", "/", &padded_input);
   return base::Base64Decode(padded_input, output);
 }
 
 }  // namespace syncer