Make the v8 Isolate used in the proxy resolver explicit.

net/proxy/proxy_resolver_v8.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 "net/proxy/proxy_resolver_v8.h"
 
 #include <algorithm>
 #include <cstdio>
 
 #include "base/basictypes.h"
@@ skipping 317 matching lines @@
 
   return IPNumberMatchesPrefix(address, prefix, prefix_length_in_bits);
 }
 
 }  // namespace
 
 // ProxyResolverV8::Context ---------------------------------------------------
 
 class ProxyResolverV8::Context {
  public:
-  explicit Context(ProxyResolverJSBindings* js_bindings)
+  explicit Context(ProxyResolverJSBindings* js_bindings,

[eroman, 2013/01/18 19:21:14]

nit: no more need for constructor to be marked explicit.

[Sven Panne, 2013/01/21 08:50:06]

Done.

+                   v8::Isolate* v8_default_isolate)
       : is_resolving_host_(false),
-        js_bindings_(js_bindings) {
+        js_bindings_(js_bindings),
+        v8_default_isolate_(v8_default_isolate) {
     DCHECK(js_bindings != NULL);
   }
 
   ~Context() {
-    v8::Locker locked;
+    v8::Locker locked(v8_default_isolate_);
 
     v8_this_.Dispose();
     v8_context_.Dispose();
 
     // Run the V8 garbage collector. We do this to be sure the
     // ExternalStringResource objects we allocated get properly disposed.
     // Otherwise when running the unit-tests they may get leaked.
     // See crbug.com/48145.
     PurgeMemory();
   }
 
   int ResolveProxy(const GURL& query_url, ProxyInfo* results) {
-    v8::Locker locked;
+    v8::Locker locked(v8_default_isolate_);
     v8::HandleScope scope;
 
     v8::Context::Scope function_scope(v8_context_);
 
     v8::Local<v8::Value> function;
     if (!GetFindProxyForURL(&function)) {
       js_bindings_->OnError(
           -1, ASCIIToUTF16("FindProxyForURL() is undefined."));
       return ERR_PAC_SCRIPT_FAILED;
     }
@@ skipping 30 matching lines @@
                        "(crbug.com/47234): ") + ret_str;
       js_bindings_->OnError(-1, error_message);
       return ERR_PAC_SCRIPT_FAILED;
     }
 
     results->UsePacString(UTF16ToASCII(ret_str));
     return OK;
   }
 
   int InitV8(const scoped_refptr<ProxyResolverScriptData>& pac_script) {
-    v8::Locker locked;
+    v8::Locker locked(v8_default_isolate_);
     v8::HandleScope scope;
 
     v8_this_ = v8::Persistent<v8::External>::New(v8::External::New(this));
     v8::Local<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
 
     // Attach the javascript bindings.
     v8::Local<v8::FunctionTemplate> alert_template =
         v8::FunctionTemplate::New(&AlertCallback, v8_this_);
     global_template->Set(ASCIILiteralToV8String("alert"), alert_template);
 
@@ skipping 61 matching lines @@
     }
 
     return OK;
   }
 
   void SetCurrentRequestContext(ProxyResolverRequestContext* context) {
     js_bindings_->set_current_request_context(context);
   }
 
   void PurgeMemory() {
-    v8::Locker locked;
+    v8::Locker locked(v8_default_isolate_);
     v8::V8::LowMemoryNotification();
   }
 
   bool is_resolving_host() const {
     base::AutoLock auto_lock(lock_);
     return is_resolving_host_;
   }
 
  private:
   class ScopedHostResolve {
@@ skipping 86 matching lines @@
 
   // V8 callback for when "myIpAddress()" is invoked by the PAC script.
   static v8::Handle<v8::Value> MyIpAddressCallback(const v8::Arguments& args) {
     Context* context =
         static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
 
     std::string result;
     bool success;
 
     {
-      v8::Unlocker unlocker;
+      v8::Unlocker unlocker(args.GetIsolate());
       ScopedHostResolve scoped_host_resolve(context);
 
       // We shouldn't be called with any arguments, but will not complain if
       // we are.
       success = context->js_bindings_->MyIpAddress(&result);
     }
 
     if (!success)
       return ASCIILiteralToV8String("127.0.0.1");
     return ASCIIStringToV8String(result);
   }
 
   // V8 callback for when "myIpAddressEx()" is invoked by the PAC script.
   static v8::Handle<v8::Value> MyIpAddressExCallback(
       const v8::Arguments& args) {
     Context* context =
         static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
 
     std::string ip_address_list;
     bool success;
 
     {
-      v8::Unlocker unlocker;
+      v8::Unlocker unlocker(args.GetIsolate());
       ScopedHostResolve scoped_host_resolve(context);
 
       // We shouldn't be called with any arguments, but will not complain if
       // we are.
       success = context->js_bindings_->MyIpAddressEx(&ip_address_list);
     }
 
     if (!success)
       ip_address_list = std::string();
     return ASCIIStringToV8String(ip_address_list);
   }
 
   // V8 callback for when "dnsResolve()" is invoked by the PAC script.
   static v8::Handle<v8::Value> DnsResolveCallback(const v8::Arguments& args) {
     Context* context =
         static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
 
     // We need at least one string argument.
     std::string hostname;
     if (!GetHostnameArgument(args, &hostname))
       return v8::Null();
 
     std::string ip_address;
     bool success;
 
     {
-      v8::Unlocker unlocker;
+      v8::Unlocker unlocker(args.GetIsolate());
       ScopedHostResolve scoped_host_resolve(context);
       success = context->js_bindings_->DnsResolve(hostname, &ip_address);
     }
 
     return success ? ASCIIStringToV8String(ip_address) : v8::Null();
   }
 
   // V8 callback for when "dnsResolveEx()" is invoked by the PAC script.
   static v8::Handle<v8::Value> DnsResolveExCallback(const v8::Arguments& args) {
     Context* context =
         static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
 
     // We need at least one string argument.
     std::string hostname;
     if (!GetHostnameArgument(args, &hostname))
       return v8::Undefined();
 
     std::string ip_address_list;
     bool success;
 
     {
-      v8::Unlocker unlocker;
+      v8::Unlocker unlocker(args.GetIsolate());
       ScopedHostResolve scoped_host_resolve(context);
       success = context->js_bindings_->DnsResolveEx(hostname, &ip_address_list);
     }
 
     if (!success)
       ip_address_list = std::string();
 
     return ASCIIStringToV8String(ip_address_list);
   }
 
@@ skipping 26 matching lines @@
       return v8::False();
     std::string ip_prefix = V8StringToUTF8(args[1]->ToString());
     if (!IsStringASCII(ip_prefix))
       return v8::False();
     return IsInNetEx(ip_address, ip_prefix) ? v8::True() : v8::False();
   }
 
   mutable base::Lock lock_;
   bool is_resolving_host_;
   ProxyResolverJSBindings* js_bindings_;
+  v8::Isolate* v8_default_isolate_;
   v8::Persistent<v8::External> v8_this_;
   v8::Persistent<v8::Context> v8_context_;
 };
 
 // ProxyResolverV8 ------------------------------------------------------------
 
 ProxyResolverV8::ProxyResolverV8(
-    ProxyResolverJSBindings* custom_js_bindings)
+    ProxyResolverJSBindings* custom_js_bindings,
+    v8::Isolate* v8_default_isolate)
     : ProxyResolver(true /*expects_pac_bytes*/),
-      js_bindings_(custom_js_bindings) {
+      js_bindings_(custom_js_bindings),
+      v8_default_isolate_(v8_default_isolate) {
 }
 
 ProxyResolverV8::~ProxyResolverV8() {}
 
 int ProxyResolverV8::GetProxyForURL(
     const GURL& query_url, ProxyInfo* results,
     const CompletionCallback& /*callback*/,
     RequestHandle* /*request*/,
     const BoundNetLog& net_log) {
   // If the V8 instance has not been initialized (either because
@@ skipping 50 matching lines @@
 
 int ProxyResolverV8::SetPacScript(
     const scoped_refptr<ProxyResolverScriptData>& script_data,
     const CompletionCallback& /*callback*/) {
   DCHECK(script_data.get());
   context_.reset();
   if (script_data->utf16().empty())
     return ERR_PAC_SCRIPT_FAILED;
 
   // Try parsing the PAC script.
-  scoped_ptr<Context> context(new Context(js_bindings_.get()));
+  scoped_ptr<Context> context(new Context(js_bindings_.get(),
+                                          v8_default_isolate_));
   int rv = context->InitV8(script_data);
   if (rv == OK)
     context_.reset(context.release());
   return rv;
 }
 
 }  // namespace net