Merge isolates to bleeding_edge.

test/cctest/test-circular-queue.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 //
 // Tests of the circular queue.
 
 #include "v8.h"
 #include "circular-queue-inl.h"
 #include "cctest.h"
 
 namespace i = v8::internal;
 
@@ skipping 66 matching lines @@
   CHECK_NE(NULL, scq.StartDequeue());
 }
 
 
 namespace {
 
 class ProducerThread: public i::Thread {
  public:
   typedef SamplingCircularQueue::Cell Record;
 
-  ProducerThread(SamplingCircularQueue* scq,
+  ProducerThread(i::Isolate* isolate,
+                 SamplingCircularQueue* scq,
                  int records_per_chunk,
                  Record value,
                  i::Semaphore* finished)
-      : scq_(scq),
+      : Thread(isolate),
+        scq_(scq),
         records_per_chunk_(records_per_chunk),
         value_(value),
         finished_(finished) { }
 
   virtual void Run() {
     for (Record i = value_; i < value_ + records_per_chunk_; ++i) {
       Record* rec = reinterpret_cast<Record*>(scq_->Enqueue());
       CHECK_NE(NULL, rec);
       *rec = i;
     }
@@ skipping 22 matching lines @@
                             kRecordsPerChunk * sizeof(Record),
                             3);
   i::Semaphore* semaphore = i::OS::CreateSemaphore(0);
   // Don't poll ahead, making possible to check data in the buffer
   // immediately after enqueuing.
   scq.FlushResidualRecords();
 
   // Check that we are using non-reserved values.
   CHECK_NE(SamplingCircularQueue::kClear, 1);
   CHECK_NE(SamplingCircularQueue::kEnd, 1);
-  ProducerThread producer1(&scq, kRecordsPerChunk, 1, semaphore);
-  ProducerThread producer2(&scq, kRecordsPerChunk, 10, semaphore);
-  ProducerThread producer3(&scq, kRecordsPerChunk, 20, semaphore);
+  i::Isolate* isolate = i::Isolate::Current();
+  ProducerThread producer1(isolate, &scq, kRecordsPerChunk, 1, semaphore);
+  ProducerThread producer2(isolate, &scq, kRecordsPerChunk, 10, semaphore);
+  ProducerThread producer3(isolate, &scq, kRecordsPerChunk, 20, semaphore);
 
   CHECK_EQ(NULL, scq.StartDequeue());
   producer1.Start();
   semaphore->Wait();
   for (Record i = 1; i < 1 + kRecordsPerChunk; ++i) {
     Record* rec = reinterpret_cast<Record*>(scq.StartDequeue());
     CHECK_NE(NULL, rec);
     CHECK_EQ(static_cast<int64_t>(i), static_cast<int64_t>(*rec));
     CHECK_EQ(rec, reinterpret_cast<Record*>(scq.StartDequeue()));
     scq.FinishDequeue();
@@ skipping 21 matching lines @@
     CHECK_EQ(static_cast<int64_t>(i), static_cast<int64_t>(*rec));
     CHECK_EQ(rec, reinterpret_cast<Record*>(scq.StartDequeue()));
     scq.FinishDequeue();
     CHECK_NE(rec, reinterpret_cast<Record*>(scq.StartDequeue()));
   }
 
   CHECK_EQ(NULL, scq.StartDequeue());
 
   delete semaphore;
 }