Remove more calls to HandleScope default ctor.

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 56 matching lines @@
 // 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
   // code!
   virtual void HandleUncaughtException(const v8::TryCatch& try_catch) OVERRIDE {
-    v8::HandleScope handle_scope;
+    v8::HandleScope handle_scope(context_->isolate());
     std::string stack_trace = "<stack trace unavailable>";
     if (!try_catch.StackTrace().IsEmpty()) {
       v8::String::Utf8Value stack_value(try_catch.StackTrace());
       if (*stack_value)
         stack_trace.assign(*stack_value, stack_value.length());
       else
         stack_trace = "<could not convert stack trace to string>";
     }
     Fatal(context_, CreateExceptionString(try_catch) + "{" + stack_trace + "}");
   }
@@ skipping 51 matching lines @@
   Invalidate();
 }
 
 void ModuleSystem::Invalidate() {
   if (!is_valid())
     return;
 
   // Clear the module system properties from the global context. It's polite,
   // and we use this as a signal in lazy handlers that we no longer exist.
   {
-    v8::HandleScope scope;
+    v8::HandleScope scope(GetIsolate());
     v8::Handle<v8::Object> global = context()->v8_context()->Global();
     global->DeleteHiddenValue(v8::String::New(kModulesField));
     global->DeleteHiddenValue(v8::String::New(kModuleSystem));
   }
 
   // Invalidate all of the successfully required handlers we own.
   for (NativeHandlerMap::iterator it = native_handler_map_.begin();
        it != native_handler_map_.end(); ++it) {
     it->second->Invalidate();
   }
@@ skipping 10 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;
+  v8::HandleScope handle_scope(GetIsolate());
   return handle_scope.Close(
       RequireForJsInner(v8::String::New(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::Handle<v8::String> module_name) {
-  v8::HandleScope handle_scope;
+  v8::HandleScope 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::New(kModulesField));
   if (modules_value.IsEmpty() || modules_value->IsUndefined()) {
@@ skipping 52 matching lines @@
       return v8::Undefined();
     }
   }
   modules->Set(module_name, exports);
   return handle_scope.Close(exports);
 }
 
 v8::Local<v8::Value> ModuleSystem::CallModuleMethod(
     const std::string& module_name,
     const std::string& method_name) {
-  v8::HandleScope handle_scope;
+  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;
+  v8::HandleScope handle_scope(GetIsolate());
   v8::Context::Scope context_scope(context()->v8_context());
 
   v8::Local<v8::Value> module;
   {
     NativesEnabledScope natives_enabled(this);
     module = v8::Local<v8::Value>::New(
         RequireForJsInner(v8::String::New(module_name.c_str())));
   }
 
   if (module.IsEmpty() || !module->IsObject()) {
@@ skipping 26 matching lines @@
     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);
 }
 
 void ModuleSystem::RunString(const std::string& code, const std::string& name) {
-  v8::HandleScope handle_scope;
+  v8::HandleScope handle_scope(GetIsolate());
   RunString(v8::String::New(code.c_str()), v8::String::New(name.c_str()));
 }
 
 // static
 void ModuleSystem::NativeLazyFieldGetter(
     v8::Local<v8::String> property,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   LazyFieldGetterInner(property,
                        info,
                        &ModuleSystem::RequireNativeFromString);
 }
 
 // static
 void ModuleSystem::LazyFieldGetter(
     v8::Local<v8::String> property,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   LazyFieldGetterInner(property, info, &ModuleSystem::Require);
 }
 
 // static
 void ModuleSystem::LazyFieldGetterInner(
     v8::Local<v8::String> property,
     const v8::PropertyCallbackInfo<v8::Value>& info,
     RequireFunction require_function) {
   CHECK(!info.Data().IsEmpty());
   CHECK(info.Data()->IsObject());
-  v8::HandleScope handle_scope;
+  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::New(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?");
@@ skipping 58 matching lines @@
                                 const std::string& module_field) {
   SetLazyField(object, field, module_name, module_field,
       &ModuleSystem::LazyFieldGetter);
 }
 
 void ModuleSystem::SetLazyField(v8::Handle<v8::Object> object,
                                 const std::string& field,
                                 const std::string& module_name,
                                 const std::string& module_field,
                                 v8::AccessorGetterCallback getter) {
-  v8::HandleScope handle_scope;
+  v8::HandleScope handle_scope(GetIsolate());
   v8::Handle<v8::Object> parameters = v8::Object::New();
   parameters->Set(v8::String::New(kModuleName),
                   v8::String::New(module_name.c_str()));
   parameters->Set(v8::String::New(kModuleField),
                   v8::String::New(module_field.c_str()));
   object->SetAccessor(v8::String::New(field.c_str()),
                       getter,
                       NULL,
                       parameters);
 }
 
 void ModuleSystem::SetNativeLazyField(v8::Handle<v8::Object> object,
                                       const std::string& field,
                                       const std::string& module_name,
                                       const std::string& module_field) {
   SetLazyField(object, field, module_name, module_field,
       &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;
+  v8::HandleScope handle_scope(GetIsolate());
   v8::Context::Scope context_scope(context()->v8_context());
 
   WebKit::WebScopedMicrotaskSuppression suppression;
   v8::TryCatch try_catch;
   try_catch.SetCaptureMessage(true);
   v8::Handle<v8::Script> script(v8::Script::New(code, name));
   if (try_catch.HasCaught()) {
     HandleException(try_catch);
     return v8::Undefined();
   }
 
   v8::Handle<v8::Value> result = script->Run();
   if (try_catch.HasCaught()) {
     HandleException(try_catch);
     return v8::Undefined();
   }
 
   return handle_scope.Close(result);
 }
 
 v8::Handle<v8::Value> ModuleSystem::GetSource(const std::string& module_name) {
-  v8::HandleScope handle_scope;
+  v8::HandleScope handle_scope(GetIsolate());
   if (!source_map_->Contains(module_name))
     return v8::Undefined();
   return handle_scope.Close(source_map_->GetSource(module_name));
 }
 
 void ModuleSystem::RequireNative(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
   std::string native_name = *v8::String::AsciiValue(args[0]->ToString());
   args.GetReturnValue().Set(RequireNativeFromString(native_name));
@@ skipping 17 matching lines @@
   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 i->second->NewInstance();
 }
 
 v8::Handle<v8::String> ModuleSystem::WrapSource(v8::Handle<v8::String> source) {
-  v8::HandleScope handle_scope;
+  v8::HandleScope handle_scope(GetIsolate());
   // Keep in order with the arguments in RequireForJsInner.
   v8::Handle<v8::String> left = v8::String::New(
       "(function(require, requireNative, exports, "
                 "console, "
                 "$Array, $Function, $JSON, $Object, $RegExp, $String) {"
        "'use strict';");
   v8::Handle<v8::String> right = v8::String::New("\n})");
   return handle_scope.Close(
       v8::String::Concat(left, v8::String::Concat(source, right)));
 }
 
 }  // namespace extensions