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

components/gcm_driver/gcm_client_impl.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 <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/field_trial_params.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/default_clock.h"
+#include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "components/crx_file/id_util.h"
 #include "components/gcm_driver/gcm_account_mapper.h"
 #include "components/gcm_driver/gcm_backoff_policy.h"
+#include "components/gcm_driver/gcm_message_status.h"
 #include "google_apis/gcm/base/encryptor.h"
 #include "google_apis/gcm/base/mcs_message.h"
 #include "google_apis/gcm/base/mcs_util.h"
 #include "google_apis/gcm/engine/checkin_request.h"
 #include "google_apis/gcm/engine/connection_factory_impl.h"
 #include "google_apis/gcm/engine/gcm_registration_request_handler.h"
 #include "google_apis/gcm/engine/gcm_store_impl.h"
 #include "google_apis/gcm/engine/gcm_unregistration_request_handler.h"
 #include "google_apis/gcm/engine/instance_id_delete_token_request_handler.h"
 #include "google_apis/gcm/engine/instance_id_get_token_request_handler.h"
@@ skipping 33 matching lines @@
 
 enum ResetStoreError {
   DESTROYING_STORE_FAILED,
   INFINITE_STORE_RESET,
   // NOTE: always keep this entry at the end. Add new value only immediately
   // above this line. Make sure to update the corresponding histogram enum
   // accordingly.
   RESET_STORE_ERROR_COUNT
 };
 
+// Indicates what type of message receipts should be sent to the GCM.
+enum MessageReceiptsToSend {
+  SEND_NONE = 0,
+  SEND_FAILURES = 1,
+  SEND_ALL = 2,
+};
+
 const char kGCMScope[] = "GCM";
 const int kMaxRegistrationRetries = 5;
 const int kMaxUnregistrationRetries = 5;
 const char kDeletedCountKey[] = "total_deleted";
 const char kMessageTypeDataMessage[] = "gcm";
 const char kMessageTypeDeletedMessagesKey[] = "deleted_messages";
 const char kMessageTypeKey[] = "message_type";
 const char kMessageTypeSendErrorKey[] = "send_error";
 const char kSendErrorMessageIdKey[] = "google.message_id";
 const char kSubtypeKey[] = "subtype";
 const char kSendMessageFromValue[] = "gcm@chrome.com";
 const int64_t kDefaultUserSerialNumber = 0LL;
 const int kDestroyGCMStoreDelayMS = 5 * 60 * 1000;  // 5 minutes.
+const char kMessageReceiptType[] = "message_receipt";
+const char kReceiptMessageIdKey[] = "message_id";
+const char kReceiptStatusKey[] = "status";
+// kReceiptGCMDestinationID is the destination ID which GCM listens to for
+// upstream receipt messages.
+const char kReceiptGCMDestinationID[] = "1029510549786@google.com";
+const int kReceiptTTLInSeconds = 10;
+const base::Feature kGCMMessageReceiptsFeature{
+    "GCMMessageReceiptsFeature", base::FEATURE_ENABLED_BY_DEFAULT};
+const char kMessageReceiptsToSend[] = "message_receipts_to_send";
 
 GCMClient::Result ToGCMClientResult(MCSClient::MessageSendStatus status) {
   switch (status) {
     case MCSClient::QUEUED:
       return GCMClient::SUCCESS;
     case MCSClient::MESSAGE_TOO_LARGE:
       return GCMClient::INVALID_PARAMETER;
     case MCSClient::QUEUE_SIZE_LIMIT_REACHED:
     case MCSClient::APP_QUEUE_SIZE_LIMIT_REACHED:
     case MCSClient::NO_CONNECTION_ON_ZERO_TTL:
@@ skipping 1234 matching lines @@
       HandleIncomingDataMessage(app_id, use_subtype, data_message_stanza,
                                 message_data);
       break;
     case DELETED_MESSAGES:
       HandleIncomingDeletedMessages(app_id, data_message_stanza, message_data);
       break;
     case SEND_ERROR:
       HandleIncomingSendError(app_id, data_message_stanza, message_data);
       break;
     case UNKNOWN:
+      SendMessageReceipt(data_message_stanza.id(), app_id,
+                         GCMMessageStatus::GCM_UNKNOWN_MESSAGE_TYPE);
       DVLOG(1) << "Unknown message_type received. Message ignored. "
                << "App ID: " << app_id << ".";
       break;
   }
 }
 
 void GCMClientImpl::HandleIncomingDataMessage(
     const std::string& app_id,
     bool was_subtype,
     const mcs_proto::DataMessageStanza& data_message_stanza,
     MessageData& message_data) {
   std::string sender = data_message_stanza.from();
+  GCMMessageStatus status = GCMMessageStatus::GCM_NO_REGISTRATION;
 
   // Drop the message when the app is not registered for the sender of the
   // message.
   bool registered = false;
 
   // First, find among all GCM registrations.
   std::unique_ptr<GCMRegistrationInfo> gcm_registration(
       new GCMRegistrationInfo);
   gcm_registration->app_id = app_id;
   auto gcm_registration_iter = registrations_.find(
       make_linked_ptr<RegistrationInfo>(gcm_registration.release()));
   if (gcm_registration_iter != registrations_.end()) {
     GCMRegistrationInfo* cached_gcm_registration =
         GCMRegistrationInfo::FromRegistrationInfo(
             gcm_registration_iter->first.get());
-    if (cached_gcm_registration &&
-        std::find(cached_gcm_registration->sender_ids.begin(),
-                  cached_gcm_registration->sender_ids.end(),
-                  sender) != cached_gcm_registration->sender_ids.end()) {
-      if (was_subtype)
-        DLOG(ERROR) << "GCM message for non-IID " << app_id << " used subtype";
-      else
-        registered = true;
+    if (cached_gcm_registration) {
+      if (std::find(cached_gcm_registration->sender_ids.begin(),
+                    cached_gcm_registration->sender_ids.end(),
+                    sender) != cached_gcm_registration->sender_ids.end()) {
+        if (was_subtype) {
+          DLOG(ERROR) << "GCM message for non-IID " << app_id
+                      << " used subtype";
+          status = GCMMessageStatus::GCM_INVALID_SUBTYPE;
+        } else {
+          registered = true;
+        }
+      } else {
+        DLOG(ERROR) << "GCM message for non-IID " << app_id
+                    << " had a registration but the sender_id " << sender
+                    << " was not valid.";
+        status = GCMMessageStatus::GCM_INVALID_SENDER_ID;
+      }
     }
   }
 
   // Then, find among all InstanceID registrations.
   if (!registered) {
     std::unique_ptr<InstanceIDTokenInfo> instance_id_token(
         new InstanceIDTokenInfo);
     instance_id_token->app_id = app_id;
     instance_id_token->authorized_entity = sender;
     instance_id_token->scope = kGCMScope;
     auto instance_id_token_iter = registrations_.find(
         make_linked_ptr<RegistrationInfo>(instance_id_token.release()));
     if (instance_id_token_iter != registrations_.end()) {
       if (was_subtype != InstanceIDUsesSubtypeForAppId(app_id)) {
         DLOG(ERROR) << "GCM message for " << app_id
                     << " incorrectly had was_subtype = " << was_subtype;
+        status = GCMMessageStatus::GCM_INVALID_SUBTYPE;
       } else {
         registered = true;
       }
     }
   }
 
   UMA_HISTOGRAM_BOOLEAN("GCM.DataMessageReceivedHasRegisteredApp", registered);
   if (registered) {
     UMA_HISTOGRAM_BOOLEAN("GCM.DataMessageReceived", true);
     bool has_collapse_key =
         data_message_stanza.has_token() && !data_message_stanza.token().empty();
     UMA_HISTOGRAM_BOOLEAN("GCM.DataMessageReceivedHasCollapseKey",
                           has_collapse_key);
   }
   recorder_.RecordDataMessageReceived(app_id, sender,
       data_message_stanza.ByteSize(), registered,
       GCMStatsRecorder::DATA_MESSAGE);
-  if (!registered)
+  if (!registered) {
+    SendMessageReceipt(data_message_stanza.id(), app_id, status);
     return;
+  }
 
   IncomingMessage incoming_message;
   incoming_message.sender_id = data_message_stanza.from();
   if (data_message_stanza.has_token())
     incoming_message.collapse_key = data_message_stanza.token();
   incoming_message.data = message_data;
   incoming_message.raw_data = data_message_stanza.raw_data();
 
-  delegate_->OnMessageReceived(app_id, incoming_message);
+  // Pass the message up to the GCMDriver. Also pass a callback which will send
+  // a receipt for this message if invoked with a message status.
+  delegate_->OnMessageReceived(app_id, incoming_message,
+                               base::Bind(&GCMClientImpl::SendMessageReceipt,
+                                          weak_ptr_factory_.GetWeakPtr(),
+                                          data_message_stanza.id(), app_id));
 }
 
 void GCMClientImpl::HandleIncomingDeletedMessages(
     const std::string& app_id,
     const mcs_proto::DataMessageStanza& data_message_stanza,
     MessageData& message_data) {
   int deleted_count = 0;
   MessageData::iterator count_iter = message_data.find(kDeletedCountKey);
   if (count_iter != message_data.end()) {
     if (!base::StringToInt(count_iter->second, &deleted_count))
@@ skipping 30 matching lines @@
 
 bool GCMClientImpl::HasStandaloneRegisteredApp() const {
   if (registrations_.empty())
     return false;
   // Note that account mapper is not counted as a standalone app since it is
   // automatically started when other app uses GCM.
   return registrations_.size() > 1 ||
          !ExistsGCMRegistrationInMap(registrations_, kGCMAccountMapperAppId);
 }
 
+void GCMClientImpl::SendMessageReceipt(const std::string& message_id,
+                                       const std::string& app_id,
+                                       GCMMessageStatus status) {
+  DCHECK(status != GCMMessageStatus::GCM_UNRESOLVED);
+
+  // Only send message receipts to GCM if the trial is enabled.
+  int message_types_to_send = base::GetFieldTrialParamByFeatureAsInt(
+      kGCMMessageReceiptsFeature, kMessageReceiptsToSend,
+      MessageReceiptsToSend::SEND_NONE);
+
+  if (message_types_to_send == MessageReceiptsToSend::SEND_NONE)
+    return;
+
+  if (message_types_to_send == MessageReceiptsToSend::SEND_FAILURES &&
+      (status == GCMMessageStatus::GCM_SUCCESS ||
+       status == GCMMessageStatus::GCM_UNRESOLVED)) {
+    return;
+  }
+
+  // Prepare a message to send to GCM which will log the status of the received
+  // message. This is aggregated by GCM to provide better error alerting.
+  OutgoingMessage message;
+  message.time_to_live = kReceiptTTLInSeconds;
+  message.id =
+      base::Int64ToString(base::Time::NowFromSystemTime().ToInternalValue());
+  message.data[kMessageTypeKey] = kMessageReceiptType;
+  message.data[kReceiptMessageIdKey] = message_id;
+  message.data[kReceiptStatusKey] = base::IntToString(static_cast<int>(status));
+
+  Send(app_id, kReceiptGCMDestinationID, message);
+}
+
 }  // namespace gcm