Remove usage of deprecated V8 APIs from c/r/extensions

chrome/renderer/extensions/module_system.cc

 // Copyright (c) 2012 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 "chrome/renderer/extensions/module_system.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
@@ skipping 37 matching lines @@
   full_message += " context";
   if (context->extension()) {
     full_message += " for ";
     full_message += context->extension()->id();
   }
   full_message += ") ";
   full_message += message;
 
   // <= dev means dev, canary, and trunk.
   if (GetCurrentChannel() <= chrome::VersionInfo::CHANNEL_DEV)
-    console::Fatal(v8::Context::GetCalling(), full_message);
+    console::Fatal(context->isolate()->GetCallingContext(), full_message);
   else
-    console::Error(v8::Context::GetCalling(), full_message);
+    console::Error(context->isolate()->GetCallingContext(), full_message);
 }
 
-void Warn(const std::string& message) {
-  console::Warn(v8::Context::GetCalling(), message);
+void Warn(v8::Isolate* isolate, const std::string& message) {
+  console::Warn(isolate->GetCallingContext(), message);
 }
 
 // Default exception handler which logs the exception.
 class DefaultExceptionHandler : public ModuleSystem::ExceptionHandler {
  public:
   explicit DefaultExceptionHandler(ChromeV8Context* context)
       : context_(context) {}
 
   // Fatally dumps the debug info from |try_catch| to the console.
   // Make sure this is never used for exceptions that originate in external
@@ skipping 100 matching lines @@
 ModuleSystem::NativesEnabledScope::~NativesEnabledScope() {
   module_system_->natives_enabled_--;
   CHECK_GE(module_system_->natives_enabled_, 0);
 }
 
 void ModuleSystem::HandleException(const v8::TryCatch& try_catch) {
   exception_handler_->HandleUncaughtException(try_catch);
 }
 
 v8::Handle<v8::Value> ModuleSystem::Require(const std::string& module_name) {
-  v8::HandleScope handle_scope(GetIsolate());
-  return handle_scope.Close(RequireForJsInner(
+  v8::EscapableHandleScope handle_scope(GetIsolate());
+  return handle_scope.Escape(RequireForJsInner(
       v8::String::NewFromUtf8(GetIsolate(), module_name.c_str())));
 }
 
 void ModuleSystem::RequireForJs(
   const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Handle<v8::String> module_name = args[0]->ToString();
   args.GetReturnValue().Set(RequireForJsInner(module_name));
 }
 
-v8::Handle<v8::Value> ModuleSystem::RequireForJsInner(
+v8::Local<v8::Value> ModuleSystem::RequireForJsInner(
     v8::Handle<v8::String> module_name) {
-  v8::HandleScope handle_scope(GetIsolate());
+  v8::EscapableHandleScope handle_scope(GetIsolate());
   v8::Context::Scope context_scope(context()->v8_context());
 
   v8::Handle<v8::Object> global(context()->v8_context()->Global());
 
   // The module system might have been deleted. This can happen if a different
   // context keeps a reference to us, but our frame is destroyed (e.g.
   // background page keeps reference to chrome object in a closed popup).
   v8::Handle<v8::Value> modules_value = global->GetHiddenValue(
       v8::String::NewFromUtf8(GetIsolate(), kModulesField));
   if (modules_value.IsEmpty() || modules_value->IsUndefined()) {
-    Warn("Extension view no longer exists");
-    return v8::Undefined();
+    Warn(GetIsolate(), "Extension view no longer exists");
+    return v8::Undefined(GetIsolate());
   }
 
   v8::Handle<v8::Object> modules(v8::Handle<v8::Object>::Cast(modules_value));
-  v8::Handle<v8::Value> exports(modules->Get(module_name));
+  v8::Local<v8::Value> exports(modules->Get(module_name));

[marja, 2013/12/02 13:36:21]

You're changing some Handles to Locals, but leaving some unchanged, is there
some logic behind this?

[jochen (gone - plz use gerrit), 2013/12/02 13:45:12]

Yes.

The once I pass to EscapableHandleScope::Escape() need to be Locals. I don't
touch the rest for now.

   if (!exports->IsUndefined())
-    return handle_scope.Close(exports);
+    return handle_scope.Escape(exports);
 
   std::string module_name_str = *v8::String::Utf8Value(module_name);
   v8::Handle<v8::Value> source(GetSource(module_name_str));
   if (source.IsEmpty() || source->IsUndefined()) {
     Fatal(context_, "No source for require(" + module_name_str + ")");
-    return v8::Undefined();
+    return v8::Undefined(GetIsolate());
   }
   v8::Handle<v8::String> wrapped_source(WrapSource(
       v8::Handle<v8::String>::Cast(source)));
   // Modules are wrapped in (function(){...}) so they always return functions.
   v8::Handle<v8::Value> func_as_value = RunString(wrapped_source, module_name);
   if (func_as_value.IsEmpty() || func_as_value->IsUndefined()) {
     Fatal(context_, "Bad source for require(" + module_name_str + ")");
-    return v8::Undefined();
+    return v8::Undefined(GetIsolate());
   }
 
   v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(func_as_value);
 
   exports = v8::Object::New();
   v8::Handle<v8::Object> natives(NewInstance());
   CHECK(!natives.IsEmpty());  // this can happen if v8 has issues
 
   // These must match the argument order in WrapSource.
   v8::Handle<v8::Value> args[] = {
-    // CommonJS.
-    natives->Get(v8::String::NewSymbol("require")),
-    natives->Get(v8::String::NewSymbol("requireNative")),
-    exports,
-    // Libraries that we magically expose to every module.
-    console::AsV8Object(),
-    // Each safe builtin. Keep in order with the arguments in WrapSource.
-    context_->safe_builtins()->GetArray(),
-    context_->safe_builtins()->GetFunction(),
-    context_->safe_builtins()->GetJSON(),
-    context_->safe_builtins()->GetObjekt(),
-    context_->safe_builtins()->GetRegExp(),
-    context_->safe_builtins()->GetString(),
-  };
+      // CommonJS.
+      natives->Get(v8::String::NewFromUtf8(
+          GetIsolate(), "require", v8::String::kInternalizedString)),
+      natives->Get(v8::String::NewFromUtf8(GetIsolate(), "requireNative",
+                                           v8::String::kInternalizedString)),
+      exports,
+      // Libraries that we magically expose to every module.
+      console::AsV8Object(),
+      // Each safe builtin. Keep in order with the arguments in WrapSource.
+      context_->safe_builtins()->GetArray(),
+      context_->safe_builtins()->GetFunction(),
+      context_->safe_builtins()->GetJSON(),
+      context_->safe_builtins()->GetObjekt(),
+      context_->safe_builtins()->GetRegExp(),
+      context_->safe_builtins()->GetString(), };
   {
     v8::TryCatch try_catch;
     try_catch.SetCaptureMessage(true);
     context_->CallFunction(func, arraysize(args), args);
     if (try_catch.HasCaught()) {
       HandleException(try_catch);
-      return v8::Undefined();
+      return v8::Undefined(GetIsolate());
     }
   }
   modules->Set(module_name, exports);
-  return handle_scope.Close(exports);
+  return handle_scope.Escape(exports);
 }
 
 v8::Local<v8::Value> ModuleSystem::CallModuleMethod(
     const std::string& module_name,
     const std::string& method_name) {
   v8::HandleScope handle_scope(GetIsolate());
   v8::Handle<v8::Value> no_args;
   return CallModuleMethod(module_name, method_name, 0, &no_args);
 }
 
 v8::Local<v8::Value> ModuleSystem::CallModuleMethod(
     const std::string& module_name,
     const std::string& method_name,
     std::vector<v8::Handle<v8::Value> >* args) {
   return CallModuleMethod(
       module_name, method_name, args->size(), vector_as_array(args));
 }
 
 v8::Local<v8::Value> ModuleSystem::CallModuleMethod(
     const std::string& module_name,
     const std::string& method_name,
     int argc,
     v8::Handle<v8::Value> argv[]) {
   TRACE_EVENT2("v8", "v8.callModuleMethod",
                "module_name", module_name,
                "method_name", method_name);
 
-  v8::HandleScope handle_scope(GetIsolate());
+  v8::EscapableHandleScope handle_scope(GetIsolate());
   v8::Context::Scope context_scope(context()->v8_context());
 
   v8::Local<v8::Value> module;
   {
     NativesEnabledScope natives_enabled(this);
     module = RequireForJsInner(
         v8::String::NewFromUtf8(GetIsolate(), module_name.c_str()));
   }
 
   if (module.IsEmpty() || !module->IsObject()) {
     Fatal(context_,
           "Failed to get module " + module_name + " to call " + method_name);
-    return handle_scope.Close(v8::Undefined());
+    return handle_scope.Escape(
+        v8::Local<v8::Primitive>(v8::Undefined(GetIsolate())));
   }
 
   v8::Local<v8::Value> value =
       v8::Handle<v8::Object>::Cast(module)->Get(
           v8::String::NewFromUtf8(GetIsolate(), method_name.c_str()));
   if (value.IsEmpty() || !value->IsFunction()) {
     Fatal(context_, module_name + "." + method_name + " is not a function");
-    return handle_scope.Close(v8::Undefined());
+    return handle_scope.Escape(
+        v8::Local<v8::Primitive>(v8::Undefined(GetIsolate())));
   }
 
   v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(value);
   v8::Local<v8::Value> result;
   {
     v8::TryCatch try_catch;
     try_catch.SetCaptureMessage(true);
     result = context_->CallFunction(func, argc, argv);
     if (try_catch.HasCaught())
       HandleException(try_catch);
   }
-  return handle_scope.Close(result);
+  return handle_scope.Escape(result);
 }
 
 void ModuleSystem::RegisterNativeHandler(const std::string& name,
     scoped_ptr<NativeHandler> native_handler) {
   native_handler_map_[name] =
       linked_ptr<NativeHandler>(native_handler.release());
 }
 
 void ModuleSystem::OverrideNativeHandlerForTest(const std::string& name) {
   overridden_native_handlers_.insert(name);
@@ skipping 31 matching lines @@
   v8::HandleScope handle_scope(info.GetIsolate());
   v8::Handle<v8::Object> parameters = v8::Handle<v8::Object>::Cast(info.Data());
   // This context should be the same as context()->v8_context().
   v8::Handle<v8::Context> context = parameters->CreationContext();
   v8::Handle<v8::Object> global(context->Global());
   v8::Handle<v8::Value> module_system_value = global->GetHiddenValue(
       v8::String::NewFromUtf8(info.GetIsolate(), kModuleSystem));
   if (module_system_value.IsEmpty() || !module_system_value->IsExternal()) {
     // ModuleSystem has been deleted.
     // TODO(kalman): See comment in header file.
-    Warn("Module system has been deleted, does extension view exist?");
+    Warn(info.GetIsolate(),
+         "Module system has been deleted, does extension view exist?");
     return;
   }
 
   ModuleSystem* module_system = static_cast<ModuleSystem*>(
       v8::Handle<v8::External>::Cast(module_system_value)->Value());
 
   std::string name = *v8::String::Utf8Value(parameters->Get(
       v8::String::NewFromUtf8(info.GetIsolate(), kModuleName))->ToString());
 
   // Switch to our v8 context because we need functions created while running
@@ skipping 76 matching lines @@
       &ModuleSystem::NativeLazyFieldGetter);
 }
 
 
 v8::Isolate* ModuleSystem::GetIsolate() const {
   return context_->isolate();
 }
 
 v8::Handle<v8::Value> ModuleSystem::RunString(v8::Handle<v8::String> code,
                                               v8::Handle<v8::String> name) {
-  v8::HandleScope handle_scope(GetIsolate());
+  v8::EscapableHandleScope handle_scope(GetIsolate());
   v8::Context::Scope context_scope(context()->v8_context());
 
   // Prepend extensions:: to |name| so that internal code can be differentiated
   // from external code in stack traces. This has no effect on behaviour.
   std::string internal_name = base::StringPrintf("extensions::%s",
                                                  *v8::String::Utf8Value(name));
 
   blink::WebScopedMicrotaskSuppression suppression;
   v8::TryCatch try_catch;
   try_catch.SetCaptureMessage(true);
   v8::Handle<v8::Script> script(
       v8::Script::New(code,
                       v8::String::NewFromUtf8(GetIsolate(),
                                               internal_name.c_str(),
                                               v8::String::kNormalString,
                                               internal_name.size())));
   if (try_catch.HasCaught()) {
     HandleException(try_catch);
-    return v8::Undefined();
+    return v8::Undefined(GetIsolate());
   }
 
-  v8::Handle<v8::Value> result = script->Run();
+  v8::Local<v8::Value> result = script->Run();
   if (try_catch.HasCaught()) {
     HandleException(try_catch);
-    return v8::Undefined();
+    return v8::Undefined(GetIsolate());
   }
 
-  return handle_scope.Close(result);
+  return handle_scope.Escape(result);
 }
 
 v8::Handle<v8::Value> ModuleSystem::GetSource(const std::string& module_name) {
-  v8::HandleScope handle_scope(GetIsolate());
+  v8::EscapableHandleScope handle_scope(GetIsolate());
   if (!source_map_->Contains(module_name))
-    return v8::Undefined();
-  return handle_scope.Close(source_map_->GetSource(GetIsolate(), module_name));
+    return v8::Undefined(GetIsolate());
+  return handle_scope.Escape(
+      v8::Local<v8::Value>(source_map_->GetSource(GetIsolate(), module_name)));
 }
 
 void ModuleSystem::RequireNative(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
   std::string native_name = *v8::String::Utf8Value(args[0]->ToString());
   args.GetReturnValue().Set(RequireNativeFromString(native_name));
 }
 
 v8::Handle<v8::Value> ModuleSystem::RequireNativeFromString(
     const std::string& native_name) {
   if (natives_enabled_ == 0) {
     // HACK: if in test throw exception so that we can test the natives-disabled
     // logic; however, under normal circumstances, this is programmer error so
     // we could crash.
     if (exception_handler_) {
-      return v8::ThrowException(
+      return GetIsolate()->ThrowException(
           v8::String::NewFromUtf8(GetIsolate(), "Natives disabled"));
     }
     Fatal(context_, "Natives disabled for requireNative(" + native_name + ")");
-    return v8::Undefined();
+    return v8::Undefined(GetIsolate());
   }
 
   if (overridden_native_handlers_.count(native_name) > 0u) {
     return RequireForJsInner(
         v8::String::NewFromUtf8(GetIsolate(), native_name.c_str()));
   }
 
   NativeHandlerMap::iterator i = native_handler_map_.find(native_name);
   if (i == native_handler_map_.end()) {
     Fatal(context_,
           "Couldn't find native for requireNative(" + native_name + ")");
-    return v8::Undefined();
+    return v8::Undefined(GetIsolate());
   }
   return i->second->NewInstance();
 }
 
 v8::Handle<v8::String> ModuleSystem::WrapSource(v8::Handle<v8::String> source) {
-  v8::HandleScope handle_scope(GetIsolate());
+  v8::EscapableHandleScope handle_scope(GetIsolate());
   // Keep in order with the arguments in RequireForJsInner.
   v8::Handle<v8::String> left = v8::String::NewFromUtf8(GetIsolate(),
       "(function(require, requireNative, exports, "
                 "console, "
                 "$Array, $Function, $JSON, $Object, $RegExp, $String) {"
        "'use strict';");
   v8::Handle<v8::String> right = v8::String::NewFromUtf8(GetIsolate(), "\n})");
-  return handle_scope.Close(
-      v8::String::Concat(left, v8::String::Concat(source, right)));
+  return handle_scope.Escape(v8::Local<v8::String>(
+      v8::String::Concat(left, v8::String::Concat(source, right))));
 }
 
 }  // namespace extensions