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

components/gcm_driver/gcm_client.h

 // 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.
 
 #ifndef COMPONENTS_GCM_DRIVER_GCM_CLIENT_H_
 #define COMPONENTS_GCM_DRIVER_GCM_CLIENT_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/memory/linked_ptr.h"
 #include "components/gcm_driver/common/gcm_messages.h"
 #include "components/gcm_driver/crypto/gcm_encryption_provider.h"
 #include "components/gcm_driver/gcm_activity.h"
+#include "components/gcm_driver/gcm_message_status.h"
 #include "components/gcm_driver/registration_info.h"
 
 template <class T> class scoped_refptr;
 
 namespace base {
 class FilePath;
 class SequencedTaskRunner;
 class Timer;
 }
 
@@ skipping 137 matching lines @@
     // |app_id|: application ID.
     // |message_id|: ID of the message being sent.
     // |result|: the type of the error if an error occured, success otherwise.
     virtual void OnSendFinished(const std::string& app_id,
                                 const std::string& message_id,
                                 Result result) = 0;
 
     // Called when a message has been received.
     // |app_id|: application ID.
     // |message|: message received.
-    virtual void OnMessageReceived(const std::string& app_id,
-                                   const IncomingMessage& message) = 0;
+    // |optional_receipt_callback|: Optional callback to invoke if desired when
+    // processing the message is complete if the receiver wants to return a
+    // delivery receipt. The callback must be invoked on the IO thread.
+    virtual void OnMessageReceived(
+        const std::string& app_id,
+        const IncomingMessage& message,
+        const MessageReceiptCallback& optional_receipt_callback) = 0;

[Peter Beverloo, 2017/02/13 13:47:06]

nit: standardize on (optional_)?receipt_callback naming. Distinguishing between
threads sgtm, but let's use the same otherwise.

[harkness, 2017/02/14 19:22:28]

I decided that I really like "optional" for standardization, even when there are
threading questions. I didn't want to switch back and forth from optional_ to
io_ or something like that.

 
     // Called when some messages have been deleted from the server.
     // |app_id|: application ID.
     virtual void OnMessagesDeleted(const std::string& app_id) = 0;
 
     // Called when a message failed to send to the server.
     // |app_id|: application ID.
     // |send_error_detials|: Details of the send error event, like mesasge ID.
     virtual void OnMessageSendError(
         const std::string& app_id,
@@ skipping 140 matching lines @@
   // to be set, and allows that component to later revoke the setting. It should
   // be unique.
   virtual void AddHeartbeatInterval(const std::string& scope,
                                     int interval_ms) = 0;
   virtual void RemoveHeartbeatInterval(const std::string& scope) = 0;
 };
 
 }  // namespace gcm
 
 #endif  // COMPONENTS_GCM_DRIVER_GCM_CLIENT_H_