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

chrome/browser/services/gcm/fake_gcm_profile_service.cc

 // Copyright 2013 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 "chrome/browser/services/gcm/fake_gcm_profile_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
@@ skipping 20 matching lines @@
   void OnRegisterFinished(const std::string& app_id,
                           const std::string& registration_id,
                           GCMClient::Result result);
   void OnUnregisterFinished(const std::string& app_id,
                             GCMClient::Result result);
   void OnSendFinished(const std::string& app_id,
                       const std::string& message_id,
                       GCMClient::Result result);
 
   void OnDispatchMessage(const std::string& app_id,
-                         const IncomingMessage& message);
+                         const IncomingMessage& message,
+                         const GCMClient::MessageReceiptCallback& callback);
 
  protected:
   // FakeGCMDriverForInstanceID overrides:
   void RegisterImpl(const std::string& app_id,
                     const std::vector<std::string>& sender_ids) override;
   void UnregisterImpl(const std::string& app_id) override;
   void UnregisterWithSenderIdImpl(const std::string& app_id,
                                   const std::string& sender_id) override;
   void SendImpl(const std::string& app_id,
                 const std::string& receiver_id,
@@ skipping 51 matching lines @@
                                                GCMClient::Result result) {
   UnregisterFinished(app_id, result);
 }
 
 void CustomFakeGCMDriver::OnSendFinished(const std::string& app_id,
                                          const std::string& message_id,
                                          GCMClient::Result result) {
   SendFinished(app_id, message_id, result);
 }
 
-void CustomFakeGCMDriver::OnDispatchMessage(const std::string& app_id,
-                                            const IncomingMessage& message) {
-  DispatchMessage(app_id, message);
+void CustomFakeGCMDriver::OnDispatchMessage(
+    const std::string& app_id,
+    const IncomingMessage& message,
+    const GCMClient::MessageReceiptCallback& callback) {
+  DispatchMessage(app_id, message, callback);
 }
 
 }  // namespace
 
 // static
 std::unique_ptr<KeyedService> FakeGCMProfileService::Build(
     content::BrowserContext* context) {
   Profile* profile = static_cast<Profile*>(context);
   std::unique_ptr<FakeGCMProfileService> service(
       new FakeGCMProfileService(profile));
@@ skipping 61 matching lines @@
 void FakeGCMProfileService::AddExpectedUnregisterResponse(
     GCMClient::Result result) {
   unregister_responses_.push_back(result);
 }
 
 void FakeGCMProfileService::SetUnregisterCallback(
     const UnregisterCallback& callback) {
   unregister_callback_ = callback;
 }
 
-void FakeGCMProfileService::DispatchMessage(const std::string& app_id,
-                                            const IncomingMessage& message) {
+void FakeGCMProfileService::DispatchMessage(
+    const std::string& app_id,
+    const IncomingMessage& message,
+    const GCMClient::MessageReceiptCallback& callback) {
   CustomFakeGCMDriver* custom_driver =
       static_cast<CustomFakeGCMDriver*>(driver());
-  custom_driver->OnDispatchMessage(app_id, message);
+  custom_driver->OnDispatchMessage(app_id, message, callback);
 }
 
 }  // namespace gcm