[Extensions Bindings] Add support for updateArgumentsPostValidate

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"
@@ skipping 15 matching lines @@
       : api_name_(api_name) {}
 
   static gin::WrapperInfo kWrapperInfo;
 
   // gin::Wrappable:
   gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
       v8::Isolate* isolate) override {
     return Wrappable<JSHookInterface>::GetObjectTemplateBuilder(isolate)
         .SetMethod("setHandleRequest", &JSHookInterface::SetHandleRequest)
         .SetMethod("setUpdateArgumentsPreValidate",
-                   &JSHookInterface::SetUpdateArgumentsPreValidate);
+                   &JSHookInterface::SetUpdateArgumentsPreValidate)
+        .SetMethod("setUpdateArgumentsPostValidate",
+                   &JSHookInterface::SetUpdateArgumentsPostValidate);
   }
 
   void ClearHooks() {
     handle_request_hooks_.clear();
     pre_validation_hooks_.clear();
+    post_validation_hooks_.clear();
   }
 
   v8::Local<v8::Function> GetHandleRequestHook(const std::string& method_name,
                                                v8::Isolate* isolate) const {
     return GetHookFromMap(handle_request_hooks_, method_name, isolate);
   }
 
   v8::Local<v8::Function> GetPreValidationHook(const std::string& method_name,
                                                v8::Isolate* isolate) const {
     return GetHookFromMap(pre_validation_hooks_, method_name, isolate);
   }
 
+  v8::Local<v8::Function> GetPostValidationHook(const std::string& method_name,
+                                                v8::Isolate* isolate) const {
+    return GetHookFromMap(post_validation_hooks_, method_name, isolate);
+  }
+
  private:
   using JSHooks = std::map<std::string, v8::Global<v8::Function>>;
 
   v8::Local<v8::Function> GetHookFromMap(const JSHooks& map,
                                          const std::string& method_name,
                                          v8::Isolate* isolate) const {
     auto iter = map.find(method_name);
     if (iter == map.end())
       return v8::Local<v8::Function>();
     return iter->second.Get(isolate);
@@ skipping 21 matching lines @@
   }
 
   // Adds a hook to update the arguments passed to the API method before we do
   // any kind of validation.
   void SetUpdateArgumentsPreValidate(v8::Isolate* isolate,
                                      const std::string& method_name,
                                      v8::Local<v8::Function> hook) {
     AddHookToMap(&pre_validation_hooks_, isolate, method_name, hook);
   }
 
+  void SetUpdateArgumentsPostValidate(v8::Isolate* isolate,
+                                      const std::string& method_name,
+                                      v8::Local<v8::Function> hook) {
+    AddHookToMap(&post_validation_hooks_, isolate, method_name, hook);
+  }
+
   std::string api_name_;
 
   JSHooks handle_request_hooks_;
   JSHooks pre_validation_hooks_;
+  JSHooks post_validation_hooks_;
 
   DISALLOW_COPY_AND_ASSIGN(JSHookInterface);
 };
 
 const char kExtensionAPIHooksPerContextKey[] = "extension_api_hooks";
 
 struct APIHooksPerContextData : public base::SupportsUserData::Data {
   APIHooksPerContextData(v8::Isolate* isolate) : isolate(isolate) {}
   ~APIHooksPerContextData() override {
     v8::HandleScope scope(isolate);
@@ skipping 69 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);
 }
 
-APIBindingHooks::RequestResult APIBindingHooks::HandleRequest(
+APIBindingHooks::RequestResult APIBindingHooks::RunHooks(
     const std::string& api_name,
     const std::string& method_name,
     v8::Local<v8::Context> context,
     const APISignature* signature,
     std::vector<v8::Local<v8::Value>>* 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()) {
     RequestResult result =
@@ skipping 15 matching lines @@
   v8::Isolate* isolate = context->GetIsolate();
 
   JSHookInterface* hook_interface = nullptr;
   gin::Converter<JSHookInterface*>::FromV8(
       isolate,
       hook_interface_object, &hook_interface);
   CHECK(hook_interface);
 
   v8::Local<v8::Function> pre_validate_hook =
       hook_interface->GetPreValidationHook(method_name, isolate);
+  v8::TryCatch try_catch(isolate);
   if (!pre_validate_hook.IsEmpty()) {
-    v8::TryCatch try_catch(isolate);
     // TODO(devlin): What to do with the result of this function call? Can it
     // only fail in the case we've already thrown?
     UpdateArguments(pre_validate_hook, context, arguments);
     if (try_catch.HasCaught()) {
       try_catch.ReThrow();
       return RequestResult(RequestResult::THROWN);
     }
   }
 
+  v8::Local<v8::Function> post_validate_hook =
+      hook_interface->GetPostValidationHook(method_name, isolate);
   v8::Local<v8::Function> handle_request =
       hook_interface->GetHandleRequestHook(method_name, isolate);
-  if (!handle_request.IsEmpty()) {
-    v8::TryCatch try_catch(isolate);
+  // If both the post validation hook and the handle request hook are empty,
+  // we're done...
+  if (post_validate_hook.IsEmpty() && handle_request.IsEmpty())
+    return RequestResult(RequestResult::NOT_HANDLED);
+
+  {
+    // ... otherwise, we have to validate the arguments.
     std::vector<v8::Local<v8::Value>> parsed_v8_args;
     std::string error;
     bool success = signature->ParseArgumentsToV8(context, *arguments, type_refs,
                                                  &parsed_v8_args, &error);
     if (try_catch.HasCaught()) {
       try_catch.ReThrow();
       return RequestResult(RequestResult::THROWN);
     }
     if (!success)
       return RequestResult(RequestResult::INVALID_INVOCATION);
+    arguments->swap(parsed_v8_args);
+  }
 
-    v8::Global<v8::Value> global_result =
-        run_js_.Run(handle_request, context, parsed_v8_args.size(),
-                    parsed_v8_args.data());
+  if (!post_validate_hook.IsEmpty()) {
+    UpdateArguments(post_validate_hook, context, arguments);
     if (try_catch.HasCaught()) {
       try_catch.ReThrow();
       return RequestResult(RequestResult::THROWN);
     }
-    RequestResult result(RequestResult::HANDLED);
-    if (!global_result.IsEmpty())
-      result.return_value = global_result.Get(isolate);
-    return result;
   }
 
-  return RequestResult(RequestResult::NOT_HANDLED);
+  if (handle_request.IsEmpty())
+    return RequestResult(RequestResult::NOT_HANDLED);
+
+  v8::Global<v8::Value> global_result =
+      run_js_.Run(handle_request, context, arguments->size(),
+                  arguments->data());
+  if (try_catch.HasCaught()) {
+    try_catch.ReThrow();
+    return RequestResult(RequestResult::THROWN);
+  }
+  RequestResult result(RequestResult::HANDLED);
+  if (!global_result.IsEmpty())
+    result.return_value = global_result.Get(isolate);
+  return result;
 }
 
 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 37 matching lines @@
   if (result.IsEmpty() ||
       !gin::Converter<std::vector<v8::Local<v8::Value>>>::FromV8(
           context->GetIsolate(), result, &new_args)) {
     return false;
   }
   arguments->swap(new_args);
   return true;
 }
 
 }  // namespace extensions