PPAPI: Support sending browser-hosted resources synchronously

content/renderer/pepper/pepper_browser_connection.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 "content/renderer/pepper/pepper_browser_connection.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/pepper/pepper_in_process_router.h"
 #include "content/renderer/render_frame_impl.h"
 #include "ipc/ipc_message_macros.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/resource_message_params.h"
+#include "ppapi/proxy/serialized_structs.h"
 
 namespace content {
 
 PepperBrowserConnection::PepperBrowserConnection(RenderFrame* render_frame)
     : RenderFrameObserver(render_frame),
       RenderFrameObserverTracker<PepperBrowserConnection>(render_frame),
       next_sequence_number_(1) {}
 
 PepperBrowserConnection::~PepperBrowserConnection() {}
 
@@ skipping 20 matching lines @@
       instance,
       // Browser provides the render process id.
       PepperRendererInstanceData(
           0, render_frame_id, document_url, plugin_url)));
 }
 
 void PepperBrowserConnection::DidDeleteInProcessInstance(PP_Instance instance) {
   Send(new ViewHostMsg_DidDeleteInProcessInstance(instance));
 }
 
-void PepperBrowserConnection::SendBrowserCreate(
+int32_t PepperBrowserConnection::SendBrowserCreate(
     int child_process_id,
     PP_Instance instance,
     const std::vector<IPC::Message>& nested_msgs,
-    const PendingResourceIDCallback& callback) {
+    const PendingResourceCallback& callback) {
   int32_t sequence_number = GetNextSequence();
-  pending_create_map_[sequence_number] = callback;
+  pending_create_map_.insert(
+      std::map<int32_t, PendingResource>::value_type(
+          sequence_number,
+          PendingResource(child_process_id, instance, callback)));
   ppapi::proxy::ResourceMessageCallParams params(0, sequence_number);
   Send(new PpapiHostMsg_CreateResourceHostsFromHost(
       routing_id(), child_process_id, params, instance, nested_msgs));
+  return sequence_number;
+}
+
+void PepperBrowserConnection::GetAllPendingBrowserHosts(
+    PP_Instance instance,
+    int child_process_id,
+    std::vector<ppapi::proxy::CompletedBrowserResourceHosts>* result) {
+  Send(new PpapiHostMsg_GetAllPendingResourceHosts(routing_id(),
+                                                   child_process_id,
+                                                   instance,
+                                                   result));
+  // We just got all the responses that were pending, and we may not receive a
+  // reply for all of them. Just ignore any replies we do get.
+  pending_create_map_.clear();
+}
+
+PepperBrowserConnection::PendingResource::PendingResource(
+    int child_process_id_param,
+    PP_Instance instance_param,
+    const PendingResourceCallback& callback_param)
+    : child_process_id(child_process_id_param),
+      instance(instance_param),
+      callback(callback_param) {
+}
+
+PepperBrowserConnection::PendingResource::~PendingResource() {
 }
 
 void PepperBrowserConnection::OnMsgCreateResourceHostsFromHostReply(
-    int32_t sequence_number,
-    const std::vector<int>& pending_resource_host_ids) {
+      const ppapi::proxy::CompletedBrowserResourceHosts& hosts) {
   // Check that the message is destined for the plugin this object is associated
   // with.
-  std::map<int32_t, PendingResourceIDCallback>::iterator it =
-      pending_create_map_.find(sequence_number);
+  std::map<int32_t, PendingResource>::iterator it =
+      pending_create_map_.find(hosts.sequence_id);
   if (it != pending_create_map_.end()) {
-    it->second.Run(pending_resource_host_ids);
+    it->second.callback.Run(hosts);
+    Send(new PpapiHostMsg_CreateResourceHostsFromHostReplyAck(
+        it->second.child_process_id,
+        it->second.instance,
+        hosts.sequence_id));
     pending_create_map_.erase(it);
   } else {
-    NOTREACHED();
+    // This can happen if we already received the pending hosts via
+    // sending GetAllPendingResourceHosts synchronously.
   }
 }
 
 int32_t PepperBrowserConnection::GetNextSequence() {
   // Return the value with wraparound, making sure we don't make a sequence
   // number with a 0 ID. Note that signed wraparound is undefined in C++ so we
   // manually check.
   int32_t ret = next_sequence_number_;
   if (next_sequence_number_ == std::numeric_limits<int32_t>::max())
     next_sequence_number_ = 1;  // Skip 0 which is invalid.
   else
     next_sequence_number_++;
   return ret;
 }
 
 }  // namespace content