[Extensions Bindings] Allow custom hooks to return values, throw

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 146 matching lines @@
       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
 
+APIBindingHooks::RequestResult::RequestResult(ResultCode code) : code(code) {}
+APIBindingHooks::RequestResult::~RequestResult() {}
+APIBindingHooks::RequestResult::RequestResult(const RequestResult& other) =
+    default;
+
 APIBindingHooks::APIBindingHooks(const binding::RunJSFunctionSync& run_js)
     : run_js_(run_js) {}
 APIBindingHooks::~APIBindingHooks() {}
 
 void APIBindingHooks::RegisterHandleRequest(const std::string& method_name,
                                             const HandleRequestHook& hook) {
   DCHECK(!hooks_used_) << "Hooks must be registered before the first use!";
   request_hooks_[method_name] = hook;
 }
 
@@ skipping 11 matching lines @@
     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 =
         request_hooks_iter->second.Run(
             signature, context, 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);
+    DCHECK_NE(RequestResult::NOT_HANDLED, result.code);
     return result;
   }
 
   // Harder case: looking up a custom hook registered on the context (since
   // these are JS, each context has a separate instance).
   v8::Local<v8::Object> hook_interface_object =
       GetJSHookInterfaceObject(api_name, context, false);
   if (hook_interface_object.IsEmpty())
-    return RequestResult::NOT_HANDLED;
+    return RequestResult(RequestResult::NOT_HANDLED);
 
   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);
   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::THROWN;
+      return RequestResult(RequestResult::THROWN);
     }
   }
 
   v8::Local<v8::Function> handle_request =
       hook_interface->GetHandleRequestHook(method_name, isolate);
   if (!handle_request.IsEmpty()) {
     v8::TryCatch try_catch(isolate);
     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::THROWN;
+      return RequestResult(RequestResult::THROWN);
     }
     if (!success)
-      return RequestResult::INVALID_INVOCATION;
+      return RequestResult(RequestResult::INVALID_INVOCATION);
 
-    run_js_.Run(handle_request, context, parsed_v8_args.size(),
-                parsed_v8_args.data());
-    return RequestResult::HANDLED;
+    v8::Global<v8::Value> global_result =
+        run_js_.Run(handle_request, context, parsed_v8_args.size(),
+                    parsed_v8_args.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;
   }
 
-  return RequestResult::NOT_HANDLED;
+  return RequestResult(RequestResult::NOT_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 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