[GCM] Adding the OnSendAcknowledgement event

components/gcm_driver/gcm_client_impl_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 "components/gcm_driver/gcm_client_impl.h"
 
 #include "base/command_line.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 17 matching lines @@
 namespace gcm {
 
 namespace {
 
 enum LastEvent {
   NONE,
   LOADING_COMPLETED,
   REGISTRATION_COMPLETED,
   UNREGISTRATION_COMPLETED,
   MESSAGE_SEND_ERROR,
+  MESSAGE_SEND_ACK,
   MESSAGE_RECEIVED,
   MESSAGES_DELETED,
 };
 
 const uint64 kDeviceAndroidId = 54321;
 const uint64 kDeviceSecurityToken = 12345;
 const int64 kSettingsCheckinInterval = 16 * 60 * 60;
 const char kAppId[] = "app_id";
 const char kSender[] = "project_id";
 const char kSender2[] = "project_id2";
@@ skipping 168 matching lines @@
  public:
   GCMClientImplTest();
   virtual ~GCMClientImplTest();
 
   virtual void SetUp() OVERRIDE;
 
   void BuildGCMClient(base::TimeDelta clock_step);
   void InitializeGCMClient();
   void StartGCMClient();
   void ReceiveMessageFromMCS(const MCSMessage& message);
+  void ReceiveOnMessageSentToMCS(
+      const std::string& app_id,
+      const std::string& message_id,
+      const MCSClient::MessageSendStatus status);
   void CompleteCheckin(uint64 android_id,
                        uint64 security_token,
                        const std::string& digest,
                        const std::map<std::string, std::string>& settings);
   void CompleteRegistration(const std::string& registration_id);
   void CompleteUnregistration(const std::string& app_id);
 
   bool ExistsRegistration(const std::string& app_id) const;
   void AddRegistration(const std::string& app_id,
                        const std::vector<std::string>& sender_ids,
                        const std::string& registration_id);
 
   // GCMClient::Delegate overrides (for verification).
   virtual void OnRegisterFinished(const std::string& app_id,
                                   const std::string& registration_id,
                                   GCMClient::Result result) OVERRIDE;
   virtual void OnUnregisterFinished(const std::string& app_id,
                                     GCMClient::Result result) OVERRIDE;
   virtual void OnSendFinished(const std::string& app_id,
                               const std::string& message_id,
                               GCMClient::Result result) OVERRIDE {}
   virtual void OnMessageReceived(const std::string& registration_id,
                                  const GCMClient::IncomingMessage& message)
       OVERRIDE;
   virtual void OnMessagesDeleted(const std::string& app_id) OVERRIDE;
   virtual void OnMessageSendError(
       const std::string& app_id,
       const gcm::GCMClient::SendErrorDetails& send_error_details) OVERRIDE;
+  virtual void OnSendAcknowledged(const std::string& app_id,
+                                  const std::string& message_id) OVERRIDE;
   virtual void OnGCMReady() OVERRIDE;
   virtual void OnActivityRecorded() OVERRIDE {}
   virtual void OnConnected(const net::IPEndPoint& ip_endpoint) OVERRIDE {}
   virtual void OnDisconnected() OVERRIDE {}
 
   GCMClientImpl* gcm_client() const { return gcm_client_.get(); }
   FakeMCSClient* mcs_client() const {
     return reinterpret_cast<FakeMCSClient*>(gcm_client_->mcs_client_.get());
   }
   ConnectionFactory* connection_factory() const {
@@ skipping 203 matching lines @@
   // Start loading and check-in.
   gcm_client_->Start();
 
   PumpLoopUntilIdle();
 }
 
 void GCMClientImplTest::ReceiveMessageFromMCS(const MCSMessage& message) {
   gcm_client_->OnMessageReceivedFromMCS(message);
 }
 
+void GCMClientImplTest::ReceiveOnMessageSentToMCS(
+      const std::string& app_id,
+      const std::string& message_id,
+      const MCSClient::MessageSendStatus status) {
+  gcm_client_->OnMessageSentToMCS(0LL, app_id, message_id, status);
+}
+
 void GCMClientImplTest::OnGCMReady() {
   last_event_ = LOADING_COMPLETED;
   QuitLoop();
 }
 
 void GCMClientImplTest::OnMessageReceived(
     const std::string& registration_id,
     const GCMClient::IncomingMessage& message) {
   last_event_ = MESSAGE_RECEIVED;
   last_app_id_ = registration_id;
@@ skipping 23 matching lines @@
 }
 
 void GCMClientImplTest::OnMessageSendError(
     const std::string& app_id,
     const gcm::GCMClient::SendErrorDetails& send_error_details) {
   last_event_ = MESSAGE_SEND_ERROR;
   last_app_id_ = app_id;
   last_error_details_ = send_error_details;
 }
 
+void GCMClientImplTest::OnSendAcknowledged(const std::string& app_id,
+                                           const std::string& message_id) {
+  last_event_ = MESSAGE_SEND_ACK;
+  last_app_id_ = app_id;
+  last_message_id_ = message_id;
+}
+
 int64 GCMClientImplTest::CurrentTime() {
   return clock()->Now().ToInternalValue() / base::Time::kMicrosecondsPerSecond;
 }
 
 TEST_F(GCMClientImplTest, LoadingCompleted) {
   EXPECT_EQ(LOADING_COMPLETED, last_event());
   EXPECT_EQ(kDeviceAndroidId, mcs_client()->last_android_id());
   EXPECT_EQ(kDeviceSecurityToken, mcs_client()->last_security_token());
 
   // Checking freshly loaded CheckinInfo.
@@ skipping 141 matching lines @@
   MCSMessage message(BuildDownstreamMessage(
       kSender, kAppId, expected_data));
   EXPECT_TRUE(message.IsValid());
   ReceiveMessageFromMCS(message);
 
   EXPECT_EQ(MESSAGES_DELETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
 }
 
 TEST_F(GCMClientImplTest, SendMessage) {
-  mcs_proto::DataMessageStanza stanza;
-  stanza.set_ttl(500);
-
   GCMClient::OutgoingMessage message;
   message.id = "007";
   message.time_to_live = 500;
   message.data["key"] = "value";
   gcm_client()->Send(kAppId, kSender, message);
 
   EXPECT_EQ(kDataMessageStanzaTag, mcs_client()->last_message_tag());
   EXPECT_EQ(kAppId, mcs_client()->last_data_message_stanza().category());
   EXPECT_EQ(kSender, mcs_client()->last_data_message_stanza().to());
   EXPECT_EQ(500, mcs_client()->last_data_message_stanza().ttl());
   EXPECT_EQ(CurrentTime(), mcs_client()->last_data_message_stanza().sent());
   EXPECT_EQ("007", mcs_client()->last_data_message_stanza().id());
   EXPECT_EQ("gcm@chrome.com", mcs_client()->last_data_message_stanza().from());
   EXPECT_EQ(kSender, mcs_client()->last_data_message_stanza().to());
   EXPECT_EQ("key", mcs_client()->last_data_message_stanza().app_data(0).key());
   EXPECT_EQ("value",
             mcs_client()->last_data_message_stanza().app_data(0).value());
 }
 
+TEST_F(GCMClientImplTest, SendMessageAcknowledged) {
+  ReceiveOnMessageSentToMCS(kAppId, "007", MCSClient::SENT);
+  EXPECT_EQ(MESSAGE_SEND_ACK, last_event());
+  EXPECT_EQ(kAppId, last_app_id());
+  EXPECT_EQ("007", last_message_id());
+}
+
 class GCMClientImplCheckinTest : public GCMClientImplTest {
  public:
   GCMClientImplCheckinTest();
   virtual ~GCMClientImplCheckinTest();
 
   virtual void SetUp() OVERRIDE;
 };
 
 GCMClientImplCheckinTest::GCMClientImplCheckinTest() {
 }
@@ skipping 258 matching lines @@
 TEST_F(GCMClientImplStartAndStopTest, StartStopAndRestartImmediately) {
   // Start the GCM and then stop and restart it immediately.
   gcm_client()->Start();
   gcm_client()->Stop();
   gcm_client()->Start();
 
   PumpLoopUntilIdle();
 }
 
 }  // namespace gcm