Use V8 Maybe APIs in extensions/renderer

extensions/renderer/script_context.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/script_context.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "content/public/child/v8_value_converter.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_api.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/features/base_feature_provider.h"
 #include "extensions/common/manifest_handlers/sandboxed_page_info.h"
 #include "extensions/common/permissions/permissions_data.h"
+#include "extensions/renderer/v8_maybe_helpers.h"
 #include "gin/per_context_data.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebScopedMicrotaskSuppression.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "v8/include/v8.h"
 
@@ skipping 139 matching lines @@
   v8::EscapableHandleScope handle_scope(isolate());
   v8::Context::Scope scope(v8_context());
 
   blink::WebScopedMicrotaskSuppression suppression;
   if (!is_valid_) {
     return handle_scope.Escape(
         v8::Local<v8::Primitive>(v8::Undefined(isolate())));
   }
 
   v8::Local<v8::Object> global = v8_context()->Global();
-  if (!web_frame_)
-    return handle_scope.Escape(function->Call(global, argc, argv));
+  if (!web_frame_) {
+    v8::Local<v8::Value> result;
+    if (function->Call(v8_context(), global, argc, argv).ToLocal(&result))
+      return handle_scope.Escape(result);
+    return handle_scope.Escape(
+        v8::Local<v8::Primitive>(v8::Undefined(isolate())));
+  }
   return handle_scope.Escape(
       v8::Local<v8::Value>(web_frame_->callFunctionEvenIfScriptDisabled(
           function, global, argc, argv)));
 }
 
 v8::Local<v8::Value> ScriptContext::CallFunction(
     const v8::Local<v8::Function>& function) const {
   return CallFunction(function, 0, nullptr);
 }
 
@@ skipping 10 matching lines @@
   }
   return ExtensionAPI::GetSharedInstance()->IsAvailable(
       api_name, extension, context_type_, GetURL());
 }
 
 void ScriptContext::DispatchEvent(const char* event_name,
                                   v8::Local<v8::Array> args) const {
   v8::HandleScope handle_scope(isolate());
   v8::Context::Scope context_scope(v8_context());
 
-  v8::Local<v8::Value> argv[] = {v8::String::NewFromUtf8(isolate(), event_name),
+  v8::Local<v8::Value> argv[] = {ToV8String(isolate(), event_name),
                                  args};
   module_system_->CallModuleMethod(
       kEventBindings, "dispatchEvent", arraysize(argv), argv);
 }
 
 void ScriptContext::DispatchOnUnloadEvent() {
   v8::HandleScope handle_scope(isolate());
   v8::Context::Scope context_scope(v8_context());
   module_system_->CallModuleMethod("unload_event", "dispatch");
 }
@@ skipping 62 matching lines @@
 
 ScriptContext* ScriptContext::GetContext() { return this; }
 
 void ScriptContext::OnResponseReceived(const std::string& name,
                                        int request_id,
                                        bool success,
                                        const base::ListValue& response,
                                        const std::string& error) {
   v8::HandleScope handle_scope(isolate());
 
+  CHECK(name.size() < v8::String::kMaxLength);
+  CHECK(error.size() < v8::String::kMaxLength);
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
   v8::Local<v8::Value> argv[] = {
       v8::Integer::New(isolate(), request_id),
-      v8::String::NewFromUtf8(isolate(), name.c_str()),
+      ToV8String(isolate(), name.c_str()),
       v8::Boolean::New(isolate(), success),
       converter->ToV8Value(&response,
                            v8::Local<v8::Context>::New(isolate(), v8_context_)),
-      v8::String::NewFromUtf8(isolate(), error.c_str())};
+      ToV8String(isolate(), error.c_str())};
 
   v8::Local<v8::Value> retval = module_system()->CallModuleMethod(
       "sendRequest", "handleResponse", arraysize(argv), argv);
 
   // In debug, the js will validate the callback parameters and return a
   // string if a validation error has occured.
   DCHECK(retval.IsEmpty() || retval->IsUndefined())
       << *v8::String::Utf8Value(retval);
 }
 
@@ skipping 26 matching lines @@
   // crbug.com/466373 is fixed, we don't know the security origin up-front and
   // may not know it here, either.
   //
   // [1] citation needed. This ScriptContext should already be in a state that
   // doesn't allow this, from ScriptContextSet::ClassifyJavaScriptContext.
   if (extension() &&
       SandboxedPageInfo::IsSandboxedPage(extension(), url_.path())) {
     static const char kMessage[] =
         "%s cannot be used within a sandboxed frame.";
     std::string error_msg = base::StringPrintf(kMessage, name.c_str());
+    CHECK(error_msg.size() < v8::String::kMaxLength);
     isolate()->ThrowException(v8::Exception::Error(
-        v8::String::NewFromUtf8(isolate(), error_msg.c_str())));
+        ToV8String(isolate(), error_msg.c_str())));
     return false;
   }
 
   Feature::Availability availability = GetAvailability(name);
   if (!availability.is_available()) {
+    CHECK(availability.message().size() < v8::String::kMaxLength);
     isolate()->ThrowException(v8::Exception::Error(
-        v8::String::NewFromUtf8(isolate(), availability.message().c_str())));
+        ToV8String(isolate(), availability.message().c_str())));
     return false;
   }
 
   return true;
 }
 
 std::string ScriptContext::GetDebugString() const {
   return base::StringPrintf(
       "  extension id:           %s\n"
       "  frame:                  %p\n"
@@ skipping 23 matching lines @@
     v8::Local<v8::Value> argv[]) {
   return context_->CallFunction(function, argc, argv);
 }
 
 gin::ContextHolder* ScriptContext::Runner::GetContextHolder() {
   v8::HandleScope handle_scope(context_->isolate());
   return gin::PerContextData::From(context_->v8_context())->context_holder();
 }
 
 }  // namespace extensions