[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 120 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 42 matching lines @@
     // creation, but also when e.g. permissions change. We need to be checking
     // for whether or not the API already exists on the object as well as
     // if we need to remove any existing APIs.
     if (!context->IsAnyFeatureAvailableToContext(*map_entry.second,
                                                  CheckAliasStatus::NOT_ALLOWED))
       continue;
 
     v8::Local<v8::String> api_name =
         gin::StringToSymbol(v8_context->GetIsolate(), map_entry.first);
     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) {
   gin::PerContextData* per_context_data = gin::PerContextData::From(context);
   if (!per_context_data)
-    return;  // Context is shutting down.
+    return v8::Local<v8::Object>();  // Context is shutting down.
   BindingsSystemPerContextData* data =
       static_cast<BindingsSystemPerContextData*>(
           per_context_data->GetUserData(kBindingsSystemPerContextKey));
   CHECK(data);
   if (!data->bindings_system) {
     NOTREACHED() << "Context outlived bindings system.";
-    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);
   } else {
     apis = data->api_object.Get(isolate);
   }
 
-  // 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;
   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> hooks_interface;
     APIBindingsSystem& api_system = data->bindings_system->api_system_;
     result = api_system.CreateAPIInstance(
         api_name_string, context, isolate,
         base::Bind(&IsAPIMethodAvailable, script_context), &hooks_interface);
 
     gin::Handle<APIBindingBridge> bridge_handle = gin::CreateHandle(
         isolate,
         new APIBindingBridge(context, result, hooks_interface,
                              script_context->GetExtensionID(),
                              script_context->GetContextTypeDescription(),
                              base::Bind(&CallJsFunction)));
     v8::Local<v8::Value> native_api_bridge = bridge_handle.ToV8();
 
     script_context->module_system()->OnNativeBindingCreated(api_name_string,
                                                             native_api_bridge);
 
     v8::Maybe<bool> success =
         apis->CreateDataProperty(context, api_name, result);
     if (!success.IsJust() || !success.FromJust())
-      return;
+      return v8::Local<v8::Object>();
   }
-  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"));
 }
 
 void NativeExtensionBindingsSystem::SendRequest(
     std::unique_ptr<APIBinding::Request> request,
     v8::Local<v8::Context> context) {
   ScriptContext* script_context =
       ScriptContextSet::GetContextByV8Context(context);
 
   GURL url;
   blink::WebLocalFrame* frame = script_context->web_frame();
@@ skipping 19 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