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>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/field_trial.h"
+#include "base/metrics/field_trial_param_associator.h"
+#include "base/metrics/field_trial_params.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/histogram_tester.h"
+#include "base/test/mock_entropy_provider.h"
+#include "base/test/scoped_feature_list.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/clock.h"
 #include "base/timer/timer.h"
 #include "google_apis/gcm/base/fake_encryptor.h"
 #include "google_apis/gcm/base/mcs_message.h"
 #include "google_apis/gcm/base/mcs_util.h"
 #include "google_apis/gcm/engine/fake_connection_factory.h"
 #include "google_apis/gcm/engine/fake_connection_handler.h"
 #include "google_apis/gcm/engine/gservices_settings.h"
@@ skipping 231 matching lines @@
 
 class GCMClientImplTest : public testing::Test,
                           public GCMClient::Delegate {
  public:
   GCMClientImplTest();
   ~GCMClientImplTest() override;
 
   void SetUp() override;
 
   void SetUpUrlFetcherFactory();
+  void InitializeFieldTrials(int messages_to_send);
 
   void BuildGCMClient(base::TimeDelta clock_step);
   void InitializeGCMClient();
   void StartGCMClient();
   void Register(const std::string& app_id,
                 const std::vector<std::string>& senders);
   void Unregister(const std::string& app_id);
   void ReceiveMessageFromMCS(const MCSMessage& message);
   void ReceiveOnMessageSentToMCS(
       const std::string& app_id,
@@ skipping 21 matching lines @@
   // GCMClient::Delegate overrides (for verification).
   void OnRegisterFinished(const linked_ptr<RegistrationInfo>& registration_info,
                           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 OnMessageReceived(
+      const std::string& registration_id,
+      const IncomingMessage& message,
+      const MessageReceiptCallback& optional_receipt_callback) 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 66 matching lines @@
   AutoAdvancingTestClock* clock() const {
     return reinterpret_cast<AutoAdvancingTestClock*>(gcm_client_->clock_.get());
   }
   net::TestURLFetcherFactory* url_fetcher_factory() {
     return &url_fetcher_factory_;
   }
   base::TestMockTimeTaskRunner* task_runner() {
     return task_runner_.get();
   }
 
+  void set_successful_receipt_generation(bool successful_receipt_generation) {
+    successful_receipt_generation_ = successful_receipt_generation;
+  }
+
  private:
   // Must be declared first so that it is destroyed last. Injected to
   // GCM client.
   base::ScopedTempDir temp_directory_;
 
   // 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_;
+  base::test::ScopedFeatureList scoped_feature_list_;
+  std::unique_ptr<base::FieldTrialList> field_trial_list_;
+  bool successful_receipt_generation_ = false;
 
   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_;
 };
 
 GCMClientImplTest::GCMClientImplTest()
     : last_event_(NONE),
       last_result_(GCMClient::UNKNOWN_ERROR),
+      field_trial_list_(base::MakeUnique<base::FieldTrialList>(
+          base::MakeUnique<base::MockEntropyProvider>())),
       task_runner_(new base::TestMockTimeTaskRunner),
       task_runner_handle_(task_runner_),
       url_request_context_getter_(
-          new net::TestURLRequestContextGetter(task_runner_)) {
-}
+          new net::TestURLRequestContextGetter(task_runner_)) {}
 
 GCMClientImplTest::~GCMClientImplTest() {}
 
 void GCMClientImplTest::SetUp() {
   testing::Test::SetUp();
   ASSERT_TRUE(CreateUniqueTempDir());
   BuildGCMClient(base::TimeDelta());
   InitializeGCMClient();
   StartGCMClient();
   SetUpUrlFetcherFactory();
   ASSERT_NO_FATAL_FAILURE(
       CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken, std::string(),
                       std::map<std::string, std::string>()));
 }
 
 void GCMClientImplTest::SetUpUrlFetcherFactory() {
   url_fetcher_factory_.set_remove_fetcher_on_delete(true);
 }
 
+void GCMClientImplTest::InitializeFieldTrials(int messages_to_send) {
+  const std::string kTrialName = "TestGCMMessageReceipts";
+  const std::string kGroupName = "UnusedName";
+  // kFeatureName and kParam name are also defined in gcm_client_impl.cc.
+  const std::string kFeatureName = "GCMMessageReceiptsFeature";
+  const std::string kParamName = "message_receipts_to_send";
+
+  // Cleanup any old field trial state and reinitialize.
+  field_trial_list_.reset();
+  field_trial_list_ = base::MakeUnique<base::FieldTrialList>(
+      base::MakeUnique<base::MockEntropyProvider>());
+  base::FieldTrialParamAssociator::GetInstance()->ClearAllParamsForTesting();
+
+  // Create a field trial with message receipts set to messages_to_send.
+  scoped_refptr<base::FieldTrial> trial =
+      base::FieldTrialList::CreateFieldTrial(kTrialName, kGroupName);
+  std::map<std::string, std::string> trial_params;
+  trial_params[kParamName] = base::IntToString(messages_to_send);
+  base::FieldTrialParamAssociator::GetInstance()->AssociateFieldTrialParams(
+      kTrialName, kGroupName, trial_params);
+
+  // Create a FeatureList and add the new trial to the list.
+  std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
+  feature_list->RegisterFieldTrialOverride(
+      kFeatureName, base::FeatureList::OVERRIDE_ENABLE_FEATURE, trial.get());
+  scoped_feature_list_.InitWithFeatureList(std::move(feature_list));
+}
+
 void GCMClientImplTest::PumpLoopUntilIdle() {
   task_runner_->RunUntilIdle();
 }
 
 bool GCMClientImplTest::CreateUniqueTempDir() {
   return temp_directory_.CreateUniqueTempDir();
 }
 
 void GCMClientImplTest::BuildGCMClient(base::TimeDelta clock_step) {
   gcm_client_.reset(new GCMClientImpl(base::WrapUnique<GCMInternalsBuilder>(
@@ skipping 145 matching lines @@
 }
 
 void GCMClientImplTest::OnGCMReady(
     const std::vector<AccountMapping>& account_mappings,
     const base::Time& last_token_fetch_time) {
   last_event_ = LOADING_COMPLETED;
   last_account_mappings_ = account_mappings;
   last_token_fetch_time_ = last_token_fetch_time;
 }
 
-void GCMClientImplTest::OnMessageReceived(const std::string& registration_id,
-                                          const IncomingMessage& message) {
+void GCMClientImplTest::OnMessageReceived(
+    const std::string& registration_id,
+    const IncomingMessage& message,
+    const MessageReceiptCallback& optional_receipt_callback) {
   last_event_ = MESSAGE_RECEIVED;
   last_app_id_ = registration_id;
   last_message_ = message;
+
+  // If receipt sending is enabled, then send success.
+  if (successful_receipt_generation_)
+    optional_receipt_callback.Run(GCMMessageStatus::GCM_SUCCESS);
 }
 
 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 295 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 816 matching lines @@
   // No need to call CompleteDeleteToken since unregistration request should
   // not be triggered.
   PumpLoopUntilIdle();
 
   EXPECT_EQ(UNREGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kExtensionAppId, last_app_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
 }
 
 TEST_F(GCMClientInstanceIDTest, DispatchDownstreamMessageWithoutSubtype) {
+  // Initialize a field trial for sending message receipts and set the messages
+  // to send to 2 = ALL.
+  InitializeFieldTrials(2);
+
   AddInstanceID(kExtensionAppId, kInstanceID);
   GetToken(kExtensionAppId, kSender, kScope);
   ASSERT_NO_FATAL_FAILURE(CompleteRegistration("token1"));
   GetToken(kExtensionAppId, kSender2, kScope);
   ASSERT_NO_FATAL_FAILURE(CompleteRegistration("token2"));
 
   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());
 
+  // Check that the last message sent was a message receipt for a failed message
+  // and that it had the values expected.
+  mcs_proto::DataMessageStanza stanza =
+      mcs_client()->last_data_message_stanza();
+  EXPECT_EQ(kExtensionAppId, stanza.category());
+  const auto& app_data = stanza.app_data();
+  ASSERT_EQ(3, app_data.size());
+  for (const auto& pair : app_data) {
+    if (pair.key() == "message_id")
+      EXPECT_EQ("", pair.value());
+    else if (pair.key() == "status")
+      EXPECT_EQ("2", pair.value());
+    else if (pair.key() == "message_type")
+      EXPECT_EQ("message_receipt", pair.value());
+    else
+      FAIL() << "Unexpected key: " << pair.key();
+  }
+
   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);
 
   EXPECT_EQ(MESSAGE_RECEIVED, last_event());
@@ skipping 23 matching lines @@
   MCSMessage message3(BuildDownstreamMessage(
       kSender3, kExtensionAppId, std::string() /* subtype */, expected_data,
       std::string() /* raw_data */));
   EXPECT_TRUE(message3.IsValid());
   ReceiveMessageFromMCS(message3);
 
   EXPECT_NE(MESSAGE_RECEIVED, last_event());
   EXPECT_NE(kExtensionAppId, last_app_id());
 }
 
+// Do not initialize a FieldTrial for sending receipts. Default state of the
+// field trial should be SEND_NONE, so check that no receipt was sent.
+TEST_F(GCMClientInstanceIDTest, ReceiptFieldTrialTestingSendNone) {
+  AddInstanceID(kExtensionAppId, kInstanceID);
+  GetToken(kExtensionAppId, kSender, kScope);
+  ASSERT_NO_FATAL_FAILURE(CompleteRegistration("token1"));
+
+  std::map<std::string, std::string> expected_data;
+
+  // Message for kSender with a subtype will be dropped and would cause an error
+  // receipt to be generated.
+  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());
+
+  // The only way to check that no messages were sent is to check that the tag
+  // is still the default value.
+  EXPECT_EQ(MCSProtoTag::kNumProtoTypes, mcs_client()->last_message_tag());
+}
+
+TEST_F(GCMClientInstanceIDTest, ReceiptFieldTrialTestingSendAll) {
+  // Initialize a field trial for sending message receipts and set the messages
+  // to send to 2 = ALL.
+  InitializeFieldTrials(2);
+  set_successful_receipt_generation(true);
+
+  AddInstanceID(kExtensionAppId, kInstanceID);
+  GetToken(kExtensionAppId, kSender, kScope);
+  ASSERT_NO_FATAL_FAILURE(CompleteRegistration("token1"));
+
+  std::map<std::string, std::string> expected_data;
+
+  // 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);
+
+  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);
+
+  // Check that the last message sent was a message receipt for a successful
+  // message and that it had the values expected.
+  mcs_proto::DataMessageStanza stanza =
+      mcs_client()->last_data_message_stanza();
+  EXPECT_EQ(kExtensionAppId, stanza.category());
+  const auto& app_data = stanza.app_data();
+  ASSERT_EQ(3, app_data.size());
+  for (const auto& pair : app_data) {
+    if (pair.key() == "message_id")
+      EXPECT_EQ("", pair.value());
+    else if (pair.key() == "status")
+      EXPECT_EQ("1", pair.value());  // Status should be GCM_SUCCESS = 1.
+    else if (pair.key() == "message_type")
+      EXPECT_EQ("message_receipt", pair.value());
+    else
+      FAIL() << "Unexpected key: " << pair.key();
+  }
+}
+
+TEST_F(GCMClientInstanceIDTest, ReceiptFieldTrialTestingSendFailures) {
+  // Initialize a field trial for sending message receipts and set the messages
+  // to send to 1 = SEND_FAILURES. Then when a successful message generates a
+  // receipt, it should not be sent.
+  InitializeFieldTrials(1);
+  set_successful_receipt_generation(true);
+
+  AddInstanceID(kExtensionAppId, kInstanceID);
+  GetToken(kExtensionAppId, kSender, kScope);
+  ASSERT_NO_FATAL_FAILURE(CompleteRegistration("token1"));
+
+  std::map<std::string, std::string> expected_data;
+
+  // 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);
+
+  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);
+
+  // The only way to check that no messages were sent is to check that the tag
+  // is still the default value.
+  EXPECT_EQ(MCSProtoTag::kNumProtoTypes, mcs_client()->last_message_tag());
+}
+
 TEST_F(GCMClientInstanceIDTest, DispatchDownstreamMessageWithSubtype) {
+  // Initialize a field trial for sending message receipts and set the messages
+  // to send to 2 = ALL.
+  InitializeFieldTrials(2);
+
   AddInstanceID(kSubtypeAppId, kInstanceID);
   GetToken(kSubtypeAppId, kSender, kScope);
   ASSERT_NO_FATAL_FAILURE(CompleteRegistration("token1"));
   GetToken(kSubtypeAppId, kSender2, kScope);
   ASSERT_NO_FATAL_FAILURE(CompleteRegistration("token2"));
 
   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());
 
+  // Check that the last message sent was a message receipt for a failed message
+  // and that it had the values expected.
+  mcs_proto::DataMessageStanza stanza =
+      mcs_client()->last_data_message_stanza();
+  EXPECT_EQ(kSubtypeAppId, stanza.category());
+  const auto& app_data = stanza.app_data();
+  ASSERT_EQ(3, app_data.size());
+  for (const auto& pair : app_data) {
+    if (pair.key() == "message_id")
+      EXPECT_EQ("", pair.value());
+    else if (pair.key() == "status")
+      EXPECT_EQ("2", pair.value());
+    else if (pair.key() == "message_type")
+      EXPECT_EQ("message_receipt", pair.value());
+    else
+      FAIL() << "Unexpected key: " << pair.key();
+  }
+
   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);
 
   EXPECT_EQ(MESSAGE_RECEIVED, last_event());
@@ skipping 53 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