extensions: Use V8 Maybe APIs in NativeHandler

extensions/renderer/binding_generating_native_handler.cc

Index: extensions/renderer/binding_generating_native_handler.cc
diff --git a/extensions/renderer/binding_generating_native_handler.cc b/extensions/renderer/binding_generating_native_handler.cc
index 2f5dc6f442d48ee282e389dff302a45e69c92bd5..77295cea6442f4a88d0d2615eb51b74274d20744 100644
--- a/extensions/renderer/binding_generating_native_handler.cc
+++ b/extensions/renderer/binding_generating_native_handler.cc
@@ -4,41 +4,109 @@
 
 #include "extensions/renderer/binding_generating_native_handler.h"
 
-#include "extensions/renderer/module_system.h"
+#include "extensions/renderer/script_context.h"
+#include "extensions/renderer/v8_helpers.h"
 
 namespace extensions {
 
+using namespace v8_helpers;
+
 BindingGeneratingNativeHandler::BindingGeneratingNativeHandler(
-    ModuleSystem* module_system,
+    ScriptContext* context,
     const std::string& api_name,
     const std::string& bind_to)
-    : module_system_(module_system), api_name_(api_name), bind_to_(bind_to) {}
+    : context_(context), api_name_(api_name), bind_to_(bind_to) {}
 
 v8::Local<v8::Object> BindingGeneratingNativeHandler::NewInstance() {
-  v8::Isolate* isolate = module_system_->GetIsolate();
+  // This long sequence of commands effectively runs the JavaScript code,
+  // such that result[bind_to] is the compiled schema for |api_name|:
+  //
+  //   var result = {};
+  //   result[bind_to] = require('binding').Binding.create(api_name).generate();
+  //   return result;
+  //
+  // Unfortunately using the v8 APIs makes that quite verbose.
+  // Each stage is marked with the code it executes.
+  v8::Isolate* isolate = context_->isolate();
   v8::EscapableHandleScope scope(isolate);
-  v8::Local<v8::Object> binding_module =
-      module_system_->Require("binding")->ToObject(isolate);
-  v8::Local<v8::Object> binding =
-      binding_module->Get(v8::String::NewFromUtf8(isolate, "Binding"))
-          ->ToObject(isolate);
+
+  // Convert |api_name| and |bind_to| into their v8::Strings to pass
+  // through the v8 APIs.
+  v8::Local<v8::String> v8_api_name;
+  v8::Local<v8::String> v8_bind_to;
+  if (!ToV8String(isolate, api_name_, &v8_api_name) ||
+      !ToV8String(isolate, bind_to_, &v8_bind_to)) {
+    NOTREACHED();
+    return v8::Local<v8::Object>();
+  }
+
+  v8::Local<v8::Context> v8_context = context_->v8_context();
+
+  v8::Local<v8::Object> binding_module;
+  // require('binding');

[not at google - send to devlin, 2015/06/24 00:34:56]

I would have preferred for each of these comments at the start of the blocks
(i.e. before the variable declarations that relate to them), not after. Easier
to scan through to see what is happening.

[bashi, 2015/06/24 03:30:44]

Done.

+  if (!context_->module_system()->Require("binding")
+           ->ToObject(v8_context)
+           .ToLocal(&binding_module)) {
+    NOTREACHED();
+    return v8::Local<v8::Object>();
+  }
+
+  v8::Local<v8::Value> binding_value;
+  v8::Local<v8::Object> binding;
+  // require('binding').Binding;
+  if (!GetProperty(v8_context, binding_module, "Binding", &binding_value) ||
+      !binding_value->ToObject(v8_context).ToLocal(&binding)) {
+    NOTREACHED();
+    return v8::Local<v8::Object>();
+  }
+
+  v8::Local<v8::Value> create_binding_value;
+  // require('Binding').Binding.create;
+  if (!GetProperty(v8_context, binding, "create", &create_binding_value) ||
+      !create_binding_value->IsFunction()) {
+    NOTREACHED();
+    return v8::Local<v8::Object>();
+  }
   v8::Local<v8::Function> create_binding =
-      binding->Get(v8::String::NewFromUtf8(isolate, "create"))
-          .As<v8::Function>();
-  v8::Local<v8::Value> argv[] = {
-      v8::String::NewFromUtf8(isolate, api_name_.c_str())};
-  v8::Local<v8::Object> binding_instance =
-      create_binding->Call(binding, arraysize(argv), argv)->ToObject(isolate);
-  v8::Local<v8::Function> generate =
-      binding_instance->Get(v8::String::NewFromUtf8(isolate, "generate"))
-          .As<v8::Function>();
+      create_binding_value.As<v8::Function>();
+
+  v8::Local<v8::Value> argv[] = {v8_api_name};
+  v8::Local<v8::Value> binding_instance_value;
+  v8::Local<v8::Object> binding_instance;
+  // require('Binding').Binding.create(api_name);
+  if (!CallFunction(v8_context, create_binding, binding, arraysize(argv), argv,
+                    &binding_instance_value) ||
+      !binding_instance_value->ToObject(v8_context)
+           .ToLocal(&binding_instance)) {
+    NOTREACHED();
+    return v8::Local<v8::Object>();
+  }
+
+  v8::Local<v8::Value> generate_value;
+  // require('Binding').Binding.create(api_name).generate;
+  if (!GetProperty(v8_context, binding_instance, "generate", &generate_value) ||
+      !generate_value->IsFunction()) {
+    NOTREACHED();
+    return v8::Local<v8::Object>();
+  }
+  v8::Local<v8::Function> generate = generate_value.As<v8::Function>();
+
   v8::Local<v8::Object> object = v8::Object::New(isolate);
-  v8::Local<v8::Value> compiled_schema =
-      generate->Call(binding_instance, 0, NULL);
-  if (!compiled_schema.IsEmpty()) {
-    object->Set(v8::String::NewFromUtf8(isolate, bind_to_.c_str()),
-                compiled_schema);
+  v8::Local<v8::Value> compiled_schema;
+  // require('Binding').Binding.create(api_name).generate();
+  if (!CallFunction(v8_context, generate, binding_instance, 0, nullptr,
+                    &compiled_schema)) {
+    NOTREACHED();
+    return v8::Local<v8::Object>();
+  }
+
+  // var result = {};
+  // result[bind_to] = ...;
+  if (!SetProperty(v8_context, object, v8_bind_to, compiled_schema)) {
+    NOTREACHED();
+    return v8::Local<v8::Object>();
   }
+  // return result;
   return scope.Escape(object);
 }