[Extensions Bindings] Add support for updateArgumentsPreValidate

extensions/renderer/native_extension_bindings_system.cc

 // Copyright 2016 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 "extensions/renderer/native_extension_bindings_system.h"
 
 #include "base/command_line.h"
 #include "content/public/common/content_switches.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_api.h"
@@ skipping 63 matching lines @@
 void CallJsFunction(v8::Local<v8::Function> function,
                     v8::Local<v8::Context> context,
                     int argc,
                     v8::Local<v8::Value> argv[]) {
   ScriptContext* script_context =
       ScriptContextSet::GetContextByV8Context(context);
   CHECK(script_context);
   script_context->SafeCallFunction(function, argc, argv);
 }
 
+// A helper class for calling JS function synchronously.
+class CallJsSyncHelper {
+ public:
+  CallJsSyncHelper(v8::Isolate* isolate) : isolate_(isolate),
+                                           weak_factory_(this) {}
+  ~CallJsSyncHelper() {}
+
+  ScriptInjectionCallback::CompleteCallback GetCallback() {
+    return base::Bind(&CallJsSyncHelper::OnJsComplete,
+                      weak_factory_.GetWeakPtr());
+  }
+
+  bool did_complete() const { return did_complete_; }
+  v8::Global<v8::Value> take_result() { return std::move(result_); }
+
+ private:
+  void OnJsComplete(const std::vector<v8::Local<v8::Value>>& results) {
+    DCHECK_EQ(1u, results.size());
+    did_complete_ = true;
+    // The locals are released after the callback is executed, so we need to
+    // grab a persistent handle.
+    result_.Reset(isolate_, results[0]);
+  }
+
+  bool did_complete_ = false;
+  v8::Isolate* isolate_;
+  v8::Global<v8::Value> result_;
+  base::WeakPtrFactory<CallJsSyncHelper> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(CallJsSyncHelper);
+};
+
+v8::Global<v8::Value> CallJsFunctionSync(v8::Local<v8::Function> function,
+                                         v8::Local<v8::Context> context,
+                                         int argc,
+                                         v8::Local<v8::Value> argv[]) {
+  CallJsSyncHelper helper(context->GetIsolate());
+  ScriptContext* script_context =
+      ScriptContextSet::GetContextByV8Context(context);
+  CHECK(script_context);
+  script_context->SafeCallFunction(function, argc, argv, helper.GetCallback());
+  // If the JS did not, in fact, execute synchronously, there's a big problem.
+  CHECK(helper.did_complete());
+  return helper.take_result();
+}
+
 // Returns the API schema indicated by |api_name|.
 const base::DictionaryValue& GetAPISchema(const std::string& api_name) {
   const base::DictionaryValue* schema =
       ExtensionAPI::GetSharedInstance()->GetSchema(api_name);
   CHECK(schema);
   return *schema;
 }
 
 // Returns true if the method specified by |method_name| is available to the
 // given |context|.
 bool IsAPIMethodAvailable(ScriptContext* context,
                           const std::string& method_name) {
   return context->GetAvailability(method_name).is_available();
 }
 
 }  // namespace
 
 NativeExtensionBindingsSystem::NativeExtensionBindingsSystem(
     const SendIPCMethod& send_ipc)
     : send_ipc_(send_ipc),
       api_system_(base::Bind(&CallJsFunction),
+                  base::Bind(&CallJsFunctionSync),
                   base::Bind(&GetAPISchema),
                   base::Bind(&NativeExtensionBindingsSystem::SendRequest,
                              base::Unretained(this))),
       weak_factory_(this) {}
 
 NativeExtensionBindingsSystem::~NativeExtensionBindingsSystem() {}
 
 void NativeExtensionBindingsSystem::DidCreateScriptContext(
     ScriptContext* context) {}
 
@@ skipping 174 matching lines @@
   params.has_callback = request->has_callback;
   params.user_gesture = request->has_user_gesture;
   // TODO(devlin): Make this work in ServiceWorkers.
   params.worker_thread_id = -1;
   params.service_worker_version_id = kInvalidServiceWorkerVersionId;
 
   send_ipc_.Run(script_context, params);
 }
 
 }  // namespace extensions