[Extensions Bindings] Add chrome.runtime.lastError support

extensions/renderer/api_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/api_bindings_system.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "extensions/renderer/api_binding_hooks.h"
 
 namespace extensions {
 
 APIBindingsSystem::APIBindingsSystem(
     const binding::RunJSFunction& call_js,
     const binding::RunJSFunctionSync& call_js_sync,
     const GetAPISchemaMethod& get_api_schema,
     const APIBinding::SendRequestMethod& send_request,
-    const APIEventHandler::EventListenersChangedMethod& event_listeners_changed)
+    const APIEventHandler::EventListenersChangedMethod& event_listeners_changed,
+    APILastError last_error)
     : type_reference_map_(base::Bind(&APIBindingsSystem::InitializeType,
                                      base::Unretained(this))),
-      request_handler_(call_js),
+      request_handler_(call_js, std::move(last_error)),
       event_handler_(call_js, event_listeners_changed),
       call_js_(call_js),
       call_js_sync_(call_js_sync),
       get_api_schema_(get_api_schema),
       send_request_(send_request) {}
 
 APIBindingsSystem::~APIBindingsSystem() {}
 
 v8::Local<v8::Object> APIBindingsSystem::CreateAPIInstance(
     const std::string& api_name,
@@ skipping 52 matching lines @@
   DCHECK_LT(dot, type_name.size() - 1);
   std::string api_name = type_name.substr(0, dot);
   // If we've already instantiated the binding, the type should have been in
   // there.
   DCHECK(api_bindings_.find(api_name) == api_bindings_.end());
 
   api_bindings_[api_name] = CreateNewAPIBinding(api_name);
 }
 
 void APIBindingsSystem::CompleteRequest(int request_id,
-                                        const base::ListValue& response) {
-  request_handler_.CompleteRequest(request_id, response);
+                                        const base::ListValue& response,
+                                        const std::string& error) {
+  request_handler_.CompleteRequest(request_id, response, error);
 }
 
 void APIBindingsSystem::FireEventInContext(const std::string& event_name,
                                            v8::Local<v8::Context> context,
                                            const base::ListValue& response) {
   event_handler_.FireEventInContext(event_name, context, response);
 }
 
 APIBindingHooks* APIBindingsSystem::GetHooksForAPI(
     const std::string& api_name) {
   DCHECK(api_bindings_.empty())
       << "Hook registration must happen before creating any binding instances.";
   std::unique_ptr<APIBindingHooks>& hooks = binding_hooks_[api_name];
   if (!hooks)
     hooks = base::MakeUnique<APIBindingHooks>(call_js_sync_);
   return hooks.get();
 }
 
 }  // namespace extensions