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

chrome/browser/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/gcm/fake_gcm_profile_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
@@ skipping 19 matching lines @@
   explicit CustomFakeGCMDriver(FakeGCMProfileService* service);
   ~CustomFakeGCMDriver() override;
 
   void OnRegisterFinished(const std::string& app_id,
                           const std::string& registration_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);
+  void OnDispatchMessage(
+      const std::string& app_id,
+      const IncomingMessage& message,
+      const MessageReceiptCallback& optional_receipt_callback);
 
  protected:
   // FakeGCMDriver 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 133 matching lines @@
     const DeleteTokenCallback& callback) {
   if (service_->is_offline_)
     return;  // Drop request.
 
   instance_id::FakeGCMDriverForInstanceID::DeleteToken(
       app_id, authorized_entity, scope, callback);
 }
 
 void FakeGCMProfileService::CustomFakeGCMDriver::OnDispatchMessage(
     const std::string& app_id,
-    const IncomingMessage& message) {
-  DispatchMessage(app_id, message);
+    const IncomingMessage& message,
+    const MessageReceiptCallback& optional_receipt_callback) {
+  DispatchMessage(app_id, message, optional_receipt_callback);
 }
 
 // static
 std::unique_ptr<KeyedService> FakeGCMProfileService::Build(
     content::BrowserContext* context) {
   Profile* profile = static_cast<Profile*>(context);
   std::unique_ptr<FakeGCMProfileService> service(
       new FakeGCMProfileService(profile));
   service->SetDriverForTesting(new CustomFakeGCMDriver(service.get()));
   return std::move(service);
 }
 
 FakeGCMProfileService::FakeGCMProfileService(Profile* profile) {}
 
 FakeGCMProfileService::~FakeGCMProfileService() {}
 
 void FakeGCMProfileService::AddExpectedUnregisterResponse(
     GCMClient::Result result) {
   unregister_responses_.push_back(result);
 }
 
-void FakeGCMProfileService::DispatchMessage(const std::string& app_id,
-                                            const IncomingMessage& message) {
+void FakeGCMProfileService::DispatchMessage(
+    const std::string& app_id,
+    const IncomingMessage& message,
+    const MessageReceiptCallback& optional_receipt_callback) {
   CustomFakeGCMDriver* custom_driver =
       static_cast<CustomFakeGCMDriver*>(driver());
-  custom_driver->OnDispatchMessage(app_id, message);
+  custom_driver->OnDispatchMessage(app_id, message, optional_receipt_callback);
 }
 
 }  // namespace gcm