Use V8 Maybe APIs in extensions/renderer

extensions/renderer/dispatcher.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/dispatcher.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
@@ skipping 62 matching lines @@
 #include "extensions/renderer/script_context.h"
 #include "extensions/renderer/script_context_set.h"
 #include "extensions/renderer/script_injection.h"
 #include "extensions/renderer/script_injection_manager.h"
 #include "extensions/renderer/send_request_natives.h"
 #include "extensions/renderer/set_icon_natives.h"
 #include "extensions/renderer/test_features_native_handler.h"
 #include "extensions/renderer/user_gestures_native_handler.h"
 #include "extensions/renderer/utils_native_handler.h"
 #include "extensions/renderer/v8_context_native_handler.h"
+#include "extensions/renderer/v8_maybe_helpers.h"
 #include "grit/extensions_renderer_resources.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/web/WebCustomElement.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/WebRuntimeFeatures.h"
 #include "third_party/WebKit/public/web/WebScopedUserGesture.h"
@@ skipping 24 matching lines @@
 static const char kEventDispatchFunction[] = "dispatchEvent";
 static const char kOnSuspendEvent[] = "runtime.onSuspend";
 static const char kOnSuspendCanceledEvent[] = "runtime.onSuspendCanceled";
 
 // Returns the global value for "chrome" from |context|. If one doesn't exist
 // creates a new object for it.
 //
 // Note that this isn't necessarily an object, since webpages can write, for
 // example, "window.chrome = true".
 v8::Local<v8::Value> GetOrCreateChrome(ScriptContext* context) {
-  v8::Local<v8::String> chrome_string(
-      v8::String::NewFromUtf8(context->isolate(), "chrome"));
-  v8::Local<v8::Object> global(context->v8_context()->Global());
-  v8::Local<v8::Value> chrome(global->Get(chrome_string));
-  if (chrome->IsUndefined()) {
+  v8::Local<v8::Context> v8_context(context->v8_context());
+  v8::Local<v8::String> chrome_string(ToV8String(context->isolate(), "chrome"));
+  v8::Local<v8::Object> global(v8_context->Global());
+  v8::Local<v8::Value> chrome;
+  if (!global->Get(v8_context, chrome_string).ToLocal(&chrome) ||
+      chrome->IsUndefined()) {
     chrome = v8::Object::New(context->isolate());
-    global->Set(chrome_string, chrome);
+    SetProperty(v8_context, global, chrome_string, chrome);
   }
   return chrome;
 }
 
 // Returns |value| cast to an object if possible, else an empty handle.
 v8::Local<v8::Object> AsObjectOrEmpty(v8::Local<v8::Value> value) {
   return value->IsObject() ? value.As<v8::Object>() : v8::Local<v8::Object>();
 }
 
 // Calls a method |method_name| in a module |module_name| belonging to the
@@ skipping 1043 matching lines @@
                                  ScriptContext* context) {
   std::string bind_name;
   v8::Local<v8::Object> bind_object =
       GetOrCreateBindObjectIfAvailable(api_name, &bind_name, context);
 
   // Empty if the bind object failed to be created, probably because the
   // extension overrode chrome with a non-object, e.g. window.chrome = true.
   if (bind_object.IsEmpty())
     return;
 
+  v8::Local<v8::Context> v8_context = context->v8_context();
   v8::Local<v8::String> v8_bind_name =
-      v8::String::NewFromUtf8(context->isolate(), bind_name.c_str());
-  if (bind_object->HasRealNamedProperty(v8_bind_name)) {
+      ToV8String(context->isolate(), bind_name.c_str());
+  if (CheckV8Call(
+          bind_object->HasRealNamedProperty(v8_context, v8_bind_name))) {
     // The bind object may already have the property if the API has been
     // registered before (or if the extension has put something there already,
     // but, whatevs).
     //
     // In the former case, we need to re-register the bindings for the APIs
     // which the extension now has permissions for (if any), but not touch any
     // others so that we don't destroy state such as event listeners.
     //
     // TODO(kalman): Only register available APIs to make this all moot.
-    if (bind_object->HasRealNamedCallbackProperty(v8_bind_name))
+    if (CheckV8Call(bind_object->HasRealNamedCallbackProperty(v8_context,
+                                                              v8_bind_name)))
       return;  // lazy binding still there, nothing to do
-    if (bind_object->Get(v8_bind_name)->IsObject())
+    v8::Local<v8::Value> bind;
+    if (bind_object->Get(v8_context, v8_bind_name).ToLocal(&bind) &&
+        bind->IsObject())
       return;  // binding has already been fully installed
   }
 
   ModuleSystem* module_system = context->module_system();
   if (!source_map_.Contains(api_name)) {
     module_system->RegisterNativeHandler(
         api_name,
         scoped_ptr<NativeHandler>(new BindingGeneratingNativeHandler(
             module_system, api_name, "binding")));
     module_system->SetNativeLazyField(
@@ skipping 79 matching lines @@
     if (extension && extension->is_platform_app())
       return true;
   }
   return false;
 }
 
 v8::Local<v8::Object> Dispatcher::GetOrCreateObject(
     const v8::Local<v8::Object>& object,
     const std::string& field,
     v8::Isolate* isolate) {
-  v8::Local<v8::String> key = v8::String::NewFromUtf8(isolate, field.c_str());
+  DCHECK(field.size() < v8::String::kMaxLength);
+  v8::Local<v8::String> key = ToV8String(isolate, field.c_str());
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
   // If the object has a callback property, it is assumed it is an unavailable
   // API, so it is safe to delete. This is checked before GetOrCreateObject is
   // called.
-  if (object->HasRealNamedCallbackProperty(key)) {
-    object->Delete(key);
-  } else if (object->HasRealNamedProperty(key)) {
-    v8::Local<v8::Value> value = object->Get(key);
+  if (CheckV8Call(object->HasRealNamedCallbackProperty(context, key))) {
+    object->Delete(context, key);
+  } else if (CheckV8Call(object->HasRealNamedProperty(context, key))) {
+    v8::Local<v8::Value> value = object->Get(context, key).ToLocalChecked();
     CHECK(value->IsObject());
     return v8::Local<v8::Object>::Cast(value);
   }
 
   v8::Local<v8::Object> new_object = v8::Object::New(isolate);
-  object->Set(key, new_object);
+  SetProperty(context, object, key, new_object);
   return new_object;
 }
 
 v8::Local<v8::Object> Dispatcher::GetOrCreateBindObjectIfAvailable(
     const std::string& api_name,
     std::string* bind_name,
     ScriptContext* context) {
   std::vector<std::string> split;
   base::SplitString(api_name, '.', &split);
 
@@ skipping 79 matching lines @@
   // The "guestViewDeny" module must always be loaded last. It registers
   // error-providing custom elements for the GuestView types that are not
   // available, and thus all of those types must have been checked and loaded
   // (or not loaded) beforehand.
   if (context_type == Feature::BLESSED_EXTENSION_CONTEXT) {
     module_system->Require("guestViewDeny");
   }
 }
 
 }  // namespace extensions