[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;

[Nicolas Zea, 2014/08/05 23:39:48]

Why was this removed?

[fgorski, 2014/08/06 16:22:27]

Because it is not needed.
It seems that when the test was originally defined, this was extra couple of
lines that shouldn't have make it. If you look below the

message.time_to_live = 500;

is pretty much the same logic. Variable "stanza" is never used in this test
other than to set TTL.

I was looking at this test to make the one which acknowledges, and accidentally
found these 3 lines.

-  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