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>
@@ skipping 123 matching lines @@
             const OutgoingMessage& message,
             const SendCallback& callback);
 
   // Get the public encryption key and the authentication secret associated with
   // |app_id|. If none have been associated with |app_id| yet, they will be
   // created. The |callback| will be invoked when it is available. Only use with
   // GCM registrations; use InstanceID::GetEncryptionInfo for InstanceID tokens.
   void GetEncryptionInfo(const std::string& app_id,
                          const GetEncryptionInfoCallback& callback);
 
+  // Send a message to GCM with information about the final status of a
+  // previously received message. This can berun as a result of a callback being
+  // executed from an AppHandler.
+  void SendMessageReceipt(const std::string& message_id,
+                          const std::string& app_id,
+                          int status);
+
   const GCMAppHandlerMap& app_handlers() const { return app_handlers_; }
 
   // This method must be called before destroying the GCMDriver. Once it has
   // been called, no other GCMDriver methods may be used.
   virtual void Shutdown();
 
   // Called when the user signs in to or out of a GAIA account.
   virtual void OnSignedIn() = 0;
   virtual void OnSignedOut() = 0;
 
@@ skipping 38 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 95 matching lines @@
                                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);
 
+  void SendMessageReceiptCallback(const std::string& message_id,
+                                  GCMClient::Result result);
+
   // Callback map (from app_id to callback) for Register.
   std::map<std::string, RegisterCallback> register_callbacks_;
 
   // Callback map (from app_id to callback) for Unregister.
   std::map<std::string, UnregisterCallback> unregister_callbacks_;
 
   // Callback map (from <app_id, message_id> to callback) for Send.
   std::map<std::pair<std::string, std::string>, SendCallback> send_callbacks_;
 
   // The encryption provider, used for key management and decryption of
   // encrypted, incoming messages.
   GCMEncryptionProvider encryption_provider_;
 
   // App handler map (from app_id to handler pointer).
   // The handler is not owned.
   GCMAppHandlerMap app_handlers_;
 
   // The default handler when no app handler can be found in the map.
   DefaultGCMAppHandler default_app_handler_;
 
   base::WeakPtrFactory<GCMDriver> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GCMDriver);
 };
 
 }  // namespace gcm
 
 #endif  // COMPONENTS_GCM_DRIVER_GCM_DRIVER_H_