Client-to-server messages in GCMNetworkChannel

sync/notifier/sync_system_resources_unittest.cc

 // Copyright (c) 2012 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 "sync/notifier/sync_system_resources.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 163 matching lines @@
   message_loop_.RunUntilIdle();
   EXPECT_EQ(invalidation::Status(invalidation::Status::SUCCESS, std::string()),
             results);
 }
 
 class TestSyncNetworkChannel : public SyncNetworkChannel {
  public:
   TestSyncNetworkChannel() {}
   virtual ~TestSyncNetworkChannel() {}
 
-  using SyncNetworkChannel::NotifyStateChange;
+  using SyncNetworkChannel::SetNetworkState;
   using SyncNetworkChannel::DeliverIncomingMessage;
 
   virtual void SendEncodedMessage(const std::string& encoded_message) OVERRIDE {
     last_encoded_message_ = encoded_message;
   }
 
   virtual void UpdateCredentials(const std::string& email,
       const std::string& token) OVERRIDE {
   }
 
@@ skipping 100 matching lines @@
       data, &message, &service_context, &scheduling_hash));
   EXPECT_EQ(kMessage, message);
   EXPECT_EQ(kServiceContext, service_context);
   EXPECT_EQ(kSchedulingHash, scheduling_hash);
 }
 
 // Simulate network channel state change. It should propagate to observer.
 TEST_F(SyncNetworkChannelTest, OnNetworkChannelStateChanged) {
   EXPECT_EQ(DEFAULT_INVALIDATION_ERROR, last_invalidator_state_);
   EXPECT_FALSE(connected_);
-  network_channel_.NotifyStateChange(INVALIDATIONS_ENABLED);
+  network_channel_.SetNetworkState(INVALIDATIONS_ENABLED);
   EXPECT_EQ(INVALIDATIONS_ENABLED, last_invalidator_state_);
   EXPECT_TRUE(connected_);
-  network_channel_.NotifyStateChange(INVALIDATION_CREDENTIALS_REJECTED);
+  network_channel_.SetNetworkState(INVALIDATION_CREDENTIALS_REJECTED);
   EXPECT_EQ(INVALIDATION_CREDENTIALS_REJECTED, last_invalidator_state_);
   EXPECT_FALSE(connected_);
 }
 
 // Call SendMessage on the channel.  SendEncodedMessage should be called for it.
 TEST_F(SyncNetworkChannelTest, SendMessage) {
   network_channel_.SendMessage(kMessage);
   std::string expected_encoded_message =
       SyncNetworkChannel::EncodeMessageForTest(
           kMessage,
@@ skipping 79 matching lines @@
         network_channel_.last_encoded_message_,
         &message, &service_context, &scheduling_hash));
     EXPECT_EQ(kMessage, message);
     EXPECT_EQ(kServiceContext, service_context);
     EXPECT_EQ(kSchedulingHash, scheduling_hash);
   }
 }
 
 }  // namespace
 }  // namespace syncer