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

components/gcm_driver/gcm_driver.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_driver.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/time/time.h"
 #include "components/gcm_driver/gcm_app_handler.h"
 
 namespace gcm {
 
 namespace {
 
 const size_t kMaxSenders = 100;
 
+const char* kGcmMessageTypeKey = "type";
+
+const char* kMessageReceiptType = "message_recipt";

[Peter Beverloo, 2016/12/15 19:24:24]

recipt -> receipt

[harkness, 2016/12/21 17:23:38]

Done.

+const char* kReceiptMessageIdKey = "message_id";
+const char* kReceiptStatusKey = "status";
+const char* kReceiptGCMDestinationID = "1029510549786@google.com";

[Peter Beverloo, 2016/12/15 19:24:24]

Also what is this number? Would other users of the GCM Driver (e.g. Samsung or
Opera) want to change it?

Would be good to add some docs.

[Peter Beverloo, 2016/12/15 19:24:24]

micro nit:

    const char kFoo[] = "bar";

[harkness, 2016/12/21 17:23:38]

Done.

[harkness, 2016/12/21 17:23:38]

Done.

+const int kReceiptTTLInSeconds = 10;
+
 }  // namespace
 
 InstanceIDHandler::InstanceIDHandler() {
 }
 
 InstanceIDHandler::~InstanceIDHandler() {
 }
 
 void InstanceIDHandler::DeleteAllTokensForApp(
     const std::string& app_id, const DeleteTokenCallback& callback) {
@@ skipping 129 matching lines @@
   SendImpl(app_id, receiver_id, message);
 }
 
 void GCMDriver::GetEncryptionInfo(
     const std::string& app_id,
     const GetEncryptionInfoCallback& callback) {
   encryption_provider_.GetEncryptionInfo(app_id, "" /* authorized_entity */,
                                          callback);
 }
 
+void GCMDriver::SendMessageReceipt(const std::string& message_id,
+                                   const std::string& app_id,
+                                   int status) {
+  DCHECK(!app_id.empty());
+
+  // 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());

[Peter Beverloo, 2016/12/15 19:24:24]

Why is the difference between Now() and NowFromSystemTime() significant?

[harkness, 2016/12/21 17:23:38]

I used it for consistency with Send(), but according to the documentation in
time.h, it's also more reliable for unit tests. However, the actual
implementation for NowFromSystemTime() just calls Now(), so it seems like the
comments in time.h are just out of date.

I can change it if you prefer, leave it for consistency, or change both here and
Send().  zea, is there any background on why the code doesn't use Now()?

+  message.data[kGcmMessageTypeKey] = kMessageReceiptType;
+  message.data[kReceiptMessageIdKey] = message_id;
+  message.data[kReceiptStatusKey] = base::IntToString(status);
+
+  SendImpl(app_id, kReceiptGCMDestinationID, message);
+}
+
+// GCM will always ack receipts, but there is no action taken when the ack is
+// received.
+void GCMDriver::SendMessageReceiptCallback(const std::string& message_id,

[Peter Beverloo, 2016/12/15 19:24:24]

unused

[harkness, 2016/12/21 17:23:38]

Yup, this was the callback stuff that I mentioned was incomplete. I've removed
it for now, although this raised the issue that I've been questioning Costin
about.

+                                           GCMClient::Result result) {}
+
 void GCMDriver::UnregisterWithSenderIdImpl(const std::string& app_id,
                                            const std::string& sender_id) {
   NOTREACHED();
 }
 
 void GCMDriver::RegisterFinished(const std::string& app_id,
                                  const std::string& registration_id,
                                  GCMClient::Result result) {
   std::map<std::string, RegisterCallback>::iterator callback_iter =
       register_callbacks_.find(app_id);
@@ skipping 106 matching lines @@
 void GCMDriver::DispatchMessageInternal(
     const std::string& app_id,
     GCMEncryptionProvider::DecryptionResult result,
     const IncomingMessage& message) {
   UMA_HISTOGRAM_ENUMERATION("GCM.Crypto.DecryptMessageResult", result,
                             GCMEncryptionProvider::DECRYPTION_RESULT_LAST + 1);
 
   switch (result) {
     case GCMEncryptionProvider::DECRYPTION_RESULT_UNENCRYPTED:
     case GCMEncryptionProvider::DECRYPTION_RESULT_DECRYPTED:
+      // TODO(beverloo): When the DefaultAppHandler is gone, call
+      // SendMessageReceipt here if there isn't a valid app handler.
       GetAppHandler(app_id)->OnMessage(app_id, message);
       return;
     case GCMEncryptionProvider::DECRYPTION_RESULT_INVALID_ENCRYPTION_HEADER:
     case GCMEncryptionProvider::DECRYPTION_RESULT_INVALID_CRYPTO_KEY_HEADER:
     case GCMEncryptionProvider::DECRYPTION_RESULT_NO_KEYS:
     case GCMEncryptionProvider::DECRYPTION_RESULT_INVALID_SHARED_SECRET:
     case GCMEncryptionProvider::DECRYPTION_RESULT_INVALID_PAYLOAD:
+      SendMessageReceipt(message.id, app_id, GCMClient::GCM_ENCRYPTION_FAILURE);
       RecordDecryptionFailure(app_id, result);
       return;
   }
 
   NOTREACHED();
 }
 
 void GCMDriver::RegisterAfterUnregister(
     const std::string& app_id,
     const std::vector<std::string>& normalized_sender_ids,
     const UnregisterCallback& unregister_callback,
     GCMClient::Result result) {
   // Invoke the original unregister callback.
   unregister_callback.Run(result);
 
   // Trigger the pending registration.
   DCHECK(register_callbacks_.find(app_id) != register_callbacks_.end());
   RegisterImpl(app_id, normalized_sender_ids);
 }
 
 }  // namespace gcm