Provide a mechanism for the GCM driver to send message receipts to GCM.

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 <stdint.h>
 
 #include <initializer_list>
 #include <memory>
@@ skipping 293 matching lines @@
                           const std::string& registration_id,
                           GCMClient::Result result) override;
   void OnUnregisterFinished(
       const linked_ptr<RegistrationInfo>& registration_info,
       GCMClient::Result result) override;
   void OnSendFinished(const std::string& app_id,
                       const std::string& message_id,
                       GCMClient::Result result) override {}
   void OnMessageReceived(const std::string& registration_id,
                          const IncomingMessage& message) override;
+  void OnMessageReceivedError(const std::string& app_id,
+                              const std::string& message_id,
+                              int status) override;
   void OnMessagesDeleted(const std::string& app_id) override;
   void OnMessageSendError(
       const std::string& app_id,
       const gcm::GCMClient::SendErrorDetails& send_error_details) override;
   void OnSendAcknowledged(const std::string& app_id,
                           const std::string& message_id) override;
   void OnGCMReady(const std::vector<AccountMapping>& account_mappings,
                   const base::Time& last_token_fetch_time) override;
   void OnActivityRecorded() override {}
   void OnConnected(const net::IPEndPoint& ip_endpoint) override {}
@@ skipping 16 matching lines @@
   }
 
   void reset_last_event() {
     last_event_ = NONE;
     last_app_id_.clear();
     last_registration_id_.clear();
     last_message_id_.clear();
     last_result_ = GCMClient::UNKNOWN_ERROR;
     last_account_mappings_.clear();
     last_token_fetch_time_ = base::Time();
+    last_receipt_app_id_.clear();
+    last_receipt_message_id_.clear();
+    last_receipt_status_ = 0;
   }
 
   LastEvent last_event() const { return last_event_; }
   const std::string& last_app_id() const { return last_app_id_; }
   const std::string& last_registration_id() const {
     return last_registration_id_;
   }
   const std::string& last_message_id() const { return last_message_id_; }
   GCMClient::Result last_result() const { return last_result_; }
+  const std::string& last_receipt_app_id() const {
+    return last_receipt_app_id_;
+  }
+  const std::string& last_receipt_message_id() const {
+    return last_receipt_message_id_;
+  }
+  int last_receipt_status() const { return last_receipt_status_; }
   const IncomingMessage& last_message() const { return last_message_; }
   const GCMClient::SendErrorDetails& last_error_details() const {
     return last_error_details_;
   }
   const base::Time& last_token_fetch_time() const {
     return last_token_fetch_time_;
   }
   const std::vector<AccountMapping>& last_account_mappings() {
     return last_account_mappings_;
   }
@@ skipping 36 matching lines @@
   // Variables used for verification.
   LastEvent last_event_;
   std::string last_app_id_;
   std::string last_registration_id_;
   std::string last_message_id_;
   GCMClient::Result last_result_;
   IncomingMessage last_message_;
   GCMClient::SendErrorDetails last_error_details_;
   base::Time last_token_fetch_time_;
   std::vector<AccountMapping> last_account_mappings_;
+  std::string last_receipt_app_id_;
+  std::string last_receipt_message_id_;
+  int last_receipt_status_;
 
   std::unique_ptr<GCMClientImpl> gcm_client_;
 
   net::TestURLFetcherFactory url_fetcher_factory_;
 
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
 
   // Injected to GCM client.
   scoped_refptr<net::TestURLRequestContextGetter> url_request_context_getter_;
@@ skipping 191 matching lines @@
   last_token_fetch_time_ = last_token_fetch_time;
 }
 
 void GCMClientImplTest::OnMessageReceived(const std::string& registration_id,
                                           const IncomingMessage& message) {
   last_event_ = MESSAGE_RECEIVED;
   last_app_id_ = registration_id;
   last_message_ = message;
 }
 
+void GCMClientImplTest::OnMessageReceivedError(const std::string& app_id,
+                                               const std::string& message_id,
+                                               int status) {
+  last_receipt_app_id_ = app_id;
+  last_receipt_message_id_ = message_id;
+  last_receipt_status_ = status;
+}
+
 void GCMClientImplTest::OnRegisterFinished(
     const linked_ptr<RegistrationInfo>& registration_info,
     const std::string& registration_id,
     GCMClient::Result result) {
   last_event_ = REGISTRATION_COMPLETED;
   last_app_id_ = registration_info->app_id;
   last_registration_id_ = registration_id;
   last_result_ = result;
 }
 
@@ skipping 293 matching lines @@
 
   reset_last_event();
 
   // Message from kSender3 will be dropped.
   MCSMessage message3(BuildDownstreamMessage(
       kSender3, kExtensionAppId, std::string() /* subtype */, expected_data,
       std::string() /* raw_data */));
   EXPECT_TRUE(message3.IsValid());
   ReceiveMessageFromMCS(message3);
 
+  // TODO(harkness): Add a check for invalid app handler once the
+  // DefaultAppHandler is removed.
+
   EXPECT_NE(MESSAGE_RECEIVED, last_event());
   EXPECT_NE(kExtensionAppId, last_app_id());
 }
 
 TEST_F(GCMClientImplTest, DispatchDownstreamMessageRawData) {
   std::vector<std::string> senders(1, kSender);
   AddRegistration(kExtensionAppId, senders, "reg_id");
 
   std::map<std::string, std::string> expected_data;
 
@@ skipping 832 matching lines @@
   std::map<std::string, std::string> expected_data;
 
   // Message for kSender with a subtype will be dropped.
   MCSMessage message0(BuildDownstreamMessage(
       kSender, kProductCategoryForSubtypes, kExtensionAppId /* subtype */,
       expected_data, std::string() /* raw_data */));
   EXPECT_TRUE(message0.IsValid());
   ReceiveMessageFromMCS(message0);
 
   EXPECT_NE(MESSAGE_RECEIVED, last_event());
+  EXPECT_EQ(kExtensionAppId, last_receipt_app_id());
+  EXPECT_EQ(GCMClient::GCM_INVALID_SUBTYPE, last_receipt_status());
 
   reset_last_event();
 
   // Message for kSender will be received.
   MCSMessage message1(BuildDownstreamMessage(
       kSender, kExtensionAppId, std::string() /* subtype */, expected_data,
       std::string() /* raw_data */));
   EXPECT_TRUE(message1.IsValid());
   ReceiveMessageFromMCS(message1);
 
@@ skipping 41 matching lines @@
   std::map<std::string, std::string> expected_data;
 
   // Message for kSender without a subtype will be dropped.
   MCSMessage message0(BuildDownstreamMessage(
       kSender, kSubtypeAppId, std::string() /* subtype */, expected_data,
       std::string() /* raw_data */));
   EXPECT_TRUE(message0.IsValid());
   ReceiveMessageFromMCS(message0);
 
   EXPECT_NE(MESSAGE_RECEIVED, last_event());
+  EXPECT_EQ(kSubtypeAppId, last_receipt_app_id());
+  EXPECT_EQ(GCMClient::GCM_INVALID_SUBTYPE, last_receipt_status());
 
   reset_last_event();
 
   // Message for kSender will be received.
   MCSMessage message1(BuildDownstreamMessage(
       kSender, kProductCategoryForSubtypes, kSubtypeAppId /* subtype */,
       expected_data, std::string() /* raw_data */));
   EXPECT_TRUE(message1.IsValid());
   ReceiveMessageFromMCS(message1);
 
@@ skipping 54 matching lines @@
   ReceiveMessageFromMCS(message);
 
   EXPECT_EQ(MESSAGE_RECEIVED, last_event());
   EXPECT_EQ(kExtensionAppId, last_app_id());
   EXPECT_EQ(expected_data.size(), last_message().data.size());
   EXPECT_EQ(expected_data, last_message().data);
   EXPECT_EQ(kSender, last_message().sender_id);
 }
 
 }  // namespace gcm