[Extensions Bindings] Allow for argument validation without conversion

extensions/renderer/api_binding_hooks.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/api_binding_hooks.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/supports_user_data.h"
+#include "extensions/renderer/api_signature.h"
 #include "gin/arguments.h"
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 #include "gin/per_context_data.h"
 #include "gin/wrappable.h"
 
 namespace extensions {
 
 namespace {
 
@@ skipping 75 matching lines @@
   DCHECK(!hooks_used_) << "Hooks must be registered before the first use!";
   request_hooks_[method_name] = hook;
 }
 
 void APIBindingHooks::RegisterJsSource(v8::Global<v8::String> source,
                                        v8::Global<v8::String> resource_name) {
   js_hooks_source_ = std::move(source);
   js_resource_name_ = std::move(resource_name);
 }
 
-bool APIBindingHooks::HandleRequest(const std::string& api_name,
-                                    const std::string& method_name,
-                                    v8::Local<v8::Context> context,
-                                    const APISignature* signature,
-                                    gin::Arguments* arguments) {
+APIBindingHooks::RequestResult APIBindingHooks::HandleRequest(
+    const std::string& api_name,
+    const std::string& method_name,
+    v8::Local<v8::Context> context,
+    const APISignature* signature,
+    gin::Arguments* arguments,
+    const ArgumentSpec::RefMap& type_refs) {
   // Easy case: a native custom hook.
   auto request_hooks_iter = request_hooks_.find(method_name);
   if (request_hooks_iter != request_hooks_.end()) {
-    request_hooks_iter->second.Run(signature, arguments);
-    return true;
+    RequestResult result =
+        request_hooks_iter->second.Run(signature, arguments, type_refs);
+    // Right now, it doesn't make sense to register a request handler that
+    // doesn't handle the request.
+    DCHECK_NE(RequestResult::NOT_HANDLED, result);
+    return result;
   }
 
   // Harder case: looking up a custom hook registered on the context (since
   // these are JS, each context has a separate instance).
   gin::PerContextData* per_context_data = gin::PerContextData::From(context);
   DCHECK(per_context_data);
   APIHooksPerContextData* data = static_cast<APIHooksPerContextData*>(
       per_context_data->GetUserData(kExtensionAPIHooksPerContextKey));
   if (!data)
-    return false;
+    return RequestResult::NOT_HANDLED;
 
   auto hook_interface_iter = data->hook_interfaces.find(api_name);
   if (hook_interface_iter == data->hook_interfaces.end())
-    return false;
+    return RequestResult::NOT_HANDLED;
 
   JSHookInterface* hook_interface = nullptr;
   gin::Converter<JSHookInterface*>::FromV8(
       context->GetIsolate(),
       hook_interface_iter->second.Get(context->GetIsolate()), &hook_interface);
   CHECK(hook_interface);
 
   auto js_hook_iter = hook_interface->js_hooks()->find(method_name);
   if (js_hook_iter == hook_interface->js_hooks()->end())
-    return false;
+    return RequestResult::NOT_HANDLED;
 
   // Found a JS handler.
   std::vector<v8::Local<v8::Value>> v8_args;
+  std::string error;
+  if (!signature->ParseArgumentsToV8(arguments, type_refs, &v8_args, &error))
+    return RequestResult::INVALID_INVOCATION;
+
   // TODO(devlin): Right now, this doesn't support exceptions or return values,
   // which we will need to at some point.
-  if (arguments->Length() == 0 || arguments->GetRemaining(&v8_args)) {
-    v8::Local<v8::Function> handler =
-        js_hook_iter->second.Get(context->GetIsolate());
-    run_js_.Run(handler, context, v8_args.size(), v8_args.data());
-  }
+  v8::Local<v8::Function> handler =
+      js_hook_iter->second.Get(context->GetIsolate());
+  run_js_.Run(handler, context, v8_args.size(), v8_args.data());
 
-  return true;
+  return RequestResult::HANDLED;
 }
 
 void APIBindingHooks::InitializeInContext(
     v8::Local<v8::Context> context,
     const std::string& api_name) {
   if (js_hooks_source_.IsEmpty())
     return;
 
   v8::Local<v8::String> source = js_hooks_source_.Get(context->GetIsolate());
   v8::Local<v8::String> resource_name =
@@ skipping 33 matching lines @@
   gin::Handle<JSHookInterface> hooks =
       gin::CreateHandle(context->GetIsolate(), new JSHookInterface(api_name));
   CHECK(!hooks.IsEmpty());
   v8::Local<v8::Object> hooks_object = hooks.ToV8().As<v8::Object>();
   data->hook_interfaces[api_name].Reset(context->GetIsolate(), hooks_object);
 
   return hooks_object;
 }
 
 }  // namespace extensions