Report InvalidatorState correctly from GCMNetworkChannel

chrome/browser/invalidation/gcm_invalidation_bridge_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 "chrome/browser/signin/fake_profile_oauth2_token_service.h"
 #include "chrome/browser/signin/fake_profile_oauth2_token_service_builder.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/gcm_driver/fake_gcm_driver.h"
@@ skipping 29 matching lines @@
                    gcm::GCMClient::SUCCESS));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CustomFakeGCMDriver);
 };
 
 class GCMInvalidationBridgeTest : public ::testing::Test {
  protected:
   GCMInvalidationBridgeTest()
-      : connection_state_(
-            syncer::GCMNetworkChannelDelegate::CONNECTION_STATE_OFFLINE) {}
+      : connection_online_(false) {}
 
   virtual ~GCMInvalidationBridgeTest() {}
 
   virtual void SetUp() OVERRIDE {
     TestingProfile::Builder builder;
     builder.AddTestingFactory(ProfileOAuth2TokenServiceFactory::GetInstance(),
                               &BuildAutoIssuingFakeProfileOAuth2TokenService);
     profile_ = builder.Build();
 
     FakeProfileOAuth2TokenService* token_service =
@@ skipping 23 matching lines @@
                         gcm::GCMClient::Result result) {
     registration_id_ = registration_id;
   }
 
   void RequestTokenFinished(const GoogleServiceAuthError& error,
                             const std::string& token) {
     issued_tokens_.push_back(token);
     request_token_errors_.push_back(error);
   }
 
-  void ConnectionStateChanged(
-      syncer::GCMNetworkChannelDelegate::ConnectionState connection_state) {
-    connection_state_ = connection_state;
+  void ConnectionStateChanged(bool online) {
+    connection_online_ = online;
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<Profile> profile_;
   scoped_ptr<gcm::GCMDriver> gcm_driver_;
   scoped_ptr<FakeIdentityProvider> identity_provider_;
 
   std::vector<std::string> issued_tokens_;
   std::vector<GoogleServiceAuthError> request_token_errors_;
   std::string registration_id_;
-  syncer::GCMNetworkChannelDelegate::ConnectionState connection_state_;
+  bool connection_online_;
 
   scoped_ptr<GCMInvalidationBridge> bridge_;
   scoped_ptr<syncer::GCMNetworkChannelDelegate> delegate_;
 };
 
 TEST_F(GCMInvalidationBridgeTest, RequestToken) {
   // Make sure that call to RequestToken reaches OAuth2TokenService and gets
   // back to callback.
   delegate_->RequestToken(
       base::Bind(&GCMInvalidationBridgeTest::RequestTokenFinished,
@@ skipping 28 matching lines @@
 TEST_F(GCMInvalidationBridgeTest, Register) {
   EXPECT_TRUE(registration_id_.empty());
   delegate_->Register(base::Bind(&GCMInvalidationBridgeTest::RegisterFinished,
                                  base::Unretained(this)));
   RunLoop();
 
   EXPECT_FALSE(registration_id_.empty());
 }
 
 TEST_F(GCMInvalidationBridgeTest, ConnectionState) {
-  EXPECT_EQ(syncer::GCMNetworkChannelDelegate::CONNECTION_STATE_OFFLINE,
-            connection_state_);
+  EXPECT_FALSE(connection_online_);
   bridge_->OnConnected(net::IPEndPoint());
   RunLoop();
-  EXPECT_EQ(syncer::GCMNetworkChannelDelegate::CONNECTION_STATE_ONLINE,
-            connection_state_);
+  EXPECT_TRUE(connection_online_);
   bridge_->OnDisconnected();
   RunLoop();
-  EXPECT_EQ(syncer::GCMNetworkChannelDelegate::CONNECTION_STATE_OFFLINE,
-            connection_state_);
+  EXPECT_FALSE(connection_online_);
 }
 
 }  // namespace
 }  // namespace invalidation