Revert "Require V8 to be explicitly initialized before an Isolate is created"

test/cctest/test-api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 19468 matching lines @@
                     "  return fib(n-1) + fib(n-2);"
                     "}"
                     "fib(%d)", limit);
   Local<Value> value = CompileRun(code.start());
   CHECK(value->IsNumber());
   return static_cast<int>(value->NumberValue());
 }
 
 class IsolateThread : public v8::base::Thread {
  public:
-  explicit IsolateThread(int fib_limit)
-      : Thread(Options("IsolateThread")), fib_limit_(fib_limit), result_(0) {}
+  IsolateThread(v8::Isolate* isolate, int fib_limit)
+      : Thread(Options("IsolateThread")),
+        isolate_(isolate),
+        fib_limit_(fib_limit),
+        result_(0) {}
 
   void Run() {
-    v8::Isolate* isolate = v8::Isolate::New();
-    result_ = CalcFibonacci(isolate, fib_limit_);
-    isolate->Dispose();
+    result_ = CalcFibonacci(isolate_, fib_limit_);
   }
 
   int result() { return result_; }
 
  private:
+  v8::Isolate* isolate_;
   int fib_limit_;
   int result_;
 };
 
 
 TEST(MultipleIsolatesOnIndividualThreads) {
-  IsolateThread thread1(21);
-  IsolateThread thread2(12);
+  v8::Isolate* isolate1 = v8::Isolate::New();
+  v8::Isolate* isolate2 = v8::Isolate::New();
+
+  IsolateThread thread1(isolate1, 21);
+  IsolateThread thread2(isolate2, 12);
 
   // Compute some fibonacci numbers on 3 threads in 3 isolates.
   thread1.Start();
   thread2.Start();
 
   int result1 = CalcFibonacci(CcTest::isolate(), 21);
   int result2 = CalcFibonacci(CcTest::isolate(), 12);
 
   thread1.Join();
   thread2.Join();
 
   // Compare results. The actual fibonacci numbers for 12 and 21 are taken
   // (I'm lazy!) from http://en.wikipedia.org/wiki/Fibonacci_number
   CHECK_EQ(result1, 10946);
   CHECK_EQ(result2, 144);
   CHECK_EQ(result1, thread1.result());
   CHECK_EQ(result2, thread2.result());
+
+  isolate1->Dispose();
+  isolate2->Dispose();
 }
 
 
 TEST(IsolateDifferentContexts) {
   v8::Isolate* isolate = v8::Isolate::New();
   Local<v8::Context> context;
   {
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
     context = v8::Context::New(isolate);
@@ skipping 3775 matching lines @@
   // TestSourceStream::GetMoreData won't block, so it's OK to just run the
   // task here in the main thread.
   task->Run();
   delete task;
 
   const v8::ScriptCompiler::CachedData* cached_data = source.GetCachedData();
   CHECK(cached_data != NULL);
   CHECK(cached_data->data != NULL);
   CHECK_GT(cached_data->length, 0);
 }