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

components/gcm_driver/gcm_client_impl.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_client_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 1326 matching lines @@
     case DELETED_MESSAGES:
       recorder_.RecordDataMessageReceived(app_id, data_message_stanza.from(),
                                           data_message_stanza.ByteSize(), true,
                                           GCMStatsRecorder::DELETED_MESSAGES);
       delegate_->OnMessagesDeleted(app_id);
       break;
     case SEND_ERROR:
       HandleIncomingSendError(app_id, data_message_stanza, message_data);
       break;
     case UNKNOWN:
+      delegate_->OnMessageReceivedError(data_message_stanza.id(), app_id,
+                                        GCMClient::GCM_UNKNOWN_MESSAGE_TYPE);
       DVLOG(1) << "Unknown message_type received. Message ignored. "
                << "App ID: " << app_id << ".";
       break;
   }
 }
 
 void GCMClientImpl::HandleIncomingDataMessage(
     const std::string& app_id,
     bool was_subtype,
     const mcs_proto::DataMessageStanza& data_message_stanza,
@@ skipping 40 matching lines @@
                     << " incorrectly had was_subtype = " << was_subtype;
       } else {
         registered = true;
       }
     }
   }
 
   recorder_.RecordDataMessageReceived(app_id, sender,
       data_message_stanza.ByteSize(), registered,
       GCMStatsRecorder::DATA_MESSAGE);
-  if (!registered)
+  if (!registered) {
+    delegate_->OnMessageReceivedError(app_id, data_message_stanza.id(),
+                                      GCMClient::GCM_INVALID_SUBTYPE);

[Peter Beverloo, 2016/12/15 19:24:24]

It's a bit unfortunate that we need to do the GCMClient -> GCMDriver ->
GCMClient hoop. Could we instead have SendMessageReceipt() live in the GCMClient
and propagate the callback to the GCMDriver? (I guess this means that the
callback has to be declared in the same file as the enumeration.)

An additional benefit here is that we can avoid constructing an OutgoingMessage
object for Android, and instead use more specialized handling.

(At least until we need _real_ support for outgoing messages, because now you're
signing yourself up to do that work.)

[harkness, 2016/12/21 17:23:37]

I've mostly moved things to the GCMClient now. It does simplify things to not
need to pass them through the Delegate.

     return;
+  }
 
   IncomingMessage incoming_message;
+  incoming_message.id = data_message_stanza.id();
   incoming_message.sender_id = data_message_stanza.from();
   if (data_message_stanza.has_token())
     incoming_message.collapse_key = data_message_stanza.token();
   incoming_message.data = message_data;
   incoming_message.raw_data = data_message_stanza.raw_data();
 
   delegate_->OnMessageReceived(app_id, incoming_message);
 }
 
 void GCMClientImpl::HandleIncomingSendError(
@@ skipping 19 matching lines @@
 bool GCMClientImpl::HasStandaloneRegisteredApp() const {
   if (registrations_.empty())
     return false;
   // Note that account mapper is not counted as a standalone app since it is
   // automatically started when other app uses GCM.
   return registrations_.size() > 1 ||
          !ExistsGCMRegistrationInMap(registrations_, kGCMAccountMapperAppId);
 }
 
 }  // namespace gcm