[Extensions Bindings] Add lastError utilities to APIBindingJSUtil

extensions/renderer/api_binding_js_util.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_js_util.h"
 
 #include "base/values.h"
 #include "extensions/renderer/api_event_handler.h"
 #include "extensions/renderer/api_request_handler.h"
 #include "extensions/renderer/api_signature.h"
 #include "extensions/renderer/api_type_reference_map.h"
 #include "gin/converter.h"
 #include "gin/object_template_builder.h"
 
 namespace extensions {
 
 gin::WrapperInfo APIBindingJSUtil::kWrapperInfo = {gin::kEmbedderNativeGin};
 
 APIBindingJSUtil::APIBindingJSUtil(const APITypeReferenceMap* type_refs,
                                    APIRequestHandler* request_handler,
-                                   APIEventHandler* event_handler)
+                                   APIEventHandler* event_handler,
+                                   const binding::RunJSFunction& run_js)
     : type_refs_(type_refs),
       request_handler_(request_handler),
-      event_handler_(event_handler) {}
+      event_handler_(event_handler),
+      run_js_(run_js) {}
 
 APIBindingJSUtil::~APIBindingJSUtil() {}
 
 gin::ObjectTemplateBuilder APIBindingJSUtil::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   return Wrappable<APIBindingJSUtil>::GetObjectTemplateBuilder(isolate)
       .SetMethod("sendRequest", &APIBindingJSUtil::SendRequest)
       .SetMethod("registerEventArgumentMassager",
                  &APIBindingJSUtil::RegisterEventArgumentMassager)
       .SetMethod("createCustomEvent", &APIBindingJSUtil::CreateCustomEvent)
-      .SetMethod("invalidateEvent", &APIBindingJSUtil::InvalidateEvent);
+      .SetMethod("invalidateEvent", &APIBindingJSUtil::InvalidateEvent)
+      .SetMethod("setLastError", &APIBindingJSUtil::SetLastError)
+      .SetMethod("clearLastError", &APIBindingJSUtil::ClearLastError)
+      .SetMethod("hasLastError", &APIBindingJSUtil::HasLastError)
+      .SetMethod("runCallbackWithLastError",
+                 &APIBindingJSUtil::RunCallbackWithLastError);
 }
 
 void APIBindingJSUtil::SendRequest(
     gin::Arguments* arguments,
     const std::string& name,
     const std::vector<v8::Local<v8::Value>>& request_args) {
   v8::Isolate* isolate = arguments->isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Object> holder;
   CHECK(arguments->GetHolder(&holder));
@@ skipping 61 matching lines @@
 void APIBindingJSUtil::InvalidateEvent(gin::Arguments* arguments,
                                        v8::Local<v8::Object> event) {
   v8::Isolate* isolate = arguments->isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Object> holder;
   CHECK(arguments->GetHolder(&holder));
   v8::Local<v8::Context> context = holder->CreationContext();
   event_handler_->InvalidateCustomEvent(context, event);
 }
 
+void APIBindingJSUtil::SetLastError(gin::Arguments* arguments,
+                                    const std::string& error) {
+  v8::Isolate* isolate = arguments->isolate();
+  v8::HandleScope handle_scope(isolate);
+  v8::Local<v8::Object> holder;
+  CHECK(arguments->GetHolder(&holder));
+  v8::Local<v8::Context> context = holder->CreationContext();
+
+  request_handler_->last_error()->SetError(context, error);
+}
+
+void APIBindingJSUtil::ClearLastError(gin::Arguments* arguments) {
+  v8::Isolate* isolate = arguments->isolate();
+  v8::HandleScope handle_scope(isolate);
+  v8::Local<v8::Object> holder;
+  CHECK(arguments->GetHolder(&holder));
+  v8::Local<v8::Context> context = holder->CreationContext();
+
+  bool report_if_unchecked = false;
+  request_handler_->last_error()->ClearError(context, report_if_unchecked);
+}
+
+void APIBindingJSUtil::HasLastError(gin::Arguments* arguments) {
+  v8::Isolate* isolate = arguments->isolate();
+  v8::HandleScope handle_scope(isolate);
+  v8::Local<v8::Object> holder;
+  CHECK(arguments->GetHolder(&holder));
+  v8::Local<v8::Context> context = holder->CreationContext();
+
+  bool has_last_error = request_handler_->last_error()->HasError(context);
+  arguments->Return(has_last_error);
+}
+
+void APIBindingJSUtil::RunCallbackWithLastError(
+    gin::Arguments* arguments,
+    const std::string& error,
+    v8::Local<v8::Function> callback,
+    std::vector<v8::Local<v8::Value>> callback_args) {

[jbroman, 2017/03/20 20:14:49]

const vector&: gin doesn't move the arguments into the callee (maybe it ought
to, but it doesn't at present), so this currently does an unnecessary copy

[Devlin, 2017/03/20 23:10:40]

Moot now with no |callback_args|, but this was actually because the various
RunJS() functions accept a v8::Local<v8::Value>[] - and you can't bind that  to
std::vector<v8::Local<v8::Value>>::data().  I was hoping that I could have taken
a non-const &, but gin barfed on that idea.  We could also hack our way out of
it with various casts, but given v8::Locals are pretty cheap to copy, this
seemed like the most appropriate.

+  v8::Isolate* isolate = arguments->isolate();
+  v8::HandleScope handle_scope(isolate);
+  v8::Local<v8::Object> holder;
+  CHECK(arguments->GetHolder(&holder));
+  v8::Local<v8::Context> context = holder->CreationContext();
+
+  request_handler_->last_error()->SetError(context, error);
+  if (!callback->IsNull() && !callback->IsUndefined())

[jbroman, 2017/03/20 20:14:49]

1. What's the point of calling this will null or undefined anyhow, since it just
sets the error and then shouts (since it will obviously never be checked if that
branch is taken)?

2. Null and undefined aren't v8::Functions, so it would be a type error to get
to this point. (specifically, the gin::Converter logic before this point should
throw an exception if either of those values is provided)

[Devlin, 2017/03/20 23:10:40]

1.  If we mimic the JS api, the function is often a curried callback from an
extension API call, which can be undefined/null if the extension is uninterested
in the result.  And in that case, immediately yelling is the right thing to do. 
But, if we change the signature to accept a bindings-supplied function, this
should never happen.

2.  D'oh.

Done.

+    run_js_.Run(callback, context, callback_args.size(), callback_args.data());
+
+  bool report_if_unchecked = true;
+  request_handler_->last_error()->ClearError(context, report_if_unchecked);
+}
+
 }  // namespace extensions