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) {
+  // 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);

[Peter Beverloo, 2017/02/15 15:17:15]

Does the server ack this? (I.e. do we bail out in
GCMDriverDesktop::SendAcknowledged?)

[harkness, 2017/02/22 17:19:32]

At the moment, this will be acknowledged and the AppHandler will be notified of
the SendAcknowledged() call. In general, I think that's a good thing, because in
the case of GCM errors, it lets the AppHandler know that the GCM is trying to
send messages that aren't getting through (for example, because of decryption
errors).

[Peter Beverloo, 2017/02/22 17:24:23]

That is not OK per the contract of OnSendAcknowledged. Please figure out a
solution here --

PushMessagingServiceImpl will DCHECK(false).
CryptAuthGCMManagerImpl will DCHECK(false).
ExtensionGCMAppHandler will ignore.
GCMAccountMapper will drop the message because there'll be an ID mismatch.
Fragile, though.
GCMInvalidationBridge will DCHECK(false).

+}
+
 }  // namespace gcm