Notify cacheinvalidations about network status

sync/notifier/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 "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 "sync/notifier/gcm_network_channel.h"
@@ skipping 100 matching lines @@
  private:
   GCMNetworkChannelTest* test_;
 };
 
 class GCMNetworkChannelTest
     : public ::testing::Test,
       public SyncNetworkChannel::Observer {
  public:
   GCMNetworkChannelTest()
       : delegate_(NULL),
-        url_fetchers_created_count_(0) {
-  }
+        url_fetchers_created_count_(0),
+        last_invalidator_state_(TRANSIENT_INVALIDATION_ERROR) {}
 
   virtual ~GCMNetworkChannelTest() {
   }
 
   virtual void SetUp() {
     request_context_getter_ = new net::TestURLRequestContextGetter(
         base::MessageLoopProxy::current());
     // Ownership of delegate goes to GCNMentworkChannel but test needs pointer
     // to it.
     delegate_ = new TestGCMNetworkChannelDelegate();
@@ skipping 24 matching lines @@
     GCMNetworkChannel::Base64EncodeURLSafe(input, output);
   }
 
   static bool Base64DecodeURLSafe(const std::string& input,
                                   std::string* output) {
     return GCMNetworkChannel::Base64DecodeURLSafe(input, output);
   }
 
   virtual void OnNetworkChannelStateChanged(
       InvalidatorState invalidator_state) OVERRIDE {
+    last_invalidator_state_ = invalidator_state;
   }
 
   void OnIncomingMessage(std::string incoming_message) {
   }
 
   GCMNetworkChannel* network_channel() {
     return gcm_network_channel_.get();
   }
 
   TestGCMNetworkChannelDelegate* delegate() {
@@ skipping 20 matching lines @@
   }
 
   void set_last_echo_token(const std::string& echo_token) {
     last_echo_token_ = echo_token;
   }
 
   const std::string& get_last_echo_token() {
     return last_echo_token_;
   }
 
+  InvalidatorState get_last_invalidator_state() {
+    return last_invalidator_state_;
+  }
+
   void RunLoopUntilIdle() {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
  private:
   base::MessageLoop message_loop_;
   TestGCMNetworkChannelDelegate* delegate_;
   scoped_ptr<GCMNetworkChannel> gcm_network_channel_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
   scoped_ptr<net::FakeURLFetcherFactory> url_fetcher_factory_;
   int url_fetchers_created_count_;
   std::string last_echo_token_;
+  InvalidatorState last_invalidator_state_;
 };
 
 void TestNetworkChannelURLFetcher::AddExtraRequestHeader(
     const std::string& header_line) {
   net::FakeURLFetcher::AddExtraRequestHeader(header_line);
   std::string header_name("echo-token: ");
   std::string echo_token;
   if (StartsWithASCII(header_line, header_name, false)) {
     echo_token = header_line;
     ReplaceFirstSubstringAfterOffset(
         &echo_token, 0, header_name, std::string());
     test_->set_last_echo_token(echo_token);
   }
 }
 
 TEST_F(GCMNetworkChannelTest, HappyCase) {
+  EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, get_last_invalidator_state());
   EXPECT_FALSE(delegate()->message_callback.is_null());
   url_fetcher_factory()->SetFakeResponse(GURL("http://test.url.com"),
                                          std::string(),
-                                         net::HTTP_OK,
+                                         net::HTTP_NO_CONTENT,
                                          net::URLRequestStatus::SUCCESS);
 
   // After construction GCMNetworkChannel should have called Register.
   EXPECT_FALSE(delegate()->register_callback.is_null());
   // Return valid registration id.
   delegate()->register_callback.Run("registration.id", gcm::GCMClient::SUCCESS);
 
   network_channel()->SendMessage("abra.cadabra");
   // SendMessage should have triggered RequestToken. No HTTP request should be
   // started yet.
   EXPECT_FALSE(delegate()->request_token_callback.is_null());
   EXPECT_EQ(url_fetchers_created_count(), 0);
   // Return valid access token. This should trigger HTTP request.
   delegate()->request_token_callback.Run(
       GoogleServiceAuthError::AuthErrorNone(), "access.token");
   RunLoopUntilIdle();
   EXPECT_EQ(url_fetchers_created_count(), 1);
 
   // Return another access token. Message should be cleared by now and shouldn't
   // be sent.
   delegate()->request_token_callback.Run(
       GoogleServiceAuthError::AuthErrorNone(), "access.token2");
   RunLoopUntilIdle();
   EXPECT_EQ(url_fetchers_created_count(), 1);
+  EXPECT_EQ(INVALIDATIONS_ENABLED, get_last_invalidator_state());
 }
 
 TEST_F(GCMNetworkChannelTest, FailedRegister) {
   // After construction GCMNetworkChannel should have called Register.
   EXPECT_FALSE(delegate()->register_callback.is_null());
   EXPECT_EQ(1, delegate()->register_call_count_);
   // Return transient error from Register call.
   delegate()->register_callback.Run("", gcm::GCMClient::NETWORK_ERROR);
   RunLoopUntilIdle();
   // GcmNetworkChannel should have scheduled Register retry.
   EXPECT_EQ(2, delegate()->register_call_count_);
   // Return persistent error from Register call.
   delegate()->register_callback.Run("", gcm::GCMClient::NOT_SIGNED_IN);
   RunLoopUntilIdle();
   // GcmNetworkChannel should give up trying.
   EXPECT_EQ(2, delegate()->register_call_count_);
 
   network_channel()->SendMessage("abra.cadabra");
   // SendMessage shouldn't trigger RequestToken.
   EXPECT_TRUE(delegate()->request_token_callback.is_null());
   EXPECT_EQ(0, url_fetchers_created_count());
 }
 
 TEST_F(GCMNetworkChannelTest, RegisterFinishesAfterSendMessage) {
   url_fetcher_factory()->SetFakeResponse(GURL("http://test.url.com"),
                                          "",
-                                         net::HTTP_OK,
+                                         net::HTTP_NO_CONTENT,
                                          net::URLRequestStatus::SUCCESS);
 
   // After construction GCMNetworkChannel should have called Register.
   EXPECT_FALSE(delegate()->register_callback.is_null());
 
   network_channel()->SendMessage("abra.cadabra");
   // SendMessage shouldn't trigger RequestToken.
   EXPECT_TRUE(delegate()->request_token_callback.is_null());
   EXPECT_EQ(url_fetchers_created_count(), 0);
 
@@ skipping 103 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) {
+  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");
+  EXPECT_FALSE(delegate()->request_token_callback.is_null());
+  delegate()->request_token_callback.Run(
+      GoogleServiceAuthError::AuthErrorNone(), "access.token");
+  RunLoopUntilIdle();
+  EXPECT_EQ(url_fetchers_created_count(), 1);
+  // Failing HTTP POST should cause TRANSIENT_INVALIDATION_ERROR.
+  EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, get_last_invalidator_state());
+  // Network change to CONNECTION_NONE shouldn't affect invalidator state.
+  network_channel()->OnNetworkChanged(
+      net::NetworkChangeNotifier::CONNECTION_NONE);
+  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());
+}
+
 #if !defined(ANDROID)
 TEST_F(GCMNetworkChannelTest, EchoToken) {
   url_fetcher_factory()->SetFakeResponse(GURL("http://test.url.com"),
                                          std::string(),
                                          net::HTTP_OK,
                                          net::URLRequestStatus::SUCCESS);
   // After construction GCMNetworkChannel should have called Register.
   // Return valid registration id.
   delegate()->register_callback.Run("registration.id", gcm::GCMClient::SUCCESS);
 
@@ skipping 24 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