Pass pepper apps API calls through the existing js apps API bindings.

chrome/renderer/pepper/pepper_extensions_common_host.cc

 // Copyright (c) 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/renderer/pepper/pepper_extensions_common_host.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/renderer/extensions/chrome_v8_context.h"
 #include "chrome/renderer/extensions/dispatcher.h"
 #include "chrome/renderer/extensions/extension_helper.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/host_message_context.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
 
 PepperExtensionsCommonHost::PepperExtensionsCommonHost(
     content::RendererPpapiHost* host,
     PP_Instance instance,
     PP_Resource resource,
-    extensions::Dispatcher* dispatcher)
+    extensions::PepperRequestProxy* pepper_request_proxy)
     : ResourceHost(host->GetPpapiHost(), instance, resource),
       renderer_ppapi_host_(host),
-      dispatcher_(dispatcher) {
+      pepper_request_proxy_(pepper_request_proxy),
+      weak_factory_(this) {
+  callback_ = base::Bind(&PepperExtensionsCommonHost::OnResponseReceived,

[not at google - send to devlin, 2013/12/03 17:32:50]

holding onto this callback is weird. just create it each request.

[Sam McNally, 2013/12/04 00:01:36]

Done.

+                         weak_factory_.GetWeakPtr());
 }
 
-PepperExtensionsCommonHost::~PepperExtensionsCommonHost() {
-  dispatcher_->request_sender()->InvalidateSource(this);
-}
+PepperExtensionsCommonHost::~PepperExtensionsCommonHost() {}
 
 // static
 PepperExtensionsCommonHost* PepperExtensionsCommonHost::Create(
     content::RendererPpapiHost* host,
     PP_Instance instance,
     PP_Resource resource) {
   content::RenderView* render_view = host->GetRenderViewForInstance(instance);
   if (!render_view)
     return NULL;
   extensions::ExtensionHelper* extension_helper =
       extensions::ExtensionHelper::Get(render_view);
   if (!extension_helper)
     return NULL;
   extensions::Dispatcher* dispatcher = extension_helper->dispatcher();
   if (!dispatcher)
     return NULL;
+  blink::WebPluginContainer* container =
+      host->GetContainerForInstance(instance);
+  if (!container)
+    return NULL;
+  blink::WebFrame* frame = container->element().document().frame();
+  if (!frame)
+    return NULL;
+  v8::HandleScope scope(v8::Isolate::GetCurrent());
+  extensions::ChromeV8Context* context =
+      dispatcher->v8_context_set().GetByV8Context(
+          frame->mainWorldScriptContext());
+  if (!context)
+    return NULL;
 
-  return new PepperExtensionsCommonHost(host, instance, resource, dispatcher);
+  return new PepperExtensionsCommonHost(
+      host, instance, resource, context->pepper_request_proxy());
 }
 
 int32_t PepperExtensionsCommonHost::OnResourceMessageReceived(
     const IPC::Message& msg,
     ppapi::host::HostMessageContext* context) {
   IPC_BEGIN_MESSAGE_MAP(PepperExtensionsCommonHost, msg)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_ExtensionsCommon_Post,
                                       OnPost)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_ExtensionsCommon_Call,
                                       OnCall)
   IPC_END_MESSAGE_MAP()
   return PP_ERROR_FAILED;
 }
 
-extensions::ChromeV8Context* PepperExtensionsCommonHost::GetContext() {
-  blink::WebPluginContainer* container =
-      renderer_ppapi_host_->GetContainerForInstance(pp_instance());
-  if (!container)
-    return NULL;
-
-  blink::WebFrame* frame = container->element().document().frame();
-  v8::HandleScope scope(v8::Isolate::GetCurrent());
-  return dispatcher_->v8_context_set().GetByV8Context(
-      frame->mainWorldScriptContext());
-}
-
 void PepperExtensionsCommonHost::OnResponseReceived(
-    const std::string& /* name */,
     int request_id,
     bool success,
     const base::ListValue& response,
     const std::string& /* error */) {
   PendingRequestMap::iterator iter = pending_request_map_.find(request_id);
 
-  // Ignore responses resulted from calls to OnPost().
-  if (iter == pending_request_map_.end()) {
-    DCHECK_EQ(0u, response.GetSize());
-    return;
-  }
+  DCHECK(iter != pending_request_map_.end());
 
   linked_ptr<ppapi::host::ReplyMessageContext> context = iter->second;
   pending_request_map_.erase(iter);
 
   context->params.set_result(success ? PP_OK : PP_ERROR_FAILED);
   SendReply(*context, PpapiPluginMsg_ExtensionsCommon_CallReply(response));
 }
 
 int32_t PepperExtensionsCommonHost::OnPost(
     ppapi::host::HostMessageContext* context,
     const std::string& request_name,
     base::ListValue& args) {

[not at google - send to devlin, 2013/12/03 17:32:50]

this (and below) is a non-const reference? ok well I guess the call site isn't
in extensions, so whatever.

[Sam McNally, 2013/12/04 00:01:36]

Done.

-  // TODO(yzshen): Add support for calling into JS for APIs that have custom
-  // bindings.
-  int request_id = dispatcher_->request_sender()->GetNextRequestId();
-  dispatcher_->request_sender()->StartRequest(this, request_name, request_id,
-                                              false, false, &args);
+  std::string error;
+  bool success = pepper_request_proxy_->StartPost(request_name, &args, &error);
+  if (!success)
+    return PP_ERROR_FAILED;
+
   return PP_OK;
 }
 
 int32_t PepperExtensionsCommonHost::OnCall(
     ppapi::host::HostMessageContext* context,
     const std::string& request_name,
     base::ListValue& args) {
-  // TODO(yzshen): Add support for calling into JS for APIs that have custom
-  // bindings.
-  int request_id = dispatcher_->request_sender()->GetNextRequestId();
+  int request_id;
+  std::string error;
+  bool success = pepper_request_proxy_->StartCall(
+      callback_, request_name, &args, &request_id, &error);
+  if (!success)
+    return PP_ERROR_FAILED;
+
   pending_request_map_[request_id] =

[not at google - send to devlin, 2013/12/03 17:32:50]

I think that pending_request_map_ is unnecessary if you curry through this
ReplyMessageContext into the base::Bound OnResponseReceieved. You could do like

scoped_ptr<ReplyMessageContext> message_context(
    new ReplyMessageContext(context->MakeReplyMessageContext());
bool success = pepper_request_proxy_->StartCall(
    base::Bind(weak_ptr_factory_.GetWeakPtr(),
               &OnResponseReceived,
               base::Passed(&message_context)),
    request_name,
    &args,
    // no need for request_id anymore, woo
    &error);
return success ? PP_OK_COMPLETIONPENDING : PP_ERROR_FAILED;

then OnResponseReceiver would receive that scoped_ptr<ReplyMessageContext> as
its first argument.

obviously that would also require that you don't hold onto the callback as a
constant member variable. however, as I said above, it's rather unidiomatic to
do that regardless.

[Sam McNally, 2013/12/04 00:01:36]

Done.

       linked_ptr<ppapi::host::ReplyMessageContext>(
           new ppapi::host::ReplyMessageContext(
               context->MakeReplyMessageContext()));
 
-  dispatcher_->request_sender()->StartRequest(this, request_name, request_id,
-                                              true, false, &args);
   return PP_OK_COMPLETIONPENDING;
 }