Use v8::internal threading support in samples/shell.cc.

test/cctest/test-api.cc

 // Copyright 2007-2009 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 9911 matching lines @@
     CHECK(regexp_success_);
     CHECK(gc_success_);
   }
  private:
   // Number of garbage collections required.
   static const int kRequiredGCs = 5;
 
   class GCThread : public i::Thread {
    public:
     explicit GCThread(i::Isolate* isolate, RegExpInterruptTest* test)
-        : Thread(isolate), test_(test) {}
+        : Thread(isolate, "GCThread"), test_(test) {}
     virtual void Run() {
       test_->CollectGarbage();
     }
    private:
      RegExpInterruptTest* test_;
   };
 
   void CollectGarbage() {
     block_->Wait();
     while (gc_during_regexp_ < kRequiredGCs) {
@@ skipping 101 matching lines @@
     CHECK(apply_success_);
     CHECK(gc_success_);
   }
  private:
   // Number of garbage collections required.
   static const int kRequiredGCs = 2;
 
   class GCThread : public i::Thread {
    public:
     explicit GCThread(i::Isolate* isolate, ApplyInterruptTest* test)
-        : Thread(isolate), test_(test) {}
+        : Thread(isolate, "GCThread"), test_(test) {}
     virtual void Run() {
       test_->CollectGarbage();
     }
    private:
      ApplyInterruptTest* test_;
   };
 
   void CollectGarbage() {
     block_->Wait();
     while (gc_during_apply_ < kRequiredGCs) {
@@ skipping 275 matching lines @@
  private:
 
   // Number of string modifications required.
   static const int kRequiredModifications = 5;
   static const int kMaxModifications = 100;
 
   class MorphThread : public i::Thread {
    public:
     explicit MorphThread(i::Isolate* isolate,
                          RegExpStringModificationTest* test)
-        : Thread(isolate), test_(test) {}
+        : Thread(isolate, "MorphThread"), test_(test) {}
     virtual void Run() {
       test_->MorphString();
     }
    private:
      RegExpStringModificationTest* test_;
   };
 
   void MorphString() {
     block_->Wait();
     while (morphs_during_regexp_ < kRequiredModifications &&
@@ skipping 2676 matching lines @@
                         "}"
                         "fib(%d)", limit);
   Local<Value> value = CompileRun(code.start());
   CHECK(value->IsNumber());
   return static_cast<int>(value->NumberValue());
 }
 
 class IsolateThread : public v8::internal::Thread {
  public:
   explicit IsolateThread(v8::Isolate* isolate, int fib_limit)
-    : Thread(NULL),
-      isolate_(isolate),
-      fib_limit_(fib_limit),
-      result_(0) { }
+      : Thread(NULL, "IsolateThread"),
+        isolate_(isolate),
+        fib_limit_(fib_limit),
+        result_(0) { }
 
   void Run() {
     result_ = CalcFibonacci(isolate_, fib_limit_);
   }
 
   int result() { return result_; }
 
  private:
   v8::Isolate* isolate_;
   int fib_limit_;
@@ skipping 27 matching lines @@
   isolate1->Dispose();
   isolate2->Dispose();
 }
 
 
 class InitDefaultIsolateThread : public v8::internal::Thread {
  public:
   enum TestCase { IgnoreOOM, SetResourceConstraints, SetFatalHandler };
 
   explicit InitDefaultIsolateThread(TestCase testCase)
-    : Thread(NULL),
-      testCase_(testCase),
-      result_(false) { }
+      : Thread(NULL, "InitDefaultIsolateThread"),
+        testCase_(testCase),
+        result_(false) { }
 
   void Run() {
     switch (testCase_) {
     case IgnoreOOM:
       v8::V8::IgnoreOutOfMemoryException();
       break;
 
     case SetResourceConstraints: {
       static const int K = 1024;
       v8::ResourceConstraints constraints;
@@ skipping 364 matching lines @@
   v8::Handle<v8::Function> define_property =
       CompileRun("(function() {"
                  "  Object.defineProperty("
                  "    this,"
                  "    1,"
                  "    { configurable: true, enumerable: true, value: 3 });"
                  "})").As<Function>();
   context->DetachGlobal();
   define_property->Call(proxy, 0, NULL);
 }