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

components/gcm_driver/gcm_driver.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_DRIVER_H_
 #define COMPONENTS_GCM_DRIVER_GCM_DRIVER_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "components/gcm_driver/common/gcm_messages.h"
 #include "components/gcm_driver/crypto/gcm_encryption_provider.h"
 #include "components/gcm_driver/default_gcm_app_handler.h"
 #include "components/gcm_driver/gcm_client.h"
+#include "components/gcm_driver/gcm_message_status.h"
 
 namespace base {
 class FilePath;
 class SequencedTaskRunner;
 }
 
 namespace gcm {
 
 class GCMAppHandler;
 class GCMConnectionObserver;
@@ skipping 161 matching lines @@
   // works in context of a signed in entity (e.g. browser profile where user is
   // signed into sync).
   // |account_tokens|: list of email addresses, account IDs and OAuth2 access
   //                   tokens.
   virtual void SetAccountTokens(
       const std::vector<GCMClient::AccountTokenInfo>& account_tokens) = 0;
 
   // Updates the |account_mapping| information in persistent store.
   virtual void UpdateAccountMapping(const AccountMapping& account_mapping) = 0;
 
-  // Removes the account mapping information reated to |account_id| from
+  // Removes the account mapping information related to |account_id| from
   // persistent store.
   virtual void RemoveAccountMapping(const std::string& account_id) = 0;
 
   // Getter and setter of last token fetch time.
   virtual base::Time GetLastTokenFetchTime() = 0;
   virtual void SetLastTokenFetchTime(const base::Time& time) = 0;
 
   // Sets whether or not GCM should try to wake the system from suspend in order
   // to send a heartbeat message.
   virtual void WakeFromSuspendForHeartbeat(bool wake) = 0;
@@ skipping 70 matching lines @@
                     const std::string& message_id,
                     GCMClient::Result result);
 
   bool HasRegisterCallback(const std::string& app_id);
 
   void ClearCallbacks();
 
   // Dispatches the OnMessage event to the app handler associated with |app_id|.
   // If |message| has been encrypted, it will be decrypted asynchronously and
   // dispatched when the decryption operation was successful. Otherwise, the
   // |message| will be dispatched immediately to the handler for |app_id|.

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

  // The |optional_receipt_callback| must be invoked on the UI thread.

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

Done.

   void DispatchMessage(const std::string& app_id,
-                       const IncomingMessage& message);
+                       const IncomingMessage& message,
+                       const MessageReceiptCallback& optional_receipt_callback);
 
  private:
   // Common code shared by Unregister and UnregisterWithSenderId.
   void UnregisterInternal(const std::string& app_id,
                           const std::string* sender_id,
                           const UnregisterCallback& callback);
 
   // Dispatches the OnMessage event to the app handler associated with |app_id|
   // if |result| indicates that it is safe to do so, or will report a decryption
   // failure for the |app_id| otherwise.
-  void DispatchMessageInternal(const std::string& app_id,
-                               GCMEncryptionProvider::DecryptionResult result,
-                               const IncomingMessage& message);
+  void DispatchMessageInternal(
+      const std::string& app_id,
+      const MessageReceiptCallback& optional_receipt_callback,
+      GCMEncryptionProvider::DecryptionResult result,
+      const IncomingMessage& message);
 
   // Called after unregistration completes in order to trigger the pending
   // registration.
   void RegisterAfterUnregister(
       const std::string& app_id,
       const std::vector<std::string>& normalized_sender_ids,
       const UnregisterCallback& unregister_callback,
       GCMClient::Result result);
 
   // Callback map (from app_id to callback) for Register.
@@ skipping 17 matching lines @@
   DefaultGCMAppHandler default_app_handler_;
 
   base::WeakPtrFactory<GCMDriver> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GCMDriver);
 };
 
 }  // namespace gcm
 
 #endif  // COMPONENTS_GCM_DRIVER_GCM_DRIVER_H_