[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 169 matching lines @@
   js_hooks_source_ = std::move(source);
   js_resource_name_ = std::move(resource_name);
 }
 
 APIBindingHooks::RequestResult APIBindingHooks::HandleRequest(
     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) {
+    const ArgumentSpec::RefMap& type_refs,
+    v8::Local<v8::Value>* return_value) {
   // 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);
+            signature, context, arguments, type_refs, return_value);
     // 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).
   v8::Local<v8::Object> hook_interface_object =
       GetJSHookInterfaceObject(api_name, context, false);
@@ skipping 30 matching lines @@
     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;
     }
     if (!success)
       return RequestResult::INVALID_INVOCATION;
 
-    run_js_.Run(handle_request, context, parsed_v8_args.size(),
-                parsed_v8_args.data());
+    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::THROWN;
+    }
+    if (!global_result.IsEmpty())
+      *return_value = global_result.Get(isolate);
     return RequestResult::HANDLED;
   }
 
   return RequestResult::NOT_HANDLED;
 }
 
 void APIBindingHooks::InitializeInContext(
     v8::Local<v8::Context> context,
     const std::string& api_name) {
   if (js_hooks_source_.IsEmpty())
@@ skipping 34 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