Lazily initialize the v8::Isolate used by ProxyResolverV8 (in the browser process).

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"
 #include "base/compiler_specific.h"
 #include "base/debug/leak_annotations.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "gin/array_buffer.h"
 #include "gin/public/isolate_holder.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
@@ skipping 315 matching lines @@
 bool IsPlainHostName(const std::string& hostname_utf8) {
   if (hostname_utf8.find('.') != std::string::npos)
     return false;
 
   // IPv6 literals might not contain any periods, however are not considered
   // plain host names.
   IPAddressNumber unused;
   return !ParseIPLiteralToNumber(hostname_utf8, &unused);
 }
 
+// All instances of ProxyResolverV8 share the same v8::Isolate. This isolate is
+// created lazily the first time it is needed and lives until process shutdown.
+// This creation might happen from any thread, as ProxyResolverV8 is typically
+// run in a threadpool.
+//
+// TODO(eroman): The lazily created isolate is never freed. Instead it should be
+// disposed once there are no longer any ProxyResolverV8 referencing it.
+class SharedIsolateFactory {
+ public:
+  SharedIsolateFactory() : has_initialized_v8_(false) {}
+
+  // Lazily creates a v8::Isolate, or returns the already created instance.
+  v8::Isolate* GetSharedIsolate() {
+    base::AutoLock l(lock_);
+
+    if (!holder_) {
+      // Do one-time initialization for V8.
+      if (!has_initialized_v8_) {
+#ifdef V8_USE_EXTERNAL_STARTUP_DATA
+        gin::IsolateHolder::LoadV8Snapshot();
+#endif
+
+        gin::IsolateHolder::Initialize(
+            gin::IsolateHolder::kNonStrictMode,
+            gin::ArrayBufferAllocator::SharedInstance());
+
+        has_initialized_v8_ = true;
+      }
+
+      holder_.reset(new gin::IsolateHolder);
+    }
+
+    return holder_->isolate();
+  }
+
+  v8::Isolate* GetSharedIsolateWithoutCreating() {
+    base::AutoLock l(lock_);
+    return holder_ ? holder_->isolate() : NULL;
+  }
+
+ private:
+  base::Lock lock_;
+  scoped_ptr<gin::IsolateHolder> holder_;
+  bool has_initialized_v8_;
+
+  DISALLOW_COPY_AND_ASSIGN(SharedIsolateFactory);
+};
+
+base::LazyInstance<SharedIsolateFactory>::Leaky g_isolate_factory =
+    LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
 // ProxyResolverV8::Context ---------------------------------------------------
 
 class ProxyResolverV8::Context {
  public:
   Context(ProxyResolverV8* parent, v8::Isolate* isolate)
       : parent_(parent),
         isolate_(isolate) {
     DCHECK(isolate);
@@ skipping 424 matching lines @@
     const scoped_refptr<ProxyResolverScriptData>& script_data,
     const CompletionCallback& /*callback*/) {
   DCHECK(script_data.get());
   DCHECK(js_bindings_);
 
   context_.reset();
   if (script_data->utf16().empty())
     return ERR_PAC_SCRIPT_FAILED;
 
   // Try parsing the PAC script.
-  scoped_ptr<Context> context(new Context(this, GetDefaultIsolate()));
+  scoped_ptr<Context> context(
+      new Context(this, g_isolate_factory.Get().GetSharedIsolate()));
   int rv = context->InitV8(script_data);
   if (rv == OK)
     context_.reset(context.release());
   return rv;
 }
 
 // static
-void ProxyResolverV8::EnsureIsolateCreated() {
-  if (g_proxy_resolver_isolate_)
-    return;
-  gin::IsolateHolder::Initialize(gin::IsolateHolder::kNonStrictMode,
-                                 gin::ArrayBufferAllocator::SharedInstance());
-  g_proxy_resolver_isolate_ = new gin::IsolateHolder;
-  ANNOTATE_LEAKING_OBJECT_PTR(g_proxy_resolver_isolate_);
-}
-
-// static
-v8::Isolate* ProxyResolverV8::GetDefaultIsolate() {
-  DCHECK(g_proxy_resolver_isolate_)
-      << "Must call ProxyResolverV8::EnsureIsolateCreated() first";
-  return g_proxy_resolver_isolate_->isolate();
-}
-
-gin::IsolateHolder* ProxyResolverV8::g_proxy_resolver_isolate_ = NULL;
-
-// static
 size_t ProxyResolverV8::GetTotalHeapSize() {
-  if (!g_proxy_resolver_isolate_)
+  v8::Isolate* isolate =
+      g_isolate_factory.Get().GetSharedIsolateWithoutCreating();
+  if (!isolate)
     return 0;
 
-  v8::Locker locked(g_proxy_resolver_isolate_->isolate());
-  v8::Isolate::Scope isolate_scope(g_proxy_resolver_isolate_->isolate());
+  v8::Locker locked(isolate);
+  v8::Isolate::Scope isolate_scope(isolate);
   v8::HeapStatistics heap_statistics;
-  g_proxy_resolver_isolate_->isolate()->GetHeapStatistics(&heap_statistics);
+  isolate->GetHeapStatistics(&heap_statistics);
   return heap_statistics.total_heap_size();
 }
 
 // static
 size_t ProxyResolverV8::GetUsedHeapSize() {
-  if (!g_proxy_resolver_isolate_)
+  v8::Isolate* isolate =
+      g_isolate_factory.Get().GetSharedIsolateWithoutCreating();
+  if (!isolate)
     return 0;
 
-  v8::Locker locked(g_proxy_resolver_isolate_->isolate());
-  v8::Isolate::Scope isolate_scope(g_proxy_resolver_isolate_->isolate());
+  v8::Locker locked(isolate);
+  v8::Isolate::Scope isolate_scope(isolate);
   v8::HeapStatistics heap_statistics;
-  g_proxy_resolver_isolate_->isolate()->GetHeapStatistics(&heap_statistics);
+  isolate->GetHeapStatistics(&heap_statistics);
   return heap_statistics.used_heap_size();
 }
 
 }  // namespace net