[Extensions Bindings] Add an ExceptionHandler class

extensions/renderer/bindings/api_request_handler.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/bindings/api_request_handler.h"
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "content/public/child/v8_value_converter.h"
+#include "extensions/renderer/bindings/exception_handler.h"
 #include "gin/converter.h"
 #include "gin/data_object_builder.h"
 #include "third_party/WebKit/public/web/WebScopedUserGesture.h"
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 
 namespace extensions {
 
 APIRequestHandler::Request::Request() {}
 APIRequestHandler::Request::~Request() = default;
 
@@ skipping 14 matching lines @@
   }
 }
 
 APIRequestHandler::PendingRequest::~PendingRequest() {}
 APIRequestHandler::PendingRequest::PendingRequest(PendingRequest&&) = default;
 APIRequestHandler::PendingRequest& APIRequestHandler::PendingRequest::operator=(
     PendingRequest&&) = default;
 
 APIRequestHandler::APIRequestHandler(const SendRequestMethod& send_request,
                                      const CallJSFunction& call_js,
-                                     APILastError last_error)
+                                     APILastError last_error,
+                                     ExceptionHandler* exception_handler)
     : send_request_(send_request),
       call_js_(call_js),
-      last_error_(std::move(last_error)) {}
+      last_error_(std::move(last_error)),
+      exception_handler_(exception_handler) {}
 
 APIRequestHandler::~APIRequestHandler() {}
 
 int APIRequestHandler::StartRequest(v8::Local<v8::Context> context,
                                     const std::string& method,
                                     std::unique_ptr<base::ListValue> arguments,
                                     v8::Local<v8::Function> callback,
                                     v8::Local<v8::Function> custom_callback,
                                     binding::RequestThread thread) {
   auto request = base::MakeUnique<Request>();
@@ skipping 74 matching lines @@
                pending_request.callback_arguments.size());
   for (const auto& arg : pending_request.callback_arguments)
     args.push_back(arg.Get(isolate));
   for (const auto& arg : response_args)
     args.push_back(converter->ToV8Value(&arg, context));
 
   blink::WebScopedUserGesture user_gesture(pending_request.user_gesture_token);
   if (!error.empty())
     last_error_.SetError(context, error);
 
+  v8::TryCatch try_catch(isolate);
   // args.size() is converted to int, but args is controlled by chrome and is
   // never close to std::numeric_limits<int>::max.
   call_js_.Run(pending_request.callback.Get(isolate), context, args.size(),
                args.data());
+  if (try_catch.HasCaught()) {
+    v8::Local<v8::Message> v8_message = try_catch.Message();
+    base::Optional<std::string> message;
+    if (!v8_message.IsEmpty())
+      message = gin::V8ToString(v8_message->Get());
+    exception_handler_->HandleException(context, "Error handling response",
+                                        &try_catch);
+  }
 
   if (!error.empty())
     last_error_.ClearError(context, true);
 }
 
 int APIRequestHandler::AddPendingRequest(v8::Local<v8::Context> context,
                                          v8::Local<v8::Function> callback) {
   int request_id = next_request_id_++;
   pending_requests_.emplace(
       request_id, PendingRequest(context->GetIsolate(), callback, context,
@@ skipping 12 matching lines @@
 }
 
 std::set<int> APIRequestHandler::GetPendingRequestIdsForTesting() const {
   std::set<int> result;
   for (const auto& pair : pending_requests_)
     result.insert(pair.first);
   return result;
 }
 
 }  // namespace extensions