Notify SyncNetworkChannel about GCM connection state

components/invalidation/gcm_network_channel_unittest.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/run_loop.h"
 #include "base/strings/string_util.h"
 #include "components/invalidation/gcm_network_channel.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 class TestGCMNetworkChannelDelegate : public GCMNetworkChannelDelegate {
  public:
   TestGCMNetworkChannelDelegate()
       : register_call_count_(0) {}
 
-  virtual void Initialize() OVERRIDE {}
+  virtual void Initialize(
+      GCMNetworkChannelDelegate::ConnectionStateCallback callback) OVERRIDE {
+    connection_state_callback = callback;
+  }
 
   virtual void RequestToken(RequestTokenCallback callback) OVERRIDE {
     request_token_callback = callback;
   }
 
   virtual void InvalidateToken(const std::string& token) OVERRIDE {
     invalidated_token = token;
   }
 
   virtual void Register(RegisterCallback callback) OVERRIDE {
     ++register_call_count_;
     register_callback = callback;
   }
 
   virtual void SetMessageReceiver(MessageCallback callback) OVERRIDE {
     message_callback = callback;
   }
 
   RequestTokenCallback request_token_callback;
   std::string invalidated_token;
   RegisterCallback register_callback;
   int register_call_count_;
   MessageCallback message_callback;
+  ConnectionStateCallback connection_state_callback;
 };
 
 // Backoff policy for test. Run first 5 retries without delay.
 const net::BackoffEntry::Policy kTestBackoffPolicy = {
   // Number of initial errors (in sequence) to ignore before applying
   // exponential back-off rules.
   5,
 
   // Initial delay for exponential back-off in ms.
   2000, // 2 seconds.
@@ skipping 345 matching lines @@
     EXPECT_EQ(input, plain);
   }
   // Presence of '-', '_'.
   input = "\xfb\xff";
   Base64EncodeURLSafe(input, &base64);
   EXPECT_EQ("-_8", base64);
   EXPECT_TRUE(Base64DecodeURLSafe(base64, &plain));
   EXPECT_EQ(input, plain);
 }
 
-TEST_F(GCMNetworkChannelTest, TransientError) {
+TEST_F(GCMNetworkChannelTest, HttpTransientError) {
   EXPECT_FALSE(delegate()->message_callback.is_null());
   // POST will fail.
   url_fetcher_factory()->SetFakeResponse(GURL("http://test.url.com"),
                                          std::string(),
                                          net::HTTP_SERVICE_UNAVAILABLE,
                                          net::URLRequestStatus::SUCCESS);
 
   delegate()->register_callback.Run("registration.id", gcm::GCMClient::SUCCESS);
 
   network_channel()->SendMessage("abra.cadabra");
@@ skipping 10 matching lines @@
   EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, get_last_invalidator_state());
   // Network change to something else should trigger retry.
   network_channel()->OnNetworkChanged(
       net::NetworkChangeNotifier::CONNECTION_WIFI);
   EXPECT_EQ(INVALIDATIONS_ENABLED, get_last_invalidator_state());
   network_channel()->OnNetworkChanged(
       net::NetworkChangeNotifier::CONNECTION_NONE);
   EXPECT_EQ(INVALIDATIONS_ENABLED, get_last_invalidator_state());
 }
 
+TEST_F(GCMNetworkChannelTest, GcmConnectionState) {
+  delegate()->connection_state_callback.Run(
+      GCMNetworkChannelDelegate::CONNECTION_STATE_OFFLINE);
+  EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, get_last_invalidator_state());
+  delegate()->connection_state_callback.Run(
+      GCMNetworkChannelDelegate::CONNECTION_STATE_ONLINE);
+  EXPECT_EQ(INVALIDATIONS_ENABLED, get_last_invalidator_state());
+}
+
 #if !defined(OS_ANDROID)
 TEST_F(GCMNetworkChannelTest, BuildUrl) {
   GURL url = BuildUrl("registration.id");
   EXPECT_TRUE(url.SchemeIsHTTPOrHTTPS());
   EXPECT_FALSE(url.host().empty());
   EXPECT_FALSE(url.path().empty());
   std::vector<std::string> parts;
   Tokenize(url.path(), "/", &parts);
   std::string buffer;
   EXPECT_TRUE(Base64DecodeURLSafe(parts[parts.size() - 1], &buffer));
@@ skipping 35 matching lines @@
   delegate()->request_token_callback.Run(
       GoogleServiceAuthError::AuthErrorNone(), "access.token");
   RunLoopUntilIdle();
   EXPECT_EQ(url_fetchers_created_count(), 3);
   // Echo_token should be from second message.
   EXPECT_EQ("echo.token", get_last_echo_token());
 }
 #endif
 
 }  // namespace syncer