Remove more calls to HandleScope default ctor.

chrome/renderer/extensions/messaging_bindings.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/messaging_bindings.h"
 
 #include <map>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 150 matching lines @@
           new ExtensionHostMsg_CloseChannel(port_id, std::string()));
       ClearPortData(port_id);
     }
   }
 
   // Holds a |callback| to run sometime after |object| is GC'ed. |callback| will
   // not be executed re-entrantly to avoid running JS in an unexpected state.
   class GCCallback {
    public:
     static void Bind(v8::Handle<v8::Object> object,
-                     v8::Handle<v8::Function> callback) {
-      GCCallback* cb = new GCCallback(object, callback);
+                     v8::Handle<v8::Function> callback,
+                     v8::Isolate* isolate) {
+      GCCallback* cb = new GCCallback(object, callback, isolate);
       cb->object_.MakeWeak(cb, NearDeathCallback);
     }
 
    private:
     static void NearDeathCallback(v8::Isolate* isolate,
                                   v8::Persistent<v8::Object>* object,
                                   GCCallback* self) {
       // v8 says we need to explicitly reset weak handles from their callbacks.
       // It's not implicit as one might expect.
       self->object_.reset();
       base::MessageLoop::current()->PostTask(FROM_HERE,
           base::Bind(&GCCallback::RunCallback, base::Owned(self)));
     }
 
-    GCCallback(v8::Handle<v8::Object> object, v8::Handle<v8::Function> callback)
-        : object_(object), callback_(callback) {
-    }
+    GCCallback(v8::Handle<v8::Object> object,
+               v8::Handle<v8::Function> callback,
+               v8::Isolate* isolate)
+        : object_(object), callback_(callback), isolate_(isolate) {}
 
     void RunCallback() {
-      v8::HandleScope handle_scope;
+      v8::HandleScope handle_scope(isolate_);
       v8::Handle<v8::Context> context = callback_->CreationContext();
       if (context.IsEmpty())
         return;
       v8::Context::Scope context_scope(context);
       WebKit::WebScopedMicrotaskSuppression suppression;
       callback_->Call(context->Global(), 0, NULL);
     }
 
     extensions::ScopedPersistent<v8::Object> object_;
     extensions::ScopedPersistent<v8::Function> callback_;
+    v8::Isolate* isolate_;
 
     DISALLOW_COPY_AND_ASSIGN(GCCallback);
   };
 
   // void BindToGC(object, callback)
   //
   // Binds |callback| to be invoked *sometime after* |object| is garbage
   // collected. We don't call the method re-entrantly so as to avoid executing
   // JS in some bizarro undefined mid-GC state.
   void BindToGC(const v8::FunctionCallbackInfo<v8::Value>& args) {
     CHECK(args.Length() == 2 && args[0]->IsObject() && args[1]->IsFunction());
-    GCCallback::Bind(args[0].As<v8::Object>(), args[1].As<v8::Function>());
+    GCCallback::Bind(args[0].As<v8::Object>(),
+                     args[1].As<v8::Function>(),
+                     args.GetIsolate());
   }
 };
 
 }  // namespace
 
 namespace extensions {
 
 ChromeV8Extension* MessagingBindings::Get(
     Dispatcher* dispatcher,
     ChromeV8Context* context) {
   return new ExtensionImpl(dispatcher, context);
 }
 
 // static
 void MessagingBindings::DispatchOnConnect(
     const ChromeV8ContextSet::ContextSet& contexts,
     int target_port_id,
     const std::string& channel_name,
     const base::DictionaryValue& source_tab,
     const std::string& source_extension_id,
     const std::string& target_extension_id,
     const GURL& source_url,
     content::RenderView* restrict_to_render_view) {
-  v8::HandleScope handle_scope;
+  v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
 
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
 
   bool port_created = false;
   std::string source_url_spec = source_url.spec();
 
   // TODO(kalman): pass in the full ChromeV8ContextSet; call ForEach.
   for (ChromeV8ContextSet::ContextSet::const_iterator it = contexts.begin();
        it != contexts.end(); ++it) {
     if (restrict_to_render_view &&
@@ skipping 40 matching lines @@
             target_port_id, kReceivingEndDoesntExistError));
   }
 }
 
 // static
 void MessagingBindings::DeliverMessage(
     const ChromeV8ContextSet::ContextSet& contexts,
     int target_port_id,
     const std::string& message,
     content::RenderView* restrict_to_render_view) {
-  v8::HandleScope handle_scope;
+  v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
 
   // TODO(kalman): pass in the full ChromeV8ContextSet; call ForEach.
   for (ChromeV8ContextSet::ContextSet::const_iterator it = contexts.begin();
        it != contexts.end(); ++it) {
     if (restrict_to_render_view &&
         restrict_to_render_view != (*it)->GetRenderView()) {
       continue;
     }
 
     // TODO(kalman): remove when ContextSet::ForEach is available.
@@ skipping 20 matching lines @@
                                              &arguments);
   }
 }
 
 // static
 void MessagingBindings::DispatchOnDisconnect(
     const ChromeV8ContextSet::ContextSet& contexts,
     int port_id,
     const std::string& error_message,
     content::RenderView* restrict_to_render_view) {
-  v8::HandleScope handle_scope;
+  v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
 
   // TODO(kalman): pass in the full ChromeV8ContextSet; call ForEach.
   for (ChromeV8ContextSet::ContextSet::const_iterator it = contexts.begin();
        it != contexts.end(); ++it) {
     if (restrict_to_render_view &&
         restrict_to_render_view != (*it)->GetRenderView()) {
       continue;
     }
 
     // TODO(kalman): remove when ContextSet::ForEach is available.
     if ((*it)->v8_context().IsEmpty())
       continue;
 
     std::vector<v8::Handle<v8::Value> > arguments;
     arguments.push_back(v8::Integer::New(port_id));
     if (!error_message.empty()) {
       arguments.push_back(v8::String::New(error_message.c_str()));
     } else {
       arguments.push_back(v8::Null());
     }
     (*it)->module_system()->CallModuleMethod("messaging",
                                              "dispatchOnDisconnect",
                                              &arguments);
   }
 }
 
 }  // namespace extensions