Commit 1ed31197ff736715ce51f0f852625e7fee2d2632 - mozc

+1

-2

src/chrome/nacl/dictionary_downloader.cc less more

32	32
33	33	#include "base/logging.h"
34	34	#include "base/mutex.h"
	35	#include "base/pepper_file_util.h"
35	36	#include "base/port.h"
36		#include "base/pepper_file_util.h"
37		#include "base/scoped_ptr.h"
38	37	#include "base/util.h"
39	38	#include "chrome/nacl/url_loader_util.h"
40	39	#include "net/http_client_pepper.h"

+2

-2

src/chrome/nacl/dictionary_downloader.h less more

29	29	#ifndef MOZC_CHROME_NACL_DICTIONARY_DOWNLOADER_H_
30	30	#define MOZC_CHROME_NACL_DICTIONARY_DOWNLOADER_H_
31	31
	32	#include <memory>
32	33	#include <string>
33	34
34	35	#include "base/port.h"
35		#include "base/scoped_ptr.h"
36	36
37	37	namespace mozc {
38	38	namespace chrome {

66	66
67	67	private:
68	68	class Impl;
69		scoped_ptr<Impl> impl_;
	69	std::unique_ptr<Impl> impl_;
70	70	DISALLOW_COPY_AND_ASSIGN(DictionaryDownloader);
71	71	};
72	72

+9

-8

src/chrome/nacl/nacl_net_test_module.cc less more

26	26	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27	27	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	28
	29	#include <memory>
29	30	#include <string>
30	31
	32	#include "base/number_util.h"
	33	#include "base/pepper_file_util.h"
31	34	#include "base/port.h"
32	35	#include "base/util.h"
33		#include "base/number_util.h"
34		#include "base/pepper_file_util.h"
35	36	#include "chrome/nacl/dictionary_downloader.h"
36	37	#include "net/http_client.h"
37	38	#include "testing/base/public/gunit.h"

92	93
93	94	TEST_F(DictionaryDownloaderTest, SimpleTest) {
94	95	SetRetryTestCounter(0);
95		scoped_ptr<DictionaryDownloader> downloader;
	96	std::unique_ptr<DictionaryDownloader> downloader;
96	97	downloader.reset(new DictionaryDownloader(base_url_, "/test01"));
97	98	downloader->StartDownload();
98	99	while (downloader->GetStatus() != DictionaryDownloader::DOWNLOAD_FINISHED) {

113	114
114	115	TEST_F(DictionaryDownloaderTest, LargeDataTest) {
115	116	SetRetryTestCounter(0);
116		scoped_ptr<DictionaryDownloader> downloader;
	117	std::unique_ptr<DictionaryDownloader> downloader;
117	118	downloader.reset(new DictionaryDownloader(
118	119	base_url_ + "?data=0123456789&times=1000000",
119	120	"/large_data"));

130	131
131	132	TEST_F(DictionaryDownloaderTest, RetryTest) {
132	133	SetRetryTestCounter(-1);
133		scoped_ptr<DictionaryDownloader> downloader;
	134	std::unique_ptr<DictionaryDownloader> downloader;
134	135	downloader.reset(new DictionaryDownloader(base_url_, "/test01"));
135	136	downloader->StartDownload();
136	137	while (downloader->GetStatus() != DictionaryDownloader::DOWNLOAD_ERROR) {

158	159
159	160	TEST_F(DictionaryDownloaderTest, DelayTest) {
160	161	SetRetryTestCounter(0);
161		scoped_ptr<DictionaryDownloader> downloader;
	162	std::unique_ptr<DictionaryDownloader> downloader;
162	163	downloader.reset(new DictionaryDownloader(base_url_, "/test01"));
163	164	downloader->SetOption(1000, 0, 0, 0, 0);
164	165	downloader->StartDownload();

173	174
174	175	TEST_F(DictionaryDownloaderTest, RetryIntervalTest) {
175	176	SetRetryTestCounter(-3);
176		scoped_ptr<DictionaryDownloader> downloader;
	177	std::unique_ptr<DictionaryDownloader> downloader;
177	178	downloader.reset(new DictionaryDownloader(base_url_, "/test01"));
178	179	downloader->SetOption(0, 0, 1000, 0, 3);
179	180	downloader->StartDownload();

197	198	}
198	199
199	200	TEST_F(DictionaryDownloaderTest, RetryIntervalBackOffTest) {
200		scoped_ptr<DictionaryDownloader> downloader;
	201	std::unique_ptr<DictionaryDownloader> downloader;
201	202	SetRetryTestCounter(-3);
202	203	downloader.reset(new DictionaryDownloader(base_url_, "/test01"));
203	204	downloader->SetOption(0, 0, 1000, 1, 3);

+12

-11

src/chrome/nacl/nacl_session_handler.cc less more

33	33	#include <ppapi/cpp/var.h>
34	34	#include <ppapi/utility/completion_callback_factory.h>
35	35
	36	#include <memory>
36	37	#include <queue>
37	38	#include <string>
38	39

238	239
239	240	while (true) {
240	241	bool stopped = false;
241		scoped_ptr<Json::Value> message;
	242	std::unique_ptr<Json::Value> message;
242	243	message.reset(message_queue_->take(&stopped));
243	244	if (stopped) {
244	245	LOG(ERROR) << " message_queue_ stopped";

301	302	LOG(ERROR) << "PepperFileUtil::ReadBinaryFile error";
302	303	return false;
303	304	}
304		scoped_ptr<mozc::packed::PackedDataManager>
	305	std::unique_ptr<mozc::packed::PackedDataManager>
305	306	data_manager(new mozc::packed::PackedDataManager());
306	307	if (!data_manager->InitWithZippedData(buffer)) {
307	308	LOG(ERROR) << "InitWithZippedData error";

339	340	const string data_file_name = "./zipped_data_oss";
340	341	#endif // GOOGLE_JAPANESE_INPUT_BUILD
341	342	CHECK(HTTPClient::Get(data_file_name, option, &output));
342		scoped_ptr<mozc::packed::PackedDataManager>
	343	std::unique_ptr<mozc::packed::PackedDataManager>
343	344	data_manager(new mozc::packed::PackedDataManager());
344	345	CHECK(data_manager->InitWithZippedData(output));
345	346	mozc::packed::RegisterPackedDataManager(data_manager.release());

404	405	pp::Instance *instance_;
405	406	BlockingQueue<Json::Value > message_queue_;
406	407	pp::CompletionCallbackFactory<MozcSessionHandlerThread> factory_;
407		scoped_ptr<EngineInterface> engine_;
408		scoped_ptr<SessionHandlerInterface> handler_;
409		scoped_ptr<const UserPOSInterface> user_pos_;
410		#ifdef GOOGLE_JAPANESE_INPUT_BUILD
411		scoped_ptr<SessionUsageObserver> usage_observer_;
412		scoped_ptr<chrome::nacl::DictionaryDownloader> downloader_;
	408	std::unique_ptr<EngineInterface> engine_;
	409	std::unique_ptr<SessionHandlerInterface> handler_;
	410	std::unique_ptr<const UserPOSInterface> user_pos_;
	411	#ifdef GOOGLE_JAPANESE_INPUT_BUILD
	412	std::unique_ptr<SessionUsageObserver> usage_observer_;
	413	std::unique_ptr<chrome::nacl::DictionaryDownloader> downloader_;
413	414	string big_dictionary_version_;
414	415	#endif // GOOGLE_JAPANESE_INPUT_BUILD
415	416	DISALLOW_COPY_AND_ASSIGN(MozcSessionHandlerThread);

424	425	private:
425	426	void CheckStatusAndStartMozcSessionHandlerThread();
426	427
427		scoped_ptr<MozcSessionHandlerThread> mozc_thread_;
	428	std::unique_ptr<MozcSessionHandlerThread> mozc_thread_;
428	429	BlockingQueue<Json::Value *> message_queue_;
429	430
430	431	DISALLOW_COPY_AND_ASSIGN(NaclSessionHandlerInstance);

441	442	return;
442	443	}
443	444
444		scoped_ptr<Json::Value> message(new Json::Value);
	445	std::unique_ptr<Json::Value> message(new Json::Value);
445	446	if (Json::Reader().parse(var_message.AsString(), *message.get())) {
446	447	message_queue_.put(message.release());
447	448	}

+0

-1

src/chrome/nacl/url_loader_util.cc less more

43	43
44	44	#include "base/logging.h"
45	45	#include "base/port.h"
46		#include "base/scoped_ptr.h"
47	46
48	47	using std::unique_ptr;
49	48

+3

-2

src/client/client.cc less more

38	38	#endif // OS_WIN
39	39
40	40	#include <cstddef>
	41	#include <memory>
41	42
42	43	#include "base/const.h"
43	44	#include "base/file_stream.h"

552	553	input.set_type(commands::Input::NO_OPERATION);
553	554
554	555	// Call IPC
555		scoped_ptr<IPCClientInterface> client(
	556	std::unique_ptr<IPCClientInterface> client(
556	557	client_factory_->NewClient(kServerAddress,
557	558	server_launcher_->server_program()));
558	559

623	624	input.SerializeToString(&request);
624	625
625	626	// Call IPC
626		scoped_ptr<IPCClientInterface> client(
	627	std::unique_ptr<IPCClientInterface> client(
627	628	client_factory_->NewClient(kServerAddress,
628	629	server_launcher_->server_program()));
629	630

+5

-4

src/client/client.h less more

31	31	#ifndef MOZC_CLIENT_CLIENT_H_
32	32	#define MOZC_CLIENT_CLIENT_H_
33	33
	34	#include <memory>
34	35	#include <string>
35	36	#include <vector>
	37
36	38	#include "base/port.h"
37		#include "base/scoped_ptr.h"
38	39	#include "client/client_interface.h"
39	40	#include "protocol/commands.pb.h"
40	41	#include "testing/base/public/gunit_prod.h"

241	242
242	243	uint64 id_;
243	244	IPCClientFactoryInterface *client_factory_;
244		scoped_ptr<ServerLauncherInterface> server_launcher_;
245		scoped_ptr<char[]> result_;
246		scoped_ptr<config::Config> preferences_;
	245	std::unique_ptr<ServerLauncherInterface> server_launcher_;
	246	std::unique_ptr<char[]> result_;
	247	std::unique_ptr<config::Config> preferences_;
247	248	int timeout_;
248	249	ServerStatus server_status_;
249	250	uint32 server_protocol_version_;

+3

-2

src/client/client_scenario_test_main.cc less more

31	31	// events specified by FLAGS_input file or interactive standard input. Input
32	32	// file format is same as one of session/session_client_main.
33	33
	34	#include <memory>
34	35	#include <string>
35	36	#include <vector>
36	37

99	100	CHECK(client.EnsureSession()) << "EnsureSession failed";
100	101	CHECK(client.NoOperation()) << "Server is not responding";
101	102
102		scoped_ptr<mozc::renderer::RendererClient> renderer_client;
	103	std::unique_ptr<mozc::renderer::RendererClient> renderer_client;
103	104	mozc::commands::RendererCommand renderer_command;
104	105
105	106	if (FLAGS_test_renderer) {

174	175	mozc::SystemUtil::SetUserProfileDirectory(FLAGS_profile_dir);
175	176	}
176	177
177		scoped_ptr<mozc::InputFileStream> input_file;
	178	std::unique_ptr<mozc::InputFileStream> input_file;
178	179	istream *input = NULL;
179	180
180	181	if (!FLAGS_input.empty()) {

+3

-2

src/client/client_stress_test_main.cc less more

35	35	#include <unistd.h>
36	36	#endif // OS_WIN
37	37
	38	#include <memory>
	39
38	40	#include "base/file_stream.h"
39	41	#include "base/flags.h"
40	42	#include "base/logging.h"
41	43	#include "base/port.h"
42		#include "base/scoped_ptr.h"
43	44	#include "base/util.h"
44	45	#include "protocol/renderer_command.pb.h"
45	46	#include "renderer/renderer_client.h"

72	73	CHECK(client.EnsureSession()) << "EnsureSession failed";
73	74	CHECK(client.NoOperation()) << "Server is not respoinding";
74	75
75		scoped_ptr<mozc::renderer::RendererClient> renderer_client;
	76	std::unique_ptr<mozc::renderer::RendererClient> renderer_client;
76	77	mozc::commands::RendererCommand renderer_command;
77	78
78	79	if (FLAGS_test_renderer) {

+6

-5

src/client/client_test.cc less more

29	29	#include "client/client.h"
30	30
31	31	#include <map>
	32	#include <memory>
32	33	#include <string>
33	34
34	35	#include "base/logging.h"

219	220	return client_->EnsureConnection();
220	221	}
221	222
222		scoped_ptr<IPCClientFactoryMock> client_factory_;
223		scoped_ptr<Client> client_;
	223	std::unique_ptr<IPCClientFactoryMock> client_factory_;
	224	std::unique_ptr<Client> client_;
224	225	TestServerLauncher *server_launcher_;
225	226	int version_diff_;
226	227

770	771	ipc_client_factory_->SetMockResponse(response);
771	772	}
772	773
773		scoped_ptr<IPCClientFactoryMock> ipc_client_factory_;
774		scoped_ptr<IPCClientMock> ipc_client_;
775		scoped_ptr<Client> client_;
	774	std::unique_ptr<IPCClientFactoryMock> ipc_client_factory_;
	775	std::unique_ptr<IPCClientMock> ipc_client_;
	776	std::unique_ptr<Client> client_;
776	777	SessionPlaybackTestServerLauncher *server_launcher_;
777	778
778	779	private:

+2

-2

src/composer/composer.h less more

31	31	#ifndef MOZC_COMPOSER_COMPOSER_H_
32	32	#define MOZC_COMPOSER_COMPOSER_H_
33	33
	34	#include <memory>
34	35	#include <set>
35	36	#include <string>
36	37	#include <vector>
37	38
38	39	#include "base/port.h"
39	40	#include "base/protobuf/repeated_field.h"
40		#include "base/scoped_ptr.h"
41	41	#include "composer/internal/typing_corrector.h"
42	42	#include "composer/internal/transliterators.h"
43	43	#include "composer/type_corrected_query.h"

259	259	commands::Context::InputFieldType input_field_type_;
260	260
261	261	size_t shifted_sequence_count_;
262		scoped_ptr<CompositionInterface> composition_;
	262	std::unique_ptr<CompositionInterface> composition_;
263	263
264	264	TypingCorrector typing_corrector_;
265	265

+2

-2

src/composer/composer_main.cc less more

29	29	#include "composer/composer.h"
30	30
31	31	#include <iostream> // NOLINT
	32	#include <memory>
32	33	#include <string>
33	34
34	35	#include "base/flags.h"
35		#include "base/scoped_ptr.h"
36	36	#include "composer/composition_interface.h"
37	37	#include "composer/table.h"
38	38	#include "protocol/commands.pb.h"

48	48
49	49	mozc::composer::Table table;
50	50	table.LoadFromFile(FLAGS_table.c_str());
51		scoped_ptr<mozc::composer::Composer> composer(
	51	std::unique_ptr<mozc::composer::Composer> composer(
52	52	new mozc::composer::Composer(&table, &Request::default_instance()));
53	53
54	54	string command;

+7

-6

src/composer/composer_test.cc less more

28	28
29	29	#include "composer/composer.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33	#include <utility>
33	34	#include <vector>

147	148	ConfigHandler::SetConfig(config);
148	149	}
149	150
150		scoped_ptr<Composer> composer_;
151		scoped_ptr<Table> table_;
152		scoped_ptr<Request> default_request_;
	151	std::unique_ptr<Composer> composer_;
	152	std::unique_ptr<Table> table_;
	153	std::unique_ptr<Request> default_request_;
153	154
154	155	private:
155	156	DISALLOW_COPY_AND_ASSIGN(ComposerTest);

3340	3341	return queries.empty();
3341	3342	}
3342	3343
3343		scoped_ptr<Request> request_;
3344		scoped_ptr<Composer> composer_;
3345		scoped_ptr<Table> table_;
	3344	std::unique_ptr<Request> request_;
	3345	std::unique_ptr<Composer> composer_;
	3346	std::unique_ptr<Table> table_;
3346	3347	Config config_backup_;
3347	3348	};
3348	3349

+11

-8

src/composer/internal/char_chunk_test.cc less more

27	27	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	28
29	29	#include "composer/internal/char_chunk.h"
	30
	31	#include <memory>
	32
30	33	#include "composer/internal/composition_input.h"
31	34	#include "composer/internal/transliterators.h"
32	35	#include "composer/table.h"

396	399	// Split "mo" to "m" and "o".
397	400	CharChunk *left_chunk_ptr = NULL;
398	401	chunk.SplitChunk(Transliterators::LOCAL, 1, &left_chunk_ptr);
399		scoped_ptr<CharChunk> left_chunk(left_chunk_ptr);
	402	std::unique_ptr<CharChunk> left_chunk(left_chunk_ptr);
400	403
401	404	// The output should be half width "m" rather than full width "ｍ".
402	405	output.clear();

1059	1062
1060	1063	CharChunk *left_new_chunk_ptr = NULL;
1061	1064	chunk.SplitChunk(Transliterators::HIRAGANA, size_t(1), &left_new_chunk_ptr);
1062		scoped_ptr<CharChunk> left_new_chunk(left_new_chunk_ptr);
	1065	std::unique_ptr<CharChunk> left_new_chunk(left_new_chunk_ptr);
1063	1066	{
1064	1067	string result;
1065	1068	chunk.AppendFixedResult(Transliterators::HIRAGANA, &result);

1276	1279	CharChunk *left_chunk_ptr = NULL;
1277	1280	EXPECT_FALSE(chunk.SplitChunk(Transliterators::CONVERSION_STRING,
1278	1281	0, &left_chunk_ptr));
1279		scoped_ptr<CharChunk> left_chunk(left_chunk_ptr);
	1282	std::unique_ptr<CharChunk> left_chunk(left_chunk_ptr);
1280	1283	EXPECT_EQ(4, chunk.GetLength(Transliterators::CONVERSION_STRING));
1281	1284	EXPECT_FALSE(chunk.SplitChunk(Transliterators::CONVERSION_STRING,
1282	1285	4, &left_chunk_ptr));

1291	1294	CharChunk *left_chunk_ptr = NULL;
1292	1295	EXPECT_TRUE(chunk.SplitChunk(Transliterators::CONVERSION_STRING,
1293	1296	1, &left_chunk_ptr));
1294		scoped_ptr<CharChunk> left_chunk(left_chunk_ptr);
	1297	std::unique_ptr<CharChunk> left_chunk(left_chunk_ptr);
1295	1298	EXPECT_EQ("a", left_chunk->conversion());
1296	1299	EXPECT_EQ("bcd", chunk.conversion());
1297	1300	}

1304	1307	CharChunk *left_chunk_ptr = NULL;
1305	1308	EXPECT_TRUE(chunk.SplitChunk(Transliterators::CONVERSION_STRING,
1306	1309	2, &left_chunk_ptr));
1307		scoped_ptr<CharChunk> left_chunk(left_chunk_ptr);
	1310	std::unique_ptr<CharChunk> left_chunk(left_chunk_ptr);
1308	1311	EXPECT_EQ("ab", left_chunk->conversion());
1309	1312	EXPECT_EQ("cd", chunk.conversion());
1310	1313	}

1317	1320	CharChunk *left_chunk_ptr = NULL;
1318	1321	EXPECT_TRUE(chunk.SplitChunk(Transliterators::CONVERSION_STRING,
1319	1322	3, &left_chunk_ptr));
1320		scoped_ptr<CharChunk> left_chunk(left_chunk_ptr);
	1323	std::unique_ptr<CharChunk> left_chunk(left_chunk_ptr);
1321	1324	EXPECT_EQ("abc", left_chunk->conversion());
1322	1325	EXPECT_EQ("d", chunk.conversion());
1323	1326	}

1856	1859	src.ambiguous_ = "ambiguous";
1857	1860	src.attributes_ = NEW_CHUNK;
1858	1861
1859		scoped_ptr<CharChunk> dest(new CharChunk(Transliterators::CONVERSION_STRING,
1860		NULL));
	1862	std::unique_ptr<CharChunk> dest(
	1863	new CharChunk(Transliterators::CONVERSION_STRING, NULL));
1861	1864	EXPECT_FALSE(src.transliterator_ == dest->transliterator_);
1862	1865	EXPECT_FALSE(src.table_ == dest->table_);
1863	1866	EXPECT_NE(src.raw_, dest->raw_);

+3

-1

src/composer/internal/composition.cc less more

28	28
29	29	#include "composer/internal/composition.h"
30	30
	31	#include <memory>
	32
31	33	#include "base/logging.h"
32	34	#include "base/util.h"
33	35	#include "composer/internal/char_chunk.h"

122	124
123	125	CharChunk *left_deleted_chunk_ptr = NULL;
124	126	(*chunk_it)->SplitChunk(Transliterators::LOCAL, 1, &left_deleted_chunk_ptr);
125		scoped_ptr<CharChunk> left_deleted_chunk(left_deleted_chunk_ptr);
	127	std::unique_ptr<CharChunk> left_deleted_chunk(left_deleted_chunk_ptr);
126	128	}
127	129	return new_position;
128	130	}

+11

-11

src/composer/internal/composition_test.cc less more

29	29	#include "composer/internal/composition.h"
30	30
31	31	#include <algorithm>
	32	#include <memory>
32	33	#include <set>
33	34	#include <string>
34	35

40	41
41	42	namespace mozc {
42	43	namespace composer {
43
44	44	namespace {
45	45
46	46	string GetString(const Composition &composition) {

76	76	return pos;
77	77	}
78	78
79		} // anonymous namespace
	79	} // namespace
80	80
81	81	class CompositionTest : public testing::Test {
82	82	protected:

86	86	composition_->SetInputMode(Transliterators::CONVERSION_STRING);
87	87	}
88	88
89		scoped_ptr<Table> table_;
90		scoped_ptr<Composition> composition_;
	89	std::unique_ptr<Table> table_;
	90	std::unique_ptr<Composition> composition_;
91	91	};
92	92
93	93	static int InitComposition(Composition* comp) {

323	323	CharChunk *left_new_chunk_ptr = NULL;
324	324	right_orig_chunk.SplitChunk(Transliterators::RAW_STRING,
325	325	test.position, &left_new_chunk_ptr);
326		scoped_ptr<CharChunk> left_new_chunk(left_new_chunk_ptr);
	326	std::unique_ptr<CharChunk> left_new_chunk(left_new_chunk_ptr);
327	327
328	328	if (left_new_chunk.get() != NULL) {
329	329	EXPECT_EQ(test.expected_left_conversion, left_new_chunk->conversion());

377	377	CharChunk *left_new_chunk_ptr = NULL;
378	378	right_orig_chunk.SplitChunk(Transliterators::CONVERSION_STRING,
379	379	test.position, &left_new_chunk_ptr);
380		scoped_ptr<CharChunk> left_new_chunk(left_new_chunk_ptr);
	380	std::unique_ptr<CharChunk> left_new_chunk(left_new_chunk_ptr);
381	381
382	382	if (left_new_chunk.get() != NULL) {
383	383	EXPECT_EQ(test.expected_left_conversion, left_new_chunk->conversion());

455	455	namespace {
456	456	string GetDeletedString(Transliterators::Transliterator t12r,
457	457	const int position) {
458		scoped_ptr<Table> table(new Table);
459		scoped_ptr<Composition> comp(new Composition(table.get()));
	458	std::unique_ptr<Table> table(new Table);
	459	std::unique_ptr<Composition> comp(new Composition(table.get()));
460	460
461	461	InitComposition(comp.get());
462	462	comp->SetDisplayMode(0, t12r);

584	584	string GetInsertedString(Transliterators::Transliterator t12r,
585	585	const size_t position,
586	586	const string &input) {
587		scoped_ptr<Table> table(new Table);
	587	std::unique_ptr<Table> table(new Table);
588	588	InitTable(table.get());
589		scoped_ptr<Composition> comp(new Composition(table.get()));
	589	std::unique_ptr<Composition> comp(new Composition(table.get()));
590	590	InitComposition(comp.get());
591	591
592	592	comp->SetTable(table.get());

2035	2035	EXPECT_EQ(Transliterators::FULL_KATAKANA, src.input_t12r());
2036	2036	EXPECT_EQ(3, src.chunks().size());
2037	2037
2038		scoped_ptr<Composition> dest(src.CloneImpl());
	2038	std::unique_ptr<Composition> dest(src.CloneImpl());
2039	2039	ASSERT_NE(nullptr, dest.get());
2040	2040	EXPECT_EQ(src.table(), dest->table());
2041	2041	EXPECT_EQ(src.input_t12r(), dest->input_t12r());

+7

-7

src/composer/internal/typing_model.cc less more

29	29	#include "composer/internal/typing_model.h"
30	30
31	31	#include <limits>
	32	#include <memory>
32	33
33	34	#include "base/port.h"
34		#include "base/scoped_ptr.h"
35	35	#include "base/string_piece.h"
36	36
37	37	namespace mozc {
38	38	namespace composer {
39
40	39	namespace {
41	40
42	41	// These header files are automatically generated by gen_typing_model.py.

46	45	#include "composer/internal/typing_model_qwerty_mobile-hiragana.h"
47	46	#include "composer/internal/typing_model_toggle_flick-hiragana.h"
48	47
49		scoped_ptr<TypingModel> g_typing_model_12keys_hiragana;
50		scoped_ptr<TypingModel> g_typing_model_flick_hiragana;
51		scoped_ptr<TypingModel> g_typing_model_godan_hiragana;
52		scoped_ptr<TypingModel> g_typing_model_qwerty_mobile_hiragana;
53		scoped_ptr<TypingModel> g_typing_model_toggle_flick_hiragana;
	48	std::unique_ptr<TypingModel> g_typing_model_12keys_hiragana;
	49	std::unique_ptr<TypingModel> g_typing_model_flick_hiragana;
	50	std::unique_ptr<TypingModel> g_typing_model_godan_hiragana;
	51	std::unique_ptr<TypingModel> g_typing_model_qwerty_mobile_hiragana;
	52	std::unique_ptr<TypingModel> g_typing_model_toggle_flick_hiragana;
	53
54	54	} // namespace
55	55
56	56	const uint8 TypingModel::kNoData = numeric_limits<uint8>::max();

+3

-2

src/composer/internal/typing_model.h less more

29	29	#ifndef MOZC_COMPOSER_INTERNAL_TYPING_MODEL_H_
30	30	#define MOZC_COMPOSER_INTERNAL_TYPING_MODEL_H_
31	31
	32	#include <memory>
	33
32	34	#include "base/port.h"
33		#include "base/scoped_ptr.h"
34	35	#include "base/string_piece.h"
35	36	#include "protocol/commands.pb.h"
36	37	// for FRIEND_TEST()

81	82	size_t GetIndex(StringPiece key) const;
82	83
83	84	// Radix table, needed by GetIndex.
84		scoped_ptr<unsigned char[]> character_to_radix_table_;
	85	std::unique_ptr<unsigned char[]> character_to_radix_table_;
85	86	const size_t characters_size_;
86	87	const uint8 *cost_table_;
87	88	const size_t cost_table_size_;

+4

-3

src/composer/table.cc less more

32	32
33	33	#include <istream> // NOLINT
34	34	#include <map>
	35	#include <memory>
35	36	#include <sstream>
36	37	#include <string>
37	38

40	41	#include "base/hash.h"
41	42	#include "base/logging.h"
42	43	#include "base/port.h"
43		#include "base/scoped_ptr.h"
44	44	#include "base/trie.h"
45	45	#include "base/util.h"
46	46	#include "composer/internal/typing_model.h"

380	380	}
381	381
382	382	bool Table::LoadFromFile(const char *filepath) {
383		scoped_ptr<istream> ifs(ConfigFileStream::LegacyOpen(filepath));
	383	std::unique_ptr<istream> ifs(ConfigFileStream::LegacyOpen(filepath));
384	384	if (ifs.get() == NULL) {
385	385	return false;
386	386	}

650	650	}
651	651	}
652	652
653		scoped_ptr<Table> table(new Table());
	653	std::unique_ptr<Table> table(new Table());
654	654	if (!table->InitializeWithRequestAndConfig(request, config)) {
655	655	return NULL;
656	656	}

659	659	table_map_[hash] = table_to_cache;
660	660	return table_to_cache;
661	661	}
	662
662	663	} // namespace composer
663	664	} // namespace mozc

+3

-2

src/composer/table.h less more

32	32	#define MOZC_COMPOSER_TABLE_H_
33	33
34	34	#include <map>
	35	#include <memory>
35	36	#include <set>
36	37	#include <string>
37	38	#include <vector>
	39
38	40	#include "base/port.h"
39		#include "base/scoped_ptr.h"
40	41	#include "base/trie.h"
41	42
42	43	namespace mozc {

152	153	void ResetEntrySet();
153	154
154	155	typedef Trie<const Entry*> EntryTrie;
155		scoped_ptr<EntryTrie> entries_;
	156	std::unique_ptr<EntryTrie> entries_;
156	157	typedef set<const Entry*> EntrySet;
157	158	EntrySet entry_set_;
158	159

+18

-18

src/converter/candidate_filter_test.cc less more

29	29	#include "converter/candidate_filter.h"
30	30
31	31	#include <climits>
	32	#include <memory>
32	33	#include <string>
33	34	#include <vector>
34	35
35	36	#include "base/freelist.h"
36	37	#include "base/number_util.h"
37	38	#include "base/port.h"
38		#include "base/scoped_ptr.h"
39	39	#include "base/util.h"
40	40	#include "converter/node.h"
41	41	#include "converter/segments.h"

130	130	suggestion_filter_.get());
131	131	}
132	132
133		scoped_ptr<FreeList<Segment::Candidate> > candidate_freelist_;
134		scoped_ptr<FreeList<Node> > node_freelist_;
	133	std::unique_ptr<FreeList<Segment::Candidate> > candidate_freelist_;
	134	std::unique_ptr<FreeList<Node> > node_freelist_;
135	135	const POSMatcher *pos_matcher_;
136	136	SuppressionDictionary suppression_dictionary_;
137		scoped_ptr<SuggestionFilter> suggestion_filter_;
	137	std::unique_ptr<SuggestionFilter> suggestion_filter_;
138	138	};
139	139
140	140	TEST_F(CandidateFilterTest, FilterTest) {
141		scoped_ptr<CandidateFilter> filter(CreateCandidateFilter());
	141	std::unique_ptr<CandidateFilter> filter(CreateCandidateFilter());
142	142	vector<const Node *> n;
143	143
144	144	GetDefaultNodes(&n);

216	216
217	217	TEST_F(CandidateFilterTest, KatakanaT13N) {
218	218	{
219		scoped_ptr<CandidateFilter> filter(CreateCandidateFilter());
	219	std::unique_ptr<CandidateFilter> filter(CreateCandidateFilter());
220	220	vector<const Node *> nodes;
221	221	GetDefaultNodes(&nodes);
222	222	// nodes[0] is KatakanaT13N

238	238	}
239	239	}
240	240	{
241		scoped_ptr<CandidateFilter> filter(CreateCandidateFilter());
	241	std::unique_ptr<CandidateFilter> filter(CreateCandidateFilter());
242	242	vector<const Node *> nodes;
243	243	GetDefaultNodes(&nodes);
244	244	// nodes[1] is KatakanaT13N

258	258	}
259	259	}
260	260	{
261		scoped_ptr<CandidateFilter> filter(CreateCandidateFilter());
	261	std::unique_ptr<CandidateFilter> filter(CreateCandidateFilter());
262	262	vector<const Node *> nodes;
263	263	GetDefaultNodes(&nodes);
264	264	// nodes[1] is not a functional word

289	289	}
290	290
291	291	TEST_F(CandidateFilterTest, IsolatedWord) {
292		scoped_ptr<CandidateFilter> filter(CreateCandidateFilter());
	292	std::unique_ptr<CandidateFilter> filter(CreateCandidateFilter());
293	293	vector<const Node *> nodes;
294	294	Segment::Candidate *c = NewCandidate();
295	295	c->key = "abc";

340	340	}
341	341
342	342	TEST_F(CandidateFilterTest, MayHaveMoreCandidates) {
343		scoped_ptr<CandidateFilter> filter(CreateCandidateFilter());
	343	std::unique_ptr<CandidateFilter> filter(CreateCandidateFilter());
344	344	vector<const Node *> n;
345	345	GetDefaultNodes(&n);
346	346

417	417	}
418	418
419	419	TEST_F(CandidateFilterTest, Regression3437022) {
420		scoped_ptr<SuppressionDictionary> dic(new SuppressionDictionary);
	420	std::unique_ptr<SuppressionDictionary> dic(new SuppressionDictionary);
421	421	const POSMatcher *pos_matcher =
422	422	UserPosManager::GetUserPosManager()->GetPOSMatcher();
423		scoped_ptr<CandidateFilter> filter(
	423	std::unique_ptr<CandidateFilter> filter(
424	424	new CandidateFilter(dic.get(), pos_matcher, suggestion_filter_.get()));
425	425
426	426	vector<const Node *> n;

473	473	}
474	474
475	475	TEST_F(CandidateFilterTest, FilterRealtimeConversionTest) {
476		scoped_ptr<CandidateFilter> filter(CreateCandidateFilter());
	476	std::unique_ptr<CandidateFilter> filter(CreateCandidateFilter());
477	477	vector<const Node *> n;
478	478
479	479	n.clear();

508	508	}
509	509
510	510	TEST_F(CandidateFilterTest, DoNotFilterExchangeableCandidates) {
511		scoped_ptr<CandidateFilter> filter(CreateCandidateFilter());
	511	std::unique_ptr<CandidateFilter> filter(CreateCandidateFilter());
512	512	vector<const Node *> nodes;
513	513
514	514	{

594	594	}
595	595
596	596	TEST_F(CandidateFilterTest, CapabilityOfSuggestionFilter_Conversion) {
597		scoped_ptr<CandidateFilter> filter(CreateCandidateFilter());
	597	std::unique_ptr<CandidateFilter> filter(CreateCandidateFilter());
598	598
599	599	// For Segments::CONVERSION, suggestion filter is not applied.
600	600	{

621	621	}
622	622
623	623	TEST_F(CandidateFilterTest, CapabilityOfSuggestionFilter_Suggestion) {
624		scoped_ptr<CandidateFilter> filter(CreateCandidateFilter());
	624	std::unique_ptr<CandidateFilter> filter(CreateCandidateFilter());
625	625
626	626	// For Segments::SUGGESTION, suggestion filter is applied regardless of its
627	627	// original key length. First test unigram case.

734	734	}
735	735
736	736	TEST_F(CandidateFilterTest, CapabilityOfSuggestionFilter_Prediction) {
737		scoped_ptr<CandidateFilter> filter(CreateCandidateFilter());
	737	std::unique_ptr<CandidateFilter> filter(CreateCandidateFilter());
738	738
739	739	// For Segments::PREDICTION, suggestion filter is applied only when its
740	740	// original key length is equal to the key of predicted node. First test

851	851	}
852	852
853	853	TEST_F(CandidateFilterTest, ReverseConversion) {
854		scoped_ptr<CandidateFilter> filter(CreateCandidateFilter());
	854	std::unique_ptr<CandidateFilter> filter(CreateCandidateFilter());
855	855	vector<const Node *> nodes;
856	856	GetDefaultNodes(&nodes);
857	857

+3

-3

src/converter/connector.h less more

29	29	#ifndef MOZC_CONVERTER_CONNECTOR_H_
30	30	#define MOZC_CONVERTER_CONNECTOR_H_
31	31
	32	#include <memory>
32	33	#include <vector>
33	34
34	35	#include "base/port.h"
35		#include "base/scoped_ptr.h"
36	36
37	37	namespace mozc {
38	38

65	65
66	66	const int cache_size_;
67	67	const uint32 cache_hash_mask_;
68		mutable scoped_ptr<uint32[]> cache_key_;
69		mutable scoped_ptr<int[]> cache_value_;
	68	mutable std::unique_ptr<uint32[]> cache_key_;
	69	mutable std::unique_ptr<int[]> cache_value_;
70	70
71	71	DISALLOW_COPY_AND_ASSIGN(Connector);
72	72	};

+2

-2

src/converter/connector_test.cc less more

29	29	#include "converter/connector.h"
30	30
31	31	#include <algorithm>
	32	#include <memory>
32	33	#include <string>
33	34	#include <vector>
34	35
35	36	#include "base/file_util.h"
36	37	#include "base/mmap.h"
37		#include "base/scoped_ptr.h"
38	38	#include "data_manager/connection_file_reader.h"
39	39	#include "testing/base/public/gunit.h"
40	40

59	59	FLAGS_test_srcdir, kTestConnectionDataImagePath);
60	60	Mmap cmmap;
61	61	ASSERT_TRUE(cmmap.Open(path.c_str())) << "Failed to open image: " << path;
62		scoped_ptr<Connector> connector(
	62	std::unique_ptr<Connector> connector(
63	63	new Connector(cmmap.begin(), cmmap.size(), 256));
64	64	ASSERT_EQ(1, connector->GetResolution());
65	65

+3

-3

src/converter/converter.h less more

29	29	#ifndef MOZC_CONVERTER_CONVERTER_H_
30	30	#define MOZC_CONVERTER_CONVERTER_H_
31	31
	32	#include <memory>
32	33	#include <string>
33	34
34		#include "base/scoped_ptr.h"
35	35	#include "converter/converter_interface.h"
36	36	#include "dictionary/pos_matcher.h"
37	37	#include "dictionary/suppression_dictionary.h"

169	169
170	170	const dictionary::POSMatcher *pos_matcher_;
171	171	const dictionary::SuppressionDictionary *suppression_dictionary_;
172		scoped_ptr<PredictorInterface> predictor_;
173		scoped_ptr<RewriterInterface> rewriter_;
	172	std::unique_ptr<PredictorInterface> predictor_;
	173	std::unique_ptr<RewriterInterface> rewriter_;
174	174	const ImmutableConverterInterface *immutable_converter_;
175	175	uint16 general_noun_id_;
176	176	};

+4

-3

src/converter/converter_main.cc less more

28	28
29	29	#include <iostream>
30	30	#include <map>
	31	#include <memory>
31	32	#include <string>
32	33	#include <vector>
33	34

90	91	return Util::StringPrintf("%s (%d)", pos_string.c_str(), id);
91	92	}
92	93
93		scoped_ptr<InputFileStream> pos_id_;
94		scoped_ptr<internal::PosIdPrinter> pos_id_printer_;
	94	std::unique_ptr<InputFileStream> pos_id_;
	95	std::unique_ptr<internal::PosIdPrinter> pos_id_printer_;
95	96
96	97	friend class Singleton<PosIdPrintUtil>;
97	98	DISALLOW_COPY_AND_ASSIGN(PosIdPrintUtil);

381	382	mozc::SystemUtil::SetUserProfileDirectory(FLAGS_user_profile_dir);
382	383	}
383	384
384		scoped_ptr<mozc::EngineInterface> engine;
	385	std::unique_ptr<mozc::EngineInterface> engine;
385	386	mozc::commands::Request request;
386	387	if (FLAGS_engine == "default") {
387	388	LOG(INFO) << "Using default preference and engine";

+2

-1

src/converter/converter_mock_test.cc less more

26	26	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27	27	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	28
	29	#include <memory>
29	30	#include <string>
30	31
31	32	#include "converter/conversion_request.h"

61	62	}
62	63
63	64	private:
64		scoped_ptr<ConverterMock> mock_;
	65	std::unique_ptr<ConverterMock> mock_;
65	66	};
66	67
67	68	TEST_F(ConverterMockTest, CopySegment) {

+3

-3

src/converter/converter_regression_test.cc less more

26	26	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27	27	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	28
	29	#include <memory>
29	30	#include <string>
30	31
31	32	#include "base/file_util.h"
32		#include "base/scoped_ptr.h"
33	33	#include "base/system_util.h"
34	34	#include "composer/composer.h"
35	35	#include "composer/table.h"

130	130	};
131	131
132	132	TEST_F(ConverterRegressionTest, QueryOfDeathTest) {
133		scoped_ptr<EngineInterface> engine(EngineFactory::Create());
	133	std::unique_ptr<EngineInterface> engine(EngineFactory::Create());
134	134	ConverterInterface *converter = engine->GetConverter();
135	135
136	136	CHECK(converter);

169	169	}
170	170
171	171	TEST_F(ConverterRegressionTest, Regression3323108) {
172		scoped_ptr<EngineInterface> engine(EngineFactory::Create());
	172	std::unique_ptr<EngineInterface> engine(EngineFactory::Create());
173	173	ConverterInterface *converter = engine->GetConverter();
174	174	Segments segments;
175	175

+47

-48

src/converter/converter_test.cc less more

28	28
29	29	#include "converter/converter.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33	#include <vector>
33	34
34	35	#include "base/logging.h"
35	36	#include "base/port.h"
36		#include "base/scoped_ptr.h"
37	37	#include "base/system_util.h"
38	38	#include "base/util.h"
39	39	#include "composer/composer.h"

72	72	#include "protocol/config.pb.h"
73	73	#include "rewriter/rewriter.h"
74	74	#include "rewriter/rewriter_interface.h"
	75	#include "testing/base/public/googletest.h"
75	76	#include "testing/base/public/gunit.h"
76	77	#include "transliteration/transliteration.h"
77	78	#include "usage_stats/usage_stats.h"
78	79	#include "usage_stats/usage_stats_testing_util.h"
79
80		DECLARE_string(test_tmpdir);
81	80
82	81	using mozc::dictionary::DictionaryImpl;
83	82	using mozc::dictionary::DictionaryInterface;

176	175
177	176	// This struct holds resources used by converter.
178	177	struct ConverterAndData {
179		scoped_ptr<DictionaryInterface> user_dictionary;
180		scoped_ptr<SuppressionDictionary> suppression_dictionary;
181		scoped_ptr<DictionaryInterface> suffix_dictionary;
182		scoped_ptr<const Connector> connector;
183		scoped_ptr<const Segmenter> segmenter;
184		scoped_ptr<DictionaryInterface> dictionary;
185		scoped_ptr<const PosGroup> pos_group;
186		scoped_ptr<const SuggestionFilter> suggestion_filter;
187		scoped_ptr<ImmutableConverterInterface> immutable_converter;
188		scoped_ptr<ConverterImpl> converter;
	178	std::unique_ptr<DictionaryInterface> user_dictionary;
	179	std::unique_ptr<SuppressionDictionary> suppression_dictionary;
	180	std::unique_ptr<DictionaryInterface> suffix_dictionary;
	181	std::unique_ptr<const Connector> connector;
	182	std::unique_ptr<const Segmenter> segmenter;
	183	std::unique_ptr<DictionaryInterface> dictionary;
	184	std::unique_ptr<const PosGroup> pos_group;
	185	std::unique_ptr<const SuggestionFilter> suggestion_filter;
	186	std::unique_ptr<ImmutableConverterInterface> immutable_converter;
	187	std::unique_ptr<ConverterImpl> converter;
189	188	};
190	189
191	190	ConverterAndData CreateConverterAndData(RewriterInterface rewriter) {

275	274	// just checking whether this causes segmentation fault or not.
276	275	// TODO(toshiyuki): make dictionary mock and test strictly.
277	276	TEST_F(ConverterTest, CanConvertTest) {
278		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	277	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
279	278	ConverterInterface *converter = engine->GetConverter();
280	279	CHECK(converter);
281	280	{

296	295	string ContextAwareConvert(const string &first_key,
297	296	const string &first_value,
298	297	const string &second_key) {
299		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	298	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
300	299	ConverterInterface *converter = engine->GetConverter();
301	300	CHECK(converter);
302	301

430	429	}
431	430
432	431	TEST_F(ConverterTest, CommitSegmentValue) {
433		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	432	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
434	433	ConverterInterface *converter = engine->GetConverter();
435	434	CHECK(converter);
436	435	Segments segments;

482	481	}
483	482
484	483	TEST_F(ConverterTest, CommitSegments) {
485		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	484	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
486	485	ConverterInterface *converter = engine->GetConverter();
487	486	CHECK(converter);
488	487	Segments segments;

568	567	}
569	568
570	569	TEST_F(ConverterTest, CommitPartialSuggestionSegmentValue) {
571		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	570	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
572	571	ConverterInterface *converter = engine->GetConverter();
573	572	CHECK(converter);
574	573	Segments segments;

614	613	}
615	614
616	615	TEST_F(ConverterTest, CommitPartialSuggestionUsageStats) {
617		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	616	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
618	617	ConverterInterface *converter = engine->GetConverter();
619	618	CHECK(converter);
620	619	Segments segments;

707	706	}
708	707
709	708	TEST_F(ConverterTest, CommitAutoPartialSuggestionUsageStats) {
710		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	709	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
711	710	ConverterInterface *converter = engine->GetConverter();
712	711	CHECK(converter);
713	712	Segments segments;

785	784	}
786	785
787	786	TEST_F(ConverterTest, CandidateKeyTest) {
788		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	787	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
789	788	ConverterInterface *converter = engine->GetConverter();
790	789	CHECK(converter);
791	790	Segments segments;

803	802	}
804	803
805	804	TEST_F(ConverterTest, Regression3437022) {
806		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	805	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
807	806	ConverterInterface *converter = engine->GetConverter();
808	807	Segments segments;
809	808

894	893	"\xE3\x81\xAE\xE3\x81\xA7\xE3\x81\x99"
895	894	};
896	895
897		scoped_ptr<ConverterAndData> converter_and_data(
	896	std::unique_ptr<ConverterAndData> converter_and_data(
898	897	CreateStubbedConverterAndData());
899	898	ConverterImpl *converter = converter_and_data->converter.get();
900	899	for (size_t i = 0; i < arraysize(kTestKeys); ++i) {

933	932
934	933	TEST_F(ConverterTest, Regression3046266) {
935	934	// Shouldn't correct nodes at the beginning of a sentence.
936		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	935	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
937	936	ConverterInterface *converter = engine->GetConverter();
938	937	Segments segments;
939	938

969	968
970	969	TEST_F(ConverterTest, Regression5502496) {
971	970	// Make sure key correction works for the first word of a sentence.
972		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	971	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
973	972	ConverterInterface *converter = engine->GetConverter();
974	973	Segments segments;
975	974

995	994	commands::Request client_request;
996	995	client_request.set_mixed_conversion(true);
997	996
998		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	997	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
999	998	ConverterInterface *converter = engine->GetConverter();
1000	999	CHECK(converter);
1001	1000

1040	1039	}
1041	1040
1042	1041	TEST_F(ConverterTest, StartPartialPrediction) {
1043		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	1042	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
1044	1043	ConverterInterface *converter = engine->GetConverter();
1045	1044	CHECK(converter);
1046	1045	Segments segments;

1058	1057	}
1059	1058
1060	1059	TEST_F(ConverterTest, StartPartialSuggestion) {
1061		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	1060	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
1062	1061	ConverterInterface *converter = engine->GetConverter();
1063	1062	CHECK(converter);
1064	1063	Segments segments;

1076	1075	}
1077	1076
1078	1077	TEST_F(ConverterTest, StartPartialPrediction_mobile) {
1079		scoped_ptr<EngineInterface> engine(CreateEngineWithMobilePredictor());
	1078	std::unique_ptr<EngineInterface> engine(CreateEngineWithMobilePredictor());
1080	1079	ConverterInterface *converter = engine->GetConverter();
1081	1080	CHECK(converter);
1082	1081	Segments segments;

1094	1093	}
1095	1094
1096	1095	TEST_F(ConverterTest, StartPartialSuggestion_mobile) {
1097		scoped_ptr<EngineInterface> engine(CreateEngineWithMobilePredictor());
	1096	std::unique_ptr<EngineInterface> engine(CreateEngineWithMobilePredictor());
1098	1097	ConverterInterface *converter = engine->GetConverter();
1099	1098	CHECK(converter);
1100	1099	Segments segments;

1178	1177	{Segments::PARTIAL_SUGGESTION, kPredictionKey, true},
1179	1178	};
1180	1179
1181		scoped_ptr<ConverterAndData> converter_and_data(
	1180	std::unique_ptr<ConverterAndData> converter_and_data(
1182	1181	CreateStubbedConverterAndData());
1183	1182	ConverterImpl *converter = converter_and_data->converter.get();
1184	1183	ASSERT_NE(nullptr, converter);

1211	1210	TEST_F(ConverterTest, VariantExpansionForSuggestion) {
1212	1211	// Create Converter with mock user dictionary
1213	1212	testing::MockDataManager data_manager;
1214		scoped_ptr<DictionaryMock> mock_user_dictionary(new DictionaryMock);
	1213	std::unique_ptr<DictionaryMock> mock_user_dictionary(new DictionaryMock);
1215	1214
1216	1215	mock_user_dictionary->AddLookupPredictive(
1217	1216	// "てすと"

1227	1226	"\xe3\x81\xa6\xe3\x81\x99\xe3\x81\xa8",
1228	1227	"<>!?",
1229	1228	Token::USER_DICTIONARY);
1230		scoped_ptr<SuppressionDictionary> suppression_dictionary(
	1229	std::unique_ptr<SuppressionDictionary> suppression_dictionary(
1231	1230	new SuppressionDictionary);
1232	1231
1233	1232	const char *dictionary_data = NULL;
1234	1233	int dictionary_size = 0;
1235	1234	data_manager.GetSystemDictionaryData(&dictionary_data, &dictionary_size);
1236	1235
1237		scoped_ptr<DictionaryInterface> dictionary(new DictionaryImpl(
	1236	std::unique_ptr<DictionaryInterface> dictionary(new DictionaryImpl(
1238	1237	SystemDictionary::Builder(dictionary_data, dictionary_size).Build(),
1239	1238	ValueDictionary::CreateValueDictionaryFromImage(
1240	1239	*data_manager.GetPOSMatcher(), dictionary_data, dictionary_size),
1241	1240	mock_user_dictionary.get(),
1242	1241	suppression_dictionary.get(),
1243	1242	data_manager.GetPOSMatcher()));
1244		scoped_ptr<const PosGroup> pos_group(
	1243	std::unique_ptr<const PosGroup> pos_group(
1245	1244	new PosGroup(data_manager.GetPosGroupData()));
1246		scoped_ptr<const DictionaryInterface> suffix_dictionary(
	1245	std::unique_ptr<const DictionaryInterface> suffix_dictionary(
1247	1246	CreateSuffixDictionaryFromDataManager(data_manager));
1248		scoped_ptr<const Connector> connector(
	1247	std::unique_ptr<const Connector> connector(
1249	1248	Connector::CreateFromDataManager(data_manager));
1250		scoped_ptr<const Segmenter> segmenter(
	1249	std::unique_ptr<const Segmenter> segmenter(
1251	1250	Segmenter::CreateFromDataManager(data_manager));
1252		scoped_ptr<const SuggestionFilter> suggestion_filter(
	1251	std::unique_ptr<const SuggestionFilter> suggestion_filter(
1253	1252	CreateSuggestionFilter(data_manager));
1254		scoped_ptr<ImmutableConverterInterface> immutable_converter(
	1253	std::unique_ptr<ImmutableConverterInterface> immutable_converter(
1255	1254	new ImmutableConverterImpl(dictionary.get(),
1256	1255	suffix_dictionary.get(),
1257	1256	suppression_dictionary.get(),

1260	1259	data_manager.GetPOSMatcher(),
1261	1260	pos_group.get(),
1262	1261	suggestion_filter.get()));
1263		scoped_ptr<const SuggestionFilter> suggegstion_filter(
	1262	std::unique_ptr<const SuggestionFilter> suggegstion_filter(
1264	1263	CreateSuggestionFilter(data_manager));
1265		scoped_ptr<ConverterImpl> converter(new ConverterImpl);
	1264	std::unique_ptr<ConverterImpl> converter(new ConverterImpl);
1266	1265	const DictionaryInterface *kNullDictionary = NULL;
1267	1266	converter->Init(data_manager.GetPOSMatcher(),
1268	1267	suppression_dictionary.get(),

1322	1321	}
1323	1322
1324	1323	TEST_F(ConverterTest, ComposerKeySelection) {
1325		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	1324	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
1326	1325	ConverterInterface *converter = engine->GetConverter();
1327	1326	composer::Table table;
1328	1327	{

1353	1352	}
1354	1353
1355	1354	TEST_F(ConverterTest, SuppressionDictionaryForRewriter) {
1356		scoped_ptr<ConverterAndData> ret(
	1355	std::unique_ptr<ConverterAndData> ret(
1357	1356	CreateConverterAndDataWithInsertDummyWordsRewriter());
1358	1357
1359	1358	// Set up suppression dictionary

1381	1380
1382	1381	TEST_F(ConverterTest, EmptyConvertReverse_Issue8661091) {
1383	1382	// This is a test case against b/8661091.
1384		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	1383	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
1385	1384	ConverterInterface *converter = engine->GetConverter();
1386	1385
1387	1386	Segments segments;

1389	1388	}
1390	1389
1391	1390	TEST_F(ConverterTest, StartReverseConversion) {
1392		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	1391	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
1393	1392	const ConverterInterface *converter = engine->GetConverter();
1394	1393
1395	1394	const string kHonKanji = "\xE6\x9C\xAC"; // "本"

1550	1549	}
1551	1550
1552	1551	TEST_F(ConverterTest, GetLastConnectivePart) {
1553		scoped_ptr<ConverterAndData> converter_and_data(
	1552	std::unique_ptr<ConverterAndData> converter_and_data(
1554	1553	CreateStubbedConverterAndData());
1555	1554	ConverterImpl *converter = converter_and_data->converter.get();
1556	1555

1627	1626	}
1628	1627
1629	1628	TEST_F(ConverterTest, ReconstructHistory) {
1630		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	1629	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
1631	1630	ConverterInterface *converter = engine->GetConverter();
1632	1631
1633	1632	// "１０"

+2

-2

src/converter/immutable_converter.cc less more

31	31	#include <algorithm>
32	32	#include <cctype>
33	33	#include <climits>
	34	#include <memory>
34	35	#include <string>
35	36	#include <utility>
36	37	#include <vector>
37	38
38	39	#include "base/logging.h"
39	40	#include "base/port.h"
40		#include "base/scoped_ptr.h"
41	41	#include "base/stl_util.h"
42	42	#include "base/string_piece.h"
43	43	#include "base/util.h"

1580	1580	(segments.request_type() == Segments::CONVERSION);
1581	1581	// Do not use KeyCorrector if user changes the boundary.
1582	1582	// http://b/issue?id=2804996
1583		scoped_ptr<KeyCorrector> key_corrector;
	1583	std::unique_ptr<KeyCorrector> key_corrector;
1584	1584	if (is_conversion && !segments.resized()) {
1585	1585	KeyCorrector::InputMode mode = KeyCorrector::ROMAN;
1586	1586	if (GET_CONFIG(preedit_method) != config::Config::ROMAN) {

+22

-23

src/converter/immutable_converter_test.cc less more

28	28
29	29	#include "converter/immutable_converter.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33	#include <utility>
33	34	#include <vector>
34	35
35	36	#include "base/logging.h"
36	37	#include "base/port.h"
37		#include "base/scoped_ptr.h"
38	38	#include "base/string_piece.h"
39	39	#include "base/system_util.h"
40	40	#include "base/util.h"

58	58	#include "prediction/suggestion_filter.h"
59	59	#include "protocol/commands.pb.h"
60	60	#include "protocol/config.pb.h"
	61	#include "testing/base/public/googletest.h"
61	62	#include "testing/base/public/gunit.h"
62
63		DECLARE_string(test_tmpdir);
64	63
65	64	using mozc::dictionary::DictionaryImpl;
66	65	using mozc::dictionary::DictionaryInterface;

162	161	}
163	162
164	163	private:
165		scoped_ptr<const DataManagerInterface> data_manager_;
166		scoped_ptr<const SuppressionDictionary> suppression_dictionary_;
167		scoped_ptr<const Connector> connector_;
168		scoped_ptr<const Segmenter> segmenter_;
169		scoped_ptr<const DictionaryInterface> suffix_dictionary_;
170		scoped_ptr<const DictionaryInterface> dictionary_;
171		scoped_ptr<const PosGroup> pos_group_;
172		scoped_ptr<const SuggestionFilter> suggestion_filter_;
173		scoped_ptr<ImmutableConverterImpl> immutable_converter_;
	164	std::unique_ptr<const DataManagerInterface> data_manager_;
	165	std::unique_ptr<const SuppressionDictionary> suppression_dictionary_;
	166	std::unique_ptr<const Connector> connector_;
	167	std::unique_ptr<const Segmenter> segmenter_;
	168	std::unique_ptr<const DictionaryInterface> suffix_dictionary_;
	169	std::unique_ptr<const DictionaryInterface> dictionary_;
	170	std::unique_ptr<const PosGroup> pos_group_;
	171	std::unique_ptr<const SuggestionFilter> suggestion_filter_;
	172	std::unique_ptr<ImmutableConverterImpl> immutable_converter_;
174	173	UserDictionaryStub user_dictionary_stub_;
175	174	};
176	175

193	192	};
194	193
195	194	TEST_F(ImmutableConverterTest, KeepKeyForPrediction) {
196		scoped_ptr<MockDataAndImmutableConverter> data_and_converter(
	195	std::unique_ptr<MockDataAndImmutableConverter> data_and_converter(
197	196	new MockDataAndImmutableConverter);
198	197	Segments segments;
199	198	segments.set_request_type(Segments::PREDICTION);

211	210	}
212	211
213	212	TEST_F(ImmutableConverterTest, DummyCandidatesCost) {
214		scoped_ptr<MockDataAndImmutableConverter> data_and_converter(
	213	std::unique_ptr<MockDataAndImmutableConverter> data_and_converter(
215	214	new MockDataAndImmutableConverter);
216	215	Segment segment;
217	216	// "てすと"

223	222	}
224	223
225	224	TEST_F(ImmutableConverterTest, DummyCandidatesInnerSegmentBoundary) {
226		scoped_ptr<MockDataAndImmutableConverter> data_and_converter(
	225	std::unique_ptr<MockDataAndImmutableConverter> data_and_converter(
227	226	new MockDataAndImmutableConverter);
228	227	Segment segment;
229	228	// "てすと"

319	318	// "ないか"
320	319	KeyCheckDictionary *dictionary =
321	320	new KeyCheckDictionary("\xe3\x81\xaa\xe3\x81\x84\xe3\x81\x8b");
322		scoped_ptr<MockDataAndImmutableConverter> data_and_converter(
	321	std::unique_ptr<MockDataAndImmutableConverter> data_and_converter(
323	322	new MockDataAndImmutableConverter(dictionary, dictionary));
324	323	ImmutableConverterImpl *converter = data_and_converter->GetConverter();
325	324	const ConversionRequest request;

348	347	// "しま"
349	348	KeyCheckDictionary *dictionary =
350	349	new KeyCheckDictionary("\xe3\x81\x97\xe3\x81\xbe");
351		scoped_ptr<MockDataAndImmutableConverter> data_and_converter(
	350	std::unique_ptr<MockDataAndImmutableConverter> data_and_converter(
352	351	new MockDataAndImmutableConverter(dictionary, dictionary));
353	352	ImmutableConverterImpl *converter = data_and_converter->GetConverter();
354	353	const ConversionRequest request;

357	356	}
358	357
359	358	TEST_F(ImmutableConverterTest, InnerSegmenBoundaryForPrediction) {
360		scoped_ptr<MockDataAndImmutableConverter> data_and_converter(
	359	std::unique_ptr<MockDataAndImmutableConverter> data_and_converter(
361	360	new MockDataAndImmutableConverter);
362	361	Segments segments;
363	362	segments.set_request_type(Segments::PREDICTION);

410	409	}
411	410
412	411	TEST_F(ImmutableConverterTest, NoInnerSegmenBoundaryForConversion) {
413		scoped_ptr<MockDataAndImmutableConverter> data_and_converter(
	412	std::unique_ptr<MockDataAndImmutableConverter> data_and_converter(
414	413	new MockDataAndImmutableConverter);
415	414	Segments segments;
416	415	segments.set_request_type(Segments::CONVERSION);

431	430	}
432	431
433	432	TEST_F(ImmutableConverterTest, NotConnectedTest) {
434		scoped_ptr<MockDataAndImmutableConverter> data_and_converter(
	433	std::unique_ptr<MockDataAndImmutableConverter> data_and_converter(
435	434	new MockDataAndImmutableConverter);
436	435	ImmutableConverterImpl *converter = data_and_converter->GetConverter();
437	436

522	521
523	522	// Verify that history segments are cleared due to its length limit and at
524	523	// least one candidate is generated.
525		scoped_ptr<MockDataAndImmutableConverter> data_and_converter(
	524	std::unique_ptr<MockDataAndImmutableConverter> data_and_converter(
526	525	new MockDataAndImmutableConverter);
527	526	EXPECT_TRUE(data_and_converter->GetConverter()->Convert(&segments));
528	527	EXPECT_EQ(0, segments.history_segments_size());

533	532
534	533	namespace {
535	534	bool AutoPartialSuggestionTestHelper(const ConversionRequest &request) {
536		scoped_ptr<MockDataAndImmutableConverter> data_and_converter(
	535	std::unique_ptr<MockDataAndImmutableConverter> data_and_converter(
537	536	new MockDataAndImmutableConverter);
538	537	Segments segments;
539	538	segments.set_request_type(Segments::PREDICTION);

591	590	ConversionRequest conversion_request(NULL, &request);
592	591	conversion_request.set_create_partial_candidates(true);
593	592
594		scoped_ptr<MockDataAndImmutableConverter> data_and_converter(
	593	std::unique_ptr<MockDataAndImmutableConverter> data_and_converter(
595	594	new MockDataAndImmutableConverter);
596	595	const string kRequestKeys[] = {
597	596	// "たかまち"

+2

-2

src/converter/lattice.h less more

29	29	#ifndef MOZC_CONVERTER_LATTICE_H_
30	30	#define MOZC_CONVERTER_LATTICE_H_
31	31
	32	#include <memory>
32	33	#include <string>
33	34	#include <vector>
34	35
35	36	#include "base/port.h"
36		#include "base/scoped_ptr.h"
37	37	#include "base/string_piece.h"
38	38	#include "converter/node.h"
39	39	#include "converter/node_allocator.h"

123	123	size_t history_end_pos_;
124	124	vector<Node *> begin_nodes_;
125	125	vector<Node *> end_nodes_;
126		scoped_ptr<NodeAllocator> node_allocator_;
	126	std::unique_ptr<NodeAllocator> node_allocator_;
127	127
128	128	// cache_info_ holds cache information about lookup.
129	129	// If cache_info_[pos] equals to len, it means key.substr(pos, k)

+2

-2

src/converter/nbest_generator.h less more

29	29	#ifndef MOZC_CONVERTER_NBEST_GENERATOR_H_
30	30	#define MOZC_CONVERTER_NBEST_GENERATOR_H_
31	31
	32	#include <memory>
32	33	#include <string>
33	34	#include <vector>
34	35
35	36	#include "base/freelist.h"
36	37	#include "base/port.h"
37		#include "base/scoped_ptr.h"
38	38	#include "converter/candidate_filter.h"
39	39	#include "converter/segments.h"
40	40	#include "dictionary/suppression_dictionary.h"

181	181	Agenda agenda_;
182	182	FreeList<QueueElement> freelist_;
183	183	vector<const Node *> nodes_;
184		scoped_ptr<converter::CandidateFilter> filter_;
	184	std::unique_ptr<converter::CandidateFilter> filter_;
185	185	bool viterbi_result_checked_;
186	186	BoundaryCheckMode check_mode_;
187	187

+17

-18

src/converter/nbest_generator_test.cc less more

28	28
29	29	#include "converter/nbest_generator.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33
33	34	#include "base/logging.h"
34	35	#include "base/port.h"
35		#include "base/scoped_ptr.h"
36	36	#include "base/system_util.h"
37	37	#include "config/config_handler.h"
38	38	#include "converter/connector.h"

53	53	#include "dictionary/user_dictionary_stub.h"
54	54	#include "prediction/suggestion_filter.h"
55	55	#include "protocol/config.pb.h"
	56	#include "testing/base/public/googletest.h"
56	57	#include "testing/base/public/gunit.h"
57
58		DECLARE_string(test_tmpdir);
59	58
60	59	using mozc::dictionary::DictionaryImpl;
61	60	using mozc::dictionary::DictionaryInterface;

144	143	}
145	144
146	145	private:
147		scoped_ptr<const DataManagerInterface> data_manager_;
148		scoped_ptr<const SuppressionDictionary> suppression_dictionary_;
149		scoped_ptr<const Connector> connector_;
150		scoped_ptr<const Segmenter> segmenter_;
151		scoped_ptr<const DictionaryInterface> suffix_dictionary_;
152		scoped_ptr<const DictionaryInterface> dictionary_;
153		scoped_ptr<const PosGroup> pos_group_;
154		scoped_ptr<const SuggestionFilter> suggestion_filter_;
155		scoped_ptr<ImmutableConverterImpl> immutable_converter_;
	146	std::unique_ptr<const DataManagerInterface> data_manager_;
	147	std::unique_ptr<const SuppressionDictionary> suppression_dictionary_;
	148	std::unique_ptr<const Connector> connector_;
	149	std::unique_ptr<const Segmenter> segmenter_;
	150	std::unique_ptr<const DictionaryInterface> suffix_dictionary_;
	151	std::unique_ptr<const DictionaryInterface> dictionary_;
	152	std::unique_ptr<const PosGroup> pos_group_;
	153	std::unique_ptr<const SuggestionFilter> suggestion_filter_;
	154	std::unique_ptr<ImmutableConverterImpl> immutable_converter_;
156	155	UserDictionaryStub user_dictionary_stub_;
157	156	};
158	157

203	202	};
204	203
205	204	TEST_F(NBestGeneratorTest, MultiSegmentConnectionTest) {
206		scoped_ptr<MockDataAndImmutableConverter> data_and_converter(
	205	std::unique_ptr<MockDataAndImmutableConverter> data_and_converter(
207	206	new MockDataAndImmutableConverter);
208	207	ImmutableConverterImpl *converter = data_and_converter->GetConverter();
209	208

232	231	converter->MakeGroup(segments, &group);
233	232	converter->Viterbi(segments, &lattice);
234	233
235		scoped_ptr<NBestGenerator> nbest_generator(
	234	std::unique_ptr<NBestGenerator> nbest_generator(
236	235	data_and_converter->CreateNBestGenerator(&lattice));
237	236
238	237	const bool kSingleSegment = false; // For 'normal' conversion

271	270	}
272	271
273	272	TEST_F(NBestGeneratorTest, SingleSegmentConnectionTest) {
274		scoped_ptr<MockDataAndImmutableConverter> data_and_converter(
	273	std::unique_ptr<MockDataAndImmutableConverter> data_and_converter(
275	274	new MockDataAndImmutableConverter);
276	275	ImmutableConverterImpl *converter = data_and_converter->GetConverter();
277	276

297	296	converter->MakeGroup(segments, &group);
298	297	converter->Viterbi(segments, &lattice);
299	298
300		scoped_ptr<NBestGenerator> nbest_generator(
	299	std::unique_ptr<NBestGenerator> nbest_generator(
301	300	data_and_converter->CreateNBestGenerator(&lattice));
302	301
303	302

334	333	}
335	334
336	335	TEST_F(NBestGeneratorTest, InnerSegmentBoundary) {
337		scoped_ptr<MockDataAndImmutableConverter> data_and_converter(
	336	std::unique_ptr<MockDataAndImmutableConverter> data_and_converter(
338	337	new MockDataAndImmutableConverter);
339	338	ImmutableConverterImpl *converter = data_and_converter->GetConverter();
340	339

360	359	converter->MakeGroup(segments, &group);
361	360	converter->Viterbi(segments, &lattice);
362	361
363		scoped_ptr<NBestGenerator> nbest_generator(
	362	std::unique_ptr<NBestGenerator> nbest_generator(
364	363	data_and_converter->CreateNBestGenerator(&lattice));
365	364
366	365	const bool kSingleSegment = true; // For realtime conversion

+4

-5

src/converter/pos_id_printer_test.cc less more

28	28
29	29	#include "converter/pos_id_printer.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33
33	34	#include "base/file_stream.h"
34	35	#include "base/file_util.h"
35	36	#include "base/flags.h"
36		#include "base/scoped_ptr.h"
	37	#include "testing/base/public/googletest.h"
37	38	#include "testing/base/public/gunit.h"
38
39		DECLARE_string(test_srcdir);
40	39
41	40	namespace mozc {
42	41	namespace internal {

54	53	pos_id_printer_.reset(new PosIdPrinter(pos_id_.get()));
55	54	}
56	55
57		scoped_ptr<InputFileStream> pos_id_;
58		scoped_ptr<PosIdPrinter> pos_id_printer_;
	56	std::unique_ptr<InputFileStream> pos_id_;
	57	std::unique_ptr<PosIdPrinter> pos_id_printer_;
59	58	};
60	59
61	60	TEST_F(PosIdPrinterTest, BasicIdTest) {

+2

-2

src/converter/quality_regression_main.cc less more

27	27	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	28
29	29	#include <iostream> // NOLINT
	30	#include <memory>
30	31	#include <string>
31	32	#include <vector>
32	33
33	34	#include "base/flags.h"
34		#include "base/scoped_ptr.h"
35	35	#include "base/util.h"
36	36	#include "converter/quality_regression_util.h"
37	37	#include "engine/engine_factory.h"

46	46	int main(int argc, char **argv) {
47	47	InitGoogle(argv[0], &argc, &argv, false);
48	48
49		scoped_ptr<EngineInterface> engine(EngineFactory::Create());
	49	std::unique_ptr<EngineInterface> engine(EngineFactory::Create());
50	50	QualityRegressionUtil util(engine->GetConverter());
51	51
52	52	vector<QualityRegressionUtil::TestItem> items;

+5

-3

src/converter/quality_regression_test.cc less more

29	29
30	30	#include <algorithm>
31	31	#include <map>
	32	#include <memory>
32	33	#include <string>
33	34	#include <utility>
34	35	#include <vector>

44	45	#include "protocol/commands.pb.h"
45	46	#include "protocol/config.pb.h"
46	47	#include "session/request_test_util.h"
	48	#include "testing/base/public/googletest.h"
47	49	#include "testing/base/public/gunit.h"
48	50
49		DECLARE_string(test_tmpdir);
	51	using std::unique_ptr;
50	52
51	53	using mozc::quality_regression::QualityRegressionUtil;
52	54

168	170
169	171
170	172	TEST_F(QualityRegressionTest, ChromeOSTest) {
171		scoped_ptr<EngineInterface> chromeos_engine(ChromeOsEngineFactory::Create());
	173	unique_ptr<EngineInterface> chromeos_engine(ChromeOsEngineFactory::Create());
172	174	QualityRegressionUtil util(chromeos_engine->GetConverter());
173	175	RunTestForPlatform(QualityRegressionUtil::CHROMEOS, &util);
174	176	}
175	177
176	178	// Test for desktop
177	179	TEST_F(QualityRegressionTest, BasicTest) {
178		scoped_ptr<EngineInterface> engine(EngineFactory::Create());
	180	unique_ptr<EngineInterface> engine(EngineFactory::Create());
179	181	QualityRegressionUtil util(engine->GetConverter());
180	182	RunTestForPlatform(QualityRegressionUtil::DESKTOP, &util);
181	183	}

+3

-3

src/converter/quality_regression_util.h less more

29	29	#ifndef MOZC_CONVERTER_QUALITY_REGRESSION_UTIL_H_
30	30	#define MOZC_CONVERTER_QUALITY_REGRESSION_UTIL_H_
31	31
	32	#include <memory>
32	33	#include <string>
33	34	#include <vector>
34	35
35	36	#include "base/port.h"
36		#include "base/scoped_ptr.h"
37	37
38	38	namespace mozc {
39	39	class Segments;

84	84
85	85	private:
86	86	ConverterInterface *converter_;
87		scoped_ptr<commands::Request> request_;
88		scoped_ptr<Segments> segments_;
	87	std::unique_ptr<commands::Request> request_;
	88	std::unique_ptr<Segments> segments_;
89	89
90	90	DISALLOW_COPY_AND_ASSIGN(QualityRegressionUtil);
91	91	};

+4

-4

src/converter/segments.h less more

30	30	#define MOZC_CONVERTER_SEGMENTS_H_
31	31
32	32	#include <deque>
	33	#include <memory>
33	34	#include <string>
34	35	#include <utility>
35	36	#include <vector>
36	37
37	38	#include "base/number_util.h"
38	39	#include "base/port.h"
39		#include "base/scoped_ptr.h"
40	40	#include "base/string_piece.h"
41	41	#include "converter/lattice.h"
42	42

339	339	string key_;
340	340	deque<Candidate *> candidates_;
341	341	vector<Candidate> meta_candidates_;
342		scoped_ptr<ObjectPool<Candidate> > pool_;
	342	std::unique_ptr<ObjectPool<Candidate>> pool_;
343	343	DISALLOW_COPY_AND_ASSIGN(Segment);
344	344	};
345	345

480	480	bool user_history_enabled_;
481	481
482	482	RequestType request_type_;
483		scoped_ptr<ObjectPool<Segment> > pool_;
	483	std::unique_ptr<ObjectPool<Segment>> pool_;
484	484	deque<Segment *> segments_;
485	485	vector<RevertEntry> revert_entries_;
486		scoped_ptr<Lattice> cached_lattice_;
	486	std::unique_ptr<Lattice> cached_lattice_;
487	487
488	488	DISALLOW_COPY_AND_ASSIGN(Segments);
489	489	};

+6

-3

src/handwriting/zinnia_handwriting.cc less more

29	29	// Handwriting module using zinnia.
30	30
31	31	#include "handwriting/zinnia_handwriting.h"
	32
	33	#include <memory>
	34	#include <string>
32	35
33	36	#include "base/file_util.h"
34	37	#include "base/logging.h"

103	106	}
104	107
105	108	const int kMaxResultSize = 100;
106		scoped_ptr<zinnia::Result> result(recognizer_->classify(*character_,
107		kMaxResultSize));
108		if (result.get() == NULL) {
	109	std::unique_ptr<zinnia::Result> result(
	110	recognizer_->classify(*character_, kMaxResultSize));
	111	if (result == nullptr) {
109	112	return HANDWRITING_ERROR;
110	113	}
111	114

+4

-4

src/handwriting/zinnia_handwriting.h less more

31	31	#ifndef MOZC_HANDWRITING_ZINNIA_HANDWRITING_H_
32	32	#define MOZC_HANDWRITING_ZINNIA_HANDWRITING_H_
33	33
	34	#include <memory>
34	35	#include <string>
35	36
36	37	#include "base/port.h"
37		#include "base/scoped_ptr.h"
38	38	#include "base/string_piece.h"
39	39	#include "handwriting/handwriting_manager.h"
40	40

58	58	HandwritingStatus Commit(const Strokes &strokes, const string &result);
59	59
60	60	private:
61		scoped_ptr<zinnia::Recognizer> recognizer_;
62		scoped_ptr<zinnia::Character> character_;
63		scoped_ptr<Mmap> mmap_;
	61	std::unique_ptr<zinnia::Recognizer> recognizer_;
	62	std::unique_ptr<zinnia::Character> character_;
	63	std::unique_ptr<Mmap> mmap_;
64	64	bool zinnia_model_error_;
65	65
66	66	DISALLOW_COPY_AND_ASSIGN(ZinniaHandwriting);

+2

-3

src/handwriting/zinnia_handwriting_test.cc less more

30	30
31	31	#include "handwriting/zinnia_handwriting.h"
32	32
	33	#include <memory>
33	34	#include <string>
34	35	#include <vector>
35	36
36	37	#include "base/file_util.h"
37	38	#include "testing/base/public/googletest.h"
38	39	#include "testing/base/public/gunit.h"
39
40		DECLARE_string(test_srcdir);
41	40
42	41	namespace mozc {
43	42	namespace handwriting {

51	50	zinnia_.reset(new ZinniaHandwriting(filepath));
52	51	}
53	52
54		scoped_ptr<ZinniaHandwriting> zinnia_;
	53	std::unique_ptr<ZinniaHandwriting> zinnia_;
55	54	};
56	55
57	56	TEST_F(ZinniaHandwritingTest, Recognize) {

+3

-1

src/mac/main.mm less more

29	29	#import <Carbon/Carbon.h>
30	30	#import <Cocoa/Cocoa.h>
31	31	#import <InputMethodKit/IMKServer.h>
	32
	33	#include <memory>
32	34
33	35	#import "mac/GoogleJapaneseInputController.h"
34	36	#import "mac/GoogleJapaneseInputServer.h"

66	68	// Start the converter server at this time explicitly to prevent the
67	69	// slow-down of the response for initial key event.
68	70	{
69		scoped_ptr<mozc::client::Client> client(new mozc::client::Client);
	71	std::unique_ptr<mozc::client::Client> client(new mozc::client::Client);
70	72	client->PingServer();
71	73	}
72	74	NSApplicationMain(argc, (const char **)argv);

+1

-1

src/mozc_version_template.txt less more

0	0	MAJOR=2
1	1	MINOR=17
2		BUILD=2149
	2	BUILD=2150
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.

+69

-67

src/prediction/dictionary_predictor_test.cc less more

29	29	#include "prediction/dictionary_predictor.h"
30	30
31	31	#include <algorithm>
	32	#include <memory>
32	33	#include <set>
33	34	#include <string>
34	35	#include <utility>

72	73	#include "testing/base/public/gunit.h"
73	74	#include "transliteration/transliteration.h"
74	75
75		using ::testing::_;
	76	using std::unique_ptr;
76	77
77	78	using mozc::dictionary::DictionaryInterface;
78	79	using mozc::dictionary::DictionaryMock;

82	83	using mozc::dictionary::SuffixToken;
83	84	using mozc::dictionary::SuppressionDictionary;
84	85	using mozc::dictionary::Token;
	86	using testing::_;
85	87
86	88	DECLARE_string(test_tmpdir);
87	89	DECLARE_bool(enable_expansion_for_dictionary_predictor);

272	274
273	275	private:
274	276	const POSMatcher *pos_matcher_;
275		scoped_ptr<SuppressionDictionary> suppression_dictionary_;
276		scoped_ptr<const Connector> connector_;
277		scoped_ptr<const Segmenter> segmenter_;
278		scoped_ptr<const DictionaryInterface> suffix_dictionary_;
279		scoped_ptr<const DictionaryInterface> dictionary_;
	277	unique_ptr<SuppressionDictionary> suppression_dictionary_;
	278	unique_ptr<const Connector> connector_;
	279	unique_ptr<const Segmenter> segmenter_;
	280	unique_ptr<const DictionaryInterface> suffix_dictionary_;
	281	unique_ptr<const DictionaryInterface> dictionary_;
280	282	DictionaryMock *dictionary_mock_;
281		scoped_ptr<const PosGroup> pos_group_;
282		scoped_ptr<ImmutableConverterInterface> immutable_converter_;
283		scoped_ptr<ConverterMock> converter_;
284		scoped_ptr<const SuggestionFilter> suggestion_filter_;
285		scoped_ptr<TestableDictionaryPredictor> dictionary_predictor_;
	283	unique_ptr<const PosGroup> pos_group_;
	284	unique_ptr<ImmutableConverterInterface> immutable_converter_;
	285	unique_ptr<ConverterMock> converter_;
	286	unique_ptr<const SuggestionFilter> suggestion_filter_;
	287	unique_ptr<TestableDictionaryPredictor> dictionary_predictor_;
286	288	};
287	289
288	290	class CallCheckDictionary : public DictionaryInterface {

595	597
596	598	composer::Table table;
597	599	table.LoadFromFile("system://romanji-hiragana.tsv");
598		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	600	unique_ptr<MockDataAndPredictor> data_and_predictor(
599	601	new MockDataAndPredictor);
600	602	// CallCheckDictionary is managed by data_and_predictor;
601	603	CallCheckDictionary *check_dictionary = new CallCheckDictionary;

635	637
636	638	composer::Table table;
637	639	table.LoadFromFile("system://romanji-hiragana.tsv");
638		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	640	unique_ptr<MockDataAndPredictor> data_and_predictor(
639	641	new MockDataAndPredictor);
640	642	// CallCheckDictionary is managed by data_and_predictor;
641	643	CallCheckDictionary *check_dictionary = new CallCheckDictionary;

700	702
701	703	composer::Table table;
702	704	table.LoadFromFile("system://romanji-hiragana.tsv");
703		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	705	unique_ptr<MockDataAndPredictor> data_and_predictor(
704	706	new MockDataAndPredictor);
705	707	// CallCheckDictionary is managed by data_and_predictor.
706	708	CallCheckDictionary *check_dictionary = new CallCheckDictionary;

759	761	transliteration::TransliterationType input_mode,
760	762	const char key, const char expected_prefix,
761	763	const char *expected_values[], size_t expected_values_size) {
762		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	764	unique_ptr<MockDataAndPredictor> data_and_predictor(
763	765	CreateDictionaryPredictorWithMockData());
764	766	const TestableDictionaryPredictor *predictor =
765	767	data_and_predictor->dictionary_predictor();

814	816	qwerty_request.set_special_romanji_table(
815	817	commands::Request::QWERTY_MOBILE_TO_HIRAGANA);
816	818
817		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	819	unique_ptr<MockDataAndPredictor> data_and_predictor(
818	820	CreateDictionaryPredictorWithMockData());
819	821	const TestableDictionaryPredictor *predictor =
820	822	data_and_predictor->dictionary_predictor();

852	854	const composer::Composer default_composer_;
853	855	const ConversionRequest default_conversion_request_;
854	856	const bool default_expansion_flag_;
855		scoped_ptr<ImmutableConverterInterface> immutable_converter_;
	857	unique_ptr<ImmutableConverterInterface> immutable_converter_;
856	858	};
857	859
858	860	TEST_F(DictionaryPredictorTest, OnOffTest) {
859		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	861	unique_ptr<MockDataAndPredictor> data_and_predictor(
860	862	CreateDictionaryPredictorWithMockData());
861	863	const DictionaryPredictor *predictor =
862	864	data_and_predictor->dictionary_predictor();

892	894	}
893	895
894	896	TEST_F(DictionaryPredictorTest, PartialSuggestion) {
895		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	897	unique_ptr<MockDataAndPredictor> data_and_predictor(
896	898	CreateDictionaryPredictorWithMockData());
897	899	{
898	900	// Set up mock converter.

940	942	"\xE3\x82\xB0\xE3\x83\xBC\xE3\x82\xB0\xE3\x83\xAB",
941	943	&segments);
942	944
943		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	945	unique_ptr<MockDataAndPredictor> data_and_predictor(
944	946	CreateDictionaryPredictorWithMockData());
945	947	const DictionaryPredictor *predictor =
946	948	data_and_predictor->dictionary_predictor();

966	968	"\xE3\x82\xB0\xE3\x83\xBC\xE3\x82\xB0\xE3\x83\xAB",
967	969	&segments);
968	970
969		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	971	unique_ptr<MockDataAndPredictor> data_and_predictor(
970	972	CreateDictionaryPredictorWithMockData());
971	973	const DictionaryPredictor *predictor =
972	974	data_and_predictor->dictionary_predictor();

989	991	"\xE4\xBA\xAC\xE9\x83\xBD",
990	992	&segments);
991	993
992		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	994	unique_ptr<MockDataAndPredictor> data_and_predictor(
993	995	CreateDictionaryPredictorWithMockData());
994	996	const DictionaryPredictor *predictor =
995	997	data_and_predictor->dictionary_predictor();

1209	1211	commands::Request request;
1210	1212	request.set_zero_query_suggestion(true);
1211	1213
1212		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	1214	unique_ptr<MockDataAndPredictor> data_and_predictor(
1213	1215	CreateDictionaryPredictorWithMockData());
1214	1216	const DictionaryPredictor *predictor =
1215	1217	data_and_predictor->dictionary_predictor();

1331	1333
1332	1334	TEST_F(DictionaryPredictorTest, AggregateUnigramPrediction) {
1333	1335	Segments segments;
1334		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	1336	unique_ptr<MockDataAndPredictor> data_and_predictor(
1335	1337	CreateDictionaryPredictorWithMockData());
1336	1338	const DictionaryPredictor *predictor =
1337	1339	data_and_predictor->dictionary_predictor();

1369	1371	}
1370	1372
1371	1373	TEST_F(DictionaryPredictorTest, AggregateBigramPrediction) {
1372		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	1374	unique_ptr<MockDataAndPredictor> data_and_predictor(
1373	1375	CreateDictionaryPredictorWithMockData());
1374	1376	const DictionaryPredictor *predictor =
1375	1377	data_and_predictor->dictionary_predictor();

1448	1450	}
1449	1451
1450	1452	TEST_F(DictionaryPredictorTest, GetRealtimeCandidateMaxSize) {
1451		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	1453	unique_ptr<MockDataAndPredictor> data_and_predictor(
1452	1454	CreateDictionaryPredictorWithMockData());
1453	1455	const DictionaryPredictor *predictor =
1454	1456	data_and_predictor->dictionary_predictor();

1519	1521	}
1520	1522
1521	1523	TEST_F(DictionaryPredictorTest, GetRealtimeCandidateMaxSizeForMixed) {
1522		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	1524	unique_ptr<MockDataAndPredictor> data_and_predictor(
1523	1525	CreateDictionaryPredictorWithMockData());
1524	1526	const DictionaryPredictor *predictor =
1525	1527	data_and_predictor->dictionary_predictor();

1558	1560
1559	1561	TEST_F(DictionaryPredictorTest, AggregateRealtimeConversion) {
1560	1562	testing::MockDataManager data_manager;
1561		scoped_ptr<const DictionaryInterface> dictionary(new DictionaryMock);
1562		scoped_ptr<ConverterMock> converter(new ConverterMock);
1563		scoped_ptr<ImmutableConverterInterface> immutable_converter(
	1563	unique_ptr<const DictionaryInterface> dictionary(new DictionaryMock);
	1564	unique_ptr<ConverterMock> converter(new ConverterMock);
	1565	unique_ptr<ImmutableConverterInterface> immutable_converter(
1564	1566	new ImmutableConverterMock);
1565		scoped_ptr<const DictionaryInterface> suffix_dictionary(
	1567	unique_ptr<const DictionaryInterface> suffix_dictionary(
1566	1568	CreateSuffixDictionaryFromDataManager(data_manager));
1567		scoped_ptr<const Connector> connector(
	1569	unique_ptr<const Connector> connector(
1568	1570	Connector::CreateFromDataManager(data_manager));
1569		scoped_ptr<const Segmenter> segmenter(
	1571	unique_ptr<const Segmenter> segmenter(
1570	1572	Segmenter::CreateFromDataManager(data_manager));
1571		scoped_ptr<const SuggestionFilter> suggestion_filter(
	1573	unique_ptr<const SuggestionFilter> suggestion_filter(
1572	1574	CreateSuggestionFilter(data_manager));
1573		scoped_ptr<TestableDictionaryPredictor> predictor(
	1575	unique_ptr<TestableDictionaryPredictor> predictor(
1574	1576	new TestableDictionaryPredictor(converter.get(),
1575	1577	immutable_converter.get(),
1576	1578	dictionary.get(),

1750	1752	} // namespace
1751	1753
1752	1754	TEST_F(DictionaryPredictorTest, GetCandidateCutoffThreshold) {
1753		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	1755	unique_ptr<MockDataAndPredictor> data_and_predictor(
1754	1756	CreateDictionaryPredictorWithMockData());
1755	1757	const DictionaryPredictor *predictor =
1756	1758	data_and_predictor->dictionary_predictor();

1767	1769	}
1768	1770
1769	1771	TEST_F(DictionaryPredictorTest, AggregateSuffixPrediction) {
1770		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	1772	unique_ptr<MockDataAndPredictor> data_and_predictor(
1771	1773	new MockDataAndPredictor);
1772	1774	data_and_predictor->Init(NULL, new TestSuffixDictionary());
1773	1775

1950	1952	}
1951	1953
1952	1954	TEST_F(DictionaryPredictorTest, ZeroQuerySuggestionAfterNumbers) {
1953		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	1955	unique_ptr<MockDataAndPredictor> data_and_predictor(
1954	1956	CreateDictionaryPredictorWithMockData());
1955	1957	const DictionaryPredictor *predictor =
1956	1958	data_and_predictor->dictionary_predictor();

2036	2038	}
2037	2039
2038	2040	TEST_F(DictionaryPredictorTest, TriggerNumberZeroQuerySuggestion) {
2039		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	2041	unique_ptr<MockDataAndPredictor> data_and_predictor(
2040	2042	CreateDictionaryPredictorWithMockData());
2041	2043	const DictionaryPredictor *predictor =
2042	2044	data_and_predictor->dictionary_predictor();

2108	2110	}
2109	2111
2110	2112	TEST_F(DictionaryPredictorTest, TriggerZeroQuerySuggestion) {
2111		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	2113	unique_ptr<MockDataAndPredictor> data_and_predictor(
2112	2114	CreateDictionaryPredictorWithMockData());
2113	2115	const DictionaryPredictor *predictor =
2114	2116	data_and_predictor->dictionary_predictor();

2156	2158
2157	2159	TEST_F(DictionaryPredictorTest, GetHistoryKeyAndValue) {
2158	2160	Segments segments;
2159		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	2161	unique_ptr<MockDataAndPredictor> data_and_predictor(
2160	2162	CreateDictionaryPredictorWithMockData());
2161	2163	const DictionaryPredictor *predictor =
2162	2164	data_and_predictor->dictionary_predictor();

2188	2190	}
2189	2191
2190	2192	TEST_F(DictionaryPredictorTest, IsAggressiveSuggestion) {
2191		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	2193	unique_ptr<MockDataAndPredictor> data_and_predictor(
2192	2194	CreateDictionaryPredictorWithMockData());
2193	2195	const DictionaryPredictor *predictor =
2194	2196	data_and_predictor->dictionary_predictor();

2260	2262	config.set_use_realtime_conversion(true);
2261	2263	config::ConfigHandler::SetConfig(config);
2262	2264
2263		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	2265	unique_ptr<MockDataAndPredictor> data_and_predictor(
2264	2266	CreateDictionaryPredictorWithMockData());
2265	2267	const DictionaryPredictor *predictor =
2266	2268	data_and_predictor->dictionary_predictor();

2307	2309	config.set_use_realtime_conversion(true);
2308	2310	config::ConfigHandler::SetConfig(config);
2309	2311
2310		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	2312	unique_ptr<MockDataAndPredictor> data_and_predictor(
2311	2313	CreateDictionaryPredictorWithMockData());
2312	2314	const DictionaryPredictor *predictor =
2313	2315	data_and_predictor->dictionary_predictor();

2363	2365	}
2364	2366
2365	2367	TEST_F(DictionaryPredictorTest, GetMissSpelledPosition) {
2366		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	2368	unique_ptr<MockDataAndPredictor> data_and_predictor(
2367	2369	CreateDictionaryPredictorWithMockData());
2368	2370	const DictionaryPredictor *predictor =
2369	2371	data_and_predictor->dictionary_predictor();

2407	2409	}
2408	2410
2409	2411	TEST_F(DictionaryPredictorTest, RemoveMissSpelledCandidates) {
2410		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	2412	unique_ptr<MockDataAndPredictor> data_and_predictor(
2411	2413	CreateDictionaryPredictorWithMockData());
2412	2414	const DictionaryPredictor *predictor =
2413	2415	data_and_predictor->dictionary_predictor();

2587	2589
2588	2590	composer::Table table;
2589	2591	table.LoadFromFile("system://romanji-hiragana.tsv");
2590		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	2592	unique_ptr<MockDataAndPredictor> data_and_predictor(
2591	2593	CreateDictionaryPredictorWithMockData());
2592	2594	const TestableDictionaryPredictor *predictor =
2593	2595	data_and_predictor->dictionary_predictor();

2667	2669
2668	2670	composer::Table table;
2669	2671	table.LoadFromFile("system://kana.tsv");
2670		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	2672	unique_ptr<MockDataAndPredictor> data_and_predictor(
2671	2673	CreateDictionaryPredictorWithMockData());
2672	2674	const TestableDictionaryPredictor *predictor =
2673	2675	data_and_predictor->dictionary_predictor();

2750	2752	}
2751	2753
2752	2754	TEST_F(DictionaryPredictorTest, SetLMCost) {
2753		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	2755	unique_ptr<MockDataAndPredictor> data_and_predictor(
2754	2756	CreateDictionaryPredictorWithMockData());
2755	2757	const TestableDictionaryPredictor *predictor =
2756	2758	data_and_predictor->dictionary_predictor();

2811	2813	TEST_F(DictionaryPredictorTest, SuggestSpellingCorrection) {
2812	2814	testing::MockDataManager data_manager;
2813	2815
2814		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	2816	unique_ptr<MockDataAndPredictor> data_and_predictor(
2815	2817	new MockDataAndPredictor());
2816	2818	data_and_predictor->Init(CreateSystemDictionaryFromDataManager(data_manager),
2817	2819	CreateSuffixDictionaryFromDataManager(data_manager));

2835	2837	TEST_F(DictionaryPredictorTest, DoNotSuggestSpellingCorrectionBeforeMismatch) {
2836	2838	testing::MockDataManager data_manager;
2837	2839
2838		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	2840	unique_ptr<MockDataAndPredictor> data_and_predictor(
2839	2841	new MockDataAndPredictor());
2840	2842	data_and_predictor->Init(CreateSystemDictionaryFromDataManager(data_manager),
2841	2843	CreateSuffixDictionaryFromDataManager(data_manager));

2859	2861	TEST_F(DictionaryPredictorTest, MobileUnigramSuggestion) {
2860	2862	testing::MockDataManager data_manager;
2861	2863
2862		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	2864	unique_ptr<MockDataAndPredictor> data_and_predictor(
2863	2865	new MockDataAndPredictor());
2864	2866	data_and_predictor->Init(CreateSystemDictionaryFromDataManager(data_manager),
2865	2867	CreateSuffixDictionaryFromDataManager(data_manager));

2900	2902	TEST_F(DictionaryPredictorTest, MobileZeroQuerySuggestion) {
2901	2903	testing::MockDataManager data_manager;
2902	2904
2903		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	2905	unique_ptr<MockDataAndPredictor> data_and_predictor(
2904	2906	new MockDataAndPredictor());
2905	2907	data_and_predictor->Init(CreateSystemDictionaryFromDataManager(data_manager),
2906	2908	CreateSuffixDictionaryFromDataManager(data_manager));

2941	2943	TEST_F(DictionaryPredictorTest, DISABLED_MobileZeroQuerySuggestionAfterEOS) {
2942	2944	testing::MockDataManager data_manager;
2943	2945
2944		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	2946	unique_ptr<MockDataAndPredictor> data_and_predictor(
2945	2947	new MockDataAndPredictor());
2946	2948	data_and_predictor->Init(CreateSystemDictionaryFromDataManager(data_manager),
2947	2949	CreateSuffixDictionaryFromDataManager(data_manager));

3016	3018	}
3017	3019
3018	3020	TEST_F(DictionaryPredictorTest, PropagateUserDictionaryAttribute) {
3019		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	3021	unique_ptr<MockDataAndPredictor> data_and_predictor(
3020	3022	CreateDictionaryPredictorWithMockData());
3021	3023	const DictionaryPredictor *predictor =
3022	3024	data_and_predictor->dictionary_predictor();

3130	3132
3131	3133	TEST_F(DictionaryPredictorTest, PropagateRealtimeConversionBoundary) {
3132	3134	testing::MockDataManager data_manager;
3133		scoped_ptr<const DictionaryInterface> dictionary(new DictionaryMock);
3134		scoped_ptr<ConverterInterface> converter(new ConverterMock);
3135		scoped_ptr<ImmutableConverterInterface> immutable_converter(
	3135	unique_ptr<const DictionaryInterface> dictionary(new DictionaryMock);
	3136	unique_ptr<ConverterInterface> converter(new ConverterMock);
	3137	unique_ptr<ImmutableConverterInterface> immutable_converter(
3136	3138	new ImmutableConverterMock);
3137		scoped_ptr<const DictionaryInterface> suffix_dictionary(
	3139	unique_ptr<const DictionaryInterface> suffix_dictionary(
3138	3140	CreateSuffixDictionaryFromDataManager(data_manager));
3139		scoped_ptr<const Connector> connector(
	3141	unique_ptr<const Connector> connector(
3140	3142	Connector::CreateFromDataManager(data_manager));
3141		scoped_ptr<const Segmenter> segmenter(
	3143	unique_ptr<const Segmenter> segmenter(
3142	3144	Segmenter::CreateFromDataManager(data_manager));
3143		scoped_ptr<const SuggestionFilter> suggestion_filter(
	3145	unique_ptr<const SuggestionFilter> suggestion_filter(
3144	3146	CreateSuggestionFilter(data_manager));
3145		scoped_ptr<TestableDictionaryPredictor> predictor(
	3147	unique_ptr<TestableDictionaryPredictor> predictor(
3146	3148	new TestableDictionaryPredictor(converter.get(),
3147	3149	immutable_converter.get(),
3148	3150	dictionary.get(),

3183	3185	}
3184	3186
3185	3187	TEST_F(DictionaryPredictorTest, PropagateResultCosts) {
3186		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	3188	unique_ptr<MockDataAndPredictor> data_and_predictor(
3187	3189	CreateDictionaryPredictorWithMockData());
3188	3190	const TestableDictionaryPredictor *predictor =
3189	3191	data_and_predictor->dictionary_predictor();

3218	3220	}
3219	3221
3220	3222	TEST_F(DictionaryPredictorTest, PredictNCandidates) {
3221		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	3223	unique_ptr<MockDataAndPredictor> data_and_predictor(
3222	3224	CreateDictionaryPredictorWithMockData());
3223	3225	const TestableDictionaryPredictor *predictor =
3224	3226	data_and_predictor->dictionary_predictor();

3259	3261	}
3260	3262
3261	3263	TEST_F(DictionaryPredictorTest, SuggestFilteredwordForExactMatchOnMobile) {
3262		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	3264	unique_ptr<MockDataAndPredictor> data_and_predictor(
3263	3265	CreateDictionaryPredictorWithMockData());
3264	3266	const TestableDictionaryPredictor *predictor =
3265	3267	data_and_predictor->dictionary_predictor();

3312	3314	}
3313	3315
3314	3316	TEST_F(DictionaryPredictorTest, SuppressFilteredwordForExactMatch) {
3315		scoped_ptr<MockDataAndPredictor> data_and_predictor(
	3317	unique_ptr<MockDataAndPredictor> data_and_predictor(
3316	3318	CreateDictionaryPredictorWithMockData());
3317	3319	const TestableDictionaryPredictor *predictor =
3318	3320	data_and_predictor->dictionary_predictor();

+3

-3

src/prediction/predictor.h less more

29	29	#ifndef MOZC_PREDICTION_PREDICTOR_H_
30	30	#define MOZC_PREDICTION_PREDICTOR_H_
31	31
	32	#include <memory>
32	33	#include <string>
33	34
34		#include "base/scoped_ptr.h"
35	35	#include "converter/conversion_request.h"
36	36	#include "prediction/predictor_interface.h"
37	37

77	77	virtual const string &GetPredictorName() const = 0;
78	78
79	79	protected:
80		scoped_ptr<PredictorInterface> dictionary_predictor_;
81		scoped_ptr<PredictorInterface> user_history_predictor_;
	80	std::unique_ptr<PredictorInterface> dictionary_predictor_;
	81	std::unique_ptr<PredictorInterface> user_history_predictor_;
82	82	};
83	83
84	84	// TODO(team): The name should be DesktopPredictor

+22

-21

src/prediction/predictor_test.cc less more

29	29	#include "prediction/predictor.h"
30	30
31	31	#include <cstddef>
	32	#include <memory>
32	33	#include <string>
33	34
34	35	#include "base/logging.h"

50	51	#include "testing/base/public/googletest.h"
51	52	#include "testing/base/public/gunit.h"
52	53
53		DECLARE_string(test_tmpdir);
54
55		using ::testing::AtMost;
56		using ::testing::Return;
57		using ::testing::_;
	54	using std::unique_ptr;
	55
58	56	using mozc::dictionary::DictionaryMock;
59	57	using mozc::dictionary::SuppressionDictionary;
	58	using testing::AtMost;
	59	using testing::Return;
	60	using testing::_;
60	61
61	62	namespace mozc {
62	63	namespace {

146	147	config::ConfigHandler::SetConfig(config);
147	148	}
148	149
149		scoped_ptr<commands::Request> mobile_client_request_;
150		scoped_ptr<mozc::composer::Composer> mobile_composer_;
151		scoped_ptr<ConversionRequest> default_request_;
152		scoped_ptr<ConversionRequest> mobile_request_;
	150	unique_ptr<commands::Request> mobile_client_request_;
	151	unique_ptr<mozc::composer::Composer> mobile_composer_;
	152	unique_ptr<ConversionRequest> default_request_;
	153	unique_ptr<ConversionRequest> mobile_request_;
153	154	};
154	155
155	156	TEST_F(PredictorTest, AllPredictorsReturnTrue) {
156		scoped_ptr<DefaultPredictor> predictor(
	157	unique_ptr<DefaultPredictor> predictor(
157	158	new DefaultPredictor(new NullPredictor(true),
158	159	new NullPredictor(true)));
159	160	Segments segments;

167	168	}
168	169
169	170	TEST_F(PredictorTest, MixedReturnValue) {
170		scoped_ptr<DefaultPredictor> predictor(
	171	unique_ptr<DefaultPredictor> predictor(
171	172	new DefaultPredictor(new NullPredictor(true),
172	173	new NullPredictor(false)));
173	174	Segments segments;

181	182	}
182	183
183	184	TEST_F(PredictorTest, AllPredictorsReturnFalse) {
184		scoped_ptr<DefaultPredictor> predictor(
	185	unique_ptr<DefaultPredictor> predictor(
185	186	new DefaultPredictor(new NullPredictor(false),
186	187	new NullPredictor(false)));
187	188	Segments segments;

195	196	}
196	197
197	198	TEST_F(PredictorTest, CallPredictorsForSuggestion) {
198		scoped_ptr<DefaultPredictor> predictor(
	199	unique_ptr<DefaultPredictor> predictor(
199	200	new DefaultPredictor(
200	201	new CheckCandSizePredictor(GET_CONFIG(suggestions_size)),
201	202	new CheckCandSizePredictor(GET_CONFIG(suggestions_size))));

211	212
212	213	TEST_F(PredictorTest, CallPredictorsForPrediction) {
213	214	const int kPredictionSize = 100;
214		scoped_ptr<DefaultPredictor> predictor(
	215	unique_ptr<DefaultPredictor> predictor(
215	216	new DefaultPredictor(new CheckCandSizePredictor(kPredictionSize),
216	217	new CheckCandSizePredictor(kPredictionSize)));
217	218	Segments segments;

228	229	// To be owned by DefaultPredictor
229	230	MockPredictor *predictor1 = new MockPredictor;
230	231	MockPredictor *predictor2 = new MockPredictor;
231		scoped_ptr<DefaultPredictor> predictor(new DefaultPredictor(predictor1,
	232	unique_ptr<DefaultPredictor> predictor(new DefaultPredictor(predictor1,
232	233	predictor2));
233	234	Segments segments;
234	235	{

245	246	}
246	247
247	248	TEST_F(PredictorTest, CallPredictorsForMobileSuggestion) {
248		scoped_ptr<MobilePredictor> predictor(
	249	unique_ptr<MobilePredictor> predictor(
249	250	new MobilePredictor(new CheckCandSizePredictor(20),
250	251	new CheckCandSizePredictor(3)));
251	252	Segments segments;

259	260	}
260	261
261	262	TEST_F(PredictorTest, CallPredictorsForMobilePartialSuggestion) {
262		scoped_ptr<MobilePredictor> predictor(
	263	unique_ptr<MobilePredictor> predictor(
263	264	new MobilePredictor(new CheckCandSizePredictor(20),
264	265	// We don't call history predictior
265	266	new CheckCandSizePredictor(-1)));

274	275	}
275	276
276	277	TEST_F(PredictorTest, CallPredictorsForMobilePrediction) {
277		scoped_ptr<MobilePredictor> predictor(
	278	unique_ptr<MobilePredictor> predictor(
278	279	new MobilePredictor(new CheckCandSizePredictor(1000),
279	280	new CheckCandSizePredictor(3)));
280	281	Segments segments;

289	290
290	291	TEST_F(PredictorTest, CallPredictorsForMobilePartialPrediction) {
291	292	DictionaryMock dictionary_mock;
292		scoped_ptr<MobilePredictor> predictor(
	293	unique_ptr<MobilePredictor> predictor(
293	294	new MobilePredictor(
294	295	new CheckCandSizePredictor(1000),
295	296	new UserHistoryPredictor(

311	312	// Will be owned by MobilePredictor
312	313	MockPredictor *predictor1 = new MockPredictor;
313	314	MockPredictor *predictor2 = new MockPredictor;
314		scoped_ptr<MobilePredictor> predictor(
	315	unique_ptr<MobilePredictor> predictor(
315	316	new MobilePredictor(predictor1, predictor2));
316	317	Segments segments;
317	318	{

330	331	TEST_F(PredictorTest, DisableAllSuggestion) {
331	332	NullPredictor *predictor1 = new NullPredictor(true);
332	333	NullPredictor *predictor2 = new NullPredictor(true);
333		scoped_ptr<DefaultPredictor> predictor(new DefaultPredictor(predictor1,
	334	unique_ptr<DefaultPredictor> predictor(new DefaultPredictor(predictor1,
334	335	predictor2));
335	336	Segments segments;
336	337	{

+3

-2

src/prediction/suggestion_filter.h less more

29	29	#ifndef MOZC_PREDICTION_SUGGESTION_FILTER_H_
30	30	#define MOZC_PREDICTION_SUGGESTION_FILTER_H_
31	31
	32	#include <memory>
32	33	#include <string>
33	34
34	35	#include "base/port.h"
35		#include "base/scoped_ptr.h"
36	36
37	37	namespace mozc {
38	38	namespace storage {

48	48	bool IsBadSuggestion(const string &text) const;
49	49
50	50	private:
51		scoped_ptr<mozc::storage::ExistenceFilter> filter_;
	51	std::unique_ptr<mozc::storage::ExistenceFilter> filter_;
52	52
53	53	DISALLOW_COPY_AND_ASSIGN(SuggestionFilter);
54	54	};
	55
55	56	} // namespace mozc
56	57
57	58	#endif // MOZC_PREDICTION_SUGGESTION_FILTER_H_

+6

-3

src/prediction/user_history_predictor.cc less more

31	31	#include <algorithm>
32	32	#include <cctype>
33	33	#include <climits>
	34	#include <memory>
34	35	#include <string>
35	36	#include <unordered_set>
36	37

59	60	#include "storage/lru_cache.h"
60	61	#include "usage_stats/usage_stats.h"
61	62
	63	using std::unique_ptr;
	64	using std::unordered_set;
	65
62	66	using mozc::commands::Request;
63	67	using mozc::dictionary::SuppressionDictionary;
64	68	using mozc::dictionary::DictionaryInterface;
65	69	using mozc::dictionary::POSMatcher;
66		using std::unordered_set;
67	70
68	71	// This flag is set by predictor.cc
69	72	// We can remove this after the ambiguity expansion feature get stable.

1331	1334	// \|input_key\| is "あｋ" and \|base_key\| is "あ"
1332	1335	string input_key;
1333	1336	string base_key;
1334		scoped_ptr<Trie<string> > expanded;
	1337	unique_ptr<Trie<string>> expanded;
1335	1338	GetInputKeyFromSegments(request, segments, &input_key, &base_key, &expanded);
1336	1339
1337	1340	int trial = 0;

1366	1369	void UserHistoryPredictor::GetInputKeyFromSegments(
1367	1370	const ConversionRequest &request, const Segments &segments,
1368	1371	string input_key, string base,
1369		scoped_ptr<Trie<string> > *expanded) {
	1372	unique_ptr<Trie<string>> *expanded) {
1370	1373	DCHECK(input_key);
1371	1374	DCHECK(base);
1372	1375

+5

-5

src/prediction/user_history_predictor.h less more

29	29	#ifndef MOZC_PREDICTION_USER_HISTORY_PREDICTOR_H_
30	30	#define MOZC_PREDICTION_USER_HISTORY_PREDICTOR_H_
31	31
	32	#include <memory>
32	33	#include <queue>
33	34	#include <set>
34	35	#include <string>

36	37	#include <vector>
37	38
38	39	#include "base/freelist.h"
39		#include "base/scoped_ptr.h"
40	40	#include "base/string_piece.h"
41	41	#include "base/trie.h"
42	42	#include "dictionary/dictionary_interface.h"

72	72	bool Save() const;
73	73
74	74	private:
75		scoped_ptr<storage::StringStorageInterface> storage_;
	75	std::unique_ptr<storage::StringStorageInterface> storage_;
76	76	};
77	77
78	78	// UserHistoryPredictor is NOT thread safe.

432	432	static void GetInputKeyFromSegments(
433	433	const ConversionRequest &request, const Segments &segments,
434	434	string input_key, string base,
435		scoped_ptr<Trie<string> >*expanded);
	435	std::unique_ptr<Trie<string>>*expanded);
436	436
437	437	bool InsertCandidates(RequestType request_type,
438	438	const ConversionRequest &request, Segments *segments,

517	517
518	518	bool content_word_learning_enabled_;
519	519	bool updated_;
520		scoped_ptr<DicCache> dic_;
521		mutable scoped_ptr<UserHistoryPredictorSyncer> syncer_;
	520	std::unique_ptr<DicCache> dic_;
	521	mutable std::unique_ptr<UserHistoryPredictorSyncer> syncer_;
522	522	};
523	523
524	524	} // namespace mozc

+40

-38

src/prediction/user_history_predictor_test.cc less more

28	28
29	29	#include "prediction/user_history_predictor.h"
30	30
	31	#include <memory>
31	32	#include <set>
32	33	#include <string>
33	34

52	53	#include "testing/base/public/googletest.h"
53	54	#include "testing/base/public/gunit.h"
54	55
55		DECLARE_string(test_tmpdir);
56	56	DECLARE_bool(enable_expansion_for_user_history_predictor);
	57
	58	using std::unique_ptr;
57	59
58	60	using mozc::commands::Request;
59	61	using mozc::dictionary::DictionaryMock;

301	303
302	304	private:
303	305	struct DataAndPredictor {
304		scoped_ptr<DictionaryMock> dictionary;
305		scoped_ptr<SuppressionDictionary> suppression_dictionary;
306		scoped_ptr<UserHistoryPredictor> predictor;
	306	unique_ptr<DictionaryMock> dictionary;
	307	unique_ptr<SuppressionDictionary> suppression_dictionary;
	308	unique_ptr<UserHistoryPredictor> predictor;
307	309	};
308	310
309	311	DataAndPredictor *CreateDataAndPredictor() const {

322	324	config::Config default_config_;
323	325	const commands::Request default_request_;
324	326	commands::Request mobile_request_;
325		scoped_ptr<ConversionRequest> default_conversion_request_;
326		scoped_ptr<ConversionRequest> mobile_conversion_request_;
	327	unique_ptr<ConversionRequest> default_conversion_request_;
	328	unique_ptr<ConversionRequest> mobile_conversion_request_;
327	329	const bool default_expansion_;
328		scoped_ptr<DataAndPredictor> data_and_predictor_;
	330	unique_ptr<DataAndPredictor> data_and_predictor_;
329	331	};
330	332
331	333	TEST_F(UserHistoryPredictorTest, UserHistoryPredictorTest) {

2876	2878	// input_key: "あｋ"
2877	2879	// key_base: "あ"
2878	2880	// key_expanded: "か","き","く","け", "こ"
2879		scoped_ptr<Trie<string> > expanded(new Trie<string>);
	2881	unique_ptr<Trie<string>> expanded(new Trie<string>);
2880	2882	// "か"
2881	2883	expanded->AddEntry("\xe3\x81\x8b", "");
2882	2884	// "き"

2962	2964	// input_key: "あし"
2963	2965	// key_base: "あ"
2964	2966	// key_expanded: "し","じ"
2965		scoped_ptr<Trie<string> > expanded(new Trie<string>);
	2967	unique_ptr<Trie<string>> expanded(new Trie<string>);
2966	2968	// "し"
2967	2969	expanded->AddEntry("\xe3\x81\x97", "");
2968	2970	// "じ"

3052	3054	// input_key: "あ"
3053	3055	// key_base: "あ"
3054	3056	// key_expanded: "か","き","く","け", "こ"
3055		scoped_ptr<Trie<string> > expanded(new Trie<string>);
	3057	unique_ptr<Trie<string>> expanded(new Trie<string>);
3056	3058	// "か", "か"
3057	3059	expanded->AddEntry("\xe3\x81\x8b", "\xe3\x81\x8b");
3058	3060	// "き", "き"

3127	3129	// input_key: "あし"
3128	3130	// key_base: "あ"
3129	3131	// key_expanded: "し","じ"
3130		scoped_ptr<Trie<string> > expanded(new Trie<string>);
	3132	unique_ptr<Trie<string>> expanded(new Trie<string>);
3131	3133	// "し", "し"
3132	3134	expanded->AddEntry("\xe3\x81\x97", "\xe3\x81\x97");
3133	3135	// "じ", "じ"

3230	3232	} // namespace
3231	3233
3232	3234	TEST_F(UserHistoryPredictorTest, GetInputKeyFromSegmentsRoman) {
3233		scoped_ptr<composer::Table> table(new composer::Table);
	3235	unique_ptr<composer::Table> table(new composer::Table);
3234	3236	table->LoadFromFile("system://romanji-hiragana.tsv");
3235		scoped_ptr<composer::Composer> composer(
	3237	unique_ptr<composer::Composer> composer(
3236	3238	new composer::Composer(table.get(), &default_request()));
3237	3239	ConversionRequest conversion_request;
3238	3240	Segments segments;

3246	3248	FLAGS_enable_expansion_for_user_history_predictor = true;
3247	3249	string input_key;
3248	3250	string base;
3249		scoped_ptr<Trie<string> > expanded;
	3251	unique_ptr<Trie<string>> expanded;
3250	3252	UserHistoryPredictor::GetInputKeyFromSegments(conversion_request,
3251	3253	segments,
3252	3254	&input_key,

3272	3274	FLAGS_enable_expansion_for_user_history_predictor = false;
3273	3275	string input_key;
3274	3276	string base;
3275		scoped_ptr<Trie<string> > expanded;
	3277	unique_ptr<Trie<string>> expanded;
3276	3278	UserHistoryPredictor::GetInputKeyFromSegments(conversion_request,
3277	3279	segments,
3278	3280	&input_key,

3295	3297
3296	3298	TEST_F(UserHistoryPredictorTest, GetInputKeyFromSegmentsRomanRandom) {
3297	3299	FLAGS_enable_expansion_for_user_history_predictor = true;
3298		scoped_ptr<composer::Table> table(new composer::Table);
	3300	unique_ptr<composer::Table> table(new composer::Table);
3299	3301	table->LoadFromFile("system://romanji-hiragana.tsv");
3300		scoped_ptr<composer::Composer> composer(
	3302	unique_ptr<composer::Composer> composer(
3301	3303	new composer::Composer(table.get(), &default_request()));
3302	3304	ConversionRequest conversion_request;
3303	3305	Segments segments;

3317	3319	&segments);
3318	3320	string input_key;
3319	3321	string base;
3320		scoped_ptr<Trie<string> > expanded;
	3322	unique_ptr<Trie<string>> expanded;
3321	3323	UserHistoryPredictor::GetInputKeyFromSegments(conversion_request,
3322	3324	segments,
3323	3325	&input_key,

3330	3332	// input_key != base by compoesr modification.
3331	3333	TEST_F(UserHistoryPredictorTest, GetInputKeyFromSegmentsShouldNotCrash) {
3332	3334	FLAGS_enable_expansion_for_user_history_predictor = true;
3333		scoped_ptr<composer::Table> table(new composer::Table);
	3335	unique_ptr<composer::Table> table(new composer::Table);
3334	3336	table->LoadFromFile("system://romanji-hiragana.tsv");
3335		scoped_ptr<composer::Composer> composer(
	3337	unique_ptr<composer::Composer> composer(
3336	3338	new composer::Composer(table.get(), &default_request()));
3337	3339	ConversionRequest conversion_request;
3338	3340	Segments segments;

3344	3346	&segments);
3345	3347	string input_key;
3346	3348	string base;
3347		scoped_ptr<Trie<string> > expanded;
	3349	unique_ptr<Trie<string>> expanded;
3348	3350	UserHistoryPredictor::GetInputKeyFromSegments(conversion_request,
3349	3351	segments,
3350	3352	&input_key,

3355	3357
3356	3358	TEST_F(UserHistoryPredictorTest, GetInputKeyFromSegmentsRomanN) {
3357	3359	FLAGS_enable_expansion_for_user_history_predictor = true;
3358		scoped_ptr<composer::Table> table(new composer::Table);
	3360	unique_ptr<composer::Table> table(new composer::Table);
3359	3361	table->LoadFromFile("system://romanji-hiragana.tsv");
3360		scoped_ptr<composer::Composer> composer(
	3362	unique_ptr<composer::Composer> composer(
3361	3363	new composer::Composer(table.get(), &default_request()));
3362		scoped_ptr<ConversionRequest> conversion_request;
	3364	unique_ptr<ConversionRequest> conversion_request;
3363	3365	Segments segments;
3364	3366
3365	3367	{

3368	3370	conversion_request.get(), &segments);
3369	3371	string input_key;
3370	3372	string base;
3371		scoped_ptr<Trie<string> > expanded;
	3373	unique_ptr<Trie<string>> expanded;
3372	3374	UserHistoryPredictor::GetInputKeyFromSegments(*conversion_request,
3373	3375	segments,
3374	3376	&input_key,

3397	3399	conversion_request.get(), &segments);
3398	3400	string input_key;
3399	3401	string base;
3400		scoped_ptr<Trie<string> > expanded;
	3402	unique_ptr<Trie<string>> expanded;
3401	3403	UserHistoryPredictor::GetInputKeyFromSegments(*conversion_request,
3402	3404	segments,
3403	3405	&input_key,

3418	3420	conversion_request.get(), &segments);
3419	3421	string input_key;
3420	3422	string base;
3421		scoped_ptr<Trie<string> > expanded;
	3423	unique_ptr<Trie<string>> expanded;
3422	3424	UserHistoryPredictor::GetInputKeyFromSegments(*conversion_request,
3423	3425	segments,
3424	3426	&input_key,

3439	3441	conversion_request.get(), &segments);
3440	3442	string input_key;
3441	3443	string base;
3442		scoped_ptr<Trie<string> > expanded;
	3444	unique_ptr<Trie<string>> expanded;
3443	3445	UserHistoryPredictor::GetInputKeyFromSegments(*conversion_request,
3444	3446	segments,
3445	3447	&input_key,

3464	3466
3465	3467	TEST_F(UserHistoryPredictorTest, GetInputKeyFromSegmentsFlickN) {
3466	3468	FLAGS_enable_expansion_for_user_history_predictor = true;
3467		scoped_ptr<composer::Table> table(new composer::Table);
	3469	unique_ptr<composer::Table> table(new composer::Table);
3468	3470	table->LoadFromFile("system://flick-hiragana.tsv");
3469		scoped_ptr<composer::Composer> composer(
	3471	unique_ptr<composer::Composer> composer(
3470	3472	new composer::Composer(table.get(), &default_request()));
3471	3473	ConversionRequest conversion_request;
3472	3474	Segments segments;

3476	3478	&segments);
3477	3479	string input_key;
3478	3480	string base;
3479		scoped_ptr<Trie<string> > expanded;
	3481	unique_ptr<Trie<string>> expanded;
3480	3482	UserHistoryPredictor::GetInputKeyFromSegments(conversion_request,
3481	3483	segments,
3482	3484	&input_key,

3500	3502
3501	3503	TEST_F(UserHistoryPredictorTest, GetInputKeyFromSegments12KeyN) {
3502	3504	FLAGS_enable_expansion_for_user_history_predictor = true;
3503		scoped_ptr<composer::Table> table(new composer::Table);
	3505	unique_ptr<composer::Table> table(new composer::Table);
3504	3506	table->LoadFromFile("system://12keys-hiragana.tsv");
3505		scoped_ptr<composer::Composer> composer(
	3507	unique_ptr<composer::Composer> composer(
3506	3508	new composer::Composer(table.get(), &default_request()));
3507	3509	ConversionRequest conversion_request;
3508	3510	Segments segments;

3515	3517	&segments);
3516	3518	string input_key;
3517	3519	string base;
3518		scoped_ptr<Trie<string> > expanded;
	3520	unique_ptr<Trie<string>> expanded;
3519	3521	UserHistoryPredictor::GetInputKeyFromSegments(conversion_request,
3520	3522	segments,
3521	3523	&input_key,

3538	3540	}
3539	3541
3540	3542	TEST_F(UserHistoryPredictorTest, GetInputKeyFromSegmentsKana) {
3541		scoped_ptr<composer::Table> table(new composer::Table);
	3543	unique_ptr<composer::Table> table(new composer::Table);
3542	3544	table->LoadFromFile("system://kana.tsv");
3543		scoped_ptr<composer::Composer> composer(
	3545	unique_ptr<composer::Composer> composer(
3544	3546	new composer::Composer(table.get(), &default_request()));
3545	3547	ConversionRequest conversion_request;
3546	3548	Segments segments;

3553	3555	FLAGS_enable_expansion_for_user_history_predictor = true;
3554	3556	string input_key;
3555	3557	string base;
3556		scoped_ptr<Trie<string> > expanded;
	3558	unique_ptr<Trie<string>> expanded;
3557	3559	UserHistoryPredictor::GetInputKeyFromSegments(conversion_request,
3558	3560	segments,
3559	3561	&input_key,

3579	3581	FLAGS_enable_expansion_for_user_history_predictor = false;
3580	3582	string input_key;
3581	3583	string base;
3582		scoped_ptr<Trie<string> > expanded;
	3584	unique_ptr<Trie<string>> expanded;
3583	3585	UserHistoryPredictor::GetInputKeyFromSegments(conversion_request,
3584	3586	segments,
3585	3587	&input_key,

+7

-5

src/renderer/mac/CandidateController.h less more

36	36	namespace mozc {
37	37	namespace client {
38	38	class SendCommandInterface;
39		} // namespace mozc::client
	39	} // namespace client
40	40
41	41	namespace renderer {
42	42	namespace mac {

60	60	// Relocate windows to prevent overlaps.
61	61	void AlignWindows();
62	62
63		// We don't use scoped_ptr<> for those two pointers because we don't
	63	// We don't use std::unique_ptr<> for those two pointers because we don't
64	64	// want to include CandidateWindow.h when the user of this class
65	65	// includes this file. Because CandidateWindow.h and InfolistWindow.h are in
66	66	// Objective-C++, the user file must be .mm files if we use
67		// scoped_ptr<>.
	67	// std::unique_ptr<>.
68	68	CandidateWindow *candidate_window_;
69	69	CandidateWindow *cascading_window_;
70	70	InfolistWindow *infolist_window_;
71	71	mozc::commands::RendererCommand command_;
	72
72	73	DISALLOW_COPY_AND_ASSIGN(CandidateController);
73	74	};
74	75
75		} // namespace mozc::renderer::mac
76		} // namespace mozc::renderer
	76	} // namespace mac
	77	} // namespace renderer
77	78	} // namespace mozc
	79
78	80	#endif // MOZC_RENDERER_MAC_CANDIDATE_CONTROLLER_H_

+10

-5

src/renderer/mac/mac_server.h less more

29	29	#ifndef MOZC_RENDERER_MAC_MAC_SERVER_H_
30	30	#define MOZC_RENDERER_MAC_MAC_SERVER_H_
31	31
	32	#include <pthread.h>
	33
	34	#include <memory>
32	35	#include <string>
33		#include <pthread.h>
34	36
35	37	#include "base/mutex.h"
36	38	#include "base/port.h"

40	42	namespace mozc {
41	43	namespace renderer {
42	44	namespace mac {
	45
43	46	class CandidateController;
44	47
45	48	// This is an implementation class of UI-renderer server based on

48	51	class MacServer : public RendererServer {
49	52	public:
50	53	MacServer(int argc, const char **argv);
	54
51	55	virtual bool AsyncExecCommand(string *proto_message);
52	56	virtual int StartMessageLoop();
53	57

62	66	Mutex mutex_;
63	67	pthread_cond_t event_;
64	68	string message_;
65		scoped_ptr<CandidateController> controller_;
	69	std::unique_ptr<CandidateController> controller_;
66	70	int argc_;
67	71	const char **argv_;
68	72
69	73	DISALLOW_COPY_AND_ASSIGN(MacServer);
70	74	};
71		} // mac
72		} // renderer
73		} // mozc
	75
	76	} // namespace mac
	77	} // namespace renderer
	78	} // namespace mozc
74	79
75	80	#endif // MOZC_RENDERER_MAC_MAC_SERVER_H_

+6

-5

src/renderer/renderer_client.cc less more

28	28
29	29	#include "renderer/renderer_client.h"
30	30
	31	#include <climits>
31	32	#include <cstddef>
32		#include <climits>
	33	#include <memory>
33	34	#include <string>
34	35
35	36	#include "base/clock.h"

278	279	scoped_lock l(&pending_command_mutex_);
279	280	if (ipc_client_factory_interface_ != NULL &&
280	281	pending_command_.get() != NULL) {
281		scoped_ptr<IPCClientInterface> client(CreateIPCClient());
	282	std::unique_ptr<IPCClientInterface> client(CreateIPCClient());
282	283	if (client.get() != NULL) {
283	284	CallCommand(client.get(), *(pending_command_.get()));
284	285	}

310	311	bool disable_renderer_path_check_;
311	312	bool suppress_error_dialog_;
312	313	IPCClientFactoryInterface *ipc_client_factory_interface_;
313		scoped_ptr<commands::RendererCommand> pending_command_;
	314	std::unique_ptr<commands::RendererCommand> pending_command_;
314	315	Mutex pending_command_mutex_;
315	316	};
316	317

371	372	}
372	373
373	374	bool RendererClient::Shutdown(bool force) {
374		scoped_ptr<IPCClientInterface> client(CreateIPCClient());
	375	std::unique_ptr<IPCClientInterface> client(CreateIPCClient());
375	376
376	377	if (client.get() == NULL) {
377	378	LOG(ERROR) << "Cannot make client object";

438	439
439	440	VLOG(2) << "Sending: " << command.DebugString();
440	441
441		scoped_ptr<IPCClientInterface> client(CreateIPCClient());
	442	std::unique_ptr<IPCClientInterface> client(CreateIPCClient());
442	443
443	444	// In case IPCClient::Init fails with timeout error, the last error should be
444	445	// checked here. See also b/3264926.

+7

-4

src/renderer/renderer_client.h less more

29	29	#ifndef MOZC_RENDERER_RENDERER_CLIENT_H_
30	30	#define MOZC_RENDERER_RENDERER_CLIENT_H_
31	31
	32	#include <memory>
32	33	#include <string>
	34
33	35	#include "base/port.h"
34		#include "base/scoped_ptr.h"
35	36	#include "renderer/renderer_interface.h"
36	37
37	38	namespace mozc {

133	134
134	135	IPCClientFactoryInterface *ipc_client_factory_interface_;
135	136
136		scoped_ptr<RendererLauncherInterface> renderer_launcher_;
	137	std::unique_ptr<RendererLauncherInterface> renderer_launcher_;
137	138	RendererLauncherInterface *renderer_launcher_interface_;
138	139	};
139		} // renderer
140		} // mozc
	140
	141	} // namespace renderer
	142	} // namespace mozc
	143
141	144	#endif // MOZC_RENDERER_RENDERER_CLIENT_H_

+7

-3

src/renderer/renderer_server.h less more

29	29	#ifndef MOZC_RENDERER_RENDERER_SERVER_H_
30	30	#define MOZC_RENDERER_RENDERER_SERVER_H_
31	31
	32	#include <memory>
32	33	#include <string>
	34
33	35	#include "base/port.h"
34	36	#include "ipc/ipc.h"
35	37	#include "renderer/renderer_interface.h"

44	46	// RendererServer base class. Implement Async* method.
45	47	class RendererServer : public IPCServer {
46	48	public:
47		explicit RendererServer();
	49	RendererServer();
48	50	virtual ~RendererServer();
49	51
50	52	void SetRendererInterface(RendererInterface *renderer_interface);

90	92	private:
91	93	uint32 timeout_;
92	94	RendererInterface *renderer_interface_;
93		scoped_ptr<ParentApplicationWatchDog> watch_dog_;
94		scoped_ptr<RendererServerSendCommand> send_command_;
	95	std::unique_ptr<ParentApplicationWatchDog> watch_dog_;
	96	std::unique_ptr<RendererServerSendCommand> send_command_;
95	97
96	98	DISALLOW_COPY_AND_ASSIGN(RendererServer);
97	99	};
	100
98	101	} // namespace renderer
99	102	} // namespace mozc
	103
100	104	#endif // MOZC_RENDERER_RENDERER_SERVER_H_

+5

-3

src/renderer/renderer_server_test.cc less more

26	26	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27	27	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	28
	29	#include "renderer/renderer_server.h"
	30
	31	#include <memory>
29	32	#include <string>
30	33
31	34	#include "base/logging.h"

36	39	#include "protocol/renderer_command.pb.h"
37	40	#include "renderer/renderer_client.h"
38	41	#include "renderer/renderer_interface.h"
39		#include "renderer/renderer_server.h"
	42	#include "testing/base/public/googletest.h"
40	43	#include "testing/base/public/gunit.h"
41		DECLARE_string(test_tmpdir);
42	44
43	45	namespace mozc {
44	46	namespace renderer {

141	143	SystemUtil::SetUserProfileDirectory(FLAGS_test_tmpdir);
142	144	mozc::IPCClientFactoryOnMemory on_memory_client_factory;
143	145
144		scoped_ptr<TestRendererServer> server(new TestRendererServer);
	146	std::unique_ptr<TestRendererServer> server(new TestRendererServer);
145	147	TestRenderer renderer;
146	148	server->SetRendererInterface(&renderer);
147	149	#ifdef OS_MACOSX

+6

-4

src/renderer/win32/candidate_window.h less more

39	39	#include <atlmisc.h>
40	40	#include <atlgdi.h>
41	41
	42	#include <memory>
42	43	#include <string>
43	44
44	45	#include "base/const.h"
45	46	#include "base/coordinates.h"
46	47	#include "base/port.h"
47		#include "base/scoped_ptr.h"
48	48
49	49	namespace mozc {
50	50

144	144	// to avoid problematic side effect as discussed in b/2317702.
145	145	void EnableOrDisableWindowForWorkaround();
146	146
147		scoped_ptr<commands::Candidates> candidates_;
	147	std::unique_ptr<commands::Candidates> candidates_;
148	148	WTL::CBitmap footer_logo_;
149	149	Size footer_logo_display_size_;
150	150	client::SendCommandInterface *send_command_interface_;
151		scoped_ptr<TableLayout> table_layout_;
152		scoped_ptr<TextRenderer> text_renderer_;
	151	std::unique_ptr<TableLayout> table_layout_;
	152	std::unique_ptr<TextRenderer> text_renderer_;
153	153	int indicator_width_;
154	154	bool metrics_changed_;
155	155	bool mouse_moving_;
156	156
157	157	DISALLOW_COPY_AND_ASSIGN(CandidateWindow);
158	158	};
	159
159	160	} // namespace win32
160	161	} // namespace renderer
161	162	} // namespace mozc
	163
162	164	#endif // MOZC_RENDERER_WIN32_CANDIDATE_WINDOW_H_

+3

-2

src/renderer/win32/indicator_window.h less more

29	29	#ifndef MOZC_RENDERER_WIN32_INDICATOR_WINDOW_H_
30	30	#define MOZC_RENDERER_WIN32_INDICATOR_WINDOW_H_
31	31
	32	#include <memory>
	33
32	34	#include "base/coordinates.h"
33	35	#include "base/port.h"
34		#include "base/scoped_ptr.h"
35	36
36	37	namespace mozc {
37	38

57	58
58	59	private:
59	60	class WindowImpl;
60		scoped_ptr<WindowImpl> impl_;
	61	std::unique_ptr<WindowImpl> impl_;
61	62
62	63	DISALLOW_COPY_AND_ASSIGN(IndicatorWindow);
63	64	};

+6

-4

src/renderer/win32/infolist_window.h less more

39	39	#include <atlmisc.h>
40	40	#include <atlgdi.h>
41	41
	42	#include <memory>
42	43	#include <string>
43	44
44	45	#include "base/const.h"
45	46	#include "base/coordinates.h"
46	47	#include "base/port.h"
47		#include "base/scoped_ptr.h"
48	48
49	49	namespace mozc {
50	50

112	112	Size DoPaintRow(WTL::CDCHandle dc, int row, int ypos);
113	113
114	114	client::SendCommandInterface *send_command_interface_;
115		scoped_ptr<commands::Candidates> candidates_;
116		scoped_ptr<TextRenderer> text_renderer_;
117		scoped_ptr<renderer::RendererStyle> style_;
	115	std::unique_ptr<commands::Candidates> candidates_;
	116	std::unique_ptr<TextRenderer> text_renderer_;
	117	std::unique_ptr<renderer::RendererStyle> style_;
118	118	bool metrics_changed_;
119	119	bool visible_;
120	120
121	121	DISALLOW_COPY_AND_ASSIGN(InfolistWindow);
122	122	};
	123
123	124	} // namespace win32
124	125	} // namespace renderer
125	126	} // namespace mozc
	127
126	128	#endif // MOZC_RENDERER_WIN32_INFOLIST_WINDOW_H_

+3

-1

src/renderer/win32/win32_renderer_client.cc less more

28	28
29	29	#include "renderer/win32/win32_renderer_client.h"
30	30
	31	#include <memory>
	32
31	33	#include "base/logging.h"
32	34	#include "base/mutex.h"
33	35	#include "base/scoped_handle.h"

188	190	return nullptr;
189	191	}
190	192
191		scoped_ptr<SenderThread> thread(new SenderThread(
	193	std::unique_ptr<SenderThread> thread(new SenderThread(
192	194	command_event.take(), quit_event.take()));
193	195
194	196	// Resume the thread.

+5

-4

src/renderer/win32/win32_renderer_util.h less more

30	30	#define MOZC_RENDERER_WIN32_WIN32_RENDERER_UTIL_H_
31	31
32	32	#include <Windows.h>
	33
	34	#include <memory>
	35	#include <string>
33	36	#include <vector>
34		#include <string>
35	37
36	38	#include "base/port.h"
37		#include "base/scoped_ptr.h"
38	39	#include "testing/base/public/gunit_prod.h"
39	40	// for FRIEND_TEST()
40	41

422	423	int initial_offset,
423	424	vector<LineLayout> *line_layouts);
424	425
425		scoped_ptr<SystemPreferenceInterface> system_preference_;
426		scoped_ptr<WindowPositionInterface> window_position_;
	426	std::unique_ptr<SystemPreferenceInterface> system_preference_;
	427	std::unique_ptr<WindowPositionInterface> window_position_;
427	428
428	429	DISALLOW_COPY_AND_ASSIGN(LayoutManager);
429	430	};

+4

-3

src/renderer/win32/win32_renderer_util_test.cc less more

26	26	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27	27	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	28
	29	#include "renderer/win32/win32_renderer_util.h"
	30
29	31	#include <Shlwapi.h>
30	32
31	33	#define _ATL_NO_AUTOMATIC_NAMESPACE

41	43	#include "base/win_font_test_helper.h"
42	44	#include "protocol/renderer_command.pb.h"
43	45	#include "renderer/win32/win32_font_util.h"
44		#include "renderer/win32/win32_renderer_util.h"
45	46	#include "testing/base/public/gunit.h"
46	47
47	48	// Following functions should be placed in global namespace for Koenig look-up

1234	1235
1235	1236	// Check DPI scale: 100%
1236	1237	{
1237		scoped_ptr<WindowPositionEmulator> emulator(
	1238	std::unique_ptr<WindowPositionEmulator> emulator(
1238	1239	WindowPositionEmulator::Create());
1239	1240	const HWND hwnd = emulator->RegisterWindow(
1240	1241	kWindowClassName, kWindowRect, kClientOffset, kClientSize, 1.0);

1265	1266
1266	1267	// Interestingly, the following results are independent of DPI scaling.
1267	1268	{
1268		scoped_ptr<WindowPositionEmulator> emulator(
	1269	std::unique_ptr<WindowPositionEmulator> emulator(
1269	1270	WindowPositionEmulator::Create());
1270	1271	const HWND hwnd = emulator->RegisterWindow(
1271	1272	kWindowClassName, kWindowRect, kClientOffset, kClientSize, 10.0);

+3

-1

src/renderer/win32/win32_server.h less more

30	30	#define MOZC_RENDERER_WIN32_WIN32_SERVER_H_
31	31
32	32	#include <windows.h>
	33
	34	#include <memory>
33	35	#include <string>
34	36
35	37	#include "base/mutex.h"

69	71	string message_;
70	72	Mutex mutex_;
71	73	HANDLE event_;
72		scoped_ptr<WindowManager> window_manager_;
	74	std::unique_ptr<WindowManager> window_manager_;
73	75
74	76	DISALLOW_COPY_AND_ASSIGN(Win32Server);
75	77	};

+9

-8

src/renderer/win32/window_manager.h less more

31	31
32	32	#include <windows.h>
33	33
	34	#include <memory>
	35
34	36	#include "base/port.h"
35		#include "base/scoped_ptr.h"
36	37
37	38	namespace mozc {
38	39

72	73	void PreTranslateMessage(const MSG &message);
73	74
74	75	private:
75		scoped_ptr<CandidateWindow> main_window_;
76		scoped_ptr<CandidateWindow> cascading_window_;
77		scoped_ptr<CompositionWindowList> composition_window_list_;
78		scoped_ptr<IndicatorWindow> indicator_window_;
79		scoped_ptr<InfolistWindow> infolist_window_;
80		scoped_ptr<LayoutManager> layout_manager_;
81		scoped_ptr<WorkingAreaInterface> working_area_;
	76	std::unique_ptr<CandidateWindow> main_window_;
	77	std::unique_ptr<CandidateWindow> cascading_window_;
	78	std::unique_ptr<CompositionWindowList> composition_window_list_;
	79	std::unique_ptr<IndicatorWindow> indicator_window_;
	80	std::unique_ptr<InfolistWindow> infolist_window_;
	81	std::unique_ptr<LayoutManager> layout_manager_;
	82	std::unique_ptr<WorkingAreaInterface> working_area_;
82	83	client::SendCommandInterface *send_command_interface_;
83	84	POINT last_position_;
84	85	int candidates_finger_print_;

+13

-13

src/rewriter/calculator_rewriter_test.cc less more

28	28
29	29	#include "rewriter/calculator_rewriter.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33
33	34	#include "base/logging.h"
34		#include "base/scoped_ptr.h"
35	35	#include "base/system_util.h"
36	36	#include "config/config_handler.h"
37	37	#include "converter/conversion_request.h"

128	128
129	129	private:
130	130	CalculatorMock calculator_mock_;
131		scoped_ptr<ConverterInterface> converter_mock_;
	131	std::unique_ptr<ConverterInterface> converter_mock_;
132	132	config::Config default_config_;
133	133	};
134	134
135	135	TEST_F(CalculatorRewriterTest, InsertCandidateTest) {
136		scoped_ptr<CalculatorRewriter> calculator_rewriter(
	136	std::unique_ptr<CalculatorRewriter> calculator_rewriter(
137	137	BuildCalculatorRewriterWithConverterMock());
138	138
139	139	{

165	165	// Pretend "key" is calculated to "value".
166	166	calculator_mock().SetCalculatePair("key", "value", true);
167	167
168		scoped_ptr<CalculatorRewriter> calculator_rewriter(
	168	std::unique_ptr<CalculatorRewriter> calculator_rewriter(
169	169	BuildCalculatorRewriterWithConverterMock());
170	170	const int counter_at_first = calculator_mock().calculation_counter();
171	171	const ConversionRequest request;

193	193	// Since this test depends on the actual implementation of
194	194	// Converter::ResizeSegments(), we cannot use converter mock here. However,
195	195	// the test itself is independent of data.
196		scoped_ptr<EngineInterface> engine_(MockDataEngineFactory::Create());
197		scoped_ptr<CalculatorRewriter> calculator_rewriter(
	196	std::unique_ptr<EngineInterface> engine_(MockDataEngineFactory::Create());
	197	std::unique_ptr<CalculatorRewriter> calculator_rewriter(
198	198	new CalculatorRewriter(engine_->GetConverter()));
199	199	const ConversionRequest request;
200	200

234	234	calculator_mock().SetCalculatePair(kExpression, "3", true);
235	235	const ConversionRequest request;
236	236
237		scoped_ptr<CalculatorRewriter> calculator_rewriter(
	237	std::unique_ptr<CalculatorRewriter> calculator_rewriter(
238	238	BuildCalculatorRewriterWithConverterMock());
239	239
240	240	Segments segments;

258	258	// Since this test depends on the actual implementation of
259	259	// Converter::ResizeSegments(), we cannot use converter mock here. However,
260	260	// the test itself is independent of data.
261		scoped_ptr<EngineInterface> engine_(MockDataEngineFactory::Create());
262		scoped_ptr<CalculatorRewriter> calculator_rewriter(
	261	std::unique_ptr<EngineInterface> engine_(MockDataEngineFactory::Create());
	262	std::unique_ptr<CalculatorRewriter> calculator_rewriter(
263	263	new CalculatorRewriter(engine_->GetConverter()));
264	264	{
265	265	Segments segments;

286	286
287	287	TEST_F(CalculatorRewriterTest, MobileEnvironmentTest) {
288	288	commands::Request input;
289		scoped_ptr<EngineInterface> engine_(MockDataEngineFactory::Create());
290		scoped_ptr<CalculatorRewriter> rewriter(
	289	std::unique_ptr<EngineInterface> engine_(MockDataEngineFactory::Create());
	290	std::unique_ptr<CalculatorRewriter> rewriter(
291	291	new CalculatorRewriter(engine_->GetConverter()));
292	292
293	293	{

308	308	config::ConfigHandler::GetDefaultConfig(&config);
309	309
310	310	const ConversionRequest request;
311		scoped_ptr<EngineInterface> engine_(MockDataEngineFactory::Create());
312		scoped_ptr<CalculatorRewriter> calculator_rewriter(
	311	std::unique_ptr<EngineInterface> engine_(MockDataEngineFactory::Create());
	312	std::unique_ptr<CalculatorRewriter> calculator_rewriter(
313	313	new CalculatorRewriter(engine_->GetConverter()));
314	314	{
315	315	Segments segments;

+3

-2

src/rewriter/collocation_rewriter.cc less more

29	29	#include "rewriter/collocation_rewriter.h"
30	30
31	31	#include <algorithm>
	32	#include <memory>
32	33	#include <string>
33	34	#include <vector>
34	35

550	551	}
551	552
552	553	private:
553		scoped_ptr<ExistenceFilter> filter_;
	554	std::unique_ptr<ExistenceFilter> filter_;
554	555
555	556	DISALLOW_COPY_AND_ASSIGN(CollocationFilter);
556	557	};

574	575	}
575	576
576	577	private:
577		scoped_ptr<ExistenceFilter> filter_;
	578	std::unique_ptr<ExistenceFilter> filter_;
578	579
579	580	DISALLOW_COPY_AND_ASSIGN(SuppressionFilter);
580	581	};

+2

-3

src/rewriter/collocation_rewriter.h less more

30	30	#define MOZC_REWRITER_COLLOCATION_REWRITER_H_
31	31
32	32	#include "base/port.h"
33		#include "base/scoped_ptr.h"
34	33	#include "converter/segments.h"
35	34	#include "rewriter/rewriter_interface.h"
36	35

65	64	// Used to test if pairs of strings are in collocation data. Since it's a
66	65	// bloom filter, non-collocation words are sometimes mistakenly boosted,
67	66	// although the possibility is very low (0.001% by default).
68		scoped_ptr<CollocationFilter> collocation_filter_;
	67	std::unique_ptr<CollocationFilter> collocation_filter_;
69	68
70	69	// Used to test if pairs of content key and value are "ateji". Since it's a
71	70	// bloom filter, non-ateji words are sometimes mistakenly classified as ateji,
72	71	// resulting in passing on the right collocations, though the possibility is
73	72	// very low (0.001% by default).
74		scoped_ptr<SuppressionFilter> suppression_filter_;
	73	std::unique_ptr<SuppressionFilter> suppression_filter_;
75	74	};
76	75
77	76	} // namespace mozc

+3

-1

src/rewriter/collocation_rewriter_test.cc less more

29	29	#include "rewriter/collocation_rewriter.h"
30	30
31	31	#include <cstddef>
	32	#include <memory>
32	33	#include <string>
33	34
34	35	#include "base/logging.h"

135	136
136	137	private:
137	138	config::Config config_backup_;
138		scoped_ptr<const CollocationRewriter> collocation_rewriter_;
	139	std::unique_ptr<const CollocationRewriter> collocation_rewriter_;
	140
139	141	DISALLOW_COPY_AND_ASSIGN(CollocationRewriterTest);
140	142	};
141	143

+3

-1

src/rewriter/correction_rewriter_test.cc less more

28	28
29	29	#include "rewriter/correction_rewriter.h"
30	30
	31	#include <memory>
31	32	#include <string>
	33
32	34	#include "config/config_handler.h"
33	35	#include "converter/conversion_request.h"
34	36	#include "converter/segments.h"

77	79	config::ConfigHandler::SetConfig(default_config_);
78	80	}
79	81
80		scoped_ptr<CorrectionRewriter> rewriter_;
	82	std::unique_ptr<CorrectionRewriter> rewriter_;
81	83
82	84	private:
83	85	config::Config default_config_;

+2

-2

src/rewriter/date_rewriter_test.cc less more

29	29	#include "rewriter/date_rewriter.h"
30	30
31	31	#include <cstddef>
	32	#include <memory>
32	33
33	34	#include "base/clock.h"
34	35	#include "base/clock_mock.h"
35	36	#include "base/port.h"
36		#include "base/scoped_ptr.h"
37	37	#include "base/system_util.h"
38	38	#include "base/util.h"
39	39	#include "composer/composer.h"

220	220	};
221	221
222	222	TEST_F(DateRewriterTest, DateRewriteTest) {
223		scoped_ptr<ClockMock> mock_clock(
	223	std::unique_ptr<ClockMock> mock_clock(
224	224	new ClockMock(kTestSeconds, kTestMicroSeconds));
225	225	Clock::SetClockForUnitTest(mock_clock.get());
226	226

+5

-4

src/rewriter/dictionary_generator.h less more

32	32	#define MOZC_REWRITER_DICTIONARY_GENERATOR_H_
33	33
34	34	#include <map>
	35	#include <memory>
35	36	#include <string>
36	37	#include <vector>
37	38
38	39	#include "base/port.h"
39		#include "base/scoped_ptr.h"
40	40
41	41	namespace mozc {
42	42

108	108	bool Output(const string &filename) const;
109	109
110	110	private:
111		scoped_ptr<ObjectPool<Token> > token_pool_;
112		scoped_ptr<map<uint64, Token *> > token_map_;
113		scoped_ptr<const UserPOSInterface> user_pos_;
	111	std::unique_ptr<ObjectPool<Token> > token_pool_;
	112	std::unique_ptr<map<uint64, Token *> > token_map_;
	113	std::unique_ptr<const UserPOSInterface> user_pos_;
114	114	const uint16 open_bracket_id_;
115	115	const uint16 close_bracket_id_;
116	116

119	119
120	120	} // namespace rewriter
121	121	} // namespace mozc
	122
122	123	#endif // MOZC_REWRITER_DICTIONARY_GENERATOR_H_

+1

-2

src/rewriter/emoji_rewriter.h less more

29	29	#ifndef MOZC_REWRITER_EMOJI_REWRITER_H_
30	30	#define MOZC_REWRITER_EMOJI_REWRITER_H_
31	31
32		#include <stddef.h>
	32	#include <cstddef>
33	33
34		#include "base/scoped_ptr.h"
35	34	#include "converter/segments.h"
36	35	#include "rewriter/embedded_dictionary.h"
37	36	#include "rewriter/rewriter_interface.h"

+2

-1

src/rewriter/emoji_rewriter_test.cc less more

29	29	#include "rewriter/emoji_rewriter.h"
30	30
31	31	#include <cstddef>
	32	#include <memory>
32	33	#include <string>
33	34
34	35	#include "base/logging.h"

195	196	}
196	197
197	198	const ConversionRequest request_;
198		scoped_ptr<EmojiRewriter> rewriter_;
	199	std::unique_ptr<EmojiRewriter> rewriter_;
199	200
200	201	private:
201	202	string original_profile_directory_;

+2

-1

src/rewriter/emoticon_rewriter.cc less more

30	30
31	31	#include <algorithm>
32	32	#include <cstring>
	33	#include <memory>
33	34	#include <string>
34	35	#include <vector>
35	36

62	63	}
63	64
64	65	private:
65		scoped_ptr<EmbeddedDictionary> dic_;
	66	std::unique_ptr<EmbeddedDictionary> dic_;
66	67	};
67	68
68	69	class ValueCostCompare {

+2

-2

src/rewriter/focus_candidate_rewriter_test.cc less more

28	28
29	29	#include "rewriter/focus_candidate_rewriter.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33	#include <vector>
33	34
34	35	#include "base/number_util.h"
35		#include "base/scoped_ptr.h"
36	36	#include "base/system_util.h"
37	37	#include "config/config_handler.h"
38	38	#include "converter/segments.h"

80	80	}
81	81
82	82	private:
83		scoped_ptr<FocusCandidateRewriter> rewriter_;
	83	std::unique_ptr<FocusCandidateRewriter> rewriter_;
84	84	config::Config default_config_;
85	85	testing::MockDataManager mock_data_manager_;
86	86	};

+7

-6

src/rewriter/language_aware_rewriter_test.cc less more

28	28
29	29	#include "rewriter/language_aware_rewriter.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33
33	34	#include "base/logging.h"
34		#include "base/scoped_ptr.h"
35	35	#include "base/system_util.h"
36	36	#include "base/util.h"
37	37	#include "composer/composer.h"

48	48	#include "dictionary/pos_matcher.h"
49	49	#include "protocol/commands.pb.h"
50	50	#include "protocol/config.pb.h"
	51	#include "testing/base/public/googletest.h"
51	52	#include "testing/base/public/gunit.h"
52	53	#include "usage_stats/usage_stats.h"
53	54	#include "usage_stats/usage_stats_testing_util.h"
54	55
55		DECLARE_string(test_tmpdir);
	56	using std::unique_ptr;
56	57
57	58	using mozc::dictionary::DictionaryMock;
58	59	using mozc::dictionary::Token;

80	81	usage_stats::UsageStats::ClearAllStatsForTest();
81	82	#ifdef MOZC_USE_PACKED_DICTIONARY
82	83	// Registers mocked PackedDataManager.
83		scoped_ptr<packed::PackedDataManager>
	84	unique_ptr<packed::PackedDataManager>
84	85	data_manager(new packed::PackedDataManager());
85	86	CHECK(data_manager->Init(string(kPackedSystemDictionary_data,
86	87	kPackedSystemDictionary_size)));

109	110	dictionary_mock_.get());
110	111	}
111	112
112		scoped_ptr<DictionaryMock> dictionary_mock_;
	113	unique_ptr<DictionaryMock> dictionary_mock_;
113	114	usage_stats::scoped_usage_stats_enabler usage_stats_enabler_;
114	115
115	116	private:

166	167	"naru",
167	168	Token::NONE);
168	169
169		scoped_ptr<LanguageAwareRewriter> rewriter(CreateLanguageAwareRewriter());
	170	unique_ptr<LanguageAwareRewriter> rewriter(CreateLanguageAwareRewriter());
170	171
171	172	const string &kPrefix = "\xE2\x86\x92 "; // "→ "
172	173	const string &kDidYouMean =

283	284	}
284	285
285	286	TEST_F(LanguageAwareRewriterTest, LanguageAwareInputUsageStats) {
286		scoped_ptr<LanguageAwareRewriter> rewriter(CreateLanguageAwareRewriter());
	287	unique_ptr<LanguageAwareRewriter> rewriter(CreateLanguageAwareRewriter());
287	288
288	289	EXPECT_STATS_NOT_EXIST("LanguageAwareSuggestionTriggered");
289	290	EXPECT_STATS_NOT_EXIST("LanguageAwareSuggestionCommitted");

+25

-25

src/rewriter/number_rewriter_test.cc less more

29	29	#include "rewriter/number_rewriter.h"
30	30
31	31	#include <cstddef>
	32	#include <memory>
32	33	#include <string>
33	34
34	35	#include "base/logging.h"

46	47	#include "dictionary/pos_matcher.h"
47	48	#include "protocol/commands.pb.h"
48	49	#include "protocol/config.pb.h"
	50	#include "testing/base/public/googletest.h"
49	51	#include "testing/base/public/gunit.h"
50
51		DECLARE_string(test_tmpdir);
52	52
53	53	using mozc::dictionary::POSMatcher;
54	54

135	135	// TODO(noriyukit): Currently this test uses mock data manager. Check if we
136	136	// can remove this registration of packed data manager.
137	137	// Registers mocked PackedDataManager.
138		scoped_ptr<packed::PackedDataManager>
	138	std::unique_ptr<packed::PackedDataManager>
139	139	data_manager(new packed::PackedDataManager());
140	140	CHECK(data_manager->Init(string(kPackedSystemDictionary_data,
141	141	kPackedSystemDictionary_size)));

174	174	} // namespace
175	175
176	176	TEST_F(NumberRewriterTest, BasicTest) {
177		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	177	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
178	178
179	179	Segments segments;
180	180	Segment *seg = segments.push_back_segment();

246	246	TestData(Segments::SUGGESTION, 8),
247	247	};
248	248
249		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	249	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
250	250
251	251	for (size_t i = 0; i < arraysize(test_data_list); ++i) {
252	252	TestData& test_data = test_data_list[i];

265	265	}
266	266
267	267	TEST_F(NumberRewriterTest, BasicTestWithSuffix) {
268		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	268	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
269	269
270	270	Segments segments;
271	271	Segment *seg = segments.push_back_segment();

323	323	}
324	324
325	325	TEST_F(NumberRewriterTest, BasicTestWithNumberSuffix) {
326		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	326	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
327	327
328	328	Segments segments;
329	329	Segment *seg = segments.push_back_segment();

352	352	}
353	353
354	354	TEST_F(NumberRewriterTest, TestWithMultipleNumberSuffix) {
355		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	355	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
356	356
357	357	Segments segments;
358	358	Segment *seg = segments.push_back_segment();

399	399	}
400	400
401	401	TEST_F(NumberRewriterTest, SpecialFormBoundaries) {
402		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	402	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
403	403	Segments segments;
404	404
405	405	// Special forms doesn't have zeros.

446	446	}
447	447
448	448	TEST_F(NumberRewriterTest, OneOfCandidatesIsEmpty) {
449		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	449	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
450	450
451	451	Segments segments;
452	452	Segment *seg = segments.push_back_segment();

498	498	}
499	499
500	500	TEST_F(NumberRewriterTest, RewriteDoesNotHappen) {
501		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	501	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
502	502
503	503	Segments segments;
504	504	Segment *seg = segments.push_back_segment();

519	519	}
520	520
521	521	TEST_F(NumberRewriterTest, NumberIsZero) {
522		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	522	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
523	523
524	524	Segments segments;
525	525	Segment *seg = segments.push_back_segment();

561	561	}
562	562
563	563	TEST_F(NumberRewriterTest, NumberIsZeroZero) {
564		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	564	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
565	565
566	566	Segments segments;
567	567	Segment *seg = segments.push_back_segment();

601	601	}
602	602
603	603	TEST_F(NumberRewriterTest, NumberIs19Digit) {
604		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	604	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
605	605
606	606	Segments segments;
607	607	Segment *seg = segments.push_back_segment();

685	685	}
686	686
687	687	TEST_F(NumberRewriterTest, NumberIsGreaterThanUInt64Max) {
688		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	688	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
689	689
690	690	Segments segments;
691	691	Segment *seg = segments.push_back_segment();

790	790	}
791	791
792	792	TEST_F(NumberRewriterTest, NumberIsGoogol) {
793		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	793	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
794	794
795	795	Segments segments;
796	796	Segment *seg = segments.push_back_segment();

864	864	TEST_F(NumberRewriterTest, RankingForKanjiCandidate) {
865	865	// If kanji candidate is higher before we rewrite segments,
866	866	// kanji should have higher raking.
867		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	867	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
868	868
869	869	Segments segments;
870	870	{

900	900	TEST_F(NumberRewriterTest, ModifyExsistingRanking) {
901	901	// Modify exsisting ranking even if the converter returns unusual results
902	902	// due to dictionary noise, etc.
903		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	903	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
904	904
905	905	Segments segments;
906	906	{

947	947	}
948	948
949	949	TEST_F(NumberRewriterTest, EraseExistingCandidates) {
950		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	950	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
951	951
952	952	Segments segments;
953	953	{

1002	1002	}
1003	1003
1004	1004	TEST_F(NumberRewriterTest, SeparatedArabicsTest) {
1005		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	1005	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
1006	1006
1007	1007	// Expected data to succeed tests.
1008	1008	const char* kSuccess[][3] = {

1069	1069	// In this case, NumberRewriter should not clear
1070	1070	// Segment::Candidate::USER_DICTIONARY bit in the base candidate.
1071	1071	TEST_F(NumberRewriterTest, PreserveUserDictionaryAttibute) {
1072		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	1072	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
1073	1073	{
1074	1074	Segments segments;
1075	1075	{

1109	1109
1110	1110	TEST_F(NumberRewriterTest, DuplicateCandidateTest) {
1111	1111	// To reproduce issue b/6714268.
1112		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	1112	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
1113	1113
1114	1114	Segments segments;
1115	1115	Segment *segment = segments.push_back_segment();

1148	1148
1149	1149	TEST_F(NumberRewriterTest, MobileEnvironmentTest) {
1150	1150	commands::Request input;
1151		scoped_ptr<NumberRewriter> rewriter(CreateNumberRewriter());
	1151	std::unique_ptr<NumberRewriter> rewriter(CreateNumberRewriter());
1152	1152
1153	1153	{
1154	1154	input.set_mixed_conversion(true);

1165	1165
1166	1166	TEST_F(NumberRewriterTest, NonNumberNounTest) {
1167	1167	// Test if "百舌鳥" is not rewritten to "100舌鳥", etc.
1168		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	1168	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
1169	1169	Segments segments;
1170	1170	Segment *segment = segments.push_back_segment();
1171	1171	segment->set_key("\xE3\x82\x82\xE3\x81\x9A"); // "もず"

1181	1181	}
1182	1182
1183	1183	TEST_F(NumberRewriterTest, RewriteForPartialSuggestion_b16765535) {
1184		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	1184	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
1185	1185
1186	1186	const char kBubun[] = "\xE9\x83\xA8\xE5\x88\x86"; // "部分"
1187	1187	Segments segments;

+5

-5

src/rewriter/rewriter_test.cc less more

29	29	#include "rewriter/rewriter.h"
30	30
31	31	#include <cstddef>
	32	#include <memory>
32	33	#include <string>
33	34
34	35	#include "base/system_util.h"

40	41	#include "dictionary/pos_group.h"
41	42	#include "protocol/config.pb.h"
42	43	#include "rewriter/rewriter_interface.h"
	44	#include "testing/base/public/googletest.h"
43	45	#include "testing/base/public/gunit.h"
44
45		DECLARE_string(test_tmpdir);
46	46
47	47	using mozc::dictionary::DictionaryInterface;
48	48	using mozc::dictionary::PosGroup;

90	90	return rewriter_.get();
91	91	}
92	92
93		scoped_ptr<ConverterMock> converter_mock_;
94		scoped_ptr<const PosGroup> pos_group_;
95		scoped_ptr<RewriterImpl> rewriter_;
	93	std::unique_ptr<ConverterMock> converter_mock_;
	94	std::unique_ptr<const PosGroup> pos_group_;
	95	std::unique_ptr<RewriterImpl> rewriter_;
96	96	};
97	97
98	98	// Command rewriter should be disabled on Android build. b/5851240

+3

-2

src/rewriter/single_kanji_rewriter.cc less more

29	29	#include "rewriter/single_kanji_rewriter.h"
30	30
31	31	#include <algorithm>
	32	#include <memory>
	33	#include <set>
32	34	#include <string>
33	35	#include <vector>
34		#include <set>
35	36
36	37	#include "base/logging.h"
37	38	#include "base/singleton.h"

85	86	}
86	87
87	88	private:
88		scoped_ptr<EmbeddedDictionary> dic_;
	89	std::unique_ptr<EmbeddedDictionary> dic_;
89	90	};
90	91
91	92	struct SingleKanjiListCompare {

+6

-7

src/rewriter/single_kanji_rewriter_test.cc less more

29	29	#include "rewriter/single_kanji_rewriter.h"
30	30
31	31	#include <cstddef>
	32	#include <memory>
32	33	#include <string>
33	34
34		#include "base/scoped_ptr.h"
35	35	#include "base/system_util.h"
36	36	#include "base/util.h"
37	37	#include "config/config_handler.h"

41	41	#include "dictionary/pos_matcher.h"
42	42	#include "protocol/commands.pb.h"
43	43	#include "protocol/config.pb.h"
	44	#include "testing/base/public/googletest.h"
44	45	#include "testing/base/public/gunit.h"
45
46		DECLARE_string(test_tmpdir);
47	46
48	47	using mozc::dictionary::POSMatcher;
49	48

76	75	const ConversionRequest default_request_;
77	76
78	77	private:
79		scoped_ptr<testing::MockDataManager> data_manager_;
	78	std::unique_ptr<testing::MockDataManager> data_manager_;
80	79	const POSMatcher *pos_matcher_;
81	80	};
82	81
83	82	TEST_F(SingleKanjiRewriterTest, CapabilityTest) {
84		scoped_ptr<SingleKanjiRewriter> rewriter(CreateSingleKanjiRewriter());
	83	std::unique_ptr<SingleKanjiRewriter> rewriter(CreateSingleKanjiRewriter());
85	84
86	85	commands::Request client_request;
87	86	client_request.set_mixed_conversion(false);

90	89	}
91	90
92	91	TEST_F(SingleKanjiRewriterTest, SetKeyTest) {
93		scoped_ptr<SingleKanjiRewriter> rewriter(CreateSingleKanjiRewriter());
	92	std::unique_ptr<SingleKanjiRewriter> rewriter(CreateSingleKanjiRewriter());
94	93
95	94	Segments segments;
96	95	Segment *segment = segments.add_segment();

115	114
116	115	TEST_F(SingleKanjiRewriterTest, MobileEnvironmentTest) {
117	116	commands::Request client_request;
118		scoped_ptr<SingleKanjiRewriter> rewriter(CreateSingleKanjiRewriter());
	117	std::unique_ptr<SingleKanjiRewriter> rewriter(CreateSingleKanjiRewriter());
119	118
120	119	{
121	120	client_request.set_mixed_conversion(true);

+2

-2

src/rewriter/symbol_rewriter.h less more

29	29	#ifndef MOZC_REWRITER_SYMBOL_REWRITER_H_
30	30	#define MOZC_REWRITER_SYMBOL_REWRITER_H_
31	31
	32	#include <memory>
32	33	#include <string>
33	34
34		#include "base/scoped_ptr.h"
35	35	#include "rewriter/embedded_dictionary.h"
36	36	#include "rewriter/rewriter_interface.h"
37	37	// for FRIEND_TEST()

101	101	bool RewriteEachCandidate(Segments *segments) const;
102	102
103	103	const ConverterInterface *parent_converter_;
104		scoped_ptr<EmbeddedDictionary> dictionary_;
	104	std::unique_ptr<EmbeddedDictionary> dictionary_;
105	105	};
106	106
107	107	} // namespace mozc

+4

-5

src/rewriter/symbol_rewriter_test.cc less more

28	28
29	29	#include "rewriter/symbol_rewriter.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33
33	34	#include "base/logging.h"
34		#include "base/scoped_ptr.h"
35	35	#include "base/system_util.h"
36	36	#include "base/util.h"
37	37	#include "config/config_handler.h"

42	42	#include "engine/mock_data_engine_factory.h"
43	43	#include "protocol/commands.pb.h"
44	44	#include "protocol/config.pb.h"
	45	#include "testing/base/public/googletest.h"
45	46	#include "testing/base/public/gunit.h"
46
47		DECLARE_string(test_tmpdir);
48	47
49	48	namespace mozc {
50	49

122	121	config::ConfigHandler::SetConfig(config);
123	122	}
124	123
125		scoped_ptr<EngineInterface> engine_;
	124	std::unique_ptr<EngineInterface> engine_;
126	125	const ConverterInterface *converter_;
127		scoped_ptr<testing::MockDataManager> data_manager_;
	126	std::unique_ptr<testing::MockDataManager> data_manager_;
128	127	};
129	128
130	129	// Note that these tests are using default symbol dictionary.

+23

-24

src/rewriter/transliteration_rewriter_test.cc less more

30	30
31	31	#include <cctype>
32	32	#include <cstddef>
	33	#include <memory>
33	34	#include <string>
34	35
35	36	#include "base/logging.h"
36		#include "base/scoped_ptr.h"
37	37	#include "base/system_util.h"
38	38	#include "base/util.h"
39	39	#include "composer/composer.h"

49	49	#include "dictionary/pos_matcher.h"
50	50	#include "protocol/commands.pb.h"
51	51	#include "protocol/config.pb.h"
	52	#include "testing/base/public/googletest.h"
52	53	#include "testing/base/public/gunit.h"
53	54	#include "transliteration/transliteration.h"
54	55	#include "usage_stats/usage_stats.h"
55	56	#include "usage_stats/usage_stats_testing_util.h"
56
57		DECLARE_string(test_tmpdir);
58	57
59	58	namespace mozc {
60	59

86	85	usage_stats::UsageStats::ClearAllStatsForTest();
87	86	#ifdef MOZC_USE_PACKED_DICTIONARY
88	87	// Registers mocked PackedDataManager.
89		scoped_ptr<packed::PackedDataManager>
	88	std::unique_ptr<packed::PackedDataManager>
90	89	data_manager(new packed::PackedDataManager());
91	90	CHECK(data_manager->Init(string(kPackedSystemDictionary_data,
92	91	kPackedSystemDictionary_size)));

128	127	};
129	128
130	129	TEST_F(TransliterationRewriterTest, T13nFromKeyTest) {
131		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	130	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
132	131	CreateTransliterationRewriter());
133	132	Segments segments;
134	133	Segment *segment = segments.add_segment();

179	178	}
180	179
181	180	TEST_F(TransliterationRewriterTest, T13nFromComposerTest) {
182		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	181	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
183	182	CreateTransliterationRewriter());
184	183
185	184	composer::Table table;

240	239
241	240
242	241	TEST_F(TransliterationRewriterTest, KeyOfT13nFromComposerTest) {
243		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	242	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
244	243	CreateTransliterationRewriter());
245	244
246	245	composer::Table table;

283	282
284	283
285	284	TEST_F(TransliterationRewriterTest, T13nWithMultiSegmentsTest) {
286		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	285	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
287	286	CreateTransliterationRewriter());
288	287
289	288	composer::Table table;

336	335	}
337	336
338	337	TEST_F(TransliterationRewriterTest, ComposerValidationTest) {
339		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	338	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
340	339	CreateTransliterationRewriter());
341	340
342	341	composer::Table table;

399	398	}
400	399
401	400	TEST_F(TransliterationRewriterTest, RewriteWithSameComposerTest) {
402		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	401	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
403	402	CreateTransliterationRewriter());
404	403
405	404	composer::Table table;

538	537	}
539	538
540	539	TEST_F(TransliterationRewriterTest, NoKeyTest) {
541		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	540	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
542	541	CreateTransliterationRewriter());
543	542
544	543	Segments segments;

558	557	}
559	558
560	559	TEST_F(TransliterationRewriterTest, NoKeyWithComposerTest) {
561		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	560	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
562	561	CreateTransliterationRewriter());
563	562
564	563	composer::Table table;

585	584	}
586	585
587	586	TEST_F(TransliterationRewriterTest, NoRewriteTest) {
588		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	587	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
589	588	CreateTransliterationRewriter());
590	589
591	590	composer::Table table;

602	601	}
603	602
604	603	TEST_F(TransliterationRewriterTest, NormalizedTransliterations) {
605		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	604	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
606	605	CreateTransliterationRewriter());
607	606
608	607	composer::Table table;

632	631
633	632	TEST_F(TransliterationRewriterTest, MobileEnvironmentTest) {
634	633	commands::Request input;
635		scoped_ptr<TransliterationRewriter> rewriter(CreateTransliterationRewriter());
636
	634	std::unique_ptr<TransliterationRewriter> rewriter(
	635	CreateTransliterationRewriter());
637	636	{
638	637	input.set_mixed_conversion(true);
639	638	const ConversionRequest request(NULL, &input);

648	647	}
649	648
650	649	TEST_F(TransliterationRewriterTest, MobileT13nTestWith12KeysHiragana) {
651		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	650	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
652	651	CreateTransliterationRewriter());
653	652
654	653	commands::Request request;

719	718	}
720	719
721	720	TEST_F(TransliterationRewriterTest, MobileT13nTestWith12KeysToNumber) {
722		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	721	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
723	722	CreateTransliterationRewriter());
724	723
725	724	commands::Request request;

791	790	}
792	791
793	792	TEST_F(TransliterationRewriterTest, MobileT13nTestWith12KeysFlick) {
794		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	793	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
795	794	CreateTransliterationRewriter());
796	795
797	796	commands::Request request;

862	861	}
863	862
864	863	TEST_F(TransliterationRewriterTest, MobileT13nTestWithQwertyHiragana) {
865		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	864	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
866	865	CreateTransliterationRewriter());
867	866
868	867	commands::Request client_request;

915	914	}
916	915
917	916	TEST_F(TransliterationRewriterTest, MobileT13nTestWithGodan) {
918		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	917	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
919	918	CreateTransliterationRewriter());
920	919
921	920	commands::Request request;

984	983	}
985	984
986	985	TEST_F(TransliterationRewriterTest, MobileT13nTest_ValidateGodanT13nTable) {
987		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	986	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
988	987	CreateTransliterationRewriter());
989	988
990	989	commands::Request request;

1061	1060	}
1062	1061
1063	1062	TEST_F(TransliterationRewriterTest, T13nOnSuggestion) {
1064		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	1063	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
1065	1064	CreateTransliterationRewriter());
1066	1065
1067	1066	commands::Request client_request;

1093	1092	}
1094	1093
1095	1094	TEST_F(TransliterationRewriterTest, T13nOnPartialSuggestion) {
1096		scoped_ptr<TransliterationRewriter> t13n_rewriter(
	1095	std::unique_ptr<TransliterationRewriter> t13n_rewriter(
1097	1096	CreateTransliterationRewriter());
1098	1097
1099	1098	commands::Request client_request;

+3

-3

src/rewriter/unicode_rewriter_test.cc less more

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

43	44	#include "engine/mock_data_engine_factory.h"
44	45	#include "protocol/commands.pb.h"
45	46	#include "protocol/config.pb.h"
	47	#include "testing/base/public/googletest.h"
46	48	#include "testing/base/public/gunit.h"
47
48		DECLARE_string(test_tmpdir);
49	49
50	50	namespace mozc {
51	51	namespace {

90	90	engine_.reset(MockDataEngineFactory::Create());
91	91	}
92	92
93		scoped_ptr<EngineInterface> engine_;
	93	std::unique_ptr<EngineInterface> engine_;
94	94	const commands::Request &default_request() const {
95	95	return default_request_;
96	96	}

+12

-11

src/rewriter/usage_rewriter_test.cc less more

28	28
29	29	#include "rewriter/usage_rewriter.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33
33	34	#include "base/system_util.h"

95	96	user_dictionary_.get());
96	97	}
97	98
98		scoped_ptr<SuppressionDictionary> suppression_dictionary_;
99		scoped_ptr<UserDictionary> user_dictionary_;
100		scoped_ptr<testing::MockDataManager> data_manager_;
	99	std::unique_ptr<SuppressionDictionary> suppression_dictionary_;
	100	std::unique_ptr<UserDictionary> user_dictionary_;
	101	std::unique_ptr<testing::MockDataManager> data_manager_;
101	102	};
102	103
103	104	TEST_F(UsageRewriterTest, CapabilityTest) {
104		scoped_ptr<UsageRewriter> rewriter(CreateUsageRewriter());
	105	std::unique_ptr<UsageRewriter> rewriter(CreateUsageRewriter());
105	106	const ConversionRequest request;
106	107	EXPECT_EQ(RewriterInterface::CONVERSION \|
107	108	RewriterInterface::PREDICTION,

110	111
111	112	TEST_F(UsageRewriterTest, ConjugationTest) {
112	113	Segments segments;
113		scoped_ptr<UsageRewriter> rewriter(CreateUsageRewriter());
	114	std::unique_ptr<UsageRewriter> rewriter(CreateUsageRewriter());
114	115	Segment *seg;
115	116
116	117	segments.Clear();

141	142
142	143	TEST_F(UsageRewriterTest, SingleSegmentSingleCandidateTest) {
143	144	Segments segments;
144		scoped_ptr<UsageRewriter> rewriter(CreateUsageRewriter());
	145	std::unique_ptr<UsageRewriter> rewriter(CreateUsageRewriter());
145	146	Segment *seg;
146	147	const ConversionRequest request;
147	148

176	177
177	178	TEST_F(UsageRewriterTest, ConfigTest) {
178	179	Segments segments;
179		scoped_ptr<UsageRewriter> rewriter(CreateUsageRewriter());
	180	std::unique_ptr<UsageRewriter> rewriter(CreateUsageRewriter());
180	181	Segment *seg;
181	182	const ConversionRequest request;
182	183

235	236
236	237	TEST_F(UsageRewriterTest, SingleSegmentMultiCandidatesTest) {
237	238	Segments segments;
238		scoped_ptr<UsageRewriter> rewriter(CreateUsageRewriter());
	239	std::unique_ptr<UsageRewriter> rewriter(CreateUsageRewriter());
239	240	Segment *seg;
240	241	const ConversionRequest request;
241	242

330	331
331	332	TEST_F(UsageRewriterTest, MultiSegmentsTest) {
332	333	Segments segments;
333		scoped_ptr<UsageRewriter> rewriter(CreateUsageRewriter());
	334	std::unique_ptr<UsageRewriter> rewriter(CreateUsageRewriter());
334	335	Segment *seg;
335	336	const ConversionRequest request;
336	337

389	390
390	391	TEST_F(UsageRewriterTest, SameUsageTest) {
391	392	Segments segments;
392		scoped_ptr<UsageRewriter> rewriter(CreateUsageRewriter());
	393	std::unique_ptr<UsageRewriter> rewriter(CreateUsageRewriter());
393	394	Segment *seg;
394	395	const ConversionRequest request;
395	396

512	513	"\xE3\x82\xA2\xE3\x83\xAB\xE3\x83\x91\xE3\x82\xAB", seg);
513	514
514	515	const ConversionRequest request;
515		scoped_ptr<UsageRewriter> rewriter(CreateUsageRewriter());
	516	std::unique_ptr<UsageRewriter> rewriter(CreateUsageRewriter());
516	517	EXPECT_TRUE(rewriter->Rewrite(request, &segments));
517	518
518	519	// Result of ("うま", "Horse"). No comment is expected.

+3

-3

src/rewriter/user_boundary_history_rewriter.h less more

29	29	#ifndef MOZC_REWRITER_USER_BOUNDARY_HISTORY_REWRITER_H_
30	30	#define MOZC_REWRITER_USER_BOUNDARY_HISTORY_REWRITER_H_
31	31
	32	#include <memory>
	33	#include <string>
32	34	#include <vector>
33		#include <string>
34	35
35	36	#include "base/port.h"
36		#include "base/scoped_ptr.h"
37	37	#include "rewriter/rewriter_interface.h"
38	38
39	39	namespace mozc {

67	67	int type) const;
68	68
69	69	const ConverterInterface *parent_converter_;
70		scoped_ptr<mozc::storage::LRUStorage> storage_;
	70	std::unique_ptr<mozc::storage::LRUStorage> storage_;
71	71	};
72	72
73	73	} // namespace mozc

+2

-1

src/rewriter/user_segment_history_rewriter.h less more

29	29	#ifndef MOZC_REWRITER_USER_SEGMENT_HISTORY_REWRITER_H_
30	30	#define MOZC_REWRITER_USER_SEGMENT_HISTORY_REWRITER_H_
31	31
	32	#include <memory>
32	33	#include <string>
33	34	#include <vector>
34	35

95	96	Segment *segment) const;
96	97
97	98
98		scoped_ptr<storage::LRUStorage> storage_;
	99	std::unique_ptr<storage::LRUStorage> storage_;
99	100	const dictionary::POSMatcher *pos_matcher_;
100	101	const dictionary::PosGroup *pos_group_;
101	102	};

+39

-40

src/rewriter/user_segment_history_rewriter_test.cc less more

28	28
29	29	#include "rewriter/user_segment_history_rewriter.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33
33	34	#include "base/clock.h"

50	51	#include "testing/base/public/googletest.h"
51	52	#include "testing/base/public/gunit.h"
52	53
53		DECLARE_string(test_tmpdir);
54
55	54	using mozc::config::CharacterFormManager;
56	55	using mozc::config::Config;
57	56	using mozc::config::ConfigHandler;

173	172	virtual void TearDown() {
174	173	Clock::SetClockForUnitTest(NULL);
175	174
176		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	175	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
177	176	CreateUserSegmentHistoryRewriter());
178	177	rewriter->Clear();
179	178	// reset config of test_tmpdir.

198	197	private:
199	198	const testing::MockDataManager mock_data_manager_;
200	199	const POSMatcher *pos_matcher_;
201		scoped_ptr<const PosGroup> pos_group_;
	200	std::unique_ptr<const PosGroup> pos_group_;
202	201	DISALLOW_COPY_AND_ASSIGN(UserSegmentHistoryRewriterTest);
203	202	};
204	203
205	204	TEST_F(UserSegmentHistoryRewriterTest, CreateFile) {
206		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	205	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
207	206	CreateUserSegmentHistoryRewriter());
208	207	const string history_file = FileUtil::JoinPath(FLAGS_test_tmpdir,
209	208	"/segment.db");

214	213	SetLearningLevel(Config::DEFAULT_HISTORY);
215	214	SetIncognito(false);
216	215	Segments segments;
217		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	216	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
218	217	CreateUserSegmentHistoryRewriter());
219	218	segments.Clear();
220	219	const ConversionRequest default_request;

225	224	TEST_F(UserSegmentHistoryRewriterTest, IncognitoModeTest) {
226	225	SetLearningLevel(Config::DEFAULT_HISTORY);
227	226	Segments segments;
228		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	227	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
229	228	CreateUserSegmentHistoryRewriter());
230	229	const ConversionRequest request;
231	230

268	267	TEST_F(UserSegmentHistoryRewriterTest, ConfigTest) {
269	268	SetIncognito(false);
270	269	Segments segments;
271		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	270	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
272	271	CreateUserSegmentHistoryRewriter());
273	272	const ConversionRequest request;
274	273

317	316	SetIncognito(false);
318	317	SetLearningLevel(Config::DEFAULT_HISTORY);
319	318	Segments segments;
320		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	319	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
321	320	CreateUserSegmentHistoryRewriter());
322	321	const ConversionRequest request;
323	322

366	365	TEST_F(UserSegmentHistoryRewriterTest, BasicTest) {
367	366	SetLearningLevel(Config::DEFAULT_HISTORY);
368	367	Segments segments;
369		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	368	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
370	369	CreateUserSegmentHistoryRewriter());
371	370	const ConversionRequest request;
372	371

464	463	TEST_F(UserSegmentHistoryRewriterTest, SequenceTest) {
465	464	SetLearningLevel(Config::DEFAULT_HISTORY);
466	465	Segments segments;
467		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	466	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
468	467	CreateUserSegmentHistoryRewriter());
469	468	const ConversionRequest request;
470	469

568	567	TEST_F(UserSegmentHistoryRewriterTest, DupTest) {
569	568	SetLearningLevel(Config::DEFAULT_HISTORY);
570	569	Segments segments;
571		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	570	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
572	571	CreateUserSegmentHistoryRewriter());
573	572	const ConversionRequest request;
574	573

628	627	TEST_F(UserSegmentHistoryRewriterTest, LearningType) {
629	628	SetLearningLevel(Config::DEFAULT_HISTORY);
630	629	Segments segments;
631		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	630	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
632	631	CreateUserSegmentHistoryRewriter());
633	632	const ConversionRequest request;
634	633

684	683	TEST_F(UserSegmentHistoryRewriterTest, ContextSensitive) {
685	684	SetLearningLevel(Config::DEFAULT_HISTORY);
686	685	Segments segments;
687		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	686	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
688	687	CreateUserSegmentHistoryRewriter());
689	688	const ConversionRequest request;
690	689

739	738	TEST_F(UserSegmentHistoryRewriterTest, ContentValueLearning) {
740	739	SetLearningLevel(Config::DEFAULT_HISTORY);
741	740	Segments segments;
742		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	741	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
743	742	CreateUserSegmentHistoryRewriter());
744	743	const ConversionRequest request;
745	744

860	859	TEST_F(UserSegmentHistoryRewriterTest, ReplaceableTest) {
861	860	SetLearningLevel(Config::DEFAULT_HISTORY);
862	861	Segments segments;
863		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	862	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
864	863	CreateUserSegmentHistoryRewriter());
865	864	const ConversionRequest request;
866	865

990	989	TEST_F(UserSegmentHistoryRewriterTest, NotReplaceableForDifferentId) {
991	990	SetLearningLevel(Config::DEFAULT_HISTORY);
992	991	Segments segments;
993		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	992	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
994	993	CreateUserSegmentHistoryRewriter());
995	994	const ConversionRequest request;
996	995

1022	1021	TEST_F(UserSegmentHistoryRewriterTest, ReplaceableForSameId) {
1023	1022	SetLearningLevel(Config::DEFAULT_HISTORY);
1024	1023	Segments segments;
1025		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	1024	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
1026	1025	CreateUserSegmentHistoryRewriter());
1027	1026	const ConversionRequest request;
1028	1027

1054	1053	TEST_F(UserSegmentHistoryRewriterTest, ReplaceableT13NTest) {
1055	1054	SetLearningLevel(Config::DEFAULT_HISTORY);
1056	1055	Segments segments;
1057		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	1056	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
1058	1057	CreateUserSegmentHistoryRewriter());
1059	1058	const ConversionRequest request;
1060	1059

1087	1086	TEST_F(UserSegmentHistoryRewriterTest, LeftRightNumber) {
1088	1087	SetLearningLevel(Config::DEFAULT_HISTORY);
1089	1088	Segments segments;
1090		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	1089	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
1091	1090	CreateUserSegmentHistoryRewriter());
1092	1091	const ConversionRequest request;
1093	1092

1149	1148	TEST_F(UserSegmentHistoryRewriterTest, BacketMatching) {
1150	1149	SetLearningLevel(Config::DEFAULT_HISTORY);
1151	1150	Segments segments;
1152		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	1151	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
1153	1152	CreateUserSegmentHistoryRewriter());
1154	1153	const ConversionRequest request;
1155	1154

1188	1187	TEST_F(UserSegmentHistoryRewriterTest, MultipleLearning) {
1189	1188	SetLearningLevel(Config::DEFAULT_HISTORY);
1190	1189	Segments segments;
1191		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	1190	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
1192	1191	CreateUserSegmentHistoryRewriter());
1193	1192	const ConversionRequest request;
1194	1193

1247	1246	TEST_F(UserSegmentHistoryRewriterTest, NumberSpecial) {
1248	1247	SetLearningLevel(Config::DEFAULT_HISTORY);
1249	1248	Segments segments;
1250		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
1251		CreateUserSegmentHistoryRewriter());
1252		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	1249	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
	1250	CreateUserSegmentHistoryRewriter());
	1251	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
1253	1252	const ConversionRequest request;
1254	1253
1255	1254	rewriter->Clear();

1297	1296	SetLearningLevel(Config::DEFAULT_HISTORY);
1298	1297	SetNumberForm(Config::HALF_WIDTH);
1299	1298	Segments segments;
1300		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
1301		CreateUserSegmentHistoryRewriter());
1302		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	1299	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
	1300	CreateUserSegmentHistoryRewriter());
	1301	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
1303	1302	const ConversionRequest request;
1304	1303
1305	1304	rewriter->Clear();

1350	1349	SetLearningLevel(Config::DEFAULT_HISTORY);
1351	1350	SetNumberForm(Config::FULL_WIDTH);
1352	1351	Segments segments;
1353		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
1354		CreateUserSegmentHistoryRewriter());
1355		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	1352	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
	1353	CreateUserSegmentHistoryRewriter());
	1354	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
1356	1355	const ConversionRequest request;
1357	1356
1358	1357	rewriter->Clear();

1400	1399	SetLearningLevel(Config::DEFAULT_HISTORY);
1401	1400	SetNumberForm(Config::HALF_WIDTH);
1402	1401	Segments segments;
1403		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
1404		CreateUserSegmentHistoryRewriter());
1405		scoped_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
	1402	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
	1403	CreateUserSegmentHistoryRewriter());
	1404	std::unique_ptr<NumberRewriter> number_rewriter(CreateNumberRewriter());
1406	1405	const ConversionRequest request;
1407	1406
1408	1407	rewriter->Clear();

1462	1461	TEST_F(UserSegmentHistoryRewriterTest, Regression2459519) {
1463	1462	SetLearningLevel(Config::DEFAULT_HISTORY);
1464	1463	Segments segments;
1465		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	1464	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
1466	1465	CreateUserSegmentHistoryRewriter());
1467	1466	const ConversionRequest request;
1468	1467

1519	1518	TEST_F(UserSegmentHistoryRewriterTest, Regression2459520) {
1520	1519	SetLearningLevel(Config::DEFAULT_HISTORY);
1521	1520	Segments segments;
1522		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	1521	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
1523	1522	CreateUserSegmentHistoryRewriter());
1524	1523	const ConversionRequest request;
1525	1524

1548	1547	TEST_F(UserSegmentHistoryRewriterTest, PuntuationsTest) {
1549	1548	SetLearningLevel(Config::DEFAULT_HISTORY);
1550	1549	Segments segments;
1551		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	1550	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
1552	1551	CreateUserSegmentHistoryRewriter());
1553	1552	const ConversionRequest request;
1554	1553

1585	1584	TEST_F(UserSegmentHistoryRewriterTest, Regression3264619) {
1586	1585	SetLearningLevel(Config::DEFAULT_HISTORY);
1587	1586	Segments segments;
1588		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	1587	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
1589	1588	CreateUserSegmentHistoryRewriter());
1590	1589	const ConversionRequest request;
1591	1590

1608	1607	TEST_F(UserSegmentHistoryRewriterTest, RandomTest) {
1609	1608	SetLearningLevel(Config::DEFAULT_HISTORY);
1610	1609	Segments segments;
1611		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	1610	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
1612	1611	CreateUserSegmentHistoryRewriter());
1613	1612	const ConversionRequest request;
1614	1613

1640	1639	TEST_F(UserSegmentHistoryRewriterTest, AnnotationAfterLearning) {
1641	1640	SetLearningLevel(Config::DEFAULT_HISTORY);
1642	1641	Segments segments;
1643		scoped_ptr<UserSegmentHistoryRewriter> rewriter(
	1642	std::unique_ptr<UserSegmentHistoryRewriter> rewriter(
1644	1643	CreateUserSegmentHistoryRewriter());
1645	1644	const ConversionRequest request;
1646	1645

+8

-8

src/rewriter/variants_rewriter_test.cc less more

28	28
29	29	#include "rewriter/variants_rewriter.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33
33	34	#include "base/logging.h"

41	42	#include "data_manager/user_pos_manager.h"
42	43	#include "dictionary/pos_matcher.h"
43	44	#include "protocol/config.pb.h"
	45	#include "testing/base/public/googletest.h"
44	46	#include "testing/base/public/gunit.h"
45
46		DECLARE_string(test_tmpdir);
47	47
48	48	using mozc::config::CharacterFormManager;
49	49	using mozc::config::Config;

108	108	};
109	109
110	110	TEST_F(VariantsRewriterTest, RewriteTest) {
111		scoped_ptr<VariantsRewriter> rewriter(CreateVariantsRewriter());
	111	std::unique_ptr<VariantsRewriter> rewriter(CreateVariantsRewriter());
112	112	Segments segments;
113	113	const ConversionRequest request;
114	114

248	248	}
249	249
250	250	TEST_F(VariantsRewriterTest, RewriteTestManyCandidates) {
251		scoped_ptr<VariantsRewriter> rewriter(CreateVariantsRewriter());
	251	std::unique_ptr<VariantsRewriter> rewriter(CreateVariantsRewriter());
252	252	Segments segments;
253	253	const ConversionRequest request;
254	254	Segment *seg = segments.push_back_segment();

653	653	TEST_F(VariantsRewriterTest, RewriteForConversion) {
654	654	CharacterFormManager *character_form_manager =
655	655	CharacterFormManager::GetCharacterFormManager();
656		scoped_ptr<VariantsRewriter> rewriter(CreateVariantsRewriter());
	656	std::unique_ptr<VariantsRewriter> rewriter(CreateVariantsRewriter());
657	657	const ConversionRequest request;
658	658	{
659	659	Segments segments;

711	711	TEST_F(VariantsRewriterTest, RewriteForPrediction) {
712	712	CharacterFormManager *character_form_manager =
713	713	CharacterFormManager::GetCharacterFormManager();
714		scoped_ptr<VariantsRewriter> rewriter(CreateVariantsRewriter());
	714	std::unique_ptr<VariantsRewriter> rewriter(CreateVariantsRewriter());
715	715	const ConversionRequest request;
716	716	{
717	717	Segments segments;

751	751	TEST_F(VariantsRewriterTest, RewriteForSuggestion) {
752	752	CharacterFormManager *character_form_manager =
753	753	CharacterFormManager::GetCharacterFormManager();
754		scoped_ptr<VariantsRewriter> rewriter(CreateVariantsRewriter());
	754	std::unique_ptr<VariantsRewriter> rewriter(CreateVariantsRewriter());
755	755	const ConversionRequest request;
756	756	{
757	757	Segments segments;

826	826	}
827	827
828	828	TEST_F(VariantsRewriterTest, Capability) {
829		scoped_ptr<VariantsRewriter> rewriter(CreateVariantsRewriter());
	829	std::unique_ptr<VariantsRewriter> rewriter(CreateVariantsRewriter());
830	830	const ConversionRequest request;
831	831	EXPECT_EQ(RewriterInterface::ALL, rewriter->capability(request));
832	832	}

+3

-2

src/rewriter/zipcode_rewriter_test.cc less more

28	28
29	29	#include "rewriter/zipcode_rewriter.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33
33	34	#include "base/logging.h"

99	100	virtual void SetUp() {
100	101	#ifdef MOZC_USE_PACKED_DICTIONARY
101	102	// Registers mocked PackedDataManager.
102		scoped_ptr<packed::PackedDataManager>
	103	std::unique_ptr<packed::PackedDataManager>
103	104	data_manager(new packed::PackedDataManager());
104	105	CHECK(data_manager->Init(string(kPackedSystemDictionary_data,
105	106	kPackedSystemDictionary_size)));

131	132	};
132	133
133	134	TEST_F(ZipcodeRewriterTest, BasicTest) {
134		scoped_ptr<ZipcodeRewriter> zipcode_rewriter(CreateZipcodeRewriter());
	135	std::unique_ptr<ZipcodeRewriter> zipcode_rewriter(CreateZipcodeRewriter());
135	136
136	137	const string kZipcode = "107-0052";
137	138	const string kAddress =

+2

-2

src/session/generic_storage_manager.cc less more

29	29	#include "session/generic_storage_manager.h"
30	30
31	31	#include <cstring>
	32	#include <memory>
32	33	#include <string>
33	34	#include <vector>
34	35

36	37	#include "base/logging.h"
37	38	#include "base/mutex.h"
38	39	#include "base/port.h"
39		#include "base/scoped_ptr.h"
40	40	#include "base/singleton.h"
41	41	#include "storage/lru_storage.h"
42	42

143	143	// We already have prepared storage.
144	144	return true;
145	145	}
146		scoped_ptr<LRUStorage> new_storage;
	146	std::unique_ptr<LRUStorage> new_storage;
147	147	new_storage.reset(new LRUStorage());
148	148	const string &filename =
149	149	ConfigFileStream::GetFileName(file_name_);

+4

-3

src/session/generic_storage_manager.h less more

29	29	#ifndef MOZC_SESSION_GENERIC_STORAGE_MANAGER_H_
30	30	#define MOZC_SESSION_GENERIC_STORAGE_MANAGER_H_
31	31
	32	#include <memory>
	33
32	34	#include "base/port.h"
33		#include "base/scoped_ptr.h"
34	35	#include "protocol/commands.pb.h"
35	36
36	37	namespace mozc {

118	119
119	120	private:
120	121	friend class GenericLruStorageProxy;
121		scoped_ptr<mozc::storage::LRUStorage> lru_storage_;
	122	std::unique_ptr<mozc::storage::LRUStorage> lru_storage_;
122	123	const string file_name_;
123	124	const size_t value_size_;
124	125	const size_t size_;
125	126	const uint32 seed_;
126	127	// Temporary buffer to insert a value into this storage.
127		scoped_ptr<char[]> value_buffer_;
	128	std::unique_ptr<char[]> value_buffer_;
128	129
129	130	DISALLOW_COPY_AND_ASSIGN(GenericLruStorage);
130	131	};

+6

-5

src/session/internal/candidate_list.h less more

32	32	#define MOZC_SESSION_INTERNAL_CANDIDATE_LIST_H_
33	33
34	34	#include <map>
	35	#include <memory>
35	36	#include <string>
36	37	#include <vector>
37	38
38	39	#include "base/port.h"
39		#include "base/scoped_ptr.h"
40	40
41	41	namespace mozc {
42	42

155	155	size_t focused_index_;
156	156	bool focused_;
157	157	string name_;
158		scoped_ptr<ObjectPool<Candidate> > candidate_pool_;
159		scoped_ptr<vector<Candidate *> > candidates_;
	158	std::unique_ptr<ObjectPool<Candidate>> candidate_pool_;
	159	std::unique_ptr<vector<Candidate *>> candidates_;
160	160	int next_available_id_;
161	161
162	162	// Map marking added candidate values. The keys are fingerprints of
163	163	// the candidate values, the values of the map are candidate ids.
164		scoped_ptr<map<uint64, int> > added_candidates_;
	164	std::unique_ptr<map<uint64, int>> added_candidates_;
165	165
166	166	// Id-to-id map. The key and value ids have the same candidate
167	167	// value. (ex. {id:0, value:"kanji"} and {id:-5, value:"kanji"}).
168	168	// The key ids are not directly stored in candidates, so accessing
169	169	// these ids, they should be converted with this map.
170		scoped_ptr<map<int, int> > alternative_ids_;
	170	std::unique_ptr<map<int, int>> alternative_ids_;
171	171
172	172	DISALLOW_COPY_AND_ASSIGN(CandidateList);
173	173	};
174	174
175	175	} // namespace session
176	176	} // namespace mozc
	177
177	178	#endif // MOZC_SESSION_INTERNAL_CANDIDATE_LIST_H_

+4

-4

src/session/internal/candidate_list_test.cc less more

28	28
29	29	#include "session/internal/candidate_list.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33
33		#include "base/scoped_ptr.h"
34	34	#include "testing/base/public/gunit.h"
35	35
36	36	namespace mozc {

75	75	sub_sub_list_2_1_->AddCandidate(212, "212"); // subsub212
76	76	}
77	77
78		scoped_ptr<CandidateList> main_list_;
	78	std::unique_ptr<CandidateList> main_list_;
79	79	// sub_list_1_ will be initialized on the fly.
80	80	CandidateList *sub_list_1_;
81		scoped_ptr<CandidateList> sub_list_2_;
82		scoped_ptr<CandidateList> sub_sub_list_2_1_;
	81	std::unique_ptr<CandidateList> sub_list_2_;
	82	std::unique_ptr<CandidateList> sub_sub_list_2_1_;
83	83	};
84	84
85	85	TEST_F(CandidateListTest, MoveToId) {

+5

-3

src/session/internal/ime_context.h less more

32	32	#ifndef MOZC_SESSION_INTERNAL_IME_CONTEXT_H_
33	33	#define MOZC_SESSION_INTERNAL_IME_CONTEXT_H_
34	34
	35	#include <memory>
	36
35	37	#include "base/port.h"
36		#include "base/scoped_ptr.h"
37	38	#include "protocol/commands.pb.h"
38	39
39	40	namespace mozc {

156	157	uint64 create_time_;
157	158	uint64 last_command_time_;
158	159
159		scoped_ptr<composer::Composer> composer_;
	160	std::unique_ptr<composer::Composer> composer_;
160	161
161		scoped_ptr<SessionConverterInterface> converter_;
	162	std::unique_ptr<SessionConverterInterface> converter_;
162	163
163	164	State state_;
164	165

186	187
187	188	} // namespace session
188	189	} // namespace mozc
	190
189	191	#endif // MOZC_SESSION_INTERNAL_IME_CONTEXT_H_

+3

-3

src/session/internal/ime_context_test.cc less more

28	28
29	29	#include "session/internal/ime_context.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33
33		#include "base/scoped_ptr.h"
34	34	#include "composer/composer.h"
35	35	#include "composer/table.h"
36	36	#include "converter/converter_interface.h"

78	78	EXPECT_EQ(composer, &context.composer());
79	79	EXPECT_EQ(composer, context.mutable_composer());
80	80
81		scoped_ptr<ConverterMock> converter_mock(new ConverterMock);
	81	std::unique_ptr<ConverterMock> converter_mock(new ConverterMock);
82	82	SessionConverter *converter = new SessionConverter(
83	83	converter_mock.get(), &default_request);
84	84	context.set_converter(converter);

119	119	// "な"
120	120	table.AddRule("na", "\xE3\x81\xAA", "");
121	121
122		scoped_ptr<MockConverterEngine> engine(new MockConverterEngine);
	122	std::unique_ptr<MockConverterEngine> engine(new MockConverterEngine);
123	123
124	124	Segments segments;
125	125	Segment *segment = segments.add_segment();

+2

-2

src/session/internal/keymap.cc less more

30	30
31	31	#include "session/internal/keymap.h"
32	32
	33	#include <memory>
33	34	#include <set>
34	35	#include <sstream>
35	36	#include <string>

39	40	#include "base/file_stream.h"
40	41	#include "base/logging.h"
41	42	#include "base/port.h"
42		#include "base/scoped_ptr.h"
43	43	#include "base/util.h"
44	44	#include "composer/key_event_util.h"
45	45	#include "composer/key_parser.h"

159	159	}
160	160
161	161	bool KeyMapManager::LoadFile(const char *filename) {
162		scoped_ptr<istream> ifs(ConfigFileStream::LegacyOpen(filename));
	162	std::unique_ptr<istream> ifs(ConfigFileStream::LegacyOpen(filename));
163	163	if (ifs.get() == NULL) {
164	164	LOG(WARNING) << "cannot load keymap table: " << filename;
165	165	return false;

+5

-4

src/session/internal/keymap_test.cc less more

28	28
29	29	// Keymap utils of Mozc interface.
30	30
	31	#include <memory>
31	32	#include <sstream>
32	33	#include <vector>
	34
33	35	#include "base/config_file_stream.h"
34		#include "base/scoped_ptr.h"
35	36	#include "base/system_util.h"
36	37	#include "composer/key_parser.h"
37	38	#include "config/config_handler.h"

40	41	#include "session/internal/keymap-inl.h"
41	42	#include "session/internal/keymap.h"
42	43	#include "session/internal/keymap_factory.h"
	44	#include "testing/base/public/googletest.h"
43	45	#include "testing/base/public/gunit.h"
44
45		DECLARE_string(test_tmpdir);
46	46
47	47	namespace mozc {
48	48	namespace keymap {

323	323	TEST_F(KeyMapTest, LoadStreamWithErrors) {
324	324	KeyMapManager manager;
325	325	vector<string> errors;
326		scoped_ptr<istream> is(ConfigFileStream::LegacyOpen("system://atok.tsv"));
	326	std::unique_ptr<istream> is(
	327	ConfigFileStream::LegacyOpen("system://atok.tsv"));
327	328	EXPECT_TRUE(manager.LoadStreamWithErrors(is.get(), &errors));
328	329	EXPECT_TRUE(errors.empty());
329	330

+2

-2

src/session/key_info_util.cc less more

28	28
29	29	#include "session/key_info_util.h"
30	30
	31	#include <memory>
31	32	#include <sstream>
32	33	#include <string>
33	34	#include <vector>

35	36	#include "base/config_file_stream.h"
36	37	#include "base/logging.h"
37	38	#include "base/port.h"
38		#include "base/scoped_ptr.h"
39	39	#include "base/util.h"
40	40	#include "composer/key_parser.h"
41	41	#include "config/config_handler.h"

89	89
90	90	vector<KeyInformation> ExtractSortedDirectModeKeysFromFile(
91	91	const string &filename) {
92		scoped_ptr<istream> ifs(ConfigFileStream::LegacyOpen(filename));
	92	std::unique_ptr<istream> ifs(ConfigFileStream::LegacyOpen(filename));
93	93	if (ifs.get() == NULL) {
94	94	DLOG(FATAL) << "could not open file: " << filename;
95	95	return vector<KeyInformation>();

+2

-1

src/session/session.cc less more

30	30
31	31	#include "session/session.h"
32	32
	33	#include <memory>
33	34	#include <string>
34	35	#include <vector>
35	36

1545	1546	// To achieve this, we create a temporary composer object to which the
1546	1547	// new input mode will be stored when \|input\| has a new input mode.
1547	1548	const composer::Composer* target_composer = &context_->composer();
1548		scoped_ptr<composer::Composer> temporary_composer;
	1549	std::unique_ptr<composer::Composer> temporary_composer;
1549	1550	if (input.has_key() && input.key().has_mode()) {
1550	1551	// Allocate an object only when it is necessary.
1551	1552	temporary_composer.reset(new composer::Composer(NULL, NULL));

+3

-3

src/session/session.h less more

31	31	#ifndef MOZC_SESSION_SESSION_H_
32	32	#define MOZC_SESSION_SESSION_H_
33	33
	34	#include <memory>
34	35	#include <string>
35	36
36	37	#include "base/coordinates.h"
37	38	#include "base/port.h"
38		#include "base/scoped_ptr.h"
39	39	#include "composer/composer.h"
40	40	#include "session/session_interface.h"
41	41	#include "transliteration/transliteration.h"

286	286	// history, user dictionary, etc.
287	287	mozc::EngineInterface *engine_;
288	288
289		scoped_ptr<ImeContext> context_;
290		scoped_ptr<ImeContext> prev_context_;
	289	std::unique_ptr<ImeContext> context_;
	290	std::unique_ptr<ImeContext> prev_context_;
291	291
292	292	void InitContext(ImeContext *context) const;
293	293

+6

-5

src/session/session_client_main.cc less more

27	27	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	28
29	29	#include <iostream>
	30	#include <memory>
30	31	#include <string>
31	32
32	33	#include "base/file_stream.h"

34	35	#include "base/flags.h"
35	36	#include "base/logging.h"
36	37	#include "base/port.h"
37		#include "base/scoped_ptr.h"
38	38	#include "base/system_util.h"
39	39	#include "base/util.h"
40	40	#include "composer/key_parser.h"

48	48	DEFINE_string(profile_dir, "", "Profile dir");
49	49
50	50	namespace mozc {
	51
51	52	void Loop(istream input, ostream output) {
52		scoped_ptr<EngineInterface> engine(EngineFactory::Create());
53		scoped_ptr<session::Session> session(new session::Session(engine.get()));
	53	std::unique_ptr<EngineInterface> engine(EngineFactory::Create());
	54	std::unique_ptr<session::Session> session(new session::Session(engine.get()));
54	55
55	56	commands::Command command;
56	57	string line;

85	86
86	87	int main(int argc, char **argv) {
87	88	InitGoogle(argv[0], &argc, &argv, false);
88		scoped_ptr<mozc::InputFileStream> input_file;
89		scoped_ptr<mozc::OutputFileStream> output_file;
	89	std::unique_ptr<mozc::InputFileStream> input_file;
	90	std::unique_ptr<mozc::OutputFileStream> output_file;
90	91	istream *input = NULL;
91	92	ostream *output = NULL;
92	93

+5

-5

src/session/session_converter.h less more

31	31	#ifndef MOZC_SESSION_SESSION_CONVERTER_H_
32	32	#define MOZC_SESSION_SESSION_CONVERTER_H_
33	33
	34	#include <memory>
34	35	#include <string>
35	36	#include <vector>
36	37
37	38	#include "base/port.h"
38		#include "base/scoped_ptr.h"
39	39	#include "session/session_converter_interface.h"
40	40
41	41	namespace mozc {

354	354	SessionConverterInterface::State state_;
355	355
356	356	const ConverterInterface *converter_;
357		scoped_ptr<Segments> segments_;
	357	std::unique_ptr<Segments> segments_;
358	358	size_t segment_index_;
359	359
360	360	// Previous suggestions to be merged with the current predictions.

366	366	// Preferences for user's operation.
367	367	OperationPreferences operation_preferences_;
368	368
369		scoped_ptr<commands::Result> result_;
370
371		scoped_ptr<CandidateList> candidate_list_;
	369	std::unique_ptr<commands::Result> result_;
	370
	371	std::unique_ptr<CandidateList> candidate_list_;
372	372	bool candidate_list_visible_;
373	373
374	374	const commands::Request *request_;

+2

-1

src/session/session_converter_stress_test.cc less more

28	28
29	29	#include "session/session_converter.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33
33	34	#include "base/clock.h"

106	107	const string kRomajiHiraganaTable = "system://romanji-hiragana.tsv";
107	108	const commands::Request default_request;
108	109
109		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	110	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
110	111	ConverterInterface* converter = engine->GetConverter();
111	112	SessionConverter sconverter(converter, &default_request);
112	113	composer::Table table;

+9

-10

src/session/session_converter_test.cc less more

34	34
35	35	#include "session/session_converter.h"
36	36
	37	#include <memory>
37	38	#include <set>
38	39	#include <string>
39	40	#include <vector>

59	60	#include "transliteration/transliteration.h"
60	61	#include "usage_stats/usage_stats.h"
61	62	#include "usage_stats/usage_stats_testing_util.h"
62
63		DECLARE_string(test_tmpdir);
64	63
65	64	namespace mozc {
66	65	namespace session {

407	406	->mutable_candidate(canidate_index)->command = command;
408	407	}
409	408
410		scoped_ptr<ConverterMock> convertermock_;
411
412		scoped_ptr<composer::Composer> composer_;
413		scoped_ptr<composer::Table> table_;
414		scoped_ptr<Request> mobile_request_;
	409	std::unique_ptr<ConverterMock> convertermock_;
	410
	411	std::unique_ptr<composer::Composer> composer_;
	412	std::unique_ptr<composer::Table> table_;
	413	std::unique_ptr<Request> mobile_request_;
415	414	const Request default_request_;
416	415	mozc::usage_stats::scoped_usage_stats_enabler usage_stats_enabler_;
417	416	};

1738	1737
1739	1738	// FinishConversion is expected to return empty Segments.
1740	1739	convertermock_->SetFinishConversion(
1741		scoped_ptr<Segments>(new Segments).get(), true);
	1740	std::unique_ptr<Segments>(new Segments).get(), true);
1742	1741
1743	1742	size_t committed_key_size = 0;
1744	1743	converter.CommitSuggestionByIndex(1, *composer_.get(),

1803	1802
1804	1803	// FinishConversion is expected to return empty Segments.
1805	1804	convertermock_->SetFinishConversion(
1806		scoped_ptr<Segments>(new Segments).get(), true);
	1805	std::unique_ptr<Segments>(new Segments).get(), true);
1807	1806
1808	1807	const int kCandidateIndex = 1;
1809	1808	size_t committed_key_size = 0;

2855	2854
2856	2855	{ // validation
2857	2856	// Copy and validate
2858		scoped_ptr<SessionConverter> dest(src.Clone());
	2857	std::unique_ptr<SessionConverter> dest(src.Clone());
2859	2858	ASSERT_TRUE(dest.get() != NULL);
2860	2859	ExpectSameSessionConverter(src, *dest);
2861	2860

+8

-8

src/session/session_handler.h less more

32	32	#define MOZC_SESSION_SESSION_HANDLER_H_
33	33
34	34	#include <map>
	35	#include <memory>
35	36	#include <string>
36	37
37	38	#include "base/port.h"
38		#include "base/scoped_ptr.h"
39	39	#include "composer/table.h"
40	40	#include "session/common.h"
41	41	#include "session/session_handler_interface.h"

133	133	SessionID CreateNewSessionID();
134	134	bool DeleteSessionID(SessionID id);
135	135
136		scoped_ptr<SessionMap> session_map_;
	136	std::unique_ptr<SessionMap> session_map_;
137	137	#ifndef MOZC_DISABLE_SESSION_WATCHDOG
138		scoped_ptr<SessionWatchDog> session_watch_dog_;
	138	std::unique_ptr<SessionWatchDog> session_watch_dog_;
139	139	#else // MOZC_DISABLE_SESSION_WATCHDOG
140	140	// Session watch dog is not aviable from android mozc and nacl mozc for now.
141	141	// TODO(kkojima): Remove this guard after

148	148	uint64 last_create_session_time_;
149	149
150	150	EngineInterface *engine_;
151		scoped_ptr<session::SessionObserverHandler> observer_handler_;
152		scoped_ptr<Stopwatch> stopwatch_;
153		scoped_ptr<user_dictionary::UserDictionarySessionHandler>
	151	std::unique_ptr<session::SessionObserverHandler> observer_handler_;
	152	std::unique_ptr<Stopwatch> stopwatch_;
	153	std::unique_ptr<user_dictionary::UserDictionarySessionHandler>
154	154	user_dictionary_session_handler_;
155		scoped_ptr<composer::TableManager> table_manager_;
156		scoped_ptr<commands::Request> request_;
	155	std::unique_ptr<composer::TableManager> table_manager_;
	156	std::unique_ptr<commands::Request> request_;
157	157
158	158	DISALLOW_COPY_AND_ASSIGN(SessionHandler);
159	159	};

+8

-9

src/session/session_handler_scenario_test.cc less more

26	26	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27	27	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	28
	29	#include <memory>
	30
29	31	#include "base/file_stream.h"
30	32	#include "base/file_util.h"
31	33	#include "base/number_util.h"
32	34	#include "base/protobuf/descriptor.h"
33	35	#include "base/protobuf/message.h"
34	36	#include "base/protobuf/text_format.h"
35		#include "base/scoped_ptr.h"
36	37	#include "base/string_piece.h"
37	38	#include "base/util.h"
38	39	#include "composer/key_parser.h"

44	45	#include "protocol/config.pb.h"
45	46	#include "session/request_test_util.h"
46	47	#include "session/session_handler_test_util.h"
	48	#include "testing/base/public/googletest.h"
47	49	#include "testing/base/public/gunit.h"
48	50	#include "usage_stats/usage_stats.h"
49	51	#include "usage_stats/usage_stats_testing_util.h"
50
51		DECLARE_string(test_srcdir);
52		DECLARE_string(test_tmpdir);
53	52
54	53	namespace {
55	54

116	115	mozc::usage_stats::UsageStats::ClearAllStatsForTest();
117	116	}
118	117
119		scoped_ptr<EngineInterface> engine_;
120		scoped_ptr<TestSessionClient> client_;
121		scoped_ptr<Config> config_;
122		scoped_ptr<Output> last_output_;
123		scoped_ptr<Request> request_;
	118	std::unique_ptr<EngineInterface> engine_;
	119	std::unique_ptr<TestSessionClient> client_;
	120	std::unique_ptr<Config> config_;
	121	std::unique_ptr<Output> last_output_;
	122	std::unique_ptr<Request> request_;
124	123	};
125	124
126	125	// Tests should be passed.

+3

-3

src/session/session_handler_stress_test.cc less more

29	29	#include "session/session_handler.h"
30	30
31	31	#include <algorithm>
	32	#include <memory>
32	33	#include <string>
33	34	#include <vector>
34	35
35	36	#include "base/file_util.h"
36	37	#include "base/port.h"
37		#include "base/scoped_ptr.h"
38	38	#include "engine/engine_factory.h"
39	39	#include "protocol/commands.pb.h"
40	40	#include "session/random_keyevents_generator.h"

45	45	#include "base/mmap.h"
46	46	#include "base/singleton.h"
47	47	#include "data_manager/android/android_data_manager.h"
48		#endif
	48	#endif // OS_ANDROID
49	49
50	50	namespace {
51	51	uint32 GenerateRandomSeed() {

118	118	TEST_F(SessionHandlerStressTest, BasicStressTest) {
119	119	vector<commands::KeyEvent> keys;
120	120	commands::Output output;
121		scoped_ptr<EngineInterface> engine(EngineFactory::Create());
	121	std::unique_ptr<EngineInterface> engine(EngineFactory::Create());
122	122	TestSessionClient client(engine.get());
123	123	size_t keyevents_size = 0;
124	124	const size_t kMaxEventSize = 10000;

+14

-13

src/session/session_handler_test.cc less more

26	26	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27	27	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	28
	29	#include "session/session_handler.h"
	30
29	31	#include <algorithm>
	32	#include <memory>
30	33	#include <string>
31	34	#include <vector>
32	35

41	44	#include "protocol/commands.pb.h"
42	45	#include "protocol/config.pb.h"
43	46	#include "session/generic_storage_manager.h"
44		#include "session/session_handler.h"
45	47	#include "session/session_handler_test_util.h"
46	48	#include "testing/base/public/googletest.h"
47	49	#include "testing/base/public/gunit.h"

52	54	DECLARE_int32(create_session_min_interval);
53	55	DECLARE_int32(last_command_timeout);
54	56	DECLARE_int32(last_create_session_timeout);
55
56	57
57	58	namespace mozc {
58	59

87	88	const size_t session_size = 3;
88	89	FLAGS_max_session_size = static_cast<int32>(session_size);
89	90	{
90		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	91	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
91	92	SessionHandler handler(engine.get());
92	93
93	94	// Create session_size + 1 sessions

112	113
113	114	FLAGS_max_session_size = static_cast<int32>(session_size);
114	115	{
115		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	116	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
116	117	SessionHandler handler(engine.get());
117	118
118	119	// Create session_size sessions

148	149	ClockMock clock(1000, 0);
149	150	Clock::SetClockForUnitTest(&clock);
150	151
151		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	152	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
152	153	SessionHandler handler(engine.get());
153	154
154	155	uint64 id = 0;

167	168	ClockMock clock(1000, 0);
168	169	Clock::SetClockForUnitTest(&clock);
169	170
170		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	171	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
171	172	SessionHandler handler(engine.get());
172	173	uint64 id = 0;
173	174	EXPECT_TRUE(CreateSession(&handler, &id));

184	185	ClockMock clock(1000, 0);
185	186	Clock::SetClockForUnitTest(&clock);
186	187
187		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	188	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
188	189	SessionHandler handler(engine.get());
189	190	uint64 id = 0;
190	191	EXPECT_TRUE(CreateSession(&handler, &id));

198	199	}
199	200
200	201	TEST_F(SessionHandlerTest, ShutdownTest) {
201		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	202	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
202	203	SessionHandler handler(engine.get());
203	204	uint64 session_id = 0;
204	205	EXPECT_TRUE(CreateSession(&handler, &session_id));

227	228	}
228	229
229	230	TEST_F(SessionHandlerTest, ClearHistoryTest) {
230		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	231	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
231	232	SessionHandler handler(engine.get());
232	233	uint64 session_id = 0;
233	234	EXPECT_TRUE(CreateSession(&handler, &session_id));

267	268	}
268	269
269	270	TEST_F(SessionHandlerTest, ElapsedTimeTest) {
270		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	271	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
271	272	SessionHandler handler(engine.get());
272	273	uint64 id = 0;
273	274

283	284	config.set_incognito_mode(false);
284	285	config::ConfigHandler::SetConfig(config);
285	286
286		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	287	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
287	288	SessionHandler handler(engine.get());
288	289	uint64 session_id = 0;
289	290	EXPECT_TRUE(CreateSession(&handler, &session_id));

407	408	// Inject mock objects.
408	409	MockStorageManager storageManager;
409	410	GenericStorageManagerFactory::SetGenericStorageManager(&storageManager);
410		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	411	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
411	412	SessionHandler handler(engine.get());
412	413	{
413	414	// InsertToStorage

461	462	}
462	463
463	464	TEST_F(SessionHandlerTest, EmojiUsageStatsTest) {
464		scoped_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
	465	std::unique_ptr<EngineInterface> engine(MockDataEngineFactory::Create());
465	466	SessionHandler handler(engine.get());
466	467
467	468	commands::Command command;

+4

-3

src/session/session_handler_test_util.h less more

31	31	#ifndef MOZC_SESSION_SESSION_HANDLER_TEST_UTIL_H_
32	32	#define MOZC_SESSION_SESSION_HANDLER_TEST_UTIL_H_
33	33
	34	#include <memory>
34	35	#include <string>
	36
35	37	#include "base/port.h"
36		#include "base/scoped_ptr.h"
37	38	#include "protocol/commands.pb.h"
38	39	#include "protocol/config.pb.h"
39	40	#include "testing/base/public/gunit.h"

138	139	bool allow_callback);
139	140
140	141	uint64 id_;
141		scoped_ptr<SessionObserverInterface> usage_observer_;
142		scoped_ptr<SessionHandlerInterface> handler_;
	142	std::unique_ptr<SessionObserverInterface> usage_observer_;
	143	std::unique_ptr<SessionHandlerInterface> handler_;
143	144	string callback_text_;
144	145
145	146	DISALLOW_COPY_AND_ASSIGN(TestSessionClient);

+5

-4

src/session/session_regression_test.cc less more

29	29	// This is a test with the actual converter. So the result of the
30	30	// conversion may differ from previous versions.
31	31
	32	#include <memory>
32	33	#include <string>
33	34
34	35	#include "base/file_util.h"

197	198	}
198	199
199	200	bool orig_use_history_rewriter_;
200		scoped_ptr<EngineInterface> engine_;
201		scoped_ptr<SessionHandler> handler_;
202		scoped_ptr<session::Session> session_;
203		scoped_ptr<composer::Table> table_;
	201	std::unique_ptr<EngineInterface> engine_;
	202	std::unique_ptr<SessionHandler> handler_;
	203	std::unique_ptr<session::Session> session_;
	204	std::unique_ptr<composer::Table> table_;
204	205	config::Config config_;
205	206	};
206	207

+6

-3

src/session/session_server.h less more

30	30
31	31	#ifndef MOZC_SESSION_SESSION_SERVER_H_
32	32	#define MOZC_SESSION_SESSION_SERVER_H_
	33
	34	#include <memory>
33	35
34	36	#include "base/port.h"
35	37	#include "ipc/ipc.h"

66	68
67	69	private:
68	70	// Must be defined earlier than session_handler_, which depends on this.
69		scoped_ptr<EngineInterface> engine_;
70		scoped_ptr<session::SessionUsageObserver> usage_observer_;
71		scoped_ptr<SessionHandlerInterface> session_handler_;
	71	std::unique_ptr<EngineInterface> engine_;
	72	std::unique_ptr<session::SessionUsageObserver> usage_observer_;
	73	std::unique_ptr<SessionHandlerInterface> session_handler_;
72	74
73	75	DISALLOW_COPY_AND_ASSIGN(SessionServer);
74	76	};
	77
75	78	} // namespace mozc
76	79
77	80	#endif // MOZC_SESSION_SESSION_SERVER_H_

+4

-4

src/session/session_server_test.cc less more

28	28
29	29	#include "session/session_server.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33	#include <vector>
33	34
34	35	#include "base/scheduler.h"
35	36	#include "base/system_util.h"
	37	#include "testing/base/public/googletest.h"
36	38	#include "testing/base/public/gunit.h"
37
38		DECLARE_string(test_tmpdir);
39	39
40	40	namespace mozc {
41	41	namespace {

73	73	};
74	74
75	75	TEST_F(SessionServerTest, SetSchedulerJobTest) {
76		scoped_ptr<JobRecorder> job_recorder(new JobRecorder);
	76	std::unique_ptr<JobRecorder> job_recorder(new JobRecorder);
77	77	Scheduler::SetSchedulerHandler(job_recorder.get());
78		scoped_ptr<SessionServer> session_server(new SessionServer);
	78	std::unique_ptr<SessionServer> session_server(new SessionServer);
79	79	const vector<Scheduler::JobSetting> &job_settings =
80	80	job_recorder->job_settings();
81	81	EXPECT_LE(2, job_settings.size());

+211

-212

src/session/session_test.cc less more

28	28
29	29	#include "session/session.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33	#include <vector>
33	34

61	62	using ::mozc::commands::Request;
62	63	using ::mozc::usage_stats::UsageStats;
63	64
64		DECLARE_string(test_tmpdir);
65
66	65	namespace mozc {
67	66
68	67	class ConverterInterface;

464	463	}
465	464
466	465	private:
467		scoped_ptr<ConverterMockForReset> converter_mock_;
	466	std::unique_ptr<ConverterMockForReset> converter_mock_;
468	467	};
469	468
470	469	class ConverterMockForRevert : public ConverterMock {

522	521	}
523	522
524	523	private:
525		scoped_ptr<ConverterMockForRevert> converter_mock_;
	524	std::unique_ptr<ConverterMockForRevert> converter_mock_;
526	525	};
527	526
528	527	} // namespace

840	839	return engine_->mutable_converter_mock();
841	840	}
842	841
843		// IMPORTANT: Use scoped_ptr and instanciate an object in SetUp() method
	842	// IMPORTANT: Use std::unique_ptr and instanciate an object in SetUp() method
844	843	// if the target object should be initialized AFTER global settings
845	844	// such as user profile dir or global config are set up for unit test.
846		// If you directly define a variable here without scoped_ptr, its
	845	// If you directly define a variable here without std::unique_ptr, its
847	846	// constructor will be called BEFORE SetUp() is called.
848		scoped_ptr<MockConverterEngine> engine_;
849		scoped_ptr<EngineInterface> mock_data_engine_;
850		scoped_ptr<TransliterationRewriter> t13n_rewriter_;
851		scoped_ptr<composer::Table> table_;
852		scoped_ptr<Request> mobile_request_;
	847	std::unique_ptr<MockConverterEngine> engine_;
	848	std::unique_ptr<EngineInterface> mock_data_engine_;
	849	std::unique_ptr<TransliterationRewriter> t13n_rewriter_;
	850	std::unique_ptr<composer::Table> table_;
	851	std::unique_ptr<Request> mobile_request_;
853	852	mozc::usage_stats::scoped_usage_stats_enabler usage_stats_enabler_;
854	853	};
855	854

868	867
869	868	// Make sure that the default roman table is initialized.
870	869	{
871		scoped_ptr<Session> session(new Session(engine_.get()));
	870	std::unique_ptr<Session> session(new Session(engine_.get()));
872	871	InitSessionToPrecomposition(session.get());
873	872	commands::Command command;
874	873	SendKey("a", session.get(), &command);

899	898
900	899	// Make sure that the initial roman table has default value.
901	900	{
902		scoped_ptr<Session> session(new Session(engine_.get()));
	901	std::unique_ptr<Session> session(new Session(engine_.get()));
903	902	InitSessionToPrecomposition(session.get());
904	903	commands::Command command;
905	904	SendKey("a", session.get(), &command);

910	909	}
911	910
912	911	TEST_F(SessionTest, TestSendKey) {
913		scoped_ptr<Session> session(new Session(engine_.get()));
	912	std::unique_ptr<Session> session(new Session(engine_.get()));
914	913	InitSessionToPrecomposition(session.get());
915	914
916	915	commands::Command command;

945	944	}
946	945
947	946	TEST_F(SessionTest, SendCommand) {
948		scoped_ptr<Session> session(new Session(engine_.get()));
	947	std::unique_ptr<Session> session(new Session(engine_.get()));
949	948	InitSessionToPrecomposition(session.get());
950	949
951	950	commands::Command command;

992	991	EXPECT_FALSE(command.output().has_preedit());
993	992	EXPECT_FALSE(command.output().has_candidates());
994	993	// test of reseting the history segements
995		scoped_ptr<MockConverterEngineForReset> engine(
	994	std::unique_ptr<MockConverterEngineForReset> engine(
996	995	new MockConverterEngineForReset);
997	996	session.reset(new Session(engine.get()));
998	997	InitSessionToPrecomposition(session.get());

1009	1008
1010	1009	TEST_F(SessionTest, SwitchInputMode) {
1011	1010	{
1012		scoped_ptr<Session> session(new Session(engine_.get()));
	1011	std::unique_ptr<Session> session(new Session(engine_.get()));
1013	1012	InitSessionToPrecomposition(session.get());
1014	1013	commands::Command command;
1015	1014

1032	1031	{
1033	1032	// Confirm that we can change the mode from DIRECT
1034	1033	// to other modes directly (without IMEOn command).
1035		scoped_ptr<Session> session(new Session(engine_.get()));
	1034	std::unique_ptr<Session> session(new Session(engine_.get()));
1036	1035	InitSessionToDirect(session.get());
1037	1036
1038	1037	commands::Command command;

1063	1062
1064	1063	TEST_F(SessionTest, RevertComposition) {
1065	1064	// Issue#2237323
1066		scoped_ptr<Session> session(new Session(engine_.get()));
	1065	std::unique_ptr<Session> session(new Session(engine_.get()));
1067	1066	InitSessionToPrecomposition(session.get());
1068	1067	commands::Command command;
1069	1068

1090	1089	}
1091	1090
1092	1091	TEST_F(SessionTest, InputMode) {
1093		scoped_ptr<Session> session(new Session(engine_.get()));
	1092	std::unique_ptr<Session> session(new Session(engine_.get()));
1094	1093	InitSessionToPrecomposition(session.get());
1095	1094	commands::Command command;
1096	1095	EXPECT_TRUE(session->InputModeHalfASCII(&command));

1110	1109	}
1111	1110
1112	1111	TEST_F(SessionTest, SelectCandidate) {
1113		scoped_ptr<Session> session(new Session(engine_.get()));
	1112	std::unique_ptr<Session> session(new Session(engine_.get()));
1114	1113	InitSessionToPrecomposition(session.get());
1115	1114
1116	1115	commands::Command command;

1141	1140	}
1142	1141
1143	1142	TEST_F(SessionTest, HighlightCandidate) {
1144		scoped_ptr<Session> session(new Session(engine_.get()));
	1143	std::unique_ptr<Session> session(new Session(engine_.get()));
1145	1144	InitSessionToPrecomposition(session.get());
1146	1145
1147	1146	commands::Command command;

1176	1175	}
1177	1176
1178	1177	TEST_F(SessionTest, Conversion) {
1179		scoped_ptr<Session> session(new Session(engine_.get()));
	1178	std::unique_ptr<Session> session(new Session(engine_.get()));
1180	1179	InitSessionToPrecomposition(session.get());
1181	1180
1182	1181	commands::Command command;

1208	1207	}
1209	1208
1210	1209	TEST_F(SessionTest, SegmentWidthShrink) {
1211		scoped_ptr<Session> session(new Session(engine_.get()));
	1210	std::unique_ptr<Session> session(new Session(engine_.get()));
1212	1211	InitSessionToPrecomposition(session.get());
1213	1212
1214	1213	commands::Command command;

1231	1230	}
1232	1231
1233	1232	TEST_F(SessionTest, ConvertPrev) {
1234		scoped_ptr<Session> session(new Session(engine_.get()));
	1233	std::unique_ptr<Session> session(new Session(engine_.get()));
1235	1234	InitSessionToPrecomposition(session.get());
1236	1235
1237	1236	commands::Command command;

1261	1260	Segments segments;
1262	1261	Segment *segment;
1263	1262	Segment::Candidate *candidate;
1264		scoped_ptr<Session> session(new Session(engine_.get()));
	1263	std::unique_ptr<Session> session(new Session(engine_.get()));
1265	1264	InitSessionToPrecomposition(session.get());
1266	1265
1267	1266	commands::Command command;

1375	1374	Segments segments;
1376	1375	Segment *segment;
1377	1376	Segment::Candidate *candidate;
1378		scoped_ptr<Session> session(new Session(engine_.get()));
	1377	std::unique_ptr<Session> session(new Session(engine_.get()));
1379	1378	InitSessionToPrecomposition(session.get());
1380	1379
1381	1380	commands::Command command;

1468	1467	Segments segments;
1469	1468	Segment *segment;
1470	1469	Segment::Candidate *candidate;
1471		scoped_ptr<Session> session(new Session(engine_.get()));
	1470	std::unique_ptr<Session> session(new Session(engine_.get()));
1472	1471	InitSessionToPrecomposition(session.get());
1473	1472
1474	1473	commands::Command command;

1559	1558	Segment::Candidate *candidate;
1560	1559
1561	1560	// Issue#1560608
1562		scoped_ptr<Session> session(new Session(engine_.get()));
	1561	std::unique_ptr<Session> session(new Session(engine_.get()));
1563	1562	InitSessionToPrecomposition(session.get());
1564	1563
1565	1564	commands::Command command;

1622	1621	Segments segments;
1623	1622	Segment *segment;
1624	1623	Segment::Candidate *candidate;
1625		scoped_ptr<Session> session(new Session(engine_.get()));
	1624	std::unique_ptr<Session> session(new Session(engine_.get()));
1626	1625	InitSessionToPrecomposition(session.get());
1627	1626
1628	1627	commands::Command command;

1686	1685	Segments segments;
1687	1686	Segment *segment;
1688	1687	Segment::Candidate *candidate;
1689		scoped_ptr<Session> session(new Session(engine_.get()));
	1688	std::unique_ptr<Session> session(new Session(engine_.get()));
1690	1689	InitSessionToPrecomposition(session.get());
1691	1690	commands::Command command;
1692	1691	InsertCharacterChars("jishin", session.get(), &command);

1734	1733	Segment *segment;
1735	1734	Segment::Candidate *candidate;
1736	1735
1737		scoped_ptr<Session> session(new Session(engine_.get()));
	1736	std::unique_ptr<Session> session(new Session(engine_.get()));
1738	1737	InitSessionToPrecomposition(session.get());
1739	1738	commands::Command command;
1740	1739	InsertCharacterChars("jishin", session.get(), &command);

1772	1771	}
1773	1772
1774	1773	TEST_F(SessionTest, ConvertToTransliterationWithMultipleSegments) {
1775		scoped_ptr<Session> session(new Session(engine_.get()));
	1774	std::unique_ptr<Session> session(new Session(engine_.get()));
1776	1775	InitSessionToPrecomposition(session.get());
1777	1776
1778	1777	commands::Command command;

1818	1817	}
1819	1818
1820	1819	TEST_F(SessionTest, ConvertToHalfWidth) {
1821		scoped_ptr<Session> session(new Session(engine_.get()));
	1820	std::unique_ptr<Session> session(new Session(engine_.get()));
1822	1821	InitSessionToPrecomposition(session.get());
1823	1822	commands::Command command;
1824	1823	InsertCharacterChars("abc", session.get(), &command);

1855	1854	Segment *segment;
1856	1855	Segment::Candidate *candidate;
1857	1856
1858		scoped_ptr<Session> session(new Session(engine_.get()));
	1857	std::unique_ptr<Session> session(new Session(engine_.get()));
1859	1858	InitSessionToPrecomposition(session.get());
1860	1859	commands::Command command;
1861	1860	InsertCharacterChars("dvd", session.get(), &command);

1904	1903	Segment *segment;
1905	1904	Segment::Candidate *candidate;
1906	1905
1907		scoped_ptr<Session> session(new Session(engine_.get()));
	1906	std::unique_ptr<Session> session(new Session(engine_.get()));
1908	1907	InitSessionToPrecomposition(session.get());
1909	1908	InsertCharacterChars("dvd", session.get(), &command);
1910	1909

1945	1944	// Convert input string to Hiragana, Katakana, and Half Katakana
1946	1945	TEST_F(SessionTest, SwitchKanaType) {
1947	1946	{ // From composition mode.
1948		scoped_ptr<Session> session(new Session(engine_.get()));
	1947	std::unique_ptr<Session> session(new Session(engine_.get()));
1949	1948	InitSessionToPrecomposition(session.get());
1950	1949	commands::Command command;
1951	1950	InsertCharacterChars("abc", session.get(), &command);

1986	1985	}
1987	1986
1988	1987	{ // From conversion mode.
1989		scoped_ptr<Session> session(new Session(engine_.get()));
	1988	std::unique_ptr<Session> session(new Session(engine_.get()));
1990	1989	InitSessionToPrecomposition(session.get());
1991	1990	commands::Command command;
1992	1991	InsertCharacterChars("kanji", session.get(), &command);

2035	2034
2036	2035	// Rotate input mode among Hiragana, Katakana, and Half Katakana
2037	2036	TEST_F(SessionTest, InputModeSwitchKanaType) {
2038		scoped_ptr<Session> session(new Session(engine_.get()));
	2037	std::unique_ptr<Session> session(new Session(engine_.get()));
2039	2038	InitSessionToPrecomposition(session.get());
2040	2039	commands::Command command;
2041	2040

2126	2125	}
2127	2126
2128	2127	TEST_F(SessionTest, TranslateHalfWidth) {
2129		scoped_ptr<Session> session(new Session(engine_.get()));
	2128	std::unique_ptr<Session> session(new Session(engine_.get()));
2130	2129	InitSessionToPrecomposition(session.get());
2131	2130	commands::Command command;
2132	2131	InsertCharacterChars("abc", session.get(), &command);

2147	2146	}
2148	2147
2149	2148	TEST_F(SessionTest, UpdatePreferences) {
2150		scoped_ptr<Session> session(new Session(engine_.get()));
	2149	std::unique_ptr<Session> session(new Session(engine_.get()));
2151	2150	InitSessionToPrecomposition(session.get());
2152	2151	commands::Command command;
2153	2152	InsertCharacterChars("aiueo", session.get(), &command);

2212	2211	table.AddRule("na", "\xe3\x81\xaa", "");
2213	2212	// This rule makes the "n" rule ambiguous.
2214	2213
2215		scoped_ptr<Session> session(new Session(engine_.get()));
	2214	std::unique_ptr<Session> session(new Session(engine_.get()));
2216	2215	session->get_internal_composer_only_for_unittest()->SetTable(&table);
2217	2216	InitSessionToPrecomposition(session.get());
2218	2217

2255	2254	// "す゛", "ず"
2256	2255	table.AddRule("\xe3\x81\x99\xe3\x82\x9b", "\xe3\x81\x9a", "");
2257	2256
2258		scoped_ptr<Session> session(new Session(engine_.get()));
	2257	std::unique_ptr<Session> session(new Session(engine_.get()));
2259	2258	session->get_internal_composer_only_for_unittest()->SetTable(&table);
2260	2259	InitSessionToPrecomposition(session.get());
2261	2260

2309	2308	Segments segments;
2310	2309	Segment *segment;
2311	2310	Segment::Candidate *candidate;
2312		scoped_ptr<Session> session(new Session(engine_.get()));
	2311	std::unique_ptr<Session> session(new Session(engine_.get()));
2313	2312	InitSessionToPrecomposition(session.get());
2314	2313	commands::Command command;
2315	2314

2346	2345	}
2347	2346
2348	2347	TEST_F(SessionTest, OutputAllCandidateWords) {
2349		scoped_ptr<Session> session(new Session(engine_.get()));
	2348	std::unique_ptr<Session> session(new Session(engine_.get()));
2350	2349	InitSessionToPrecomposition(session.get());
2351	2350	commands::Command command;
2352	2351

2463	2462	}
2464	2463
2465	2464	TEST_F(SessionTest, RequestUndo) {
2466		scoped_ptr<Session> session(new Session(engine_.get()));
	2465	std::unique_ptr<Session> session(new Session(engine_.get()));
2467	2466
2468	2467	// It is OK not to check ImeContext::DIRECT because you cannot
2469	2468	// assign any key event to Undo command in DIRECT mode.

2491	2490	}
2492	2491
2493	2492	TEST_F(SessionTest, UndoForSingleSegment) {
2494		scoped_ptr<Session> session(new Session(engine_.get()));
	2493	std::unique_ptr<Session> session(new Session(engine_.get()));
2495	2494	InitSessionToPrecomposition(session.get());
2496	2495
2497	2496	// Undo requires capability DELETE_PRECEDING_TEXT.

2628	2627	}
2629	2628
2630	2629	TEST_F(SessionTest, ClearUndoContextByKeyEvent_Issue5529702) {
2631		scoped_ptr<Session> session(new Session(engine_.get()));
	2630	std::unique_ptr<Session> session(new Session(engine_.get()));
2632	2631	InitSessionToPrecomposition(session.get());
2633	2632
2634	2633	// Undo requires capability DELETE_PRECEDING_TEXT.

2663	2662	}
2664	2663
2665	2664	TEST_F(SessionTest, UndoForMultipleSegments) {
2666		scoped_ptr<Session> session(new Session(engine_.get()));
	2665	std::unique_ptr<Session> session(new Session(engine_.get()));
2667	2666	InitSessionToPrecomposition(session.get());
2668	2667
2669	2668	// Undo requires capability DELETE_PRECEDING_TEXT.

2805	2804	}
2806	2805
2807	2806	TEST_F(SessionTest, UndoOrRewind_undo) {
2808		scoped_ptr<Session> session(new Session(engine_.get()));
	2807	std::unique_ptr<Session> session(new Session(engine_.get()));
2809	2808	InitSessionToPrecomposition(session.get());
2810	2809
2811	2810	// Undo requires capability DELETE_PRECEDING_TEXT.

2863	2862	}
2864	2863
2865	2864	TEST_F(SessionTest, UndoOrRewind_rewind) {
2866		scoped_ptr<Session> session(new Session(engine_.get()));
	2865	std::unique_ptr<Session> session(new Session(engine_.get()));
2867	2866	InitSessionToPrecomposition(session.get(), *mobile_request_);
2868	2867
2869	2868	Segments segments;

2895	2894
2896	2895	TEST_F(SessionTest, CommitRawText) {
2897	2896	{ // From composition mode.
2898		scoped_ptr<Session> session(new Session(engine_.get()));
	2897	std::unique_ptr<Session> session(new Session(engine_.get()));
2899	2898	InitSessionToPrecomposition(session.get());
2900	2899	commands::Command command;
2901	2900	InsertCharacterChars("abc", session.get(), &command);

2918	2917	EXPECT_EQ(ImeContext::PRECOMPOSITION, session->context().state());
2919	2918	}
2920	2919	{ // From conversion mode.
2921		scoped_ptr<Session> session(new Session(engine_.get()));
	2920	std::unique_ptr<Session> session(new Session(engine_.get()));
2922	2921	InitSessionToPrecomposition(session.get());
2923	2922	commands::Command command;
2924	2923	InsertCharacterChars("abc", session.get(), &command);

2960	2959	// "す゛", "ず"
2961	2960	table.AddRule("\xe3\x81\x99\xe3\x82\x9b", "\xe3\x81\x9a", "");
2962	2961
2963		scoped_ptr<Session> session(new Session(engine_.get()));
	2962	std::unique_ptr<Session> session(new Session(engine_.get()));
2964	2963	session->get_internal_composer_only_for_unittest()->SetTable(&table);
2965	2964	InitSessionToPrecomposition(session.get());
2966	2965

3015	3014
3016	3015	TEST_F(SessionTest, ConvertNextPage_PrevPage) {
3017	3016	commands::Command command;
3018		scoped_ptr<Session> session(new Session(engine_.get()));
	3017	std::unique_ptr<Session> session(new Session(engine_.get()));
3019	3018
3020	3019	InitSessionToPrecomposition(session.get());
3021	3020

3119	3118	TEST_F(SessionTest, NeedlessClearUndoContext) {
3120	3119	// This is a unittest against http://b/3423910.
3121	3120
3122		scoped_ptr<Session> session(new Session(engine_.get()));
	3121	std::unique_ptr<Session> session(new Session(engine_.get()));
3123	3122	InitSessionToPrecomposition(session.get());
3124	3123
3125	3124	// Undo requires capability DELETE_PRECEDING_TEXT.

3200	3199	}
3201	3200
3202	3201	TEST_F(SessionTest, ClearUndoContextAfterDirectInputAfterConversion) {
3203		scoped_ptr<Session> session(new Session(engine_.get()));
	3202	std::unique_ptr<Session> session(new Session(engine_.get()));
3204	3203	InitSessionToPrecomposition(session.get());
3205	3204
3206	3205	// Prepare Numpad

3250	3249
3251	3250	TEST_F(SessionTest, TemporaryInputModeAfterUndo) {
3252	3251	// This is a unittest against http://b/3423599.
3253		scoped_ptr<Session> session(new Session(engine_.get()));
	3252	std::unique_ptr<Session> session(new Session(engine_.get()));
3254	3253	InitSessionToPrecomposition(session.get());
3255	3254
3256	3255	// Undo requires capability DELETE_PRECEDING_TEXT.

3321	3320
3322	3321	TEST_F(SessionTest, DCHECKFailureAfterUndo) {
3323	3322	// This is a unittest against http://b/3437358.
3324		scoped_ptr<Session> session(new Session(engine_.get()));
	3323	std::unique_ptr<Session> session(new Session(engine_.get()));
3325	3324	InitSessionToPrecomposition(session.get());
3326	3325
3327	3326	commands::Capability capability;

3356	3355
3357	3356	TEST_F(SessionTest, ConvertToFullOrHalfAlphanumericAfterUndo) {
3358	3357	// This is a unittest against http://b/3423592.
3359		scoped_ptr<Session> session(new Session(engine_.get()));
	3358	std::unique_ptr<Session> session(new Session(engine_.get()));
3360	3359	InitSessionToPrecomposition(session.get());
3361	3360
3362	3361	// Undo requires capability DELETE_PRECEDING_TEXT.

3420	3419	config::ConfigHandler::SetConfig(config);
3421	3420	ASSERT_EQ(config::Config::KANA, GET_CONFIG(preedit_method));
3422	3421
3423		scoped_ptr<Session> session(new Session(engine_.get()));
	3422	std::unique_ptr<Session> session(new Session(engine_.get()));
3424	3423	InitSessionToPrecomposition(session.get());
3425	3424
3426	3425	// Undo requires capability DELETE_PRECEDING_TEXT.

3514	3513	Segments segments;
3515	3514	Segment *segment;
3516	3515	Segment::Candidate *candidate;
3517		scoped_ptr<Session> session(new Session(engine_.get()));
	3516	std::unique_ptr<Session> session(new Session(engine_.get()));
3518	3517	InitSessionToPrecomposition(session.get());
3519	3518
3520	3519	commands::Command command;

3573	3572	Segments segments;
3574	3573	Segment *segment;
3575	3574	Segment::Candidate *candidate;
3576		scoped_ptr<Session> session(new Session(engine_.get()));
	3575	std::unique_ptr<Session> session(new Session(engine_.get()));
3577	3576	InitSessionToPrecomposition(session.get());
3578	3577
3579	3578	commands::Command command;

3641	3640	TEST_F(SessionTest, T13NWithResegmentation) {
3642	3641	// This is a unittest against http://b/3272827
3643	3642	Segment::Candidate *candidate;
3644		scoped_ptr<Session> session(new Session(engine_.get()));
	3643	std::unique_ptr<Session> session(new Session(engine_.get()));
3645	3644	InitSessionToPrecomposition(session.get());
3646	3645
3647	3646	commands::Command command;

3753	3752	config::ConfigHandler::SetConfig(config);
3754	3753	ASSERT_EQ(shortcut, GET_CONFIG(selection_shortcut));
3755	3754
3756		scoped_ptr<Session> session(new Session(engine_.get()));
	3755	std::unique_ptr<Session> session(new Session(engine_.get()));
3757	3756	InitSessionToPrecomposition(session.get());
3758	3757
3759	3758	Segments segments;

3786	3785	ASSERT_EQ(config::Config::SHORTCUT_ASDFGHJKL,
3787	3786	GET_CONFIG(selection_shortcut));
3788	3787
3789		scoped_ptr<Session> session(new Session(engine_.get()));
	3788	std::unique_ptr<Session> session(new Session(engine_.get()));
3790	3789	InitSessionToPrecomposition(session.get());
3791	3790
3792	3791	Segments segments;

3822	3821	}
3823	3822
3824	3823	TEST_F(SessionTest, NumpadKey) {
3825		scoped_ptr<Session> session(new Session(engine_.get()));
	3824	std::unique_ptr<Session> session(new Session(engine_.get()));
3826	3825	InitSessionToPrecomposition(session.get());
3827	3826	commands::Command command;
3828	3827

3954	3953	ASSERT_EQ(config::Config::COMMA_PERIOD, GET_CONFIG(punctuation_method));
3955	3954	ASSERT_EQ(config::Config::CORNER_BRACKET_SLASH, GET_CONFIG(symbol_method));
3956	3955
3957		scoped_ptr<Session> session(new Session(engine_.get()));
	3956	std::unique_ptr<Session> session(new Session(engine_.get()));
3958	3957	InitSessionToPrecomposition(session.get());
3959	3958
3960	3959	{

3987	3986
3988	3987	TEST_F(SessionTest, InsertCharacterWithShiftKey) {
3989	3988	{ // Basic behavior
3990		scoped_ptr<Session> session(new Session(engine_.get()));
	3989	std::unique_ptr<Session> session(new Session(engine_.get()));
3991	3990	InitSessionToPrecomposition(session.get());
3992	3991	commands::Command command;
3993	3992	EXPECT_TRUE(SendKey("a", session.get(), &command));

4005	4004	}
4006	4005
4007	4006	{ // Revert back to the previous input mode.
4008		scoped_ptr<Session> session(new Session(engine_.get()));
	4007	std::unique_ptr<Session> session(new Session(engine_.get()));
4009	4008	InitSessionToPrecomposition(session.get());
4010	4009	commands::Command command;
4011	4010	session->InputModeFullKatakana(&command);

4028	4027	TEST_F(SessionTest, ExitTemporaryAlphanumModeAfterCommitingSugesstion) {
4029	4028	// This is a unittest against http://b/2977131.
4030	4029	{
4031		scoped_ptr<Session> session(new Session(engine_.get()));
	4030	std::unique_ptr<Session> session(new Session(engine_.get()));
4032	4031	InitSessionToPrecomposition(session.get());
4033	4032	commands::Command command;
4034	4033	EXPECT_TRUE(SendKey("N", session.get(), &command));

4064	4063	}
4065	4064
4066	4065	{
4067		scoped_ptr<Session> session(new Session(engine_.get()));
	4066	std::unique_ptr<Session> session(new Session(engine_.get()));
4068	4067	InitSessionToPrecomposition(session.get());
4069	4068	commands::Command command;
4070	4069	EXPECT_TRUE(SendKey("N", session.get(), &command));

4098	4097	}
4099	4098
4100	4099	{
4101		scoped_ptr<Session> session(new Session(engine_.get()));
	4100	std::unique_ptr<Session> session(new Session(engine_.get()));
4102	4101	InitSessionToPrecomposition(session.get());
4103	4102	commands::Command command;
4104	4103	EXPECT_TRUE(SendKey("N", session.get(), &command));

4136	4135
4137	4136	TEST_F(SessionTest, StatusOutput) {
4138	4137	{ // Basic behavior
4139		scoped_ptr<Session> session(new Session(engine_.get()));
	4138	std::unique_ptr<Session> session(new Session(engine_.get()));
4140	4139	InitSessionToPrecomposition(session.get());
4141	4140	commands::Command command;
4142	4141	EXPECT_TRUE(SendKey("a", session.get(), &command)); // "あ"

4193	4192	}
4194	4193
4195	4194	{ // Katakana mode + Shift key
4196		scoped_ptr<Session> session(new Session(engine_.get()));
	4195	std::unique_ptr<Session> session(new Session(engine_.get()));
4197	4196	InitSessionToPrecomposition(session.get());
4198	4197	commands::Command command;
4199	4198	session->InputModeFullKatakana(&command);

4263	4262	segment->add_candidate()->value = "MOZUKU";
4264	4263	}
4265	4264
4266		scoped_ptr<Session> session(new Session(engine_.get()));
	4265	std::unique_ptr<Session> session(new Session(engine_.get()));
4267	4266	InitSessionToPrecomposition(session.get());
4268	4267	commands::Command command;
4269	4268	SendKey("M", session.get(), &command);

4353	4352	}
4354	4353
4355	4354	TEST_F(SessionTest, ExpandSuggestion) {
4356		scoped_ptr<Session> session(new Session(engine_.get()));
	4355	std::unique_ptr<Session> session(new Session(engine_.get()));
4357	4356	InitSessionToPrecomposition(session.get());
4358	4357	commands::Command command;
4359	4358

4395	4394
4396	4395	TEST_F(SessionTest, ExpandSuggestionDirectMode) {
4397	4396	// On direct mode, ExpandSuggestion() should do nothing.
4398		scoped_ptr<Session> session(new Session(engine_.get()));
	4397	std::unique_ptr<Session> session(new Session(engine_.get()));
4399	4398	commands::Command command;
4400	4399
4401	4400	session->IMEOff(&command);

4408	4407
4409	4408	TEST_F(SessionTest, ExpandSuggestionConversionMode) {
4410	4409	// On conversion mode, ExpandSuggestion() should do nothing.
4411		scoped_ptr<Session> session(new Session(engine_.get()));
	4410	std::unique_ptr<Session> session(new Session(engine_.get()));
4412	4411	InitSessionToPrecomposition(session.get());
4413	4412	commands::Command command;
4414	4413

4450	4449	candidate->attributes = Segment::Candidate::PARTIALLY_KEY_CONSUMED;
4451	4450	candidate->consumed_key_size = Util::CharsLen(kJueri);
4452	4451
4453		scoped_ptr<Session> session(new Session(engine_.get()));
	4452	std::unique_ptr<Session> session(new Session(engine_.get()));
4454	4453	InitSessionToPrecomposition(session.get(), request);
4455	4454
4456	4455	commands::Command command;

4540	4539	candidate = AddCandidate(kShino, "shino", segment);
4541	4540	}
4542	4541
4543		scoped_ptr<Session> session(new Session(engine_.get()));
	4542	std::unique_ptr<Session> session(new Session(engine_.get()));
4544	4543	InitSessionToPrecomposition(session.get(), request);
4545	4544
4546	4545	commands::Command command;

4587	4586	}
4588	4587
4589	4588	TEST_F(SessionTest, ToggleAlphanumericMode) {
4590		scoped_ptr<Session> session(new Session(engine_.get()));
	4589	std::unique_ptr<Session> session(new Session(engine_.get()));
4591	4590	InitSessionToPrecomposition(session.get());
4592	4591	commands::Command command;
4593	4592

4695	4694	}
4696	4695
4697	4696	TEST_F(SessionTest, InsertSpace) {
4698		scoped_ptr<Session> session(new Session(engine_.get()));
	4697	std::unique_ptr<Session> session(new Session(engine_.get()));
4699	4698	InitSessionToPrecomposition(session.get());
4700	4699	commands::Command command;
4701	4700

4734	4733	}
4735	4734
4736	4735	TEST_F(SessionTest, InsertSpaceToggled) {
4737		scoped_ptr<Session> session(new Session(engine_.get()));
	4736	std::unique_ptr<Session> session(new Session(engine_.get()));
4738	4737	InitSessionToPrecomposition(session.get());
4739	4738	commands::Command command;
4740	4739

4773	4772	}
4774	4773
4775	4774	TEST_F(SessionTest, InsertSpaceHalfWidth) {
4776		scoped_ptr<Session> session(new Session(engine_.get()));
	4775	std::unique_ptr<Session> session(new Session(engine_.get()));
4777	4776	InitSessionToPrecomposition(session.get());
4778	4777	commands::Command command;
4779	4778

4816	4815	}
4817	4816
4818	4817	TEST_F(SessionTest, InsertSpaceFullWidth) {
4819		scoped_ptr<Session> session(new Session(engine_.get()));
	4818	std::unique_ptr<Session> session(new Session(engine_.get()));
4820	4819	InitSessionToPrecomposition(session.get());
4821	4820	commands::Command command;
4822	4821

4874	4873	config::ConfigHandler::SetConfig(config);
4875	4874	}
4876	4875	{
4877		scoped_ptr<Session> session(new Session(engine_.get()));
	4876	std::unique_ptr<Session> session(new Session(engine_.get()));
4878	4877	InitSessionToPrecomposition(session.get());
4879	4878
4880	4879	commands::Command command;

4888	4887	EXPECT_EQ(ImeContext::PRECOMPOSITION, session->context().state());
4889	4888	}
4890	4889	{
4891		scoped_ptr<Session> session(new Session(engine_.get()));
	4890	std::unique_ptr<Session> session(new Session(engine_.get()));
4892	4891	InitSessionToPrecomposition(session.get());
4893	4892
4894	4893	commands::Command command;

4922	4921	config::ConfigHandler::SetConfig(config);
4923	4922	}
4924	4923	{
4925		scoped_ptr<Session> session(new Session(engine_.get()));
	4924	std::unique_ptr<Session> session(new Session(engine_.get()));
4926	4925	InitSessionToPrecomposition(session.get());
4927	4926
4928	4927	commands::Command command;

4938	4937	EXPECT_EQ(commands::HALF_KATAKANA, command.output().mode());
4939	4938	}
4940	4939	{
4941		scoped_ptr<Session> session(new Session(engine_.get()));
	4940	std::unique_ptr<Session> session(new Session(engine_.get()));
4942	4941	InitSessionToPrecomposition(session.get());
4943	4942
4944	4943	commands::Command command;

4975	4974	config::ConfigHandler::SetConfig(config);
4976	4975	}
4977	4976	{
4978		scoped_ptr<Session> session(new Session(engine_.get()));
	4977	std::unique_ptr<Session> session(new Session(engine_.get()));
4979	4978	InitSessionToPrecomposition(session.get());
4980	4979
4981	4980	commands::Command command;

4992	4991	EXPECT_EQ(commands::HALF_ASCII, command.output().mode());
4993	4992	}
4994	4993	{
4995		scoped_ptr<Session> session(new Session(engine_.get()));
	4994	std::unique_ptr<Session> session(new Session(engine_.get()));
4996	4995	InitSessionToPrecomposition(session.get());
4997	4996
4998	4997	commands::Command command;

5030	5029	config::ConfigHandler::SetConfig(config);
5031	5030	}
5032	5031	{
5033		scoped_ptr<Session> session(new Session(engine_.get()));
	5032	std::unique_ptr<Session> session(new Session(engine_.get()));
5034	5033	InitSessionToPrecomposition(session.get());
5035	5034
5036	5035	commands::Command command;

5042	5041	EXPECT_FALSE(command.output().consumed());
5043	5042	}
5044	5043	{
5045		scoped_ptr<Session> session(new Session(engine_.get()));
	5044	std::unique_ptr<Session> session(new Session(engine_.get()));
5046	5045	InitSessionToPrecomposition(session.get());
5047	5046
5048	5047	commands::Command command;

5080	5079	config.set_space_character_form(config::Config::FUNDAMENTAL_HALF_WIDTH);
5081	5080	config::ConfigHandler::SetConfig(config);
5082	5081
5083		scoped_ptr<Session> session(new Session(engine_.get()));
	5082	std::unique_ptr<Session> session(new Session(engine_.get()));
5084	5083	InitSessionToPrecomposition(session.get());
5085	5084	commands::Command command;
5086	5085

5122	5121	config.set_space_character_form(config::Config::FUNDAMENTAL_FULL_WIDTH);
5123	5122	config::ConfigHandler::SetConfig(config);
5124	5123
5125		scoped_ptr<Session> session(new Session(engine_.get()));
	5124	std::unique_ptr<Session> session(new Session(engine_.get()));
5126	5125	InitSessionToPrecomposition(session.get());
5127	5126	commands::Command command;
5128	5127

5163	5162	config.set_custom_keymap_table(custom_keymap_table);
5164	5163	config::ConfigHandler::SetConfig(config);
5165	5164
5166		scoped_ptr<Session> session(new Session(engine_.get()));
	5165	std::unique_ptr<Session> session(new Session(engine_.get()));
5167	5166	InitSessionToPrecomposition(session.get());
5168	5167	commands::Command command;
5169	5168

5204	5203	config.set_custom_keymap_table(custom_keymap_table);
5205	5204	config::ConfigHandler::SetConfig(config);
5206	5205
5207		scoped_ptr<Session> session(new Session(engine_.get()));
	5206	std::unique_ptr<Session> session(new Session(engine_.get()));
5208	5207	InitSessionToDirect(session.get());
5209	5208
5210	5209	commands::Command command;

5251	5250	config.set_custom_keymap_table(custom_keymap_table);
5252	5251	config::ConfigHandler::SetConfig(config);
5253	5252
5254		scoped_ptr<Session> session(new Session(engine_.get()));
	5253	std::unique_ptr<Session> session(new Session(engine_.get()));
5255	5254	InitSessionToDirect(session.get());
5256	5255
5257	5256	commands::Command command;

5311	5310	config.set_space_character_form(config::Config::FUNDAMENTAL_FULL_WIDTH);
5312	5311	config::ConfigHandler::SetConfig(config);
5313	5312
5314		scoped_ptr<Session> session(new Session(engine_.get()));
	5313	std::unique_ptr<Session> session(new Session(engine_.get()));
5315	5314	InitSessionToPrecomposition(session.get());
5316	5315	commands::Command command;
5317	5316

5363	5362	config.set_space_character_form(config::Config::FUNDAMENTAL_FULL_WIDTH);
5364	5363	config::ConfigHandler::SetConfig(config);
5365	5364
5366		scoped_ptr<Session> session(new Session(engine_.get()));
	5365	std::unique_ptr<Session> session(new Session(engine_.get()));
5367	5366
5368	5367	{
5369	5368	InitSessionToConversionWithAiueo(session.get());

5433	5432	}
5434	5433
5435	5434	TEST_F(SessionTest, InsertSpaceFullWidthOnHalfKanaInput) {
5436		scoped_ptr<Session> session(new Session(engine_.get()));
	5435	std::unique_ptr<Session> session(new Session(engine_.get()));
5437	5436	InitSessionToPrecomposition(session.get());
5438	5437	commands::Command command;
5439	5438

5453	5452	}
5454	5453
5455	5454	TEST_F(SessionTest, IsFullWidthInsertSpace) {
5456		scoped_ptr<Session> session;
	5455	std::unique_ptr<Session> session;
5457	5456	config::Config config;
5458	5457
5459	5458	{ // When \|empty_command\| does not have \|empty_command.key().input()\| field,

5627	5626	TEST_F(SessionTest, Issue1951385) {
5628	5627	// This is a unittest against http://b/1951385
5629	5628	Segments segments;
5630		scoped_ptr<Session> session(new Session(engine_.get()));
	5629	std::unique_ptr<Session> session(new Session(engine_.get()));
5631	5630	InitSessionToPrecomposition(session.get());
5632	5631	commands::Command command;
5633	5632

5668	5667	segment->add_candidate()->value = "\xe9\x99\xb0\xe8\xac\x80\xe8\xaa\xac";
5669	5668	GetConverterMock()->SetStartPredictionForRequest(&segments, true);
5670	5669
5671		scoped_ptr<Session> session(new Session(engine_.get()));
	5670	std::unique_ptr<Session> session(new Session(engine_.get()));
5672	5671	InitSessionToPrecomposition(session.get());
5673	5672	commands::Command command;
5674	5673	EXPECT_TRUE(session->SegmentWidthShrink(&command));

5689	5688
5690	5689	TEST_F(SessionTest, Issue1975771) {
5691	5690	// This is a unittest against http://b/1975771
5692		scoped_ptr<Session> session(new Session(engine_.get()));
	5691	std::unique_ptr<Session> session(new Session(engine_.get()));
5693	5692	InitSessionToPrecomposition(session.get());
5694	5693
5695	5694	// Trigger suggest by pressing "a".

5723	5722	// "a<tab><ctrl-N>a" raised an exception because CommitFirstSegment
5724	5723	// did not check if the current status is in conversion or
5725	5724	// precomposition.
5726		scoped_ptr<Session> session(new Session(engine_.get()));
	5725	std::unique_ptr<Session> session(new Session(engine_.get()));
5727	5726	InitSessionToPrecomposition(session.get());
5728	5727
5729	5728	// "a"

5755	5754	//
5756	5755	// The composition should have been reset if CommitSegment submitted
5757	5756	// the all segments (e.g. the size of segments is one).
5758		scoped_ptr<Session> session(new Session(engine_.get()));
	5757	std::unique_ptr<Session> session(new Session(engine_.get()));
5759	5758	InitSessionToPrecomposition(session.get());
5760	5759	commands::Command command;
5761	5760	InsertCharacterChars("mozu", session.get(), &command);

5788	5787
5789	5788	TEST_F(SessionTest, Issue2026354) {
5790	5789	// This is a unittest against http://b/2026354
5791		scoped_ptr<Session> session(new Session(engine_.get()));
	5790	std::unique_ptr<Session> session(new Session(engine_.get()));
5792	5791	InitSessionToPrecomposition(session.get());
5793	5792
5794	5793	commands::Command command;

5817	5816	Segments segments;
5818	5817	Segment *segment;
5819	5818	Segment::Candidate *candidate;
5820		scoped_ptr<Session> session(new Session(engine_.get()));
	5819	std::unique_ptr<Session> session(new Session(engine_.get()));
5821	5820	InitSessionToPrecomposition(session.get());
5822	5821
5823	5822	segment = segments.add_segment();

5845	5844
5846	5845	TEST_F(SessionTest, Issue2187132) {
5847	5846	// This is a unittest against http://b/2187132
5848		scoped_ptr<Session> session(new Session(engine_.get()));
	5847	std::unique_ptr<Session> session(new Session(engine_.get()));
5849	5848	InitSessionToPrecomposition(session.get());
5850	5849	commands::Command command;
5851	5850

5877	5876	config::ConfigHandler::SetConfig(config);
5878	5877	ASSERT_EQ(config::Config::KANA, GET_CONFIG(preedit_method));
5879	5878
5880		scoped_ptr<Session> session(new Session(engine_.get()));
	5879	std::unique_ptr<Session> session(new Session(engine_.get()));
5881	5880	InitSessionToPrecomposition(session.get());
5882	5881
5883	5882	commands::Command command;

5899	5898
5900	5899	TEST_F(SessionTest, Issue1556649) {
5901	5900	// This is a unittest against http://b/1556649
5902		scoped_ptr<Session> session(new Session(engine_.get()));
	5901	std::unique_ptr<Session> session(new Session(engine_.get()));
5903	5902	InitSessionToPrecomposition(session.get());
5904	5903	commands::Command command;
5905	5904	InsertCharacterChars("kudoudesu", session.get(), &command);

5927	5926	// This is a unittest against http://b/1518994.
5928	5927	// - Can't input space in ascii mode.
5929	5928	{
5930		scoped_ptr<Session> session(new Session(engine_.get()));
	5929	std::unique_ptr<Session> session(new Session(engine_.get()));
5931	5930	InitSessionToPrecomposition(session.get());
5932	5931	commands::Command command;
5933	5932	EXPECT_TRUE(SendKey("a", session.get(), &command));

5943	5942	}
5944	5943
5945	5944	{
5946		scoped_ptr<Session> session(new Session(engine_.get()));
	5945	std::unique_ptr<Session> session(new Session(engine_.get()));
5947	5946	InitSessionToPrecomposition(session.get());
5948	5947	commands::Command command;
5949	5948	EXPECT_TRUE(SendKey("a", session.get(), &command));

5960	5959	TEST_F(SessionTest, Issue1571043) {
5961	5960	// This is a unittest against http://b/1571043.
5962	5961	// - Underline of composition is separated.
5963		scoped_ptr<Session> session(new Session(engine_.get()));
	5962	std::unique_ptr<Session> session(new Session(engine_.get()));
5964	5963	InitSessionToPrecomposition(session.get());
5965	5964	commands::Command command;
5966	5965	InsertCharacterChars("aiu", session.get(), &command);

5978	5977	TEST_F(SessionTest, Issue1799384) {
5979	5978	// This is a unittest against http://b/1571043.
5980	5979	// - ConvertToHiragana converts Vu to U+3094 "ヴ"
5981		scoped_ptr<Session> session(new Session(engine_.get()));
	5980	std::unique_ptr<Session> session(new Session(engine_.get()));
5982	5981	InitSessionToPrecomposition(session.get());
5983	5982	commands::Command command;
5984	5983	InsertCharacterChars("ravu", session.get(), &command);

6014	6013	// This is a unittest against http://b/2217250.
6015	6014	// Temporary direct input mode through a special sequence such as
6016	6015	// www. continues even after committing them
6017		scoped_ptr<Session> session(new Session(engine_.get()));
	6016	std::unique_ptr<Session> session(new Session(engine_.get()));
6018	6017	InitSessionToPrecomposition(session.get());
6019	6018	commands::Command command;
6020	6019	InsertCharacterChars("www.", session.get(), &command);

6030	6029	// This is a unittest against http://b/2223823
6031	6030	// Input mode does not recover like MS-IME by single shift key down
6032	6031	// and up.
6033		scoped_ptr<Session> session(new Session(engine_.get()));
	6032	std::unique_ptr<Session> session(new Session(engine_.get()));
6034	6033	InitSessionToPrecomposition(session.get());
6035	6034	commands::Command command;
6036	6035	SendKey("G", session.get(), &command);

6046	6045	TEST_F(SessionTest, Issue2223762) {
6047	6046	// This is a unittest against http://b/2223762.
6048	6047	// - The first space in half-width alphanumeric mode is full-width.
6049		scoped_ptr<Session> session(new Session(engine_.get()));
	6048	std::unique_ptr<Session> session(new Session(engine_.get()));
6050	6049	InitSessionToPrecomposition(session.get());
6051	6050	commands::Command command;
6052	6051

6064	6063	// - F6 and F7 convert space to half-width.
6065	6064
6066	6065	{ // DisplayAsFullKatakana
6067		scoped_ptr<Session> session(new Session(engine_.get()));
	6066	std::unique_ptr<Session> session(new Session(engine_.get()));
6068	6067	InitSessionToPrecomposition(session.get());
6069	6068	commands::Command command;
6070	6069

6085	6084	}
6086	6085
6087	6086	{ // ConvertToFullKatakana
6088		scoped_ptr<Session> session(new Session(engine_.get()));
	6087	std::unique_ptr<Session> session(new Session(engine_.get()));
6089	6088	InitSessionToPrecomposition(session.get());
6090	6089	commands::Command command;
6091	6090

6127	6126	// This is a unittest against http://b/2269058.
6128	6127	// - Temporary input mode should not be overridden by a permanent
6129	6128	// input mode change.
6130		scoped_ptr<Session> session(new Session(engine_.get()));
	6129	std::unique_ptr<Session> session(new Session(engine_.get()));
6131	6130	InitSessionToPrecomposition(session.get());
6132	6131	commands::Command command;
6133	6132

6146	6145	// This is a unittest against http://b/2272745.
6147	6146	// A temporary input mode remains when a composition is canceled.
6148	6147	{
6149		scoped_ptr<Session> session(new Session(engine_.get()));
	6148	std::unique_ptr<Session> session(new Session(engine_.get()));
6150	6149	InitSessionToPrecomposition(session.get());
6151	6150	commands::Command command;
6152	6151

6158	6157	}
6159	6158
6160	6159	{
6161		scoped_ptr<Session> session(new Session(engine_.get()));
	6160	std::unique_ptr<Session> session(new Session(engine_.get()));
6162	6161	InitSessionToPrecomposition(session.get());
6163	6162	commands::Command command;
6164	6163

6177	6176	config.set_session_keymap(config::Config::MSIME);
6178	6177	config::ConfigHandler::SetConfig(config);
6179	6178
6180		scoped_ptr<Session> session(new Session(engine_.get()));
	6179	std::unique_ptr<Session> session(new Session(engine_.get()));
6181	6180	InitSessionToPrecomposition(session.get());
6182	6181	ASSERT_EQ(config::Config::MSIME, GET_CONFIG(session_keymap));
6183	6182

6208	6207	config.set_session_keymap(config::Config::MSIME);
6209	6208	config::ConfigHandler::SetConfig(config);
6210	6209
6211		scoped_ptr<Session> session(new Session(engine_.get()));
	6210	std::unique_ptr<Session> session(new Session(engine_.get()));
6212	6211	InitSessionToPrecomposition(session.get());
6213	6212	ASSERT_EQ(config::Config::MSIME, GET_CONFIG(session_keymap));
6214	6213

6220	6219	TEST_F(SessionTest, Issue2379374) {
6221	6220	// This is a unittest against http://b/2379374.
6222	6221	// Numpad ignores Direct input style when typing after conversion.
6223		scoped_ptr<Session> session(new Session(engine_.get()));
	6222	std::unique_ptr<Session> session(new Session(engine_.get()));
6224	6223	InitSessionToPrecomposition(session.get());
6225	6224	commands::Command command;
6226	6225

6275	6274	// After typing "google", the input mode does not come back to the
6276	6275	// previous input mode.
6277	6276	{
6278		scoped_ptr<Session> session(new Session(engine_.get()));
	6277	std::unique_ptr<Session> session(new Session(engine_.get()));
6279	6278	InitSessionToPrecomposition(session.get());
6280	6279	commands::Command command;
6281	6280

6290	6289	}
6291	6290
6292	6291	{
6293		scoped_ptr<Session> session(new Session(engine_.get()));
	6292	std::unique_ptr<Session> session(new Session(engine_.get()));
6294	6293	InitSessionToPrecomposition(session.get());
6295	6294	commands::Command command;
6296	6295

6304	6303	}
6305	6304
6306	6305	{
6307		scoped_ptr<Session> session(new Session(engine_.get()));
	6306	std::unique_ptr<Session> session(new Session(engine_.get()));
6308	6307	InitSessionToPrecomposition(session.get());
6309	6308	commands::Command command;
6310	6309

6322	6321	}
6323	6322
6324	6323	{
6325		scoped_ptr<Session> session(new Session(engine_.get()));
	6324	std::unique_ptr<Session> session(new Session(engine_.get()));
6326	6325	InitSessionToPrecomposition(session.get());
6327	6326	commands::Command command;
6328	6327

6340	6339	// This is a unittest against http://b/2555503.
6341	6340	// Mode respects the previous character too much.
6342	6341
6343		scoped_ptr<Session> session(new Session(engine_.get()));
	6342	std::unique_ptr<Session> session(new Session(engine_.get()));
6344	6343	InitSessionToPrecomposition(session.get());
6345	6344	commands::Command command;
6346	6345	SendKey("a", session.get(), &command);

6362	6361	// This is a unittest against http://b/2791640.
6363	6362	// Existing preedit should be committed when IME is turned off.
6364	6363
6365		scoped_ptr<Session> session(new Session(engine_.get()));
	6364	std::unique_ptr<Session> session(new Session(engine_.get()));
6366	6365	InitSessionToPrecomposition(session.get());
6367	6366
6368	6367	commands::Command command;

6384	6383
6385	6384	// Check "hankaku/zenkaku"
6386	6385	{
6387		scoped_ptr<Session> session(new Session(engine_.get()));
	6386	std::unique_ptr<Session> session(new Session(engine_.get()));
6388	6387	InitSessionToPrecomposition(session.get());
6389	6388
6390	6389	commands::Command command;

6403	6402
6404	6403	// Check "kanji"
6405	6404	{
6406		scoped_ptr<Session> session(new Session(engine_.get()));
	6405	std::unique_ptr<Session> session(new Session(engine_.get()));
6407	6406	InitSessionToPrecomposition(session.get());
6408	6407
6409	6408	commands::Command command;

6426	6425	// InputModeChange commands from direct mode are supported only for Windows
6427	6426	// for now.
6428	6427	#ifdef OS_WIN
6429		scoped_ptr<Session> session(new Session(engine_.get()));
	6428	std::unique_ptr<Session> session(new Session(engine_.get()));
6430	6429	InitSessionToDirect(session.get());
6431	6430	commands::Command command;
6432	6431

6482	6481
6483	6482	TEST_F(SessionTest, IMEOnWithModeTest) {
6484	6483	{
6485		scoped_ptr<Session> session(new Session(engine_.get()));
	6484	std::unique_ptr<Session> session(new Session(engine_.get()));
6486	6485	InitSessionToDirect(session.get());
6487	6486
6488	6487	commands::Command command;

6499	6498	EXPECT_SINGLE_SEGMENT(kHiraganaA, command);
6500	6499	}
6501	6500	{
6502		scoped_ptr<Session> session(new Session(engine_.get()));
	6501	std::unique_ptr<Session> session(new Session(engine_.get()));
6503	6502	InitSessionToDirect(session.get());
6504	6503
6505	6504	commands::Command command;

6514	6513	EXPECT_SINGLE_SEGMENT("\xE3\x82\xA2", command);
6515	6514	}
6516	6515	{
6517		scoped_ptr<Session> session(new Session(engine_.get()));
	6516	std::unique_ptr<Session> session(new Session(engine_.get()));
6518	6517	InitSessionToDirect(session.get());
6519	6518
6520	6519	commands::Command command;

6529	6528	EXPECT_SINGLE_SEGMENT("\xEF\xBD\xB1", command);
6530	6529	}
6531	6530	{
6532		scoped_ptr<Session> session(new Session(engine_.get()));
	6531	std::unique_ptr<Session> session(new Session(engine_.get()));
6533	6532	InitSessionToDirect(session.get());
6534	6533
6535	6534	commands::Command command;

6544	6543	EXPECT_SINGLE_SEGMENT("\xEF\xBD\x81", command);
6545	6544	}
6546	6545	{
6547		scoped_ptr<Session> session(new Session(engine_.get()));
	6546	std::unique_ptr<Session> session(new Session(engine_.get()));
6548	6547	InitSessionToDirect(session.get());
6549	6548
6550	6549	commands::Command command;

6561	6560	}
6562	6561
6563	6562	TEST_F(SessionTest, InputModeConsumed) {
6564		scoped_ptr<Session> session(new Session(engine_.get()));
	6563	std::unique_ptr<Session> session(new Session(engine_.get()));
6565	6564	InitSessionToPrecomposition(session.get());
6566	6565	commands::Command command;
6567	6566	EXPECT_TRUE(session->InputModeHiragana(&command));

6593	6592	config.set_session_keymap(config::Config::MSIME);
6594	6593	config::ConfigHandler::SetConfig(config);
6595	6594
6596		scoped_ptr<Session> session(new Session(engine_.get()));
	6595	std::unique_ptr<Session> session(new Session(engine_.get()));
6597	6596	InitSessionToPrecomposition(session.get());
6598	6597	ASSERT_EQ(config::Config::MSIME, GET_CONFIG(session_keymap));
6599	6598	// In MSIME keymap, Hiragana is assigned for

6606	6605	}
6607	6606
6608	6607	TEST_F(SessionTest, InputModeOutputHasComposition) {
6609		scoped_ptr<Session> session(new Session(engine_.get()));
	6608	std::unique_ptr<Session> session(new Session(engine_.get()));
6610	6609	InitSessionToPrecomposition(session.get());
6611	6610	commands::Command command;
6612	6611	SendKey("a", session.get(), &command);

6650	6649	}
6651	6650
6652	6651	TEST_F(SessionTest, InputModeOutputHasCandidates) {
6653		scoped_ptr<Session> session(new Session(engine_.get()));
	6652	std::unique_ptr<Session> session(new Session(engine_.get()));
6654	6653	InitSessionToPrecomposition(session.get());
6655	6654
6656	6655	Segments segments;

6706	6705	}
6707	6706
6708	6707	TEST_F(SessionTest, PerformedCommand) {
6709		scoped_ptr<Session> session(new Session(engine_.get()));
	6708	std::unique_ptr<Session> session(new Session(engine_.get()));
6710	6709	InitSessionToPrecomposition(session.get());
6711	6710
6712	6711	{

6754	6753	}
6755	6754
6756	6755	TEST_F(SessionTest, ResetContext) {
6757		scoped_ptr<MockConverterEngineForReset> engine(
	6756	std::unique_ptr<MockConverterEngineForReset> engine(
6758	6757	new MockConverterEngineForReset);
6759	6758	ConverterMockForReset *convertermock = engine->mutable_converter_mock();
6760	6759
6761		scoped_ptr<Session> session(new Session(engine.get()));
	6760	std::unique_ptr<Session> session(new Session(engine.get()));
6762	6761	InitSessionToPrecomposition(session.get());
6763	6762	commands::Command command;
6764	6763

6775	6774	}
6776	6775
6777	6776	TEST_F(SessionTest, ClearUndoOnResetContext) {
6778		scoped_ptr<Session> session(new Session(engine_.get()));
	6777	std::unique_ptr<Session> session(new Session(engine_.get()));
6779	6778	InitSessionToPrecomposition(session.get());
6780	6779
6781	6780	// Undo requires capability DELETE_PRECEDING_TEXT.

6826	6825	}
6827	6826
6828	6827	TEST_F(SessionTest, IssueResetConversion) {
6829		scoped_ptr<MockConverterEngineForReset> engine(
	6828	std::unique_ptr<MockConverterEngineForReset> engine(
6830	6829	new MockConverterEngineForReset);
6831	6830	ConverterMockForReset *convertermock = engine->mutable_converter_mock();
6832	6831
6833		scoped_ptr<Session> session(new Session(engine.get()));
	6832	std::unique_ptr<Session> session(new Session(engine.get()));
6834	6833	InitSessionToPrecomposition(session.get());
6835	6834	commands::Command command;
6836	6835

6846	6845	}
6847	6846
6848	6847	TEST_F(SessionTest, IssueRevert) {
6849		scoped_ptr<MockConverterEngineForRevert> engine(
	6848	std::unique_ptr<MockConverterEngineForRevert> engine(
6850	6849	new MockConverterEngineForRevert);
6851	6850	ConverterMockForRevert *convertermock = engine->mutable_converter_mock();
6852	6851
6853		scoped_ptr<Session> session(new Session(engine.get()));
	6852	std::unique_ptr<Session> session(new Session(engine.get()));
6854	6853	InitSessionToPrecomposition(session.get());
6855	6854	commands::Command command;
6856	6855

6865	6864
6866	6865	// Undo command must call RervertConversion
6867	6866	TEST_F(SessionTest, Issue3428520) {
6868		scoped_ptr<MockConverterEngineForRevert> engine(
	6867	std::unique_ptr<MockConverterEngineForRevert> engine(
6869	6868	new MockConverterEngineForRevert);
6870	6869	ConverterMockForRevert *convertermock = engine->mutable_converter_mock();
6871	6870
6872		scoped_ptr<Session> session(new Session(engine.get()));
	6871	std::unique_ptr<Session> session(new Session(engine.get()));
6873	6872	InitSessionToPrecomposition(session.get());
6874	6873
6875	6874	// Undo requires capability DELETE_PRECEDING_TEXT.

6909	6908
6910	6909	// Revert command must clear the undo context.
6911	6910	TEST_F(SessionTest, Issue5742293) {
6912		scoped_ptr<Session> session(new Session(engine_.get()));
	6911	std::unique_ptr<Session> session(new Session(engine_.get()));
6913	6912	InitSessionToPrecomposition(session.get());
6914	6913
6915	6914	// Undo requires capability DELETE_PRECEDING_TEXT.

6947	6946	config.set_use_auto_conversion(false);
6948	6947	config::ConfigHandler::SetConfig(config);
6949	6948	{
6950		scoped_ptr<Session> session(new Session(engine_.get()));
	6949	std::unique_ptr<Session> session(new Session(engine_.get()));
6951	6950	InitSessionToPrecomposition(session.get());
6952	6951	commands::Command command;
6953	6952

6960	6959	"\xE3\x81\xA6\xE3\x81\x99\xE3\x81\xA8\xE3\x80\x82", command);
6961	6960	}
6962	6961	{
6963		scoped_ptr<Session> session(new Session(engine_.get()));
	6962	std::unique_ptr<Session> session(new Session(engine_.get()));
6964	6963	InitSessionToPrecomposition(session.get());
6965	6964	commands::Command command;
6966	6965

6979	6978	config.set_use_auto_conversion(true);
6980	6979	config::ConfigHandler::SetConfig(config);
6981	6980	{
6982		scoped_ptr<Session> session(new Session(engine_.get()));
	6981	std::unique_ptr<Session> session(new Session(engine_.get()));
6983	6982	InitSessionToPrecomposition(session.get());
6984	6983
6985	6984	commands::Command command;

6990	6989	EXPECT_SINGLE_SEGMENT_AND_KEY(kAiueo, kAiueo, command);
6991	6990	}
6992	6991	{
6993		scoped_ptr<Session> session(new Session(engine_.get()));
	6992	std::unique_ptr<Session> session(new Session(engine_.get()));
6994	6993	InitSessionToPrecomposition(session.get());
6995	6994
6996	6995	commands::Command command;

7005	7004
7006	7005	// Don't trigger auto conversion for the pattern number + "."
7007	7006	{
7008		scoped_ptr<Session> session(new Session(engine_.get()));
	7007	std::unique_ptr<Session> session(new Session(engine_.get()));
7009	7008	InitSessionToPrecomposition(session.get());
7010	7009	commands::Command command;
7011	7010

7020	7019
7021	7020	// Don't trigger auto conversion for the ".."
7022	7021	{
7023		scoped_ptr<Session> session(new Session(engine_.get()));
	7022	std::unique_ptr<Session> session(new Session(engine_.get()));
7024	7023	InitSessionToPrecomposition(session.get());
7025	7024	commands::Command command;
7026	7025

7033	7032	}
7034	7033
7035	7034	{
7036		scoped_ptr<Session> session(new Session(engine_.get()));
	7035	std::unique_ptr<Session> session(new Session(engine_.get()));
7037	7036	InitSessionToPrecomposition(session.get());
7038	7037	commands::Command command;
7039	7038

7050	7049
7051	7050	// Don't trigger auto conversion for "." only.
7052	7051	{
7053		scoped_ptr<Session> session(new Session(engine_.get()));
	7052	std::unique_ptr<Session> session(new Session(engine_.get()));
7054	7053	InitSessionToPrecomposition(session.get());
7055	7054	commands::Command command;
7056	7055

7062	7061	}
7063	7062
7064	7063	{
7065		scoped_ptr<Session> session(new Session(engine_.get()));
	7064	std::unique_ptr<Session> session(new Session(engine_.get()));
7066	7065	InitSessionToPrecomposition(session.get());
7067	7066	commands::Command command;
7068	7067

7076	7075
7077	7076	// Do auto conversion even if romanji-table is modified.
7078	7077	{
7079		scoped_ptr<Session> session(new Session(engine_.get()));
	7078	std::unique_ptr<Session> session(new Session(engine_.get()));
7080	7079	InitSessionToPrecomposition(session.get());
7081	7080
7082	7081	// Modify romanji-table to convert "zz" -> "。"

7121	7120	config::Config::AUTO_CONVERSION_EXCLAMATION_MARK);
7122	7121
7123	7122	for (int i = 0; i < 4; ++i) {
7124		scoped_ptr<Session> session(new Session(engine_.get()));
	7123	std::unique_ptr<Session> session(new Session(engine_.get()));
7125	7124	InitSessionToPrecomposition(session.get());
7126	7125	commands::Command command;
7127	7126

7161	7160	TEST_F(SessionTest, InputSpaceWithKatakanaMode) {
7162	7161	// This is a unittest against http://b/3203944.
7163	7162	// Input mode should not be changed when a space key is typed.
7164		scoped_ptr<Session> session(new Session(engine_.get()));
	7163	std::unique_ptr<Session> session(new Session(engine_.get()));
7165	7164	InitSessionToPrecomposition(session.get());
7166	7165
7167	7166	commands::Command command;

7180	7179	TEST_F(SessionTest, AlphanumericOfSSH) {
7181	7180	// This is a unittest against http://b/3199626
7182	7181	// 'ssh' (っｓｈ) + F10 should be 'ssh'.
7183		scoped_ptr<Session> session(new Session(engine_.get()));
	7182	std::unique_ptr<Session> session(new Session(engine_.get()));
7184	7183	InitSessionToPrecomposition(session.get());
7185	7184
7186	7185	commands::Command command;

7214	7213	config::Config config;
7215	7214	config.set_session_keymap(config::Config::MSIME);
7216	7215	config::ConfigHandler::SetConfig(config);
7217		scoped_ptr<Session> session(new Session(engine_.get()));
	7216	std::unique_ptr<Session> session(new Session(engine_.get()));
7218	7217
7219	7218	InitSessionToPrecomposition(session.get(), *mobile_request_);
7220	7219	commands::Command command;

7396	7395	commands::Command command;
7397	7396
7398	7397	{
7399		scoped_ptr<Session> session(new Session(engine_.get()));
	7398	std::unique_ptr<Session> session(new Session(engine_.get()));
7400	7399	InitSessionToPrecomposition(session.get(), *mobile_request_);
7401	7400	// "は"
7402	7401	InsertCharacterCodeAndString('6', "\xE3\x81\xAF", session.get(), &command);

7413	7412	}
7414	7413
7415	7414	{
7416		scoped_ptr<Session> session(new Session(engine_.get()));
	7415	std::unique_ptr<Session> session(new Session(engine_.get()));
7417	7416	InitSessionToPrecomposition(session.get(), *mobile_request_);
7418	7417
7419	7418	SendKey("6", session.get(), &command);

7430	7429	}
7431	7430
7432	7431	{
7433		scoped_ptr<Session> session(new Session(engine_.get()));
	7432	std::unique_ptr<Session> session(new Session(engine_.get()));
7434	7433	InitSessionToPrecomposition(session.get(), *mobile_request_);
7435	7434
7436	7435	SendKey("1", session.get(), &command);

7509	7508	}
7510	7509
7511	7510	TEST_F(SessionTest, CommitCandidateAt2ndOf3Segments) {
7512		scoped_ptr<Session> session(new Session(engine_.get()));
	7511	std::unique_ptr<Session> session(new Session(engine_.get()));
7513	7512	InitSessionToPrecomposition(session.get());
7514	7513
7515	7514	ConversionRequest request;

7585	7584	}
7586	7585
7587	7586	TEST_F(SessionTest, CommitCandidateAt3rdOf3Segments) {
7588		scoped_ptr<Session> session(new Session(engine_.get()));
	7587	std::unique_ptr<Session> session(new Session(engine_.get()));
7589	7588	InitSessionToPrecomposition(session.get());
7590	7589
7591	7590	ConversionRequest request;

7648	7647	}
7649	7648
7650	7649	TEST_F(SessionTest, CommitCandidate_suggestion) {
7651		scoped_ptr<Session> session(new Session(engine_.get()));
	7650	std::unique_ptr<Session> session(new Session(engine_.get()));
7652	7651	InitSessionToPrecomposition(session.get(), *mobile_request_);
7653	7652
7654	7653	Segments segments_mo;

7671	7670	EXPECT_EQ("MOCHA", command.output().candidates().candidate(0).value());
7672	7671
7673	7672	GetConverterMock()->SetFinishConversion(
7674		scoped_ptr<Segments>(new Segments).get(), true);
	7673	std::unique_ptr<Segments>(new Segments).get(), true);
7675	7674	SetSendCommandCommand(commands::SessionCommand::SUBMIT_CANDIDATE, &command);
7676	7675	command.mutable_input()->mutable_command()->set_id(1);
7677	7676	session->SendCommand(&command);

7698	7697	}
7699	7698
7700	7699	TEST_F(SessionTest, CommitCandidate_T13N) {
7701		scoped_ptr<Session> session(new Session(engine_.get()));
	7700	std::unique_ptr<Session> session(new Session(engine_.get()));
7702	7701	InitSessionToPrecomposition(session.get(), *mobile_request_);
7703	7702
7704	7703	{

7746	7745	#else
7747	7746	EXPECT_TRUE(FindCandidateID(command.output().candidates(), "TOK", &id));
7748	7747	GetConverterMock()->SetFinishConversion(
7749		scoped_ptr<Segments>(new Segments).get(), true);
	7748	std::unique_ptr<Segments>(new Segments).get(), true);
7750	7749	SetSendCommandCommand(commands::SessionCommand::SUBMIT_CANDIDATE, &command);
7751	7750	command.mutable_input()->mutable_command()->set_id(id);
7752	7751	session->SendCommand(&command);

7758	7757	}
7759	7758
7760	7759	TEST_F(SessionTest, RequestConvertReverse) {
7761		scoped_ptr<Session> session(new Session(engine_.get()));
	7760	std::unique_ptr<Session> session(new Session(engine_.get()));
7762	7761	InitSessionToPrecomposition(session.get());
7763	7762
7764	7763	commands::Command command;

7772	7771	}
7773	7772
7774	7773	TEST_F(SessionTest, ConvertReverse) {
7775		scoped_ptr<Session> session(new Session(engine_.get()));
	7774	std::unique_ptr<Session> session(new Session(engine_.get()));
7776	7775	InitSessionToPrecomposition(session.get());
7777	7776	// "阿伊宇江於"
7778	7777	const char kKanjiAiueo[] =

7792	7791	}
7793	7792
7794	7793	TEST_F(SessionTest, EscapeFromConvertReverse) {
7795		scoped_ptr<Session> session(new Session(engine_.get()));
	7794	std::unique_ptr<Session> session(new Session(engine_.get()));
7796	7795	InitSessionToPrecomposition(session.get());
7797	7796	// "阿伊宇江於"
7798	7797	const char kKanjiAiueo[] =

7819	7818	}
7820	7819
7821	7820	TEST_F(SessionTest, SecondEscapeFromConvertReverse) {
7822		scoped_ptr<Session> session(new Session(engine_.get()));
	7821	std::unique_ptr<Session> session(new Session(engine_.get()));
7823	7822	InitSessionToPrecomposition(session.get());
7824	7823	// "阿伊宇江於"
7825	7824	const char kKanjiAiueo[] =

7851	7850
7852	7851	TEST_F(SessionTest, SecondEscapeFromConvertReverse_Issue5687022) {
7853	7852	// This is a unittest against http://b/5687022
7854		scoped_ptr<Session> session(new Session(engine_.get()));
	7853	std::unique_ptr<Session> session(new Session(engine_.get()));
7855	7854	InitSessionToPrecomposition(session.get());
7856	7855	const char kInput[] = "abcde";
7857	7856	const char kReading[] = "abcde";

7878	7877	// without any text normalization even if the input text contains any
7879	7878	// special characters which Mozc usually do normalization.
7880	7879
7881		scoped_ptr<Session> session(new Session(engine_.get()));
	7880	std::unique_ptr<Session> session(new Session(engine_.get()));
7882	7881	InitSessionToPrecomposition(session.get());
7883	7882	// "ゔ"
7884	7883	const char kInput[] = "\xE3\x82\x94";

7902	7901	}
7903	7902
7904	7903	TEST_F(SessionTest, EscapeFromCompositionAfterConvertReverse) {
7905		scoped_ptr<Session> session(new Session(engine_.get()));
	7904	std::unique_ptr<Session> session(new Session(engine_.get()));
7906	7905	InitSessionToPrecomposition(session.get());
7907	7906	// "阿伊宇江於"
7908	7907	const char kKanjiAiueo[] =

7932	7931	}
7933	7932
7934	7933	TEST_F(SessionTest, ConvertReverseFromOffState) {
7935		scoped_ptr<Session> session(new Session(engine_.get()));
	7934	std::unique_ptr<Session> session(new Session(engine_.get()));
7936	7935	InitSessionToPrecomposition(session.get());
7937	7936	// "阿伊宇江於"
7938	7937	const string kanji_aiueo =

7950	7949
7951	7950	TEST_F(SessionTest, DCHECKFailureAfterConvertReverse) {
7952	7951	// This is a unittest against http://b/5145295.
7953		scoped_ptr<Session> session(new Session(engine_.get()));
	7952	std::unique_ptr<Session> session(new Session(engine_.get()));
7954	7953	InitSessionToPrecomposition(session.get());
7955	7954
7956	7955	commands::Command command;

7973	7972	}
7974	7973
7975	7974	TEST_F(SessionTest, LaunchTool) {
7976		scoped_ptr<Session> session(new Session(engine_.get()));
	7975	std::unique_ptr<Session> session(new Session(engine_.get()));
7977	7976
7978	7977	{
7979	7978	commands::Command command;

8001	8000	}
8002	8001
8003	8002	TEST_F(SessionTest, NotZeroQuerySuggest) {
8004		scoped_ptr<Session> session(new Session(engine_.get()));
	8003	std::unique_ptr<Session> session(new Session(engine_.get()));
8005	8004	InitSessionToPrecomposition(session.get());
8006	8005
8007	8006	// Disable zero query suggest.

8180	8179	command.Clear();
8181	8180	// FinishConversion is expected to return empty Segments.
8182	8181	GetConverterMock()->SetFinishConversion(
8183		scoped_ptr<Segments>(new Segments).get(), true);
	8182	std::unique_ptr<Segments>(new Segments).get(), true);
8184	8183	session.CommitFirstSuggestion(&command);
8185	8184	EXPECT_TRUE(command.output().consumed());
8186	8185	EXPECT_FALSE(command.output().has_preedit());

8284	8283	request.set_special_romanji_table(
8285	8284	commands::Request::TWELVE_KEYS_TO_HALFWIDTHASCII);
8286	8285	session.SetRequest(&request);
8287		scoped_ptr<composer::Table> table(new composer::Table());
	8286	std::unique_ptr<composer::Table> table(new composer::Table());
8288	8287	table->InitializeWithRequestAndConfig(
8289	8288	request, config::ConfigHandler::GetConfig());
8290	8289	session.SetTable(table.get());

8653	8652	}
8654	8653
8655	8654	TEST_F(SessionTest, MoveCursor) {
8656		scoped_ptr<Session> session(new Session(engine_.get()));
	8655	std::unique_ptr<Session> session(new Session(engine_.get()));
8657	8656	InitSessionToPrecomposition(session.get());
8658	8657	commands::Command command;
8659	8658

8669	8668	}
8670	8669
8671	8670	TEST_F(SessionTest, MoveCursorRightWithCommit) {
8672		scoped_ptr<Session> session(new Session(engine_.get()));
	8671	std::unique_ptr<Session> session(new Session(engine_.get()));
8673	8672	commands::Request request;
8674	8673	request.CopyFrom(*mobile_request_);
8675	8674	request.set_special_romanji_table(

8698	8697	}
8699	8698
8700	8699	TEST_F(SessionTest, MoveCursorLeftWithCommit) {
8701		scoped_ptr<Session> session(new Session(engine_.get()));
	8700	std::unique_ptr<Session> session(new Session(engine_.get()));
8702	8701	commands::Request request;
8703	8702	request.CopyFrom(*mobile_request_);
8704	8703	request.set_special_romanji_table(

8734	8733	}
8735	8734
8736	8735	TEST_F(SessionTest, CommitHead) {
8737		scoped_ptr<Session> session(new Session(engine_.get()));
	8736	std::unique_ptr<Session> session(new Session(engine_.get()));
8738	8737	composer::Table table;
8739	8738	// "も"
8740	8739	table.AddRule("mo", "\xe3\x82\x82", "");

8761	8760	}
8762	8761
8763	8762	TEST_F(SessionTest, PasswordWithToggleAlpabetInput) {
8764		scoped_ptr<Session> session(new Session(engine_.get()));
	8763	std::unique_ptr<Session> session(new Session(engine_.get()));
8765	8764
8766	8765	commands::Request request;
8767	8766	request.CopyFrom(*mobile_request_);

8813	8812	}
8814	8813
8815	8814	TEST_F(SessionTest, SwitchInputFieldType) {
8816		scoped_ptr<Session> session(new Session(engine_.get()));
	8815	std::unique_ptr<Session> session(new Session(engine_.get()));
8817	8816	InitSessionToPrecomposition(session.get());
8818	8817
8819	8818	// initial state is NORMAL

8831	8830	}
8832	8831
8833	8832	TEST_F(SessionTest, CursorKeysInPasswordMode) {
8834		scoped_ptr<Session> session(new Session(engine_.get()));
	8833	std::unique_ptr<Session> session(new Session(engine_.get()));
8835	8834
8836	8835	commands::Request request;
8837	8836	request.CopyFrom(*mobile_request_);

8878	8877	}
8879	8878
8880	8879	TEST_F(SessionTest, BackKeyCommitsPreeditInPasswordMode) {
8881		scoped_ptr<Session> session(new Session(engine_.get()));
	8880	std::unique_ptr<Session> session(new Session(engine_.get()));
8882	8881	InitSessionToPrecomposition(session.get());
8883	8882	commands::Command command;
8884	8883	commands::Request request;

8985	8984	}
8986	8985
8987	8986	TEST_F(SessionTest, ImeOff) {
8988		scoped_ptr<MockConverterEngineForReset> engine(
	8987	std::unique_ptr<MockConverterEngineForReset> engine(
8989	8988	new MockConverterEngineForReset);
8990	8989	ConverterMockForReset *convertermock = engine->mutable_converter_mock();
8991	8990
8992	8991	convertermock->Reset();
8993		scoped_ptr<Session> session(new Session(engine.get()));
	8992	std::unique_ptr<Session> session(new Session(engine.get()));
8994	8993	InitSessionToPrecomposition(session.get());
8995	8994	commands::Command command;
8996	8995	session->IMEOff(&command);

9389	9388	// Also it is not necessary to test in case of changing to CONVERSION state,
9390	9389	// because conversion window is always shown under current cursor.
9391	9390	TEST_F(SessionTest, CaretManagePrecompositionToCompositionTest) {
9392		scoped_ptr<Session> session(new Session(engine_.get()));
	9391	std::unique_ptr<Session> session(new Session(engine_.get()));
9393	9392	InitSessionToPrecomposition(session.get());
9394	9393
9395	9394	commands::Command command;

9456	9455	segment->add_candidate()->value = "MOZUKU";
9457	9456	}
9458	9457
9459		scoped_ptr<Session> session(new Session(engine_.get()));
	9458	std::unique_ptr<Session> session(new Session(engine_.get()));
9460	9459	InitSessionToPrecomposition(session.get());
9461	9460	commands::Command command;
9462	9461	const int kCaretInitialXpos = 10;

9567	9566	// Actual: ^a\|i
9568	9567	// In the session side, we can only support the former case.
9569	9568
9570		scoped_ptr<Session> session(new Session(engine_.get()));
	9569	std::unique_ptr<Session> session(new Session(engine_.get()));
9571	9570	InitSessionToPrecomposition(session.get());
9572	9571
9573	9572	commands::Command command;

9618	9617	segment->add_candidate()->value = "m";
9619	9618	}
9620	9619
9621		scoped_ptr<ConversionRequest> request_m_conv;
	9620	std::unique_ptr<ConversionRequest> request_m_conv;
9622	9621
9623	9622	// [CONV-L] -> [COMP-R]
9624	9623	// Expectation: ^\|a -> ^a\|

9695	9694	}
9696	9695
9697	9696	TEST_F(SessionTest, CaretJumpCaseTest) {
9698		scoped_ptr<Session> session(new Session(engine_.get()));
	9697	std::unique_ptr<Session> session(new Session(engine_.get()));
9699	9698	InitSessionToPrecomposition(session.get());
9700	9699
9701	9700	commands::Command command;

9832	9831	}
9833	9832
9834	9833	TEST_F(SessionTest, DeleteHistory) {
9835		scoped_ptr<Session> session(new Session(engine_.get()));
	9834	std::unique_ptr<Session> session(new Session(engine_.get()));
9836	9835	InitSessionToPrecomposition(session.get());
9837	9836
9838	9837	Segments segments;

9910	9909	}
9911	9910
9912	9911	TEST_F(SessionTest, IndirectImeOnOff) {
9913		scoped_ptr<Session> session(new Session(engine_.get()));
	9912	std::unique_ptr<Session> session(new Session(engine_.get()));
9914	9913	InitSessionToPrecomposition(session.get());
9915	9914
9916	9915	{

9957	9956	}
9958	9957
9959	9958	TEST_F(SessionTest, MakeSureIMEOn) {
9960		scoped_ptr<Session> session(new Session(engine_.get()));
	9959	std::unique_ptr<Session> session(new Session(engine_.get()));
9961	9960	InitSessionToDirect(session.get());
9962	9961
9963	9962	{

10009	10008	}
10010	10009
10011	10010	TEST_F(SessionTest, MakeSureIMEOff) {
10012		scoped_ptr<Session> session(new Session(engine_.get()));
	10011	std::unique_ptr<Session> session(new Session(engine_.get()));
10013	10012	InitSessionToPrecomposition(session.get());
10014	10013
10015	10014	{

+7

-7

src/session/session_usage_observer_test.cc less more

28	28
29	29	#include "session/session_usage_observer.h"
30	30
	31	#include <memory>
31	32	#include <string>
32	33
33	34	#include "base/clock.h"

35	36	#include "base/logging.h"
36	37	#include "base/scheduler.h"
37	38	#include "base/scheduler_stub.h"
38		#include "base/scoped_ptr.h"
39	39	#include "base/system_util.h"
40	40	#include "base/util.h"
41	41	#include "config/stats_config_util.h"

114	114	event_stats->mutable_time_length_stats());
115	115	}
116	116
117		scoped_ptr<SchedulerStub> scheduler_stub_;
118		scoped_ptr<config::StatsConfigUtilMock> stats_config_util_mock_;
	117	std::unique_ptr<SchedulerStub> scheduler_stub_;
	118	std::unique_ptr<config::StatsConfigUtilMock> stats_config_util_mock_;
119	119	};
120	120
121	121	TEST_F(SessionUsageObserverTest, DoNotSaveWhenDeleted) {
122	122	stats_config_util_mock_->SetEnabled(false);
123	123
124		scoped_ptr<SessionUsageObserver> observer(new SessionUsageObserver);
	124	std::unique_ptr<SessionUsageObserver> observer(new SessionUsageObserver);
125	125
126	126	// Add command
127	127	commands::Command command;

138	138	}
139	139
140	140	TEST_F(SessionUsageObserverTest, ClientSideStatsInfolist) {
141		scoped_ptr<SessionUsageObserver> observer(new SessionUsageObserver);
	141	std::unique_ptr<SessionUsageObserver> observer(new SessionUsageObserver);
142	142
143	143	// create session
144	144	{

267	267	}
268	268
269	269	TEST_F(SessionUsageObserverTest, LogTouchEvent) {
270		scoped_ptr<SessionUsageObserver> observer(new SessionUsageObserver);
	270	std::unique_ptr<SessionUsageObserver> observer(new SessionUsageObserver);
271	271
272	272	// create session
273	273	{

483	483	}
484	484
485	485	TEST_F(SessionUsageObserverTest, LogTouchEventPasswordField) {
486		scoped_ptr<SessionUsageObserver> observer(new SessionUsageObserver);
	486	std::unique_ptr<SessionUsageObserver> observer(new SessionUsageObserver);
487	487
488	488	// create session
489	489	{

+3

-3

src/session/session_watch_dog.cc less more

30	30
31	31	#include <algorithm>
32	32	#include <cstring>
	33	#include <memory>
33	34	#include <numeric>
34	35	#include <string>
35	36

37	38	#include "base/cpu_stats.h"
38	39	#include "base/logging.h"
39	40	#include "base/port.h"
40		#include "base/scoped_ptr.h"
41	41	#include "base/system_util.h"
42	42	#include "base/unnamed_event.h"
43	43	#include "client/client_interface.h"

97	97	}
98	98
99	99	void SessionWatchDog::Run() {
100		scoped_ptr<client::ClientInterface> client_impl;
	100	std::unique_ptr<client::ClientInterface> client_impl;
101	101	if (client_ == NULL) {
102	102	VLOG(2) << "default client is used";
103	103	client_impl.reset(client::ClientFactory::NewClient());
104	104	client_ = client_impl.get();
105	105	}
106	106
107		scoped_ptr<CPUStatsInterface> cpu_stats_impl;
	107	std::unique_ptr<CPUStatsInterface> cpu_stats_impl;
108	108	if (cpu_stats_ == NULL) {
109	109	VLOG(2) << "default cpu_stats is used";
110	110	cpu_stats_impl.reset(new CPUStats);

+5

-2

src/session/session_watch_dog.h less more

31	31	#ifndef MOZC_SESSION_SESSION_WATCH_DOG_H_
32	32	#define MOZC_SESSION_SESSION_WATCH_DOG_H_
33	33
	34	#include <memory>
	35
34	36	#include "base/port.h"
35		#include "base/scoped_ptr.h"
36	37	#include "base/thread.h"
37	38
38	39	namespace mozc {

86	87	int32 interval_sec_;
87	88	client::ClientInterface *client_;
88	89	CPUStatsInterface *cpu_stats_;
89		scoped_ptr<UnnamedEvent> event_;
	90	std::unique_ptr<UnnamedEvent> event_;
90	91
91	92	DISALLOW_COPY_AND_ASSIGN(SessionWatchDog);
92	93	};
	94
93	95	} // namespace mozc
	96
94	97	#endif // MOZC_SESSION_SESSION_WATCH_DOG_H_