extensions: Use V8 Maybe APIs in NativeHandler

extensions/renderer/binding_generating_native_handler.cc

 // Copyright 2014 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/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);
 }
 
 }  // namespace extensions