Adding support for pre-sent messages

components/copresence/rpc/rpc_handler.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/copresence/rpc/rpc_handler.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/logging.h"
@@ skipping 13 matching lines @@
 #include "components/copresence/handlers/directive_handler.h"
 #include "components/copresence/handlers/gcm_handler.h"
 #include "components/copresence/proto/codes.pb.h"
 #include "components/copresence/proto/data.pb.h"
 #include "components/copresence/proto/rpcs.pb.h"
 #include "components/copresence/public/copresence_constants.h"
 #include "components/copresence/public/copresence_delegate.h"
 #include "components/copresence/rpc/http_post.h"
 #include "net/http/http_status_code.h"
 
+using google::protobuf::MessageLite;
+
 // TODO(ckehoe): Return error messages for bad requests.
 
 namespace copresence {
 
-using google::protobuf::MessageLite;
-using google::protobuf::RepeatedPtrField;
-
 const char RpcHandler::kReportRequestRpcName[] = "report";
 
 namespace {
 
 const int kTokenLoggingSuffix = 5;
 const int kInvalidTokenExpiryTimeMs = 10 * 60 * 1000;  // 10 minutes.
 const int kMaxInvalidTokens = 10000;
 const char kRegisterDeviceRpcName[] = "registerdevice";
 const char kDefaultCopresenceServer[] =
     "https://www.googleapis.com/copresence/v2/copresence";
@@ skipping 111 matching lines @@
 
 }  // namespace
 
 
 // Public functions.
 
 RpcHandler::RpcHandler(CopresenceDelegate* delegate,
                        CopresenceStateImpl* state,
                        DirectiveHandler* directive_handler,
                        GCMHandler* gcm_handler,
+                       const MessagesCallback& new_messages_callback,
                        const PostCallback& server_post_callback)
     : delegate_(delegate),
       state_(state),
       directive_handler_(directive_handler),
       gcm_handler_(gcm_handler),
+      new_messages_callback_(new_messages_callback),
       server_post_callback_(server_post_callback),
       invalid_audio_token_cache_(
           base::TimeDelta::FromMilliseconds(kInvalidTokenExpiryTimeMs),
           kMaxInvalidTokens) {
     DCHECK(delegate_);
     DCHECK(directive_handler_);
     // |gcm_handler_| is optional.
 
     if (server_post_callback_.is_null()) {
       server_post_callback_ =
@@ skipping 294 matching lines @@
   }
 
   for (const SubscriptionResult& result :
       response.manage_subscriptions_response().subscription_result()) {
     DVLOG(2) << "Created subscription with id " << result.subscription_id();
   }
 
   if (response.has_update_signals_response()) {
     const UpdateSignalsResponse& update_response =
         response.update_signals_response();
-    DispatchMessages(update_response.message());
+    new_messages_callback_.Run(update_response.message());
 
     for (const Directive& directive : update_response.directive())
       directive_handler_->AddDirective(directive);
 
     for (const Token& token : update_response.token()) {
       state_->UpdateTokenStatus(token.id(), token.status());
       switch (token.status()) {
         case VALID:
           // TODO(rkc/ckehoe): Store the token in a |valid_token_cache_| with a
           // short TTL (like 10s) and send it up with every report request.
@@ skipping 39 matching lines @@
       directive_handler_->GetCurrentAudioToken(AUDIBLE);
   const std::string& inaudible_token =
       directive_handler_->GetCurrentAudioToken(INAUDIBLE);
 
   if (!audible_token.empty())
     AddTokenToRequest(AudioToken(audible_token, true), request);
   if (!inaudible_token.empty())
     AddTokenToRequest(AudioToken(inaudible_token, false), request);
 }
 
-void RpcHandler::DispatchMessages(
-    const RepeatedPtrField<SubscribedMessage>& messages) {
-  if (messages.size() == 0)
-    return;
-
-  // Index the messages by subscription id.
-  std::map<std::string, std::vector<Message>> messages_by_subscription;
-  DVLOG(3) << "Dispatching " << messages.size() << " messages";
-  for (const SubscribedMessage& message : messages) {
-    for (const std::string& subscription_id : message.subscription_id()) {
-      messages_by_subscription[subscription_id].push_back(
-          message.published_message());
-    }
-  }
-
-  // Send the messages for each subscription.
-  for (const auto& map_entry : messages_by_subscription) {
-    // TODO(ckehoe): Once we have the app ID from the server, we need to pass
-    // it in here and get rid of the app id registry from the main API class.
-    const std::string& subscription = map_entry.first;
-    const std::vector<Message>& messages = map_entry.second;
-    delegate_->HandleMessages(std::string(), subscription, messages);
-  }
-}
-
 // TODO(ckehoe): Pass in the version string and
 // group this with the local functions up top.
 RequestHeader* RpcHandler::CreateRequestHeader(
     const std::string& client_name,
     const std::string& device_id) const {
   RequestHeader* header = new RequestHeader;
 
   header->set_allocated_framework_version(CreateVersion(
       "Chrome", delegate_->GetPlatformVersionString()));
   if (!client_name.empty()) {
@@ skipping 50 matching lines @@
       api_key,
       auth_token,
       command_line->GetSwitchValueASCII(switches::kCopresenceTracingToken),
       *request_proto);
 
   http_post->Start(base::Bind(callback, http_post));
   pending_posts_.insert(http_post);
 }
 
 }  // namespace copresence