v8::platform Namespace Reference

Namespaces
	anonymous_namespace{default-platform-unittest.cc}
	anonymous_namespace{task-queue-unittest.cc}
	anonymous_namespace{worker-thread-unittest.cc}

Classes
class	DefaultPlatform
class	TaskQueue
class	WorkerThread

Functions
	TEST (DefaultPlatformTest, PumpMessageLoop)
v8::Platform *	CreateDefaultPlatform (int thread_pool_size=0)
	Returns a new instance of the default v8::Platform implementation. More...
bool	PumpMessageLoop (v8::Platform *platform, v8::Isolate *isolate)
	Pumps the message loop for the given isolate. More...
	TEST (TaskQueueTest, Basic)
	TEST (TaskQueueTest, TerminateMultipleReaders)
	TEST (WorkerThreadTest, Basic)

Function Documentation

CreateDefaultPlatform()

v8::Platform * v8::platform::CreateDefaultPlatform

(

int

thread_pool_size = 0

)

Returns a new instance of the default v8::Platform implementation.

The caller will take ownership of the returned pointer. |thread_pool_size| is the number of worker threads to allocate for background jobs. If a value of zero is passed, a suitable default based on the current number of processors online will be chosen.

Definition at line 19 of file default-platform.cc.

                                                        {
  DefaultPlatform* platform = new DefaultPlatform();
  platform->SetThreadPoolSize(thread_pool_size);
  platform->EnsureInitialized();
  return platform;
}

References v8::platform::DefaultPlatform::EnsureInitialized(), and v8::platform::DefaultPlatform::SetThreadPoolSize().

Referenced by main(), v8::Shell::Main(), and anonymous_namespace{run-all-unittests.cc}::FINAL::SetUp().

Here is the call graph for this function:

Here is the caller graph for this function:

PumpMessageLoop()

bool v8::platform::PumpMessageLoop	(	v8::Platform *	platform,
		v8::Isolate *	isolate
	)

Pumps the message loop for the given isolate.

The caller has to make sure that this is called from the right thread. Returns true if a task was executed, and false otherwise. This call does not block if no task is pending. The |platform| has to be created using |CreateDefaultPlatform|.

Definition at line 27 of file default-platform.cc.

                                                               {
  return reinterpret_cast<DefaultPlatform*>(platform)->PumpMessageLoop(isolate);
}

TEST() [1/4]

v8::platform::TEST	(	DefaultPlatformTest	,
		PumpMessageLoop
	)

Definition at line 25 of file default-platform-unittest.cc.

                                           {
  InSequence s;
 
  int dummy;
  Isolate* isolate = reinterpret_cast<Isolate*>(&dummy);
 
  DefaultPlatform platform;
  EXPECT_FALSE(platform.PumpMessageLoop(isolate));
 
  StrictMock<MockTask>* task = new StrictMock<MockTask>;
  platform.CallOnForegroundThread(isolate, task);
  EXPECT_CALL(*task, Run());
  EXPECT_CALL(*task, Die());
  EXPECT_TRUE(platform.PumpMessageLoop(isolate));
  EXPECT_FALSE(platform.PumpMessageLoop(isolate));
}

References v8::platform::DefaultPlatform::CallOnForegroundThread(), and v8::platform::DefaultPlatform::PumpMessageLoop().

Here is the call graph for this function:

TEST() [2/4]

v8::platform::TEST	(	TaskQueueTest	,
		Basic
	)

Definition at line 38 of file task-queue-unittest.cc.

                           {
  TaskQueue queue;
  MockTask task;
  queue.Append(&task);
  EXPECT_EQ(&task, queue.GetNext());
  queue.Terminate();
  EXPECT_THAT(queue.GetNext(), IsNull());
}

References v8::platform::TaskQueue::Append(), v8::platform::TaskQueue::GetNext(), and v8::platform::TaskQueue::Terminate().

Here is the call graph for this function:

TEST() [3/4]

v8::platform::TEST	(	TaskQueueTest	,
		TerminateMultipleReaders
	)

Definition at line 48 of file task-queue-unittest.cc.

                                              {
  TaskQueue queue;
  TaskQueueThread thread1(&queue);
  TaskQueueThread thread2(&queue);
  thread1.Start();
  thread2.Start();
  queue.Terminate();
  thread1.Join();
  thread2.Join();
}

References v8::platform::TaskQueue::Terminate().

Here is the call graph for this function:

TEST() [4/4]

v8::platform::TEST	(	WorkerThreadTest	,
		Basic
	)

Definition at line 28 of file worker-thread-unittest.cc.

                              {
  static const size_t kNumTasks = 10;
 
  TaskQueue queue;
  for (size_t i = 0; i < kNumTasks; ++i) {
    InSequence s;
    StrictMock<MockTask>* task = new StrictMock<MockTask>;
    EXPECT_CALL(*task, Run());
    EXPECT_CALL(*task, Die());
    queue.Append(task);
  }
 
  WorkerThread thread1(&queue);
  WorkerThread thread2(&queue);
 
  // TaskQueue DCHECKS that it's empty in its destructor.
  queue.Terminate();
}

References v8::platform::TaskQueue::Append(), and v8::platform::TaskQueue::Terminate().

Here is the call graph for this function: