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

components/gcm_driver/gcm_driver_desktop.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_desktop.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 35 matching lines @@
   // Called on IO thread.
   void OnRegisterFinished(const linked_ptr<RegistrationInfo>& registration_info,
                           const std::string& registration_id,
                           GCMClient::Result result) override;
   void OnUnregisterFinished(
       const linked_ptr<RegistrationInfo>& registration_info,
       GCMClient::Result result) override;
   void OnSendFinished(const std::string& app_id,
                       const std::string& message_id,
                       GCMClient::Result result) override;
-  void OnMessageReceived(const std::string& app_id,
-                         const IncomingMessage& message) override;
+  void OnMessageReceived(
+      const std::string& app_id,
+      const IncomingMessage& message,
+      const MessageReceiptCallback& receipt_callback) override;
   void OnMessagesDeleted(const std::string& app_id) override;
   void OnMessageSendError(
       const std::string& app_id,
       const GCMClient::SendErrorDetails& send_error_details) override;
   void OnSendAcknowledged(const std::string& app_id,
                           const std::string& message_id) override;
   void OnGCMReady(const std::vector<AccountMapping>& account_mappings,
                   const base::Time& last_token_fetch_time) override;
   void OnActivityRecorded() override;
   void OnConnected(const net::IPEndPoint& ip_endpoint) override;
@@ skipping 36 matching lines @@
   void GetToken(const std::string& app_id,
                 const std::string& authorized_entity,
                 const std::string& scope,
                 const std::map<std::string, std::string>& options);
   void DeleteToken(const std::string& app_id,
                    const std::string& authorized_entity,
                    const std::string& scope);
 
   void RecordDecryptionFailure(const std::string& app_id,
                                GCMEncryptionProvider::DecryptionResult result);
+  void SendMessageReceipt(const MessageReceiptCallback& receipt_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(); }
 
  private:
   scoped_refptr<base::SequencedTaskRunner> ui_thread_;
   scoped_refptr<base::SequencedTaskRunner> io_thread_;
 
   base::WeakPtr<GCMDriverDesktop> service_;
 
@@ skipping 102 matching lines @@
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
   ui_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::SendFinished, service_, app_id, message_id,
                  result));
 }
 
 void GCMDriverDesktop::IOWorker::OnMessageReceived(
     const std::string& app_id,
-    const IncomingMessage& message) {
+    const IncomingMessage& message,
+    const MessageReceiptCallback& receipt_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, receipt_callback));
 }
 
 void GCMDriverDesktop::IOWorker::OnMessagesDeleted(const std::string& app_id) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
   ui_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::MessagesDeleted, service_, app_id));
 }
 
@@ skipping 248 matching lines @@
   gcm_client_->RemoveHeartbeatInterval(scope);
 }
 
 void GCMDriverDesktop::IOWorker::RecordDecryptionFailure(
     const std::string& app_id,
     GCMEncryptionProvider::DecryptionResult result) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
   gcm_client_->RecordDecryptionFailure(app_id, result);
 }
 
+void GCMDriverDesktop::IOWorker::SendMessageReceipt(
+    const MessageReceiptCallback& receipt_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.
+  receipt_callback.Run(status);
+}
+
 GCMDriverDesktop::GCMDriverDesktop(
     std::unique_ptr<GCMClientFactory> gcm_client_factory,
     const GCMClient::ChromeBuildInfo& chrome_build_info,
     const std::string& channel_status_request_url,
     const std::string& user_agent,
     PrefService* prefs,
     const base::FilePath& store_path,
     const scoped_refptr<net::URLRequestContextGetter>& request_context,
     const scoped_refptr<base::SequencedTaskRunner>& ui_thread,
     const scoped_refptr<base::SequencedTaskRunner>& io_thread,
@@ skipping 685 matching lines @@
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   // Remove all the queued tasks since they no longer make sense after
   // GCM service is stopped.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   gcm_started_ = false;
   delayed_task_controller_.reset();
   ClearCallbacks();
 }
 
-void GCMDriverDesktop::MessageReceived(const std::string& app_id,
-                                       const IncomingMessage& message) {
+void GCMDriverDesktop::MessageReceived(
+    const std::string& app_id,
+    const IncomingMessage& message,
+    const MessageReceiptCallback& receipt_callback) {

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

nit: it'd be a lot clearer if this were called io_receipt_callback to
distinguish from the other receipt_callbacks.

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

I agree, but I also think everything is better with optional, and I didn't want
to mix things here.

   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   // Drop the event if the service has been stopped.
   if (!gcm_started_)
     return;
 
-  DispatchMessage(app_id, message);
+  // Dispatch the message to the GCMDriver, but wrap the IO bound callback in a
+  // new callback which should be called on the UI thread.
+  DispatchMessage(app_id, message,
+                  base::Bind(&GCMDriverDesktop::DoSendMessageReceipt,
+                             weak_ptr_factory_.GetWeakPtr(), receipt_callback));
 }
 
 void GCMDriverDesktop::MessagesDeleted(const std::string& app_id) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   // Drop the event if the service has been stopped.
   if (!gcm_started_)
     return;
 
   GetAppHandler(app_id)->OnMessagesDeleted(app_id);
@@ skipping 98 matching lines @@
     return false;
 
   if (std::get<1>(a) < std::get<1>(b))
     return true;
   if (std::get<1>(a) > std::get<1>(b))
     return false;
 
   return std::get<2>(a) < std::get<2>(b);
 }
 
+void GCMDriverDesktop::DoSendMessageReceipt(
+    const MessageReceiptCallback& receipt_callback,
+    GCMMessageStatus status) {
+  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+
+  io_thread_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMDriverDesktop::IOWorker::SendMessageReceipt,
+                 base::Unretained(io_worker_.get()), receipt_callback, status));

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

You can skip the indirection and just invoke |receipt_callback| directly:

  io_thread_->PostTask(FROM_HERE, base::Bind(receipt_callback, status));

That way you don't need GCMDriverDesktop::IOWorker::SendMessageReceipt either.

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

Good point, I'd forgotten that it wasn't being called from anywhere else.

+}
 }  // namespace gcm