[Extensions Bindings] Add chrome.runtime.lastError support

extensions/renderer/native_extension_bindings_system.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/native_extension_bindings_system.h"
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "content/public/common/content_switches.h"
 #include "extensions/common/constants.h"
@@ skipping 308 matching lines @@
     const SendEventListenerIPCMethod& send_event_listener_ipc)
     : send_request_ipc_(send_request_ipc),
       send_event_listener_ipc_(send_event_listener_ipc),
       api_system_(
           base::Bind(&CallJsFunction),
           base::Bind(&CallJsFunctionSync),
           base::Bind(&GetAPISchema),
           base::Bind(&NativeExtensionBindingsSystem::SendRequest,
                      base::Unretained(this)),
           base::Bind(&NativeExtensionBindingsSystem::OnEventListenerChanged,
-                     base::Unretained(this))),
+                     base::Unretained(this)),
+          APILastError(base::Bind(&GetRuntime))),
       weak_factory_(this) {}
 
 NativeExtensionBindingsSystem::~NativeExtensionBindingsSystem() {}
 
 void NativeExtensionBindingsSystem::DidCreateScriptContext(
     ScriptContext* context) {}
 
 void NativeExtensionBindingsSystem::WillReleaseScriptContext(
     ScriptContext* context) {}
 
@@ skipping 56 matching lines @@
     // expose this under the name of the feature (e.g., 'tabs'), but in some
     // cases, this will be a prefixed API, such as 'app.runtime'. Find what the
     // property on the chrome object is named, and use that. So in the case of
     // 'app.runtime', we surface a getter for simply 'app'.
     base::StringPiece accessor_name =
         GetFirstDifferentAPIName(map_entry.first, base::StringPiece());
     last_accessor = accessor_name;
     v8::Local<v8::String> api_name =
         gin::StringToSymbol(v8_context->GetIsolate(), accessor_name);
     v8::Maybe<bool> success = chrome->SetAccessor(
-        v8_context, api_name, &GetAPIHelper, nullptr, api_name);
+        v8_context, api_name, &BindingAccessor, nullptr, api_name);
     if (!success.IsJust() || !success.FromJust()) {
       LOG(ERROR) << "Failed to create API on Chrome object.";
       return;
     }
   }
 }
 
 void NativeExtensionBindingsSystem::DispatchEventInContext(
     const std::string& event_name,
     const base::ListValue* event_args,
     const base::DictionaryValue* filtering_info,
     ScriptContext* context) {
   v8::HandleScope handle_scope(context->isolate());
   v8::Context::Scope context_scope(context->v8_context());
   // TODO(devlin): Take into account |filtering_info|.
   api_system_.FireEventInContext(event_name, context->v8_context(),
                                  *event_args);
 }
 
 void NativeExtensionBindingsSystem::HandleResponse(
     int request_id,
     bool success,
     const base::ListValue& response,
     const std::string& error) {
-  api_system_.CompleteRequest(request_id, response);
+  api_system_.CompleteRequest(request_id, response, error);
 }
 
 RequestSender* NativeExtensionBindingsSystem::GetRequestSender() {
   return nullptr;
 }
 
-// static
-void NativeExtensionBindingsSystem::GetAPIHelper(
+void NativeExtensionBindingsSystem::BindingAccessor(
     v8::Local<v8::Name> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   v8::Isolate* isolate = info.GetIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context = info.Holder()->CreationContext();
+
+  // We use info.Data() to store a real name here instead of using the provided
+  // one to handle any weirdness from the caller (non-existent strings, etc).
+  v8::Local<v8::String> api_name = info.Data().As<v8::String>();
+  v8::Local<v8::Object> binding = GetAPIHelper(context, api_name);
+  if (!binding.IsEmpty())
+    info.GetReturnValue().Set(binding);
+}
+
+// static
+v8::Local<v8::Object> NativeExtensionBindingsSystem::GetAPIHelper(
+    v8::Local<v8::Context> context,
+    v8::Local<v8::String> api_name) {
   BindingsSystemPerContextData* data = GetBindingsDataFromContext(context);
   if (!data)
-    return;
+    return v8::Local<v8::Object>();
 
+  v8::Isolate* isolate = context->GetIsolate();
   v8::Local<v8::Object> apis;
   if (data->api_object.IsEmpty()) {
     apis = v8::Object::New(isolate);
     data->api_object = v8::Global<v8::Object>(isolate, apis);
     if (data->bindings_system->get_internal_api_.IsEmpty()) {
       data->bindings_system->get_internal_api_.Set(
           isolate, v8::FunctionTemplate::New(
                        isolate, &NativeExtensionBindingsSystem::GetInternalAPI,
                        v8::Local<v8::Value>(), v8::Local<v8::Signature>(), 0,
                        v8::ConstructorBehavior::kThrow));
     }
   } else {
     apis = data->api_object.Get(isolate);
   }
   v8::Local<v8::Function> get_internal_api =
       data->bindings_system->get_internal_api_.Get(isolate)
           ->GetFunction(context)
           .ToLocalChecked();
 
-  // We use info.Data() to store a real name here instead of using the provided
-  // one to handle any weirdness from the caller (non-existent strings, etc).
-  v8::Local<v8::String> api_name = info.Data().As<v8::String>();
-  v8::Local<v8::Value> result;
+  v8::Local<v8::Object> result;

[jbroman, 2017/02/13 19:41:27]

nit: Does this variable still need to exist? Looks like we could just have
"return value.As<v8::Object>();" and "return root_binding;" below.

[Devlin, 2017/02/14 04:57:08]

Done.

   v8::Maybe<bool> has_property = apis->HasRealNamedProperty(context, api_name);
   if (!has_property.IsJust())
-    return;
+    return v8::Local<v8::Object>();
 
   if (has_property.FromJust()) {
-    result = apis->GetRealNamedProperty(context, api_name).ToLocalChecked();
+    v8::Local<v8::Value> value =
+        apis->GetRealNamedProperty(context, api_name).ToLocalChecked();
+    DCHECK(value->IsObject());
+    result = value.As<v8::Object>();
   } else {
     ScriptContext* script_context =
         ScriptContextSet::GetContextByV8Context(context);
     std::string api_name_string;
     CHECK(gin::Converter<std::string>::FromV8(isolate, api_name,
                                               &api_name_string));
 
     v8::Local<v8::Object> root_binding = CreateFullBinding(
         context, script_context, &data->bindings_system->api_system_,
         FeatureProvider::GetAPIFeatures(), api_name_string, get_internal_api);
     if (root_binding.IsEmpty())
-      return;
+      return v8::Local<v8::Object>();
 
     v8::Maybe<bool> success =
         apis->CreateDataProperty(context, api_name, root_binding);
     if (!success.IsJust() || !success.FromJust())
-      return;
+      return v8::Local<v8::Object>();
 
     result = root_binding;
   }
 
-  info.GetReturnValue().Set(result);
+  return result;
+}
+
+v8::Local<v8::Object> NativeExtensionBindingsSystem::GetRuntime(
+    v8::Local<v8::Context> context) {
+  return GetAPIHelper(context,
+                      gin::StringToSymbol(context->GetIsolate(), "runtime"));
 }
 
 // static
 void NativeExtensionBindingsSystem::GetInternalAPI(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
   CHECK_EQ(1, info.Length());
   CHECK(info[0]->IsString());
 
   v8::Isolate* isolate = info.GetIsolate();
   v8::HandleScope handle_scope(isolate);
@@ skipping 95 matching lines @@
 
 void NativeExtensionBindingsSystem::OnEventListenerChanged(
     const std::string& event_name,
     binding::EventListenersChanged change,
     v8::Local<v8::Context> context) {
   send_event_listener_ipc_.Run(
       change, ScriptContextSet::GetContextByV8Context(context), event_name);
 }
 
 }  // namespace extensions