Commit ea122acccf7b77566640c997bdfed1023e71f163 - mozc

+1

-1

src/base/cpu_stats_main.cc less more

66	66	if (FLAGS_dummy_threads_size > 0) {
67	67	threads.reset(new DummyThread[FLAGS_dummy_threads_size]);
68	68	for (int i = 0; i < FLAGS_dummy_threads_size; ++i) {
69		threads[i].Start();
	69	threads[i].Start("CpuStatsMain");
70	70	}
71	71	}
72	72

+6

-6

src/base/mutex_test.cc less more

81	81	g_counter = 0;
82	82	Mutex mutex;
83	83	MutexTestThread t(&mutex, 1, 1000);
84		t.Start();
	84	t.Start("MutextBasicTest");
85	85
86	86	Util::Sleep(100); // still g_counter is locked
87	87	scoped_lock lockA(&mutex); // get mutex 2nd

100	100	MutexTestSleepThread t(&mutex, 1);
101	101
102	102	EXPECT_TRUE(mutex.TryLock());
103		t.Start();
	103	t.Start("TryLockTest");
104	104	Util::Sleep(100);
105	105	EXPECT_EQ(0, g_counter);
106	106	mutex.Unlock();

110	110	{
111	111	scoped_try_lock lock(&mutex);
112	112	EXPECT_TRUE(lock.locked());
113		t.Start();
	113	t.Start("TryLockTest");
114	114	Util::Sleep(100);
115	115	EXPECT_EQ(1, g_counter);
116	116	}

133	133	uint64 start_sec;
134	134	uint32 start_usec;
135	135	Clock::GetTimeOfDay(&start_sec, &start_usec);
136		t.Start();
	136	t.Start("TryLockTest");
137	137
138	138	Util::Sleep(100);
139	139	EXPECT_EQ(1, g_counter);

164	164	}
165	165
166	166	for (int i = 0; i < kThreadsSize; ++i) {
167		threads[i]->Start();
	167	threads[i]->Start("MutextBatchTest");
168	168	}
169	169
170	170	for (int i = 0; i < kThreadsSize; ++i) {

227	227	}
228	228
229	229	for (size_t i = 0; i < kThreadsSize; ++i) {
230		threads[i]->Start();
	230	threads[i]->Start("ReaderWriterTest");
231	231	}
232	232
233	233	const uint32 kSleepTime = 500; // 500 msec

+1

-1

src/base/scheduler.cc less more

117	117	}
118	118
119	119	void Start() {
120		timer_thread_.Start();
	120	timer_thread_.Start("QueueTimer");
121	121	}
122	122
123	123	private:

+3

-3

src/base/singleton_test.cc less more

95	95	ThreadTest test3;
96	96
97	97	// Create the ThreadInstance simultaneously.
98		test1.Start();
99		test2.Start();
100		test3.Start();
	98	test1.Start("ThreadTest");
	99	test2.Start("ThreadTest");
	100	test3.Start("ThreadTest");
101	101
102	102	test1.Join();
103	103	test2.Join();

+11

-2

src/base/thread.cc less more

64	64	bool joinable_;
65	65	};
66	66
67		void Thread::Start() {
	67	void Thread::Start(const string &thread_name) {
	68	// TODO(mozc-dev): Set thread name.
68	69	if (IsRunning()) {
69	70	return;
70	71	}

126	127	bool joinable_;
127	128	};
128	129
129		void Thread::Start() {
	130	void Thread::Start(const string &thread_name) {
130	131	if (IsRunning()) {
131	132	return;
132	133	}

138	139	static_cast<void *>(this))) {
139	140	state_->is_running_ = false;
140	141	state_->handle_.reset();
	142	} else {
	143	#if defined(OS_NACL)
	144	// NaCl doesn't support setname.
	145	#elif defined(OS_MACOSX)
	146	pthread_setname_np(thread_name.c_str());
	147	#else // !(OS_NACL \| OS_MACOSX)
	148	pthread_setname_np(*state_->handle_, thread_name.c_str());
	149	#endif // !(OS_NACL \| OS_MACOSX)
141	150	}
142	151	}
143	152

+2

-1

src/base/thread.h less more

30	30	#define MOZC_BASE_THREAD_H_
31	31
32	32	#include <memory>
	33	#include <string>
33	34
34	35	#include "base/port.h"
35	36

44	45
45	46	virtual void Run() = 0;
46	47
47		void Start();
	48	void Start(const string &thread_name);
48	49	bool IsRunning() const;
49	50	void SetJoinable(bool joinable);
50	51	void Join();

+6

-6

src/base/thread_test.cc less more

61	61	TEST(ThreadTest, BasicThreadTest) {
62	62	{
63	63	TestThread t(1000);
64		t.Start();
	64	t.Start("BasicThreadTest");
65	65	EXPECT_TRUE(t.IsRunning());
66	66	t.Join();
67	67	EXPECT_FALSE(t.IsRunning());

71	71	{
72	72	TestThread t(1000);
73	73	t.clear_invoked();
74		t.Start();
	74	t.Start("BasicThreadTest");
75	75
76	76	Util::Sleep(3000);
77	77	EXPECT_FALSE(t.IsRunning());

81	81
82	82	{
83	83	TestThread t(3000);
84		t.Start();
	84	t.Start("BasicThreadTest");
85	85	Util::Sleep(1000);
86	86	t.Terminate();
87	87	Util::Sleep(100);

93	93	{
94	94	TestThread t(1000);
95	95	t.clear_invoked();
96		t.Start();
	96	t.Start("RestartTest");
97	97	EXPECT_TRUE(t.IsRunning());
98	98	t.Join();
99	99	EXPECT_TRUE(t.invoked());
100	100	EXPECT_FALSE(t.IsRunning());
101	101	t.clear_invoked();
102		t.Start();
	102	t.Start("RestartTest");
103	103	EXPECT_TRUE(t.IsRunning());
104	104	t.Join();
105	105	EXPECT_TRUE(t.invoked());
106	106	EXPECT_FALSE(t.IsRunning());
107	107	t.clear_invoked();
108		t.Start();
	108	t.Start("RestartTest");
109	109	EXPECT_TRUE(t.IsRunning());
110	110	t.Join();
111	111	EXPECT_TRUE(t.invoked());

+4

-4

src/base/unnamed_event_test.cc less more

61	61	UnnamedEvent event;
62	62	EXPECT_TRUE(event.IsAvailable());
63	63	UnnamedEventNotifierThread t(&event, 400);
64		t.Start();
	64	t.Start("UnnamedEventTest");
65	65	EXPECT_FALSE(event.Wait(100));
66	66	EXPECT_FALSE(event.Wait(100));
67	67	EXPECT_TRUE(event.Wait(800));

72	72	UnnamedEvent event;
73	73	EXPECT_TRUE(event.IsAvailable());
74	74	UnnamedEventNotifierThread t(&event, 100);
75		t.Start();
	75	t.Start("UnnamedEventTest");
76	76	EXPECT_TRUE(event.Wait(2000));
77	77	t.Join();
78	78	}

81	81	UnnamedEvent event;
82	82	EXPECT_TRUE(event.IsAvailable());
83	83	UnnamedEventNotifierThread t(&event, 3000);
84		t.Start();
	84	t.Start("UnnamedEventTest");
85	85	EXPECT_FALSE(event.Wait(100));
86	86	EXPECT_FALSE(event.Wait(1000));
87	87	EXPECT_FALSE(event.Wait(1000));

92	92	UnnamedEvent event;
93	93	EXPECT_TRUE(event.IsAvailable());
94	94	UnnamedEventNotifierThread t(&event, 2000);
95		t.Start();
	95	t.Start("UnnamedEventTest");
96	96	EXPECT_FALSE(event.Wait(500));
97	97	EXPECT_FALSE(event.Wait(500));
98	98	EXPECT_TRUE(event.Wait(5000));

+1

-1

src/chrome/nacl/nacl_session_handler.cc less more

437	437	NaclSessionHandlerInstance::NaclSessionHandlerInstance(PP_Instance instance)
438	438	: pp::Instance(instance) {
439	439	mozc_thread_.reset(new MozcSessionHandlerThread(this, &message_queue_));
440		mozc_thread_->Start();
	440	mozc_thread_->Start("NaclSessionHandler");
441	441	}
442	442
443	443	void NaclSessionHandlerInstance::HandleMessage(const pp::Var &var_message) {

+1

-1

src/dictionary/suppression_dictionary_test.cc less more

127	127	DictionaryLoaderThread thread;
128	128
129	129	// Load dictionary in another thread.
130		thread.Start();
	130	thread.Start("SuppressionDictionaryTest");
131	131
132	132	for (int i = 0; i < 100; ++i) {
133	133	const string key = "key" + NumberUtil::SimpleItoa(i);

+2

-2

src/dictionary/user_dictionary.cc less more

225	225	value_ = value;
226	226	pos_ = pos;
227	227	}
228		Start();
	228	Start("UserDictionaryReloader");
229	229	}
230	230
231	231	// When the user dictionary exists AND the modification time has been updated,

245	245	return;
246	246	}
247	247	modified_at_ = modification_time;
248		Start();
	248	Start("UserDictionaryReloader");
249	249	}
250	250
251	251	virtual void Run() {

+1

-1

src/ipc/ipc.cc less more

71	71	if (server_thread_.get() == NULL) {
72	72	server_thread_.reset(new IPCServerThread(this));
73	73	server_thread_->SetJoinable(true);
74		server_thread_->Start();
	74	server_thread_->Start("IPCServer");
75	75	} else {
76	76	LOG(WARNING) << "Another thead is already running";
77	77	}

+2

-2

src/ipc/ipc_main.cc less more

101	101	mozc::EchoServer con(FLAGS_server_address, 10, 1000);
102	102	mozc::EchoServerThread server_thread_main(&con);
103	103	server_thread_main.SetJoinable(true);
104		server_thread_main.Start();
	104	server_thread_main.Start("IpcMain");
105	105
106	106	vector<mozc::MultiConnections> cons(FLAGS_num_threads);
107	107	for (size_t i = 0; i < cons.size(); ++i) {
108	108	cons[i].SetJoinable(true);
109		cons[i].Start();
	109	cons[i].Start("MultiConnections");
110	110	}
111	111	for (size_t i = 0; i < cons.size(); ++i) {
112	112	cons[i].Join();

+2

-2

src/ipc/ipc_path_manager_test.cc less more

96	96
97	97	TEST_F(IPCPathManagerTest, IPCPathManagerTest) {
98	98	CreateThread t;
99		t.Start();
	99	t.Start("IPCPathManagerTest");
100	100	Util::Sleep(1000);
101	101	IPCPathManager *manager =
102	102	IPCPathManager::GetIPCPathManager("test");

123	123	vector<BatchGetPathNameThread *> threads(64);
124	124	for (size_t i = 0; i < threads.size(); ++i) {
125	125	threads[i] = new BatchGetPathNameThread;
126		threads[i]->Start();
	126	threads[i]->Start("IPCPathManagerBatchTest");
127	127	}
128	128	for (size_t i = 0; i < threads.size(); ++i) {
129	129	threads[i]->Join();

+1

-1

src/ipc/ipc_test.cc less more

143	143	cons[i]->SetMachPortManager(&manager);
144	144	#endif
145	145	cons[i]->SetJoinable(true);
146		cons[i]->Start();
	146	cons[i]->Start("IPCTest");
147	147	}
148	148	for (size_t i = 0; i < cons.size(); ++i) {
149	149	cons[i]->Join();

+2

-2

src/ipc/named_event_test.cc less more

104	104
105	105	TEST_F(NamedEventTest, NamedEventBasicTest) {
106	106	NamedEventListenerThread listner(kName, 0, 50, 100);
107		listner.Start();
	107	listner.Start("NamedEventBasicTest");
108	108	Util::Sleep(200);
109	109	NamedEventNotifier notifier(kName);
110	110	ASSERT_TRUE(notifier.IsAvailable());

150	150	vector<std::unique_ptr<NamedEventListenerThread>> listeners(kNumRequests);
151	151	for (size_t i = 0; i < kNumRequests; ++i) {
152	152	listeners[i].reset(new NamedEventListenerThread(kName, 33 * i, 50, 100));
153		listeners[i]->Start();
	153	listeners[i]->Start("NamedEventMultipleListenerTest");
154	154	}
155	155
156	156	Util::Sleep(200);

+2

-2

src/ipc/process_watch_dog.cc less more

55	55	LOG(ERROR) << "::CreateEvent() failed.";
56	56	return;
57	57	}
58		Thread::Start(); // start
	58	Thread::Start("WatchDog"); // start
59	59	}
60	60
61	61	ProcessWatchDog::~ProcessWatchDog() {

219	219	thread_id_(UnknownProcessID),
220	220	is_finished_(false),
221	221	mutex_(new Mutex) {
222		Thread::Start();
	222	Thread::Start("WatchDog");
223	223	}
224	224
225	225	ProcessWatchDog::~ProcessWatchDog() {

+1

-1

src/mozc_version_template.txt less more

0	0	MAJOR=2
1	1	MINOR=17
2		BUILD=2425
	2	BUILD=2426
3	3	REVISION=102
4	4	# NACL_DICTIONARY_VERSION is the target version of the system dictionary to be
5	5	# downloaded by NaCl Mozc.

+2

-2

src/prediction/user_history_predictor.cc less more

469	469	syncer_.reset(new UserHistoryPredictorSyncer(
470	470	this,
471	471	UserHistoryPredictorSyncer::LOAD));
472		syncer_->Start();
	472	syncer_->Start("UserHistoryPredictor:Load");
473	473
474	474	return true;
475	475	}

486	486	syncer_.reset(new UserHistoryPredictorSyncer(
487	487	this,
488	488	UserHistoryPredictorSyncer::SAVE));
489		syncer_->Start();
	489	syncer_->Start("UserHistoryPredictor:Save");
490	490
491	491	return true;
492	492	}

+1

-1

src/renderer/renderer_client.cc less more

124	124	path_ = path;
125	125	disable_renderer_path_check_ = disable_renderer_path_check;
126	126	ipc_client_factory_interface_ = ipc_client_factory_interface;
127		Thread::Start();
	127	Thread::Start("Renderer");
128	128	}
129	129
130	130	void Run() {

+1

-1

src/session/session_handler.cc less more

215	215	bool SessionHandler::StartWatchDog() {
216	216	#ifndef MOZC_DISABLE_SESSION_WATCHDOG
217	217	if (!session_watch_dog_->IsRunning()) {
218		session_watch_dog_->Start();
	218	session_watch_dog_->Start("WatchDog");
219	219	}
220	220	return session_watch_dog_->IsRunning();
221	221	#else // MOZC_DISABLE_SESSION_WATCHDOG

+2

-2

src/session/session_watch_dog_test.cc less more

105	105
106	106	EXPECT_EQ(0, client.GetFunctionCallCount("Cleanup"));
107	107
108		watchdog.Start(); // start
	108	watchdog.Start("SessionWatchDogTest"); // start
109	109
110	110	mozc::Util::Sleep(100);
111	111	EXPECT_TRUE(watchdog.IsRunning());

144	144
145	145	EXPECT_EQ(0, client.GetFunctionCallCount("Cleanup"));
146	146
147		watchdog.Start(); // start
	147	watchdog.Start("SessionWatchDogCPUStatsTest"); // start
148	148
149	149	mozc::Util::Sleep(100);
150	150	EXPECT_TRUE(watchdog.IsRunning());

+1

-1

src/unix/ibus/selection_monitor.cc less more

547	547
548	548	// Implements SelectionMonitorInterface::StartMonitoring.
549	549	virtual void StartMonitoring() {
550		Thread::Start();
	550	Thread::Start("SelectionMonitor");
551	551	}
552	552
553	553	// Implements SelectionMonitorInterface::QueryQuit.