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

chrome/renderer/extensions/pepper_request_proxy.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/renderer/extensions/pepper_request_proxy.h"
+
+#include "base/values.h"
+#include "chrome/renderer/extensions/chrome_v8_context.h"
+#include "content/public/renderer/v8_value_converter.h"
+
+namespace extensions {
+
+PepperRequestProxy::PepperRequestProxy(ChromeV8Context* context)
+    : context_(context), next_request_id_(0) {}
+
+PepperRequestProxy::~PepperRequestProxy() {}
+
+bool PepperRequestProxy::StartCall(const ResponseCallback& callback,
+                                   const std::string& request_name,
+                                   const base::ListValue& args,
+                                   int* request_id,
+                                   std::string* error) {
+  *request_id = next_request_id_++;
+  pending_request_map_[*request_id] = callback;
+  scoped_ptr<base::ListValue> mutable_args(args.DeepCopy());

[yzshen1, 2013/11/27 23:56:52]

It is unfortunate that we have to do a deep copy here. :/
Is there any way we can avoid this? For example, maybe we could take ownership
of |args|. Or we probably don't have to modify |args| -- we convert it to
|v8_args|, we could add request_id / request_name there.

[Sam McNally, 2013/11/28 00:04:50]

Done.

+  mutable_args->Insert(0, new base::FundamentalValue(*request_id));
+
+  bool result =
+      StartRequest(request_name, "callMethod", mutable_args.get(), error);
+  if (!result)
+    pending_request_map_.erase(*request_id);
+  return result;
+}
+
+bool PepperRequestProxy::StartPost(const std::string& request_name,
+                                   const base::ListValue& args,
+                                   std::string* error) {
+  scoped_ptr<base::ListValue> mutable_args(args.DeepCopy());
+  return StartRequest(request_name, "postMethod", mutable_args.get(), error);
+}
+
+bool PepperRequestProxy::StartRequest(const std::string& request_name,
+                                      const std::string& method_name,
+                                      base::ListValue* args,
+                                      std::string* error) {
+  args->Insert(0, new base::StringValue(request_name));
+
+  // TODO(sammc): Converting from base::Value to v8::Value and then back to
+  // base::Value is not optimal. For most API calls the JS code doesn't do much.
+  // http://crbug.com/324115.
+  v8::HandleScope scope(v8::Isolate::GetCurrent());
+  scoped_ptr<content::V8ValueConverter> converter(
+      content::V8ValueConverter::create());
+  std::vector<v8::Handle<v8::Value> > v8_args;
+  for (base::ListValue::const_iterator it = args->begin(); it != args->end();
+       ++it) {
+    v8_args.push_back(converter->ToV8Value(*it, context_->v8_context()));
+  }
+  v8::Handle<v8::Value> v8_error = context_->module_system()->CallModuleMethod(
+      "pepper_request", method_name, &v8_args);
+  if (v8_error->IsString()) {
+    if (error)
+      *error = *v8::String::Utf8Value(v8_error);
+    return false;
+  }
+
+  return true;
+}
+
+void PepperRequestProxy::OnResponseReceived(int request_id,
+                                            bool success,
+                                            const base::ListValue& args,
+                                            const std::string& error) {
+  PendingRequestMap::iterator it = pending_request_map_.find(request_id);
+  DCHECK(it != pending_request_map_.end());
+  it->second.Run(request_id, success, args, error);
+  pending_request_map_.erase(it);
+}
+
+}  // namespace extensions