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

components/gcm_driver/gcm_driver_desktop.cc

Index: components/gcm_driver/gcm_driver_desktop.cc
diff --git a/components/gcm_driver/gcm_driver_desktop.cc b/components/gcm_driver/gcm_driver_desktop.cc
index 599957d2a5979fced996c2440031f4cee4344b7c..f5a1ce6fbbfd5204338452d23754fc6755304778 100644
--- a/components/gcm_driver/gcm_driver_desktop.cc
+++ b/components/gcm_driver/gcm_driver_desktop.cc
@@ -54,7 +54,8 @@ class GCMDriverDesktop::IOWorker : public GCMClient::Delegate {
                       const std::string& message_id,
                       GCMClient::Result result) override;
   void OnMessageReceived(const std::string& app_id,
-                         const IncomingMessage& message) override;
+                         const IncomingMessage& message,
+                         const MessageReceiptCallback& callback) override;
   void OnMessagesDeleted(const std::string& app_id) override;
   void OnMessageSendError(
       const std::string& app_id,
@@ -111,6 +112,8 @@ class GCMDriverDesktop::IOWorker : public GCMClient::Delegate {
 
   void RecordDecryptionFailure(const std::string& app_id,
                                GCMEncryptionProvider::DecryptionResult result);
+  void SendMessageReceipt(const MessageReceiptCallback& callback,
+                          GCMMessageStatus status);
 
   // For testing purpose. Can be called from UI thread. Use with care.
   GCMClient* gcm_client_for_testing() const { return gcm_client_.get(); }
@@ -233,15 +236,13 @@ void GCMDriverDesktop::IOWorker::OnSendFinished(const std::string& app_id,
 
 void GCMDriverDesktop::IOWorker::OnMessageReceived(
     const std::string& app_id,
-    const IncomingMessage& message) {
+    const IncomingMessage& message,
+    const MessageReceiptCallback& callback) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
-  ui_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriverDesktop::MessageReceived,
-                 service_,
-                 app_id,
-                 message));
+  ui_thread_->PostTask(FROM_HERE,
+                       base::Bind(&GCMDriverDesktop::MessageReceived, service_,
+                                  app_id, message, callback));
 }
 
 void GCMDriverDesktop::IOWorker::OnMessagesDeleted(const std::string& app_id) {
@@ -510,6 +511,16 @@ void GCMDriverDesktop::IOWorker::RecordDecryptionFailure(
   gcm_client_->RecordDecryptionFailure(app_id, result);
 }
 
+void GCMDriverDesktop::IOWorker::SendMessageReceipt(
+    const MessageReceiptCallback& callback,
+    GCMMessageStatus status) {
+  DCHECK(io_thread_->RunsTasksOnCurrentThread());
+
+  // The callback was created by the GCMClient on the IO thead so it is safe to
+  // invoke from here.
+  callback.Run(status);
+}
+
 GCMDriverDesktop::GCMDriverDesktop(
     std::unique_ptr<GCMClientFactory> gcm_client_factory,
     const GCMClient::ChromeBuildInfo& chrome_build_info,
@@ -1216,14 +1227,15 @@ void GCMDriverDesktop::RemoveCachedData() {
 }
 
 void GCMDriverDesktop::MessageReceived(const std::string& app_id,
-                                       const IncomingMessage& message) {
+                                       const IncomingMessage& message,
+                                       const MessageReceiptCallback& callback) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   // Drop the event if the service has been stopped.
   if (!gcm_started_)
     return;
 
-  DispatchMessage(app_id, message);
+  DispatchMessage(app_id, message, callback);

[Peter Beverloo, 2017/02/08 17:09:09]

The |callback| passed to DispatchMessage any beyond *must* be invoked on the UI
thread. The one that's being passed now *must* be invoked on the IO thread.

The simplest path here would be to -

GCMDriverDesktop
    void SendMessageReceipt(
        const MessageReceiptCallback& io_receipt_callback,
        GCMMessageStatus status);

--> DispatchMessage(..., base::Bind(&SendMessageReceipt, callback))

GCMDriverAndroid
    void SendMessageReceipt(
        const std::string& message_id,
        const std::string& app_id,
        GCMMessageStatus status);

--> DispatchMessage(..., base::Bind(&SendMessageReceipt, message_id,
                                    app_id))

That way you don't need DoSendMessageReceipt either, since SendMessageReceipt
can take care of posting the task if needs be (desktop).

[harkness, 2017/02/09 16:27:30]

Good point, I hadn't considered that there was a step in the GCMDriver(Desktop)
where we could intercept that before it got into Dispatch Message.

Moved the re-bind to that level.

 }
 
 void GCMDriverDesktop::MessagesDeleted(const std::string& app_id) {
@@ -1342,4 +1354,14 @@ bool GCMDriverDesktop::TokenTupleComparer::operator()(
   return std::get<2>(a) < std::get<2>(b);
 }
 
+void GCMDriverDesktop::DoSendMessageReceipt(
+    const MessageReceiptCallback& callback,
+    GCMMessageStatus status) {
+  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+
+  io_thread_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMDriverDesktop::IOWorker::SendMessageReceipt,
+                 base::Unretained(io_worker_.get()), callback, status));
+}
 }  // namespace gcm