diff --git a/src/android/jni/BUILD.bazel b/src/android/jni/BUILD.bazel
index 549ce32e8..b1f1af8a2 100644
--- a/src/android/jni/BUILD.bazel
+++ b/src/android/jni/BUILD.bazel
@@ -39,6 +39,9 @@ load("//:build_defs.bzl", "MOZC_TAGS", "mozc_cc_library", "mozc_py_binary", "moz
 mozc_cc_library(
     name = "mozcjni",
     srcs = ["mozcjni.cc"],
+    linkopts = mozc_select(
+        android = ["-llog"],
+    ),
     tags = MOZC_TAGS.ANDROID_ONLY,
     # Scheuklappen: keep
     visibility = [
diff --git a/src/composer/BUILD.bazel b/src/composer/BUILD.bazel
index cb2168ef8..995646543 100644
--- a/src/composer/BUILD.bazel
+++ b/src/composer/BUILD.bazel
@@ -86,8 +86,6 @@ mozc_cc_test(
         "//base:util",
         "//config:character_form_manager",
         "//config:config_handler",
-        "//data_manager/testing:mock_data_manager",
-        "//engine:spellchecker_interface",
         "//protocol:commands_cc_proto",
         "//protocol:config_cc_proto",
         "//testing:gunit_main",
diff --git a/src/composer/composer_test.cc b/src/composer/composer_test.cc
index 7c1263e87..89e0f4a01 100644
--- a/src/composer/composer_test.cc
+++ b/src/composer/composer_test.cc
@@ -46,11 +46,8 @@
 #include "composer/table.h"
 #include "config/character_form_manager.h"
 #include "config/config_handler.h"
-#include "data_manager/testing/mock_data_manager.h"
-#include "engine/spellchecker_interface.h"
 #include "protocol/commands.pb.h"
 #include "protocol/config.pb.h"
-#include "testing/gmock.h"
 #include "testing/gunit.h"
 #include "transliteration/transliteration.h"
 
@@ -58,19 +55,10 @@ namespace mozc {
 namespace composer {
 namespace {
 
-using ProbableKeyEvent = commands::KeyEvent_ProbableKeyEvent;
-using ProbableKeyEvents = mozc::protobuf::RepeatedPtrField<ProbableKeyEvent>;
-
-using ::mozc::commands::CheckSpellingResponse;
 using ::mozc::commands::KeyEvent;
 using ::mozc::commands::Request;
 using ::mozc::config::CharacterFormManager;
 using ::mozc::config::Config;
-using ::testing::_;
-using ::testing::Return;
-
-// ProbableKeyEvent is the inner-class member so needs to define as alias.
-using ProbableKeyEvent = ::mozc::commands::KeyEvent::ProbableKeyEvent;
 
 bool InsertKey(const absl::string_view key_string, Composer *composer) {
   commands::KeyEvent key;
@@ -134,7 +122,6 @@ class ComposerTest : public ::testing::Test {
     table_.reset();
   }
 
-  const testing::MockDataManager mock_data_manager_;
   std::unique_ptr<Composer> composer_;
   std::unique_ptr<Table> table_;
   std::unique_ptr<Request> request_;
@@ -1222,8 +1209,7 @@ TEST_F(ComposerTest, ShiftKeyOperation) {
 
 TEST_F(ComposerTest, ShiftKeyOperationForKatakana) {
   config_->set_shift_key_mode_switch(Config::KATAKANA_INPUT_MODE);
-  table_->InitializeWithRequestAndConfig(*request_, *config_,
-                                         mock_data_manager_);
+  table_->InitializeWithRequestAndConfig(*request_, *config_);
   composer_->Reset();
   composer_->SetInputMode(transliteration::HIRAGANA);
   InsertKey("K", composer_.get());
@@ -1259,8 +1245,7 @@ TEST_F(ComposerTest, AutoIMETurnOffEnabled) {
   config_->set_preedit_method(Config::ROMAN);
   config_->set_use_auto_ime_turn_off(true);
 
-  table_->InitializeWithRequestAndConfig(*request_, *config_,
-                                         mock_data_manager_);
+  table_->InitializeWithRequestAndConfig(*request_, *config_);
 
   commands::KeyEvent key;
 
@@ -1371,8 +1356,7 @@ TEST_F(ComposerTest, AutoIMETurnOffDisabled) {
   config_->set_preedit_method(Config::ROMAN);
   config_->set_use_auto_ime_turn_off(false);
 
-  table_->InitializeWithRequestAndConfig(*request_, *config_,
-                                         mock_data_manager_);
+  table_->InitializeWithRequestAndConfig(*request_, *config_);
 
   commands::KeyEvent key;
 
@@ -1405,8 +1389,7 @@ TEST_F(ComposerTest, AutoIMETurnOffKana) {
   config_->set_preedit_method(Config::KANA);
   config_->set_use_auto_ime_turn_off(true);
 
-  table_->InitializeWithRequestAndConfig(*request_, *config_,
-                                         mock_data_manager_);
+  table_->InitializeWithRequestAndConfig(*request_, *config_);
 
   commands::KeyEvent key;
 
@@ -2126,8 +2109,7 @@ TEST_F(ComposerTest, Issue2797991Case4) {
 TEST_F(ComposerTest, CaseSensitiveByConfiguration) {
   {
     config_->set_shift_key_mode_switch(Config::OFF);
-    table_->InitializeWithRequestAndConfig(*request_, *config_,
-                                           mock_data_manager_);
+    table_->InitializeWithRequestAndConfig(*request_, *config_);
 
     table_->AddRule("i", "い", "");
     table_->AddRule("I", "イ", "");
@@ -2141,8 +2123,7 @@ TEST_F(ComposerTest, CaseSensitiveByConfiguration) {
   composer_->Reset();
   {
     config_->set_shift_key_mode_switch(Config::ASCII_INPUT_MODE);
-    table_->InitializeWithRequestAndConfig(*request_, *config_,
-                                           mock_data_manager_);
+    table_->InitializeWithRequestAndConfig(*request_, *config_);
 
     table_->AddRule("i", "い", "");
     table_->AddRule("I", "イ", "");
@@ -2159,8 +2140,7 @@ TEST_F(ComposerTest,
        InputUppercaseInAlphanumericModeWithShiftKeyModeSwitchIsKatakana) {
   {
     config_->set_shift_key_mode_switch(Config::KATAKANA_INPUT_MODE);
-    table_->InitializeWithRequestAndConfig(*request_, *config_,
-                                           mock_data_manager_);
+    table_->InitializeWithRequestAndConfig(*request_, *config_);
 
     table_->AddRule("i", "い", "");
     table_->AddRule("I", "イ", "");
@@ -2208,8 +2188,7 @@ TEST_F(ComposerTest, DeletingAlphanumericPartShouldQuitToggleAlphanumericMode) {
   // 2. Type Back-space 6 times ("い")
   // 3. Type "i" (should be "いい")
 
-  table_->InitializeWithRequestAndConfig(*request_, *config_,
-                                         mock_data_manager_);
+  table_->InitializeWithRequestAndConfig(*request_, *config_);
 
   table_->AddRule("i", "い", "");
 
@@ -2240,8 +2219,7 @@ TEST_F(ComposerTest, DeletingAlphanumericPartShouldQuitToggleAlphanumericMode) {
 TEST_F(ComposerTest, InputModesChangeWhenCursorMoves) {
   // The expectation of this test is the same as MS-IME's
 
-  table_->InitializeWithRequestAndConfig(*request_, *config_,
-                                         mock_data_manager_);
+  table_->InitializeWithRequestAndConfig(*request_, *config_);
 
   table_->AddRule("i", "い", "");
   table_->AddRule("gi", "ぎ", "");
@@ -2520,7 +2498,7 @@ TEST_F(ComposerTest, 12KeysAsciiGetQueryForPrediction) {
       commands::Request::TWELVE_KEYS_TO_HALFWIDTHASCII);
   composer_->SetRequest(&request);
   table_->InitializeWithRequestAndConfig(
-      request, config::ConfigHandler::DefaultConfig(), mock_data_manager_);
+      request, config::ConfigHandler::DefaultConfig());
   composer_->InsertCharacter("2");
   EXPECT_EQ(composer_->GetStringForPreedit(), "a");
   EXPECT_EQ(composer_->GetQueryForConversion(), "a");
diff --git a/src/composer/table.cc b/src/composer/table.cc
index bd7b6e60a..b95786b8c 100644
--- a/src/composer/table.cc
+++ b/src/composer/table.cc
@@ -138,8 +138,7 @@ constexpr absl::string_view kSquareClose = "]";
 constexpr absl::string_view kMiddleDot = "・";
 
 bool Table::InitializeWithRequestAndConfig(
-    const commands::Request &request, const config::Config &config,
-    const DataManagerInterface &data_manager) {
+    const commands::Request &request, const config::Config &config) {
   case_sensitive_ = false;
   bool result = false;
   if (request.special_romanji_table() !=
@@ -566,9 +565,8 @@ const Table &Table::GetDefaultTable() {
 TableManager::TableManager()
     : custom_roman_table_fingerprint_(Fingerprint32("")) {}
 
-const Table *TableManager::GetTable(
-    const mozc::commands::Request &request, const mozc::config::Config &config,
-    const mozc::DataManagerInterface &data_manager) {
+const Table *TableManager::GetTable(const mozc::commands::Request &request,
+                                    const mozc::config::Config &config) {
   // calculate the hash depending on the request and the config
   uint32_t hash = request.special_romanji_table();
   hash = hash * (mozc::config::Config_PreeditMethod_PreeditMethod_MAX + 1) +
@@ -602,7 +600,7 @@ const Table *TableManager::GetTable(
   }
 
   auto table = std::make_unique<Table>();
-  if (!table->InitializeWithRequestAndConfig(request, config, data_manager)) {
+  if (!table->InitializeWithRequestAndConfig(request, config)) {
     return nullptr;
   }
 
diff --git a/src/composer/table.h b/src/composer/table.h
index 4932a52df..ea9018710 100644
--- a/src/composer/table.h
+++ b/src/composer/table.h
@@ -37,7 +37,6 @@
 #include <istream>
 #include <memory>
 #include <string>
-#include <utility>
 #include <vector>
 
 #include "absl/container/flat_hash_map.h"
@@ -45,7 +44,6 @@
 #include "absl/strings/string_view.h"
 #include "base/container/trie.h"
 #include "composer/internal/special_key.h"
-#include "data_manager/data_manager_interface.h"
 #include "protocol/commands.pb.h"
 #include "protocol/config.pb.h"
 
@@ -94,8 +92,7 @@ class Table final {
   Table &operator=(const Table &) = delete;
 
   bool InitializeWithRequestAndConfig(const commands::Request &request,
-                                      const config::Config &config,
-                                      const DataManagerInterface &data_manager);
+                                      const config::Config &config);
 
   // Return true if adding the input-pending pair makes a loop of
   // conversion rules.
@@ -161,8 +158,7 @@ class TableManager {
   // Return Table for the request and the config
   // TableManager has ownership of the return value;
   const Table *GetTable(const commands::Request &request,
-                        const config::Config &config,
-                        const DataManagerInterface &data_manager);
+                        const config::Config &config);
 
   void ClearCaches();
 
diff --git a/src/composer/table_test.cc b/src/composer/table_test.cc
index b95c1bfc1..f3d2f301d 100644
--- a/src/composer/table_test.cc
+++ b/src/composer/table_test.cc
@@ -151,8 +151,8 @@ TEST_F(TableTest, Punctuations) {
     config::Config config;
     config.set_punctuation_method(test_case.method);
     Table table;
-    ASSERT_TRUE(table.InitializeWithRequestAndConfig(request, config,
-                                                     mock_data_manager_));
+    ASSERT_TRUE(table.InitializeWithRequestAndConfig(request, config));
+
     const Entry *entry = table.LookUp(test_case.input);
     EXPECT_NE(entry, nullptr) << "Failed index = " << index;
     if (entry) {
@@ -188,8 +188,8 @@ TEST_F(TableTest, Symbols) {
     config::Config config;
     config.set_symbol_method(test_case.method);
     Table table;
-    ASSERT_TRUE(table.InitializeWithRequestAndConfig(request, config,
-                                                     mock_data_manager_));
+    ASSERT_TRUE(table.InitializeWithRequestAndConfig(request, config));
+
     const Entry *entry = table.LookUp(test_case.input);
     EXPECT_NE(entry, nullptr) << "Failed index = " << index;
     if (entry) {
@@ -205,8 +205,7 @@ TEST_F(TableTest, KanaSuppressed) {
   commands::Request request;
 
   Table table;
-  ASSERT_TRUE(table.InitializeWithRequestAndConfig(request, config_,
-                                                   mock_data_manager_));
+  ASSERT_TRUE(table.InitializeWithRequestAndConfig(request, config_));
 
   const Entry *entry = table.LookUp("a");
   ASSERT_NE(entry, nullptr);
@@ -217,8 +216,8 @@ TEST_F(TableTest, KanaSuppressed) {
 TEST_F(TableTest, KanaCombination) {
   Table table;
   commands::Request request;
-  ASSERT_TRUE(table.InitializeWithRequestAndConfig(request, config_,
-                                                   mock_data_manager_));
+  ASSERT_TRUE(table.InitializeWithRequestAndConfig(request, config_));
+
   const Entry *entry = table.LookUp("か゛");
   ASSERT_NE(entry, nullptr);
   EXPECT_EQ(entry->result(), "が");
@@ -355,7 +354,7 @@ TEST_F(TableTest, CustomPunctuationsAndSymbols) {
 
   Table table;
   commands::Request request;
-  table.InitializeWithRequestAndConfig(request, config_, mock_data_manager_);
+  table.InitializeWithRequestAndConfig(request, config_);
 
   const Entry *entry = nullptr;
   entry = table.LookUp("mozc");
@@ -459,36 +458,36 @@ TEST_F(TableTest, CaseSensitivity) {
   commands::Request request;
   {
     Table table;
-    table.InitializeWithRequestAndConfig(request, config_, mock_data_manager_);
+    table.InitializeWithRequestAndConfig(request, config_);
     EXPECT_FALSE(table.case_sensitive());
   }
   {
     Table table;
-    table.InitializeWithRequestAndConfig(request, config_, mock_data_manager_);
+    table.InitializeWithRequestAndConfig(request, config_);
     table.AddRule("", "", "");
     EXPECT_FALSE(table.case_sensitive());
   }
   {
     Table table;
-    table.InitializeWithRequestAndConfig(request, config_, mock_data_manager_);
+    table.InitializeWithRequestAndConfig(request, config_);
     table.AddRule("a", "", "");
     EXPECT_FALSE(table.case_sensitive());
   }
   {
     Table table;
-    table.InitializeWithRequestAndConfig(request, config_, mock_data_manager_);
+    table.InitializeWithRequestAndConfig(request, config_);
     table.AddRule("A", "", "");
     EXPECT_TRUE(table.case_sensitive());
   }
   {
     Table table;
-    table.InitializeWithRequestAndConfig(request, config_, mock_data_manager_);
+    table.InitializeWithRequestAndConfig(request, config_);
     table.AddRule("a{A}a", "", "");
     EXPECT_FALSE(table.case_sensitive());
   }
   {
     Table table;
-    table.InitializeWithRequestAndConfig(request, config_, mock_data_manager_);
+    table.InitializeWithRequestAndConfig(request, config_);
     table.AddRule("A{A}A", "", "");
     EXPECT_TRUE(table.case_sensitive());
   }
@@ -504,7 +503,7 @@ TEST_F(TableTest, CaseSensitiveByConfiguration) {
   // config::Config::OFF
   {
     config_.set_shift_key_mode_switch(config::Config::OFF);
-    table.InitializeWithRequestAndConfig(request, config_, mock_data_manager_);
+    table.InitializeWithRequestAndConfig(request, config_);
 
     table.AddRule("a", "[a]", "");
     table.AddRule("A", "[A]", "");
@@ -544,7 +543,7 @@ TEST_F(TableTest, CaseSensitiveByConfiguration) {
   // config::Config::ASCII_INPUT_MODE
   {
     config_.set_shift_key_mode_switch(config::Config::ASCII_INPUT_MODE);
-    table.InitializeWithRequestAndConfig(request, config_, mock_data_manager_);
+    table.InitializeWithRequestAndConfig(request, config_);
 
     table.AddRule("a", "[a]", "");
     table.AddRule("A", "[A]", "");
@@ -584,7 +583,7 @@ TEST_F(TableTest, CaseSensitiveByConfiguration) {
   // config::Config::KATAKANA_INPUT_MODE
   {
     config_.set_shift_key_mode_switch(config::Config::KATAKANA_INPUT_MODE);
-    table.InitializeWithRequestAndConfig(request, config_, mock_data_manager_);
+    table.InitializeWithRequestAndConfig(request, config_);
 
     table.AddRule("a", "[a]", "");
     table.AddRule("A", "[A]", "");
@@ -628,7 +627,7 @@ TEST_F(TableTest, CaseSensitiveByConfiguration) {
 // This feature was implemented as b/2910223 as per following request.
 // http://www.google.com/support/forum/p/ime/thread?tid=4ea9aed4ac8a2ba6&hl=ja
 //
-// The following test checks if a case-sensitive and a case-inensitive roman
+// The following test checks if a case-sensitive and a case-insensitive roman
 // table enables and disables this "case-sensitive mode", respectively.
 TEST_F(TableTest, AutomaticCaseSensitiveDetection) {
   constexpr absl::string_view kCaseInsensitiveRomanTable = {
@@ -649,8 +648,8 @@ TEST_F(TableTest, AutomaticCaseSensitiveDetection) {
     EXPECT_FALSE(table.case_sensitive())
         << "case-sensitive mode should be desabled by default.";
     // Load a custom config with case-sensitive custom roman table.
-    ASSERT_TRUE(table.InitializeWithRequestAndConfig(request, config,
-                                                     mock_data_manager_));
+    ASSERT_TRUE(table.InitializeWithRequestAndConfig(request, config));
+
     EXPECT_TRUE(table.case_sensitive())
         << "Case sensitive roman table should enable case-sensitive mode.";
     // Explicitly disable case-sensitive mode.
@@ -663,8 +662,8 @@ TEST_F(TableTest, AutomaticCaseSensitiveDetection) {
     // Load a custom config with case-insensitive custom roman table.
     config::Config config(config::ConfigHandler::DefaultConfig());
     config.set_custom_roman_table(kCaseInsensitiveRomanTable);
-    ASSERT_TRUE(table.InitializeWithRequestAndConfig(request, config,
-                                                     mock_data_manager_));
+    ASSERT_TRUE(table.InitializeWithRequestAndConfig(request, config));
+
     EXPECT_FALSE(table.case_sensitive())
         << "Case insensitive roman table should disable case-sensitive mode.";
     // Explicitly enable case-sensitive mode.
@@ -683,7 +682,7 @@ TEST_F(TableTest, MobileMode) {
     request.set_special_romanji_table(
         mozc::commands::Request::TWELVE_KEYS_TO_HIRAGANA);
     mozc::composer::Table table;
-    table.InitializeWithRequestAndConfig(request, config_, mock_data_manager_);
+    table.InitializeWithRequestAndConfig(request, config_);
     {
       const mozc::composer::Entry *entry = nullptr;
       size_t key_length = 0;
@@ -715,7 +714,7 @@ TEST_F(TableTest, MobileMode) {
     request.set_special_romanji_table(
         mozc::commands::Request::TWELVE_KEYS_TO_HALFWIDTHASCII);
     Table table;
-    table.InitializeWithRequestAndConfig(request, config_, mock_data_manager_);
+    table.InitializeWithRequestAndConfig(request, config_);
     const mozc::composer::Entry *entry = nullptr;
     size_t key_length = 0;
     bool fixed = false;
@@ -730,7 +729,7 @@ TEST_F(TableTest, MobileMode) {
     request.set_special_romanji_table(
         mozc::commands::Request::GODAN_TO_HIRAGANA);
     Table table;
-    table.InitializeWithRequestAndConfig(request, config_, mock_data_manager_);
+    table.InitializeWithRequestAndConfig(request, config_);
     {
       const mozc::composer::Entry *entry = nullptr;
       size_t key_length = 0;
@@ -745,7 +744,7 @@ TEST_F(TableTest, MobileMode) {
     request.set_special_romanji_table(
         mozc::commands::Request::FLICK_TO_HIRAGANA);
     Table table;
-    table.InitializeWithRequestAndConfig(request, config_, mock_data_manager_);
+    table.InitializeWithRequestAndConfig(request, config_);
 
     size_t key_length = 0;
     bool fixed = false;
@@ -759,7 +758,7 @@ TEST_F(TableTest, MobileMode) {
     request.set_special_romanji_table(
         mozc::commands::Request::NOTOUCH_TO_HIRAGANA);
     Table table;
-    table.InitializeWithRequestAndConfig(request, config_, mock_data_manager_);
+    table.InitializeWithRequestAndConfig(request, config_);
 
     size_t key_length = 0;
     bool fixed = false;
@@ -1026,11 +1025,9 @@ TEST_F(TableTest, TableManager) {
           config.set_preedit_method(preedit);
           config.set_punctuation_method(punctuation);
           config.set_symbol_method(symbol);
-          const Table *table =
-              table_manager.GetTable(request, config, mock_data_manager_);
+          const Table *table = table_manager.GetTable(request, config);
           EXPECT_NE(table, nullptr);
-          EXPECT_EQ(table_manager.GetTable(request, config,
-                                             mock_data_manager_), table);
+          EXPECT_EQ(table_manager.GetTable(request, config), table);
           EXPECT_FALSE(table_set.contains(table));
           table_set.insert(table);
         }
@@ -1049,11 +1046,9 @@ TEST_F(TableTest, TableManager) {
     config.set_punctuation_method(Config::KUTEN_TOUTEN);
     config.set_symbol_method(Config::CORNER_BRACKET_MIDDLE_DOT);
     config.set_custom_roman_table(kRule);
-    const Table *table =
-        table_manager.GetTable(request, config, mock_data_manager_);
+    const Table *table = table_manager.GetTable(request, config);
     EXPECT_NE(table, nullptr);
-    EXPECT_EQ(table_manager.GetTable(request, config, mock_data_manager_),
-                table);
+    EXPECT_EQ(table_manager.GetTable(request, config), table);
     EXPECT_NE(table->LookUp("a"), nullptr);
     EXPECT_EQ(table->LookUp("kk"), nullptr);
 
@@ -1061,11 +1056,9 @@ TEST_F(TableTest, TableManager) {
         "a\t[A]\n"       // 2 entry rule
         "kk\t[X]\tk\n";  // 3 entry rule
     config.set_custom_roman_table(kRule2);
-    const Table *table2 =
-        table_manager.GetTable(request, config, mock_data_manager_);
+    const Table *table2 = table_manager.GetTable(request, config);
     EXPECT_NE(table2, nullptr);
-    EXPECT_EQ(table_manager.GetTable(request, config, mock_data_manager_),
-                table2);
+    EXPECT_EQ(table_manager.GetTable(request, config), table2);
     EXPECT_NE(table2->LookUp("a"), nullptr);
     EXPECT_NE(table2->LookUp("kk"), nullptr);
   }
diff --git a/src/converter/BUILD.bazel b/src/converter/BUILD.bazel
index 2d47385f7..96a1a100d 100644
--- a/src/converter/BUILD.bazel
+++ b/src/converter/BUILD.bazel
@@ -422,7 +422,6 @@ mozc_cc_library(
         ":immutable_converter_interface",
         ":segments",
         "//base:japanese_util",
-        "//base:logging",
         "//base:util",
         "//base:vlog",
         "//base/strings:assign",
@@ -438,6 +437,8 @@ mozc_cc_library(
         "//transliteration",
         "//usage_stats",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log",
+        "@com_google_absl//absl/log:check",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/types:span",
     ],
@@ -644,7 +645,11 @@ mozc_cc_library(
     hdrs = ["converter_mock.h"],
     deps = [
         ":converter_interface",
+        ":segments",
+        "//request:conversion_request",
         "//testing:gunit",
+        "@com_google_absl//absl/strings",
+        "@com_google_absl//absl/types:span",
     ],
 )
 
diff --git a/src/converter/converter.cc b/src/converter/converter.cc
index 6624d7365..f3d43af43 100644
--- a/src/converter/converter.cc
+++ b/src/converter/converter.cc
@@ -37,10 +37,11 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 #include "base/japanese_util.h"
-#include "base/logging.h"
 #include "base/strings/assign.h"
 #include "base/util.h"
 #include "base/vlog.h"
@@ -273,8 +274,8 @@ void Converter::Init(const engine::Modules &modules,
   general_noun_id_ = pos_matcher_->GetGeneralNounId();
 }
 
-bool Converter::StartConversionForRequest(
-    const ConversionRequest &original_request, Segments *segments) const {
+bool Converter::StartConversion(const ConversionRequest &original_request,
+                                Segments *segments) const {
   ConversionRequest request = CreateConversionRequestWithType(
       original_request, ConversionRequest::CONVERSION);
   if (!request.has_composer()) {
@@ -300,8 +301,8 @@ bool Converter::StartConversionForRequest(
   return Convert(request, conversion_key, segments);
 }
 
-bool Converter::StartConversion(Segments *segments,
-                                const absl::string_view key) const {
+bool Converter::StartConversionWithKey(Segments *segments,
+                                       const absl::string_view key) const {
   if (key.empty()) {
     return false;
   }
@@ -425,8 +426,8 @@ bool Converter::Predict(const ConversionRequest &request,
   return IsValidSegments(request, *segments);
 }
 
-bool Converter::StartPredictionForRequest(
-    const ConversionRequest &original_request, Segments *segments) const {
+bool Converter::StartPrediction(const ConversionRequest &original_request,
+                                Segments *segments) const {
   ConversionRequest request = CreateConversionRequestWithType(
       original_request, ConversionRequest::PREDICTION);
   if (!request.has_composer()) {
@@ -438,22 +439,22 @@ bool Converter::StartPredictionForRequest(
   return Predict(request, prediction_key, segments);
 }
 
-bool Converter::StartPrediction(Segments *segments,
-                                const absl::string_view key) const {
+bool Converter::StartPredictionWithKey(Segments *segments,
+                                       const absl::string_view key) const {
   ConversionRequest default_request;
   default_request.set_request_type(ConversionRequest::PREDICTION);
   return Predict(default_request, key, segments);
 }
 
-bool Converter::StartSuggestion(Segments *segments,
-                                const absl::string_view key) const {
+bool Converter::StartSuggestionWithKey(Segments *segments,
+                                       const absl::string_view key) const {
   ConversionRequest default_request;
   default_request.set_request_type(ConversionRequest::SUGGESTION);
   return Predict(default_request, key, segments);
 }
 
-bool Converter::StartSuggestionForRequest(
-    const ConversionRequest &original_request, Segments *segments) const {
+bool Converter::StartSuggestion(const ConversionRequest &original_request,
+                                Segments *segments) const {
   ConversionRequest request = CreateConversionRequestWithType(
       original_request, ConversionRequest::SUGGESTION);
   DCHECK(request.has_composer());
@@ -461,21 +462,21 @@ bool Converter::StartSuggestionForRequest(
   return Predict(request, prediction_key, segments);
 }
 
-bool Converter::StartPartialSuggestion(Segments *segments,
-                                       const absl::string_view key) const {
+bool Converter::StartPartialSuggestionWithKey(
+    Segments *segments, const absl::string_view key) const {
   ConversionRequest default_request;
   default_request.set_request_type(ConversionRequest::PARTIAL_SUGGESTION);
   return Predict(default_request, key, segments);
 }
 
-bool Converter::StartPartialSuggestionForRequest(
+bool Converter::StartPartialSuggestion(
     const ConversionRequest &original_request, Segments *segments) const {
   ConversionRequest request = CreateConversionRequestWithType(
       original_request, ConversionRequest::PARTIAL_SUGGESTION);
   DCHECK(request.has_composer());
   const size_t cursor = request.composer().GetCursor();
   if (cursor == 0 || cursor == request.composer().GetLength()) {
-    return StartSuggestionForRequest(request, segments);
+    return StartSuggestion(request, segments);
   }
 
   std::string conversion_key = request.composer().GetQueryForConversion();
@@ -484,21 +485,21 @@ bool Converter::StartPartialSuggestionForRequest(
   return Predict(request, conversion_key, segments);
 }
 
-bool Converter::StartPartialPrediction(Segments *segments,
-                                       const absl::string_view key) const {
+bool Converter::StartPartialPredictionWithKey(
+    Segments *segments, const absl::string_view key) const {
   ConversionRequest default_request;
   default_request.set_request_type(ConversionRequest::PARTIAL_PREDICTION);
   return Predict(default_request, key, segments);
 }
 
-bool Converter::StartPartialPredictionForRequest(
+bool Converter::StartPartialPrediction(
     const ConversionRequest &original_request, Segments *segments) const {
   ConversionRequest request = CreateConversionRequestWithType(
       original_request, ConversionRequest::PARTIAL_PREDICTION);
   DCHECK(request.has_composer());
   const size_t cursor = request.composer().GetCursor();
   if (cursor == 0 || cursor == request.composer().GetLength()) {
-    return StartPredictionForRequest(request, segments);
+    return StartPrediction(request, segments);
   }
 
   std::string conversion_key = request.composer().GetQueryForConversion();
diff --git a/src/converter/converter.h b/src/converter/converter.h
index 3f94607b3..8c27c8a91 100644
--- a/src/converter/converter.h
+++ b/src/converter/converter.h
@@ -64,38 +64,38 @@ class Converter final : public ConverterInterface {
             ImmutableConverterInterface *immutable_converter);
 
   ABSL_MUST_USE_RESULT
-  bool StartConversionForRequest(const ConversionRequest &request,
-                                 Segments *segments) const override;
+  bool StartConversion(const ConversionRequest &request,
+                       Segments *segments) const override;
   ABSL_MUST_USE_RESULT
-  bool StartConversion(Segments *segments,
-                       absl::string_view key) const override;
+  bool StartConversionWithKey(Segments *segments,
+                              absl::string_view key) const override;
   ABSL_MUST_USE_RESULT
   bool StartReverseConversion(Segments *segments,
                               absl::string_view key) const override;
   ABSL_MUST_USE_RESULT
-  bool StartPredictionForRequest(const ConversionRequest &request,
-                                 Segments *segments) const override;
+  bool StartPrediction(const ConversionRequest &request,
+                       Segments *segments) const override;
   ABSL_MUST_USE_RESULT
-  bool StartPrediction(Segments *segments,
-                       absl::string_view key) const override;
+  bool StartPredictionWithKey(Segments *segments,
+                              absl::string_view key) const override;
   ABSL_MUST_USE_RESULT
-  bool StartSuggestionForRequest(const ConversionRequest &request,
-                                 Segments *segments) const override;
+  bool StartSuggestion(const ConversionRequest &request,
+                       Segments *segments) const override;
   ABSL_MUST_USE_RESULT
-  bool StartSuggestion(Segments *segments,
-                       absl::string_view key) const override;
+  bool StartSuggestionWithKey(Segments *segments,
+                              absl::string_view key) const override;
   ABSL_MUST_USE_RESULT
-  bool StartPartialPredictionForRequest(const ConversionRequest &request,
-                                        Segments *segments) const override;
+  bool StartPartialPrediction(const ConversionRequest &request,
+                              Segments *segments) const override;
   ABSL_MUST_USE_RESULT
-  bool StartPartialPrediction(Segments *segments,
-                              absl::string_view key) const override;
+  bool StartPartialPredictionWithKey(Segments *segments,
+                                     absl::string_view key) const override;
   ABSL_MUST_USE_RESULT
-  bool StartPartialSuggestionForRequest(const ConversionRequest &request,
-                                        Segments *segments) const override;
+  bool StartPartialSuggestion(const ConversionRequest &request,
+                              Segments *segments) const override;
   ABSL_MUST_USE_RESULT
-  bool StartPartialSuggestion(Segments *segments,
-                              absl::string_view key) const override;
+  bool StartPartialSuggestionWithKey(Segments *segments,
+                                     absl::string_view key) const override;
 
   void FinishConversion(const ConversionRequest &request,
                         Segments *segments) const override;
diff --git a/src/converter/converter_interface.h b/src/converter/converter_interface.h
index 6512d6fa1..630cf7d65 100644
--- a/src/converter/converter_interface.h
+++ b/src/converter/converter_interface.h
@@ -56,14 +56,14 @@ class ConverterInterface {
 
   // Starts conversion for given request.
   ABSL_MUST_USE_RESULT
-  virtual bool StartConversionForRequest(const ConversionRequest &request,
-                                         Segments *segments) const = 0;
+  virtual bool StartConversion(const ConversionRequest &request,
+                               Segments *segments) const = 0;
 
   // Start conversion with key.
   // key is a request written in Hiragana sequence
   ABSL_MUST_USE_RESULT
-  virtual bool StartConversion(Segments *segments,
-                               absl::string_view key) const = 0;
+  virtual bool StartConversionWithKey(Segments *segments,
+                                      absl::string_view key) const = 0;
 
   // Start reverse conversion with key.
   ABSL_MUST_USE_RESULT
@@ -72,43 +72,43 @@ class ConverterInterface {
 
   // Starts prediction for given request.
   ABSL_MUST_USE_RESULT
-  virtual bool StartPredictionForRequest(const ConversionRequest &request,
-                                         Segments *segments) const = 0;
+  virtual bool StartPrediction(const ConversionRequest &request,
+                               Segments *segments) const = 0;
 
   // Start prediction with key (request_type = PREDICTION)
   ABSL_MUST_USE_RESULT
-  virtual bool StartPrediction(Segments *segments,
-                               absl::string_view key) const = 0;
+  virtual bool StartPredictionWithKey(Segments *segments,
+                                      absl::string_view key) const = 0;
 
   // Starts suggestion for given request.
   ABSL_MUST_USE_RESULT
-  virtual bool StartSuggestionForRequest(const ConversionRequest &request,
-                                         Segments *segments) const = 0;
+  virtual bool StartSuggestion(const ConversionRequest &request,
+                               Segments *segments) const = 0;
 
   // Start suggestion with key (request_type = SUGGESTION)
   ABSL_MUST_USE_RESULT
-  virtual bool StartSuggestion(Segments *segments,
-                               absl::string_view key) const = 0;
+  virtual bool StartSuggestionWithKey(Segments *segments,
+                                      absl::string_view key) const = 0;
 
   // Starts partial prediction for given request.
   ABSL_MUST_USE_RESULT
-  virtual bool StartPartialPredictionForRequest(
-      const ConversionRequest &request, Segments *segments) const = 0;
+  virtual bool StartPartialPrediction(const ConversionRequest &request,
+                                      Segments *segments) const = 0;
 
   // Start prediction with key (request_type = PARTIAL_PREDICTION)
   ABSL_MUST_USE_RESULT
-  virtual bool StartPartialPrediction(Segments *segments,
-                                      absl::string_view key) const = 0;
+  virtual bool StartPartialPredictionWithKey(Segments *segments,
+                                             absl::string_view key) const = 0;
 
   // Starts partial suggestion for given request.
   ABSL_MUST_USE_RESULT
-  virtual bool StartPartialSuggestionForRequest(
-      const ConversionRequest &request, Segments *segments) const = 0;
+  virtual bool StartPartialSuggestion(const ConversionRequest &request,
+                                      Segments *segments) const = 0;
 
   // Start suggestion with key (request_type = PARTIAL_SUGGESTION)
   ABSL_MUST_USE_RESULT
-  virtual bool StartPartialSuggestion(Segments *segments,
-                                      absl::string_view key) const = 0;
+  virtual bool StartPartialSuggestionWithKey(Segments *segments,
+                                             absl::string_view key) const = 0;
 
   // Finish conversion.
   // Segments are cleared. Context is not cleared
diff --git a/src/converter/converter_main.cc b/src/converter/converter_main.cc
index 1cde117a0..9e5fd4e69 100644
--- a/src/converter/converter_main.cc
+++ b/src/converter/converter_main.cc
@@ -296,14 +296,14 @@ bool ExecCommand(const ConverterInterface &converter, const std::string &line,
   if (func == "startconversion" || func == "start" || func == "s") {
     CHECK_FIELDS_LENGTH(2);
     composer.SetPreeditTextForTestOnly(fields[1]);
-    return converter.StartConversionForRequest(*conversion_request, segments);
+    return converter.StartConversion(*conversion_request, segments);
   } else if (func == "convertwithnodeinfo" || func == "cn") {
     CHECK_FIELDS_LENGTH(5);
     Lattice::SetDebugDisplayNode(
         NumberUtil::SimpleAtoi(fields[2]),  // begin pos
         NumberUtil::SimpleAtoi(fields[3]),  // end pos
         fields[4]);
-    const bool result = converter.StartConversion(segments, fields[1]);
+    const bool result = converter.StartConversionWithKey(segments, fields[1]);
     Lattice::ResetDebugDisplayNode();
     return result;
   } else if (func == "reverseconversion" || func == "reverse" || func == "r") {
@@ -312,16 +312,16 @@ bool ExecCommand(const ConverterInterface &converter, const std::string &line,
   } else if (func == "startprediction" || func == "predict" || func == "p") {
     if (fields.size() >= 2) {
       composer.SetPreeditTextForTestOnly(fields[1]);
-      return converter.StartPredictionForRequest(*conversion_request, segments);
+      return converter.StartPrediction(*conversion_request, segments);
     } else {
-      return converter.StartPredictionForRequest(*conversion_request, segments);
+      return converter.StartPrediction(*conversion_request, segments);
     }
   } else if (func == "startsuggestion" || func == "suggest") {
     if (fields.size() >= 2) {
       composer.SetPreeditTextForTestOnly(fields[1]);
-      return converter.StartSuggestionForRequest(*conversion_request, segments);
+      return converter.StartSuggestion(*conversion_request, segments);
     } else {
-      return converter.StartSuggestionForRequest(*conversion_request, segments);
+      return converter.StartSuggestion(*conversion_request, segments);
     }
   } else if (func == "finishconversion" || func == "finish") {
     converter.FinishConversion(*conversion_request, segments);
diff --git a/src/converter/converter_mock.h b/src/converter/converter_mock.h
index 6d2696cba..7b273a00e 100644
--- a/src/converter/converter_mock.h
+++ b/src/converter/converter_mock.h
@@ -30,7 +30,15 @@
 #ifndef MOZC_CONVERTER_CONVERTER_MOCK_H_
 #define MOZC_CONVERTER_CONVERTER_MOCK_H_
 
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
 #include "converter/converter_interface.h"
+#include "converter/segments.h"
+#include "request/conversion_request.h"
 #include "testing/gmock.h"
 
 namespace mozc {
@@ -40,32 +48,32 @@ class StrictMockConverter : public ConverterInterface {
   StrictMockConverter() = default;
   ~StrictMockConverter() override = default;
 
-  MOCK_METHOD(bool, StartConversionForRequest,
+  MOCK_METHOD(bool, StartConversion,
               (const ConversionRequest &request, Segments *segments),
               (const, override));
-  MOCK_METHOD(bool, StartConversion,
+  MOCK_METHOD(bool, StartConversionWithKey,
               (Segments * segments, absl::string_view key), (const, override));
   MOCK_METHOD(bool, StartReverseConversion,
               (Segments * segments, absl::string_view key), (const, override));
-  MOCK_METHOD(bool, StartPredictionForRequest,
+  MOCK_METHOD(bool, StartPrediction,
               (const ConversionRequest &request, Segments *segments),
               (const, override));
-  MOCK_METHOD(bool, StartPrediction,
+  MOCK_METHOD(bool, StartPredictionWithKey,
               (Segments * segments, absl::string_view key), (const, override));
-  MOCK_METHOD(bool, StartSuggestionForRequest,
+  MOCK_METHOD(bool, StartSuggestion,
               (const ConversionRequest &request, Segments *segments),
               (const, override));
-  MOCK_METHOD(bool, StartSuggestion,
+  MOCK_METHOD(bool, StartSuggestionWithKey,
               (Segments * segments, absl::string_view key), (const, override));
-  MOCK_METHOD(bool, StartPartialPredictionForRequest,
+  MOCK_METHOD(bool, StartPartialPrediction,
               (const ConversionRequest &request, Segments *segments),
               (const, override));
-  MOCK_METHOD(bool, StartPartialPrediction,
+  MOCK_METHOD(bool, StartPartialPredictionWithKey,
               (Segments * segments, absl::string_view key), (const, override));
-  MOCK_METHOD(bool, StartPartialSuggestionForRequest,
+  MOCK_METHOD(bool, StartPartialSuggestion,
               (const ConversionRequest &request, Segments *segments),
               (const, override));
-  MOCK_METHOD(bool, StartPartialSuggestion,
+  MOCK_METHOD(bool, StartPartialSuggestionWithKey,
               (Segments * segments, absl::string_view key), (const, override));
   MOCK_METHOD(void, FinishConversion,
               (const ConversionRequest &request, Segments *segments),
diff --git a/src/converter/converter_regression_test.cc b/src/converter/converter_regression_test.cc
index f8af4addf..b82bf07da 100644
--- a/src/converter/converter_regression_test.cc
+++ b/src/converter/converter_regression_test.cc
@@ -54,16 +54,16 @@ TEST_F(ConverterRegressionTest, QueryOfDeathTest) {
   CHECK(converter);
   {
     Segments segments;
-    EXPECT_TRUE(converter->StartConversion(&segments, "りゅきゅけmぽ"));
+    EXPECT_TRUE(converter->StartConversionWithKey(&segments, "りゅきゅけmぽ"));
   }
   {
     Segments segments;
-    EXPECT_TRUE(converter->StartConversion(&segments, "5.1,||t:1"));
+    EXPECT_TRUE(converter->StartConversionWithKey(&segments, "5.1,||t:1"));
   }
   {
     Segments segments;
     // Converter returns false, but not crash.
-    EXPECT_FALSE(converter->StartConversion(&segments, ""));
+    EXPECT_FALSE(converter->StartConversionWithKey(&segments, ""));
   }
   {
     Segments segments;
@@ -74,7 +74,7 @@ TEST_F(ConverterRegressionTest, QueryOfDeathTest) {
     composer::Composer composer(&table, &request, nullptr);
     conv_request.set_composer(&composer);
     // Converter returns false, but not crash.
-    EXPECT_FALSE(converter->StartConversionForRequest(conv_request, &segments));
+    EXPECT_FALSE(converter->StartConversion(conv_request, &segments));
   }
 }
 
@@ -83,7 +83,8 @@ TEST_F(ConverterRegressionTest, Regression3323108) {
   ConverterInterface *converter = engine->GetConverter();
   Segments segments;
 
-  EXPECT_TRUE(converter->StartConversion(&segments, "ここではきものをぬぐ"));
+  EXPECT_TRUE(
+      converter->StartConversionWithKey(&segments, "ここではきものをぬぐ"));
   EXPECT_EQ(segments.conversion_segments_size(), 3);
   const ConversionRequest default_request;
   EXPECT_TRUE(converter->ResizeSegment(&segments, default_request, 1, 2));
diff --git a/src/converter/converter_test.cc b/src/converter/converter_test.cc
index 05254671d..443b96df6 100644
--- a/src/converter/converter_test.cc
+++ b/src/converter/converter_test.cc
@@ -359,11 +359,11 @@ TEST_F(ConverterTest, CanConvertTest) {
   CHECK(converter);
   {
     Segments segments;
-    EXPECT_TRUE(converter->StartConversion(&segments, "-"));
+    EXPECT_TRUE(converter->StartConversionWithKey(&segments, "-"));
   }
   {
     Segments segments;
-    EXPECT_TRUE(converter->StartConversion(&segments, "おきておきて"));
+    EXPECT_TRUE(converter->StartConversionWithKey(&segments, "おきておきて"));
   }
 }
 
@@ -377,7 +377,7 @@ std::string ContextAwareConvert(const std::string &first_key,
   CHECK(converter);
 
   Segments segments;
-  EXPECT_TRUE(converter->StartConversion(&segments, first_key));
+  EXPECT_TRUE(converter->StartConversionWithKey(&segments, first_key));
 
   std::string converted;
   int segment_num = 0;
@@ -411,7 +411,7 @@ std::string ContextAwareConvert(const std::string &first_key,
   // TODO(team): Use StartConversionForRequest instead of StartConversion.
   const ConversionRequest default_request;
   converter->FinishConversion(default_request, &segments);
-  EXPECT_TRUE(converter->StartConversion(&segments, second_key));
+  EXPECT_TRUE(converter->StartConversionWithKey(&segments, second_key));
   EXPECT_EQ(segments.segments_size(), segment_num + 1);
 
   return segments.segment(segment_num).candidate(0).value;
@@ -773,7 +773,7 @@ TEST_F(ConverterTest, CandidateKeyTest) {
   ConverterInterface *converter = engine->GetConverter();
   CHECK(converter);
   Segments segments;
-  EXPECT_TRUE(converter->StartConversion(&segments, "わたしは"));
+  EXPECT_TRUE(converter->StartConversionWithKey(&segments, "わたしは"));
   EXPECT_EQ(segments.segments_size(), 1);
   EXPECT_EQ(segments.segment(0).candidate(0).key, "わたしは");
   EXPECT_EQ(segments.segment(0).candidate(0).content_key, "わたし");
@@ -793,7 +793,7 @@ TEST_F(ConverterTest, Regression3437022) {
 
   {
     // Make sure convert result is one segment
-    EXPECT_TRUE(converter->StartConversion(&segments, kKey1 + kKey2));
+    EXPECT_TRUE(converter->StartConversionWithKey(&segments, kKey1 + kKey2));
     EXPECT_EQ(segments.conversion_segments_size(), 1);
     EXPECT_EQ(segments.conversion_segment(0).candidate(0).value,
               kValue1 + kValue2);
@@ -801,14 +801,14 @@ TEST_F(ConverterTest, Regression3437022) {
   {
     // Make sure we can convert first part
     segments.Clear();
-    EXPECT_TRUE(converter->StartConversion(&segments, kKey1));
+    EXPECT_TRUE(converter->StartConversionWithKey(&segments, kKey1));
     EXPECT_EQ(segments.conversion_segments_size(), 1);
     EXPECT_EQ(segments.conversion_segment(0).candidate(0).value, kValue1);
   }
   {
     // Make sure we can convert last part
     segments.Clear();
-    EXPECT_TRUE(converter->StartConversion(&segments, kKey2));
+    EXPECT_TRUE(converter->StartConversionWithKey(&segments, kKey2));
     EXPECT_EQ(segments.conversion_segments_size(), 1);
     EXPECT_EQ(segments.conversion_segment(0).candidate(0).value, kValue2);
   }
@@ -821,7 +821,7 @@ TEST_F(ConverterTest, Regression3437022) {
   dic->AddEntry(kKey1 + kKey2, kValue1 + kValue2);
   dic->UnLock();
 
-  EXPECT_TRUE(converter->StartConversion(&segments, kKey1 + kKey2));
+  EXPECT_TRUE(converter->StartConversionWithKey(&segments, kKey1 + kKey2));
 
   int rest_size = 0;
   for (const Segment &segment : segments.conversion_segments().drop(1)) {
@@ -904,7 +904,7 @@ TEST_F(ConverterTest, Regression3046266) {
 
   constexpr char kValueNotExpected[] = "中";
 
-  EXPECT_TRUE(converter->StartConversion(&segments, kKey1));
+  EXPECT_TRUE(converter->StartConversionWithKey(&segments, kKey1));
   EXPECT_EQ(segments.conversion_segments_size(), 1);
   EXPECT_TRUE(converter->CommitSegmentValue(&segments, 0, 0));
 
@@ -912,7 +912,7 @@ TEST_F(ConverterTest, Regression3046266) {
   const ConversionRequest default_request;
   converter->FinishConversion(default_request, &segments);
 
-  EXPECT_TRUE(converter->StartConversion(&segments, kKey2));
+  EXPECT_TRUE(converter->StartConversionWithKey(&segments, kKey2));
   EXPECT_EQ(segments.conversion_segments_size(), 1);
   const Segment &segment = segments.conversion_segment(0);
   for (size_t i = 0; i < segment.candidates_size(); ++i) {
@@ -930,7 +930,7 @@ TEST_F(ConverterTest, Regression5502496) {
   constexpr char kKey[] = "みんあ";
   constexpr char kValueExpected[] = "みんな";
 
-  EXPECT_TRUE(converter->StartConversion(&segments, kKey));
+  EXPECT_TRUE(converter->StartConversionWithKey(&segments, kKey));
   EXPECT_EQ(segments.conversion_segments_size(), 1);
   const Segment &segment = segments.conversion_segment(0);
   bool found = false;
@@ -942,7 +942,7 @@ TEST_F(ConverterTest, Regression5502496) {
   EXPECT_TRUE(found);
 }
 
-TEST_F(ConverterTest, StartSuggestionForRequest) {
+TEST_F(ConverterTest, StartSuggestion) {
   commands::Request client_request;
   client_request.set_mixed_conversion(true);
 
@@ -966,7 +966,7 @@ TEST_F(ConverterTest, StartSuggestionForRequest) {
     Segments segments;
     ConversionRequest request(&composer, &client_request, &config);
     request.set_request_type(ConversionRequest::SUGGESTION);
-    EXPECT_TRUE(converter->StartSuggestionForRequest(request, &segments));
+    EXPECT_TRUE(converter->StartSuggestion(request, &segments));
     EXPECT_EQ(segments.segments_size(), 1);
     ASSERT_TRUE(segments.segment(0).meta_candidates_size() >=
                 transliteration::HALF_ASCII);
@@ -983,7 +983,7 @@ TEST_F(ConverterTest, StartSuggestionForRequest) {
     Segments segments;
     ConversionRequest request(&composer, &client_request, &config);
     request.set_request_type(ConversionRequest::SUGGESTION);
-    EXPECT_TRUE(converter->StartSuggestionForRequest(request, &segments));
+    EXPECT_TRUE(converter->StartSuggestion(request, &segments));
     EXPECT_EQ(segments.segments_size(), 1);
     ASSERT_TRUE(segments.segment(0).meta_candidates_size() >=
                 transliteration::HALF_ASCII);
@@ -999,7 +999,7 @@ TEST_F(ConverterTest, StartPartialPrediction) {
   ConverterInterface *converter = engine->GetConverter();
   CHECK(converter);
   Segments segments;
-  EXPECT_TRUE(converter->StartPartialPrediction(&segments, "わたしは"));
+  EXPECT_TRUE(converter->StartPartialPredictionWithKey(&segments, "わたしは"));
   EXPECT_EQ(segments.segments_size(), 1);
   EXPECT_EQ(segments.segment(0).candidate(0).key, "わたしは");
   EXPECT_EQ(segments.segment(0).candidate(0).content_key, "わたしは");
@@ -1011,7 +1011,7 @@ TEST_F(ConverterTest, StartPartialSuggestion) {
   ConverterInterface *converter = engine->GetConverter();
   CHECK(converter);
   Segments segments;
-  EXPECT_TRUE(converter->StartPartialSuggestion(&segments, "わたしは"));
+  EXPECT_TRUE(converter->StartPartialSuggestionWithKey(&segments, "わたしは"));
   EXPECT_EQ(segments.segments_size(), 1);
   EXPECT_EQ(segments.segment(0).candidate(0).key, "わたしは");
   EXPECT_EQ(segments.segment(0).candidate(0).content_key, "わたしは");
@@ -1022,7 +1022,7 @@ TEST_F(ConverterTest, StartPartialPredictionMobile) {
   ConverterInterface *converter = engine->GetConverter();
   CHECK(converter);
   Segments segments;
-  EXPECT_TRUE(converter->StartPartialPrediction(&segments, "わたしは"));
+  EXPECT_TRUE(converter->StartPartialPredictionWithKey(&segments, "わたしは"));
   EXPECT_EQ(segments.segments_size(), 1);
   EXPECT_EQ(segments.segment(0).candidate(0).key, "わたしは");
   EXPECT_EQ(segments.segment(0).candidate(0).content_key, "わたしは");
@@ -1033,7 +1033,7 @@ TEST_F(ConverterTest, StartPartialSuggestionMobile) {
   ConverterInterface *converter = engine->GetConverter();
   CHECK(converter);
   Segments segments;
-  EXPECT_TRUE(converter->StartPartialSuggestion(&segments, "わたしは"));
+  EXPECT_TRUE(converter->StartPartialSuggestionWithKey(&segments, "わたしは"));
   EXPECT_EQ(segments.segments_size(), 1);
   EXPECT_EQ(segments.segment(0).candidate(0).key, "わたしは");
   EXPECT_EQ(segments.segment(0).candidate(0).content_key, "わたしは");
@@ -1179,7 +1179,7 @@ TEST_F(ConverterTest, VariantExpansionForSuggestion) {
   Segments segments;
   {
     // Dictionary suggestion
-    EXPECT_TRUE(converter.StartSuggestion(&segments, "てすと"));
+    EXPECT_TRUE(converter.StartSuggestionWithKey(&segments, "てすと"));
     EXPECT_EQ(segments.conversion_segments_size(), 1);
     EXPECT_LE(1, segments.conversion_segment(0).candidates_size());
     EXPECT_TRUE(FindCandidateByValue("<>!?", segments.conversion_segment(0)));
@@ -1189,7 +1189,7 @@ TEST_F(ConverterTest, VariantExpansionForSuggestion) {
   {
     // Realtime conversion
     segments.Clear();
-    EXPECT_TRUE(converter.StartSuggestion(&segments, "てすとの"));
+    EXPECT_TRUE(converter.StartSuggestionWithKey(&segments, "てすとの"));
     EXPECT_EQ(segments.conversion_segments_size(), 1);
     EXPECT_LE(1, segments.conversion_segment(0).candidates_size());
     EXPECT_TRUE(FindCandidateByValue("<>!?の", segments.conversion_segment(0)));
@@ -1210,7 +1210,7 @@ TEST_F(ConverterTest, ComposerKeySelection) {
     composer.InsertCharacterPreedit("わたしh");
     ConversionRequest request(&composer, &default_request(), &config);
     request.set_composer_key_selection(ConversionRequest::CONVERSION_KEY);
-    ASSERT_TRUE(converter->StartConversionForRequest(request, &segments));
+    ASSERT_TRUE(converter->StartConversion(request, &segments));
     EXPECT_EQ(segments.conversion_segments_size(), 2);
     EXPECT_EQ(segments.conversion_segment(0).candidate(0).value, "私");
     EXPECT_EQ(segments.conversion_segment(1).candidate(0).value, "h");
@@ -1221,7 +1221,7 @@ TEST_F(ConverterTest, ComposerKeySelection) {
     composer.InsertCharacterPreedit("わたしh");
     ConversionRequest request(&composer, &default_request(), &config);
     request.set_composer_key_selection(ConversionRequest::PREDICTION_KEY);
-    ASSERT_TRUE(converter->StartConversionForRequest(request, &segments));
+    ASSERT_TRUE(converter->StartConversion(request, &segments));
     EXPECT_EQ(segments.conversion_segments_size(), 1);
     EXPECT_EQ(segments.conversion_segment(0).candidate(0).value, "私");
   }
@@ -1245,7 +1245,7 @@ TEST_F(ConverterTest, SuppressionDictionaryForRewriter) {
   composer.InsertCharacter("placeholder");
   const ConversionRequest request(&composer, &default_request(), &config);
   Segments segments;
-  EXPECT_TRUE(ret->converter->StartConversionForRequest(request, &segments));
+  EXPECT_TRUE(ret->converter->StartConversion(request, &segments));
 
   // Verify that words inserted by the rewriter is suppressed if its in the
   // suppression_dictionary.
@@ -1517,7 +1517,7 @@ TEST_F(ConverterTest, LimitCandidatesSize) {
   ConversionRequest request(&composer, &request_proto, &config);
 
   Segments segments;
-  ASSERT_TRUE(converter->StartConversionForRequest(request, &segments));
+  ASSERT_TRUE(converter->StartConversion(request, &segments));
   ASSERT_EQ(segments.conversion_segments_size(), 1);
   const int original_candidates_size = segments.segment(0).candidates_size();
   const int original_meta_candidates_size =
@@ -1528,7 +1528,7 @@ TEST_F(ConverterTest, LimitCandidatesSize) {
 
   segments.Clear();
   request_proto.set_candidates_size_limit(original_candidates_size - 1);
-  ASSERT_TRUE(converter->StartConversionForRequest(request, &segments));
+  ASSERT_TRUE(converter->StartConversion(request, &segments));
   ASSERT_EQ(segments.conversion_segments_size(), 1);
   EXPECT_GE(original_candidates_size - 1,
             segments.segment(0).candidates_size());
@@ -1539,7 +1539,7 @@ TEST_F(ConverterTest, LimitCandidatesSize) {
 
   segments.Clear();
   request_proto.set_candidates_size_limit(0);
-  ASSERT_TRUE(converter->StartConversionForRequest(request, &segments));
+  ASSERT_TRUE(converter->StartConversion(request, &segments));
   ASSERT_EQ(segments.conversion_segments_size(), 1);
   EXPECT_EQ(segments.segment(0).candidates_size(), 1);
   EXPECT_EQ(segments.segment(0).meta_candidates_size(),
@@ -1561,7 +1561,7 @@ TEST_F(ConverterTest, UserEntryShouldBePromoted) {
   CHECK(converter);
   {
     Segments segments;
-    EXPECT_TRUE(converter->StartConversion(&segments, "あい"));
+    EXPECT_TRUE(converter->StartConversionWithKey(&segments, "あい"));
     ASSERT_EQ(segments.conversion_segments_size(), 1);
     ASSERT_LT(1, segments.conversion_segment(0).candidates_size());
     EXPECT_EQ(segments.conversion_segment(0).candidate(0).value, "哀");
@@ -1583,7 +1583,7 @@ TEST_F(ConverterTest, UserEntryShouldBePromotedMobilePrediction) {
   CHECK(converter);
   {
     Segments segments;
-    EXPECT_TRUE(converter->StartPrediction(&segments, "あい"));
+    EXPECT_TRUE(converter->StartPredictionWithKey(&segments, "あい"));
     ASSERT_EQ(segments.conversion_segments_size(), 1);
     ASSERT_LT(1, segments.conversion_segment(0).candidates_size());
 
@@ -1618,7 +1618,7 @@ TEST_F(ConverterTest, SuppressionEntryShouldBePrioritized) {
   CHECK(converter);
   {
     Segments segments;
-    EXPECT_TRUE(converter->StartConversion(&segments, "あい"));
+    EXPECT_TRUE(converter->StartConversionWithKey(&segments, "あい"));
     ASSERT_EQ(segments.conversion_segments_size(), 1);
     ASSERT_LT(1, segments.conversion_segment(0).candidates_size());
     EXPECT_FALSE(FindCandidateByValue("哀", segments.conversion_segment(0)));
@@ -1643,7 +1643,7 @@ TEST_F(ConverterTest, SuppressionEntryShouldBePrioritizedPrediction) {
     CHECK(converter);
     {
       Segments segments;
-      EXPECT_TRUE(converter->StartPrediction(&segments, "あい"));
+      EXPECT_TRUE(converter->StartPredictionWithKey(&segments, "あい"));
       ASSERT_EQ(segments.conversion_segments_size(), 1);
       ASSERT_LT(1, segments.conversion_segment(0).candidates_size());
       EXPECT_FALSE(FindCandidateByValue("哀", segments.conversion_segment(0)));
@@ -1665,7 +1665,7 @@ TEST_F(ConverterTest, AbbreviationShouldBeIndependent) {
   CHECK(converter);
   {
     Segments segments;
-    EXPECT_TRUE(converter->StartConversion(&segments, "じゅうじか"));
+    EXPECT_TRUE(converter->StartConversionWithKey(&segments, "じゅうじか"));
     ASSERT_EQ(segments.conversion_segments_size(), 1);
     EXPECT_FALSE(
         FindCandidateByValue("Google+うじか", segments.conversion_segment(0)));
@@ -1689,7 +1689,7 @@ TEST_F(ConverterTest, AbbreviationShouldBeIndependentPrediction) {
 
     {
       Segments segments;
-      EXPECT_TRUE(converter->StartPrediction(&segments, "じゅうじか"));
+      EXPECT_TRUE(converter->StartPredictionWithKey(&segments, "じゅうじか"));
       ASSERT_EQ(segments.conversion_segments_size(), 1);
       EXPECT_FALSE(FindCandidateByValue("Google+うじか",
                                         segments.conversion_segment(0)));
@@ -1711,7 +1711,7 @@ TEST_F(ConverterTest, SuggestionOnlyShouldBeIndependent) {
   CHECK(converter);
   {
     Segments segments;
-    EXPECT_TRUE(converter->StartConversion(&segments, "じゅうじか"));
+    EXPECT_TRUE(converter->StartConversionWithKey(&segments, "じゅうじか"));
     ASSERT_EQ(segments.conversion_segments_size(), 1);
     EXPECT_FALSE(
         FindCandidateByValue("Google+うじか", segments.conversion_segment(0)));
@@ -1734,7 +1734,7 @@ TEST_F(ConverterTest, SuggestionOnlyShouldBeIndependentPrediction) {
     CHECK(converter);
     {
       Segments segments;
-      EXPECT_TRUE(converter->StartConversion(&segments, "じゅうじか"));
+      EXPECT_TRUE(converter->StartConversionWithKey(&segments, "じゅうじか"));
       ASSERT_EQ(segments.conversion_segments_size(), 1);
       EXPECT_FALSE(FindCandidateByValue("Google+うじか",
                                         segments.conversion_segment(0)));
@@ -1763,8 +1763,7 @@ TEST_F(ConverterTest, RewriterShouldRespectDefaultCandidates) {
   absl::flat_hash_set<std::string> seen;
   for (int i = 0; i < 4; ++i) {
     segments.Clear();
-    EXPECT_TRUE(
-        converter->StartPredictionForRequest(conversion_request, &segments));
+    EXPECT_TRUE(converter->StartPrediction(conversion_request, &segments));
     const Segment &segment = segments.conversion_segment(0);
     if (i == 0) {
       top_candidate = segment.candidate(0).value;
@@ -1783,8 +1782,7 @@ TEST_F(ConverterTest, RewriterShouldRespectDefaultCandidates) {
   }
 
   segments.Clear();
-  EXPECT_TRUE(
-      converter->StartPredictionForRequest(conversion_request, &segments));
+  EXPECT_TRUE(converter->StartPrediction(conversion_request, &segments));
 
   int default_candidate_index = -1;
   for (int i = 0; i < segments.conversion_segment(0).candidates_size(); ++i) {
@@ -1814,8 +1812,7 @@ TEST_F(ConverterTest,
   Segments segments;
   composer.SetPreeditTextForTestOnly("おつかれ");
 
-  EXPECT_TRUE(
-      converter->StartPredictionForRequest(conversion_request, &segments));
+  EXPECT_TRUE(converter->StartPrediction(conversion_request, &segments));
 
   int o_index = GetCandidateIndexByValue("お", segments.conversion_segment(0));
   int otsukare_index =
@@ -1855,8 +1852,7 @@ TEST_F(ConverterTest, DoNotAddOverlappingNodesForPrediction) {
   }
   composer.SetPreeditTextForTestOnly("てはい");
 
-  EXPECT_TRUE(
-      converter->StartPredictionForRequest(conversion_request, &segments));
+  EXPECT_TRUE(converter->StartPrediction(conversion_request, &segments));
   EXPECT_FALSE(FindCandidateByValue("て廃", segments.conversion_segment(0)));
 }
 
diff --git a/src/converter/quality_regression_util.cc b/src/converter/quality_regression_util.cc
index 0e1d76f94..70211524a 100644
--- a/src/converter/quality_regression_util.cc
+++ b/src/converter/quality_regression_util.cc
@@ -250,7 +250,7 @@ absl::StatusOr<bool> QualityRegressionUtil::ConvertAndTest(
     composer::Composer composer(&table, &request_, &config_);
     composer.SetPreeditTextForTestOnly(key);
     ConversionRequest conv_req(&composer, &request_, &config_);
-    if (!converter_->StartConversionForRequest(conv_req, &segments_)) {
+    if (!converter_->StartConversion(conv_req, &segments_)) {
       return absl::UnknownError(absl::StrCat(
           "StartConversionForRequest failed: ", item.OutputAsTSV()));
     }
@@ -263,7 +263,7 @@ absl::StatusOr<bool> QualityRegressionUtil::ConvertAndTest(
     composer::Composer composer(&table, &request_, &config_);
     composer.SetPreeditTextForTestOnly(key);
     ConversionRequest conv_req(&composer, &request_, &config_);
-    if (!converter_->StartPredictionForRequest(conv_req, &segments_)) {
+    if (!converter_->StartPrediction(conv_req, &segments_)) {
       return absl::UnknownError(absl::StrCat(
           "StartPredictionForRequest failed: ", item.OutputAsTSV()));
     }
@@ -271,9 +271,9 @@ absl::StatusOr<bool> QualityRegressionUtil::ConvertAndTest(
     composer::Composer composer(&table, &request_, &config_);
     composer.SetPreeditTextForTestOnly(key);
     ConversionRequest conv_req(&composer, &request_, &config_);
-    if (!converter_->StartSuggestionForRequest(conv_req, &segments_)) {
-      return absl::UnknownError(absl::StrCat(
-          "StartSuggestionForRequest failed: ", item.OutputAsTSV()));
+    if (!converter_->StartSuggestion(conv_req, &segments_)) {
+      return absl::UnknownError(
+          absl::StrCat("StartSuggestion failed: ", item.OutputAsTSV()));
     }
   } else if (command == kZeroQueryExpect || command == kZeroQueryNotExpect) {
     commands::Request request = request_;
@@ -284,9 +284,9 @@ absl::StatusOr<bool> QualityRegressionUtil::ConvertAndTest(
       composer.SetPreeditTextForTestOnly(key);
       ConversionRequest conv_req(&composer, &request, &config_);
       conv_req.set_max_conversion_candidates_size(10);
-      if (!converter_->StartSuggestionForRequest(conv_req, &segments_)) {
-        return absl::UnknownError(absl::StrCat(
-            "StartSuggestionForRequest failed: ", item.OutputAsTSV()));
+      if (!converter_->StartSuggestion(conv_req, &segments_)) {
+        return absl::UnknownError(
+            absl::StrCat("StartSuggestion failed: ", item.OutputAsTSV()));
       }
       if (!converter_->CommitSegmentValue(&segments_, 0, 0)) {
         return absl::UnknownError(
@@ -299,7 +299,7 @@ absl::StatusOr<bool> QualityRegressionUtil::ConvertAndTest(
       composer::Composer composer(&table, &request, &config_);
       ConversionRequest conv_req(&composer, &request, &config_);
       conv_req.set_max_conversion_candidates_size(10);
-      if (!converter_->StartPredictionForRequest(conv_req, &segments_)) {
+      if (!converter_->StartPrediction(conv_req, &segments_)) {
         return absl::UnknownError(absl::StrCat(
             "StartPredictionForRequest failed: ", item.OutputAsTSV()));
       }
diff --git a/src/engine/BUILD.bazel b/src/engine/BUILD.bazel
index 84f73dccf..dfe876baa 100644
--- a/src/engine/BUILD.bazel
+++ b/src/engine/BUILD.bazel
@@ -129,7 +129,9 @@ mozc_cc_library(
         "//dictionary/system:system_dictionary",
         "//dictionary/system:value_dictionary",
         "//prediction:rescorer_interface",
+        "//prediction:single_kanji_prediction_aggregator",
         "//prediction:suggestion_filter",
+        "//prediction:zero_query_dict",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings",
diff --git a/src/engine/data_loader.cc b/src/engine/data_loader.cc
index ea9acfbcc..ae0d1ddc2 100644
--- a/src/engine/data_loader.cc
+++ b/src/engine/data_loader.cc
@@ -68,8 +68,12 @@ EngineReloadResponse::Status ConvertStatus(DataManager::Status status) {
 }
 }  // namespace
 
+uint64_t DataLoader::GetRequestId(const EngineReloadRequest &request) const {
+  return Fingerprint(request.SerializeAsString());
+}
+
 uint64_t DataLoader::RegisterRequest(const EngineReloadRequest &request) {
-  const uint64_t id = Fingerprint(request.SerializeAsString());
+  const uint64_t id = GetRequestId(request);
 
   absl::WriterMutexLock lock(&mutex_);
 
diff --git a/src/engine/data_loader.h b/src/engine/data_loader.h
index 0f401814e..9465c03e3 100644
--- a/src/engine/data_loader.h
+++ b/src/engine/data_loader.h
@@ -61,12 +61,15 @@ class DataLoader {
   // executed asynchronously.
   using ResponseFuture = BackgroundFuture<Response>;
 
+  // Returns the request id associated with the request.
+  uint64_t GetRequestId(const EngineReloadRequest &request) const;
+
   // Accepts engine reload request and immediately returns the engine id with
   // the highest priority defined as follows:
   //  - Request with higher request priority (e.g., downloaded > bundled)
   //  - When the priority is the same, the request registered last.
   // The engine id 0 is reserved for unused engine.
-  virtual uint64_t RegisterRequest(const EngineReloadRequest &request);
+  uint64_t RegisterRequest(const EngineReloadRequest &request);
 
   // Unregister the request associated with the `id` and immediately returns
   // the new engine id after the unregistration. This method is usually called
@@ -74,7 +77,7 @@ class DataLoader {
   // avoid the multiple loading operations.  Client needs to load or use the
   // engine of returned id. The unregistered request will not be accepted after
   // calling this method.
-  virtual uint64_t UnregisterRequest(uint64_t id);
+  uint64_t UnregisterRequest(uint64_t id);
 
   // Builds the new engine associated with `id`.
   // This method returns the future object immediately.
diff --git a/src/engine/engine.cc b/src/engine/engine.cc
index a9d491607..5c42f11df 100644
--- a/src/engine/engine.cc
+++ b/src/engine/engine.cc
@@ -257,65 +257,82 @@ bool Engine::ReloadAndWait() {
   return GetUserDataManager()->Wait();
 }
 
-bool Engine::MaybeReloadEngine(EngineReloadResponse *response) {
-  if (!loader_ || response == nullptr) {
+bool Engine::MaybeBuildDataLoader() {
+  if (!loader_) {
     return false;
   }
 
-  // Maybe build new engine if new request is received.
-  // EngineBuilder::Build just returns a future object so
-  // client needs to replace the new engine when the future is the ready to use.
-  if (!engine_response_future_ && current_data_id_ != latest_data_id_ &&
+  // Maybe build new data loader if new request is received.
+  // DataLoader::Build just returns a future object so client needs to replace
+  // the new data manager when the future is the ready to use.
+  if (!loader_response_future_ && current_data_id_ != latest_data_id_ &&
       latest_data_id_ != 0) {
-    engine_response_future_ = loader_->Build(latest_data_id_);
+    loader_response_future_ = loader_->Build(latest_data_id_);
     // Wait the engine if the no new engine is loaded so far.
-    if (current_data_id_ == 0 || always_wait_for_engine_response_future_) {
-      engine_response_future_->Wait();
+    if (current_data_id_ == 0 || always_wait_for_loader_response_future_) {
+      loader_response_future_->Wait();
     }
   }
 
-  if (!engine_response_future_ || !engine_response_future_->Ready()) {
-    // Response is not ready to reload engine_.
-    return false;
-  }
+  bool is_ready = loader_response_future_ && loader_response_future_->Ready();
+  return is_ready;
+}
 
+std::unique_ptr<DataLoader::Response> Engine::GetDataLoaderResponse() {
   // Replaces the engine when the new engine is ready to use.
-  mozc::DataLoader::Response &&engine_response =
-      std::move(*engine_response_future_).Get();
-  engine_response_future_.reset();
-  *response = engine_response.response;
+  mozc::DataLoader::Response loader_response =
+      std::move(*loader_response_future_).Get();
+  loader_response_future_.reset();
 
-  if (!engine_response.modules ||
-      engine_response.response.status() != EngineReloadResponse::RELOAD_READY) {
-    // The engine_response does not contain a valid result.
+  if (!loader_response.modules ||
+      loader_response.response.status() != EngineReloadResponse::RELOAD_READY) {
+    // The loader_response does not contain a valid result.
 
     // This engine id causes a critical error, so rollback the id.
     LOG(ERROR) << "Failure in engine loading: "
-               << protobuf::Utf8Format(engine_response.response);
+               << protobuf::Utf8Format(loader_response.response);
     const uint64_t rollback_id =
-        loader_->UnregisterRequest(engine_response.id);
-    // Update latest_engine_id_ if latest_engine_id_ == engine_response.id.
-    // Otherwise, latest_engine_id_ may already be updated by the new request.
-    latest_data_id_.compare_exchange_strong(engine_response.id, rollback_id);
+        loader_->UnregisterRequest(loader_response.id);
+    // Update latest_data_id_ if latest_data_id_ == loader_response.id.
+    // Otherwise, latest_data_id_ may already be updated by the new request.
+    latest_data_id_.compare_exchange_strong(loader_response.id, rollback_id);
+
+    return nullptr;
+  }
+  return std::make_unique<DataLoader::Response>(std::move(loader_response));
+}
+
+bool Engine::MaybeReloadEngine(EngineReloadResponse *response) {
+  if (response == nullptr) {
+    return false;
+  }
+
+  if (!MaybeBuildDataLoader()) {
+    return false;
+  }
 
+  std::unique_ptr<DataLoader::Response> loader_response =
+      GetDataLoaderResponse();
+  if (!loader_response) {
     return false;
   }
+  *response = loader_response->response;
 
   if (user_data_manager_) {
     user_data_manager_->Wait();
   }
 
   // Reloads DataManager.
-  const bool is_mobile = engine_response.response.request().engine_type() ==
+  const bool is_mobile = loader_response->response.request().engine_type() ==
                          EngineReloadRequest::MOBILE;
   absl::Status reload_status =
-      ReloadModules(std::move(engine_response.modules), is_mobile);
+      ReloadModules(std::move(loader_response->modules), is_mobile);
   if (!reload_status.ok()) {
     LOG(ERROR) << reload_status;
     return false;
   }
 
-  current_data_id_ = engine_response.id;
+  current_data_id_ = loader_response->id;
   response->set_status(EngineReloadResponse::RELOADED);
   return true;
 }
diff --git a/src/engine/engine.h b/src/engine/engine.h
index 58af6ea1d..cd6e85e8e 100644
--- a/src/engine/engine.h
+++ b/src/engine/engine.h
@@ -132,14 +132,17 @@ class Engine : public EngineInterface {
   // For testing only.
   engine::Modules *GetModulesForTesting() const { return modules_.get(); }
 
+  bool MaybeBuildDataLoader();
+  std::unique_ptr<DataLoader::Response> GetDataLoaderResponse();
+
   // Maybe reload a new data manager. Returns true if reloaded.
   bool MaybeReloadEngine(EngineReloadResponse *response) override;
   bool SendEngineReloadRequest(const EngineReloadRequest& request) override;
   void SetDataLoaderForTesting(std::unique_ptr<DataLoader> loader) override {
     loader_ = std::move(loader);
   }
-  void SetAlwaysWaitForEngineResponseFutureForTesting(bool value) {
-    always_wait_for_engine_response_future_ = value;
+  void SetAlwaysWaitForLoaderResponseFutureForTesting(bool value) {
+    always_wait_for_loader_response_future_ = value;
   }
 
  private:
@@ -164,10 +167,9 @@ class Engine : public EngineInterface {
 
   std::atomic<uint64_t> latest_data_id_ = 0;
   std::atomic<uint64_t> current_data_id_ = 0;
-  std::unique_ptr<DataLoader::ResponseFuture> engine_response_future_;
+  std::unique_ptr<DataLoader::ResponseFuture> loader_response_future_;
   // used only in unittest to perform blocking behavior.
-  bool always_wait_for_engine_response_future_ = false;
-
+  bool always_wait_for_loader_response_future_ = false;
 };
 
 }  // namespace mozc
diff --git a/src/engine/engine_test.cc b/src/engine/engine_test.cc
index 2b3d1f5c1..44ea53b5c 100644
--- a/src/engine/engine_test.cc
+++ b/src/engine/engine_test.cc
@@ -55,7 +55,6 @@ namespace engine {
 
 namespace {
 
-using ::testing::_;
 using ::testing::InSequence;
 using ::testing::Return;
 
@@ -73,9 +72,6 @@ class MockSpellchecker : public engine::SpellcheckerInterface {
 
 class MockDataLoader : public DataLoader {
  public:
-  MOCK_METHOD(uint64_t, RegisterRequest, (const EngineReloadRequest &),
-              (override));
-  MOCK_METHOD(uint64_t, UnregisterRequest, (uint64_t), (override));
   MOCK_METHOD(std::unique_ptr<ResponseFuture>, Build, (uint64_t),
               (const override));
 };
@@ -112,14 +108,19 @@ TEST(EngineTest, DataLoadSuccessfulScenarioTest) {
   CHECK_OK(modules->Init(std::move(data_manager)));
 
   auto data_loader = std::make_unique<MockDataLoader>();
-  EXPECT_CALL(*data_loader, RegisterRequest(_)).WillRepeatedly(Return(1));
-  EXPECT_CALL(*data_loader, Build(1))
+
+  EngineReloadRequest request;
+  request.set_engine_type(EngineReloadRequest::MOBILE);
+  request.set_file_path("placeholder");  // OK for MockDataLoader
+  const uint64_t id = data_loader->GetRequestId(request);
+
+  EXPECT_CALL(*data_loader, Build(id))
       .WillOnce(Return(
           std::make_unique<BackgroundFuture<DataLoader::Response>>([&]() {
             // takes 0.1 seconds to make engine.
             absl::SleepFor(absl::Milliseconds(100));
             DataLoader::Response result;
-            result.id = 1;
+            result.id = id;
             result.response.set_status(EngineReloadResponse::RELOAD_READY);
             result.modules = std::move(modules);
             return result;
@@ -132,10 +133,6 @@ TEST(EngineTest, DataLoadSuccessfulScenarioTest) {
   Engine &engine = *engine_status.value();
   engine.SetDataLoaderForTesting(std::move(data_loader));
 
-  EngineReloadRequest request;
-  request.set_engine_type(EngineReloadRequest::MOBILE);
-  request.set_file_path("placeholder");  // OK for MockDataLoader
-
   EXPECT_TRUE(engine.SendEngineReloadRequest(request));
 
   EngineReloadResponse response;
@@ -171,14 +168,22 @@ TEST(EngineTest, DataUpdateSuccessfulScenarioTest) {
 
   InSequence seq;  // EXPECT_CALL is called sequentially.
 
-  EXPECT_CALL(*data_loader, RegisterRequest(_)).WillRepeatedly(Return(1));
+  EngineReloadRequest request1;
+  request1.set_engine_type(EngineReloadRequest::MOBILE);
+  request1.set_file_path("placeholder1");  // OK for MockDataLoader
+  const uint64_t id1 = data_loader->GetRequestId(request1);
 
-  EXPECT_CALL(*data_loader, Build(1))
+  EngineReloadRequest request2;
+  request2.set_engine_type(EngineReloadRequest::MOBILE);
+  request2.set_file_path("placeholder2");  // OK for MockDataLoader
+  const uint64_t id2 = data_loader->GetRequestId(request2);
+
+  EXPECT_CALL(*data_loader, Build(id1))
       .WillOnce(Return(
           std::make_unique<BackgroundFuture<DataLoader::Response>>([&]() {
             absl::SleepFor(absl::Milliseconds(100));
             DataLoader::Response result;
-            result.id = 1;
+            result.id = id1;
             result.response.set_status(EngineReloadResponse::RELOAD_READY);
             result.modules = std::move(modules1);
             return result;
@@ -190,37 +195,29 @@ TEST(EngineTest, DataUpdateSuccessfulScenarioTest) {
 
   Engine &engine = *engine_status.value();
   engine.SetDataLoaderForTesting(std::move(data_loader));
-  engine.SetAlwaysWaitForEngineResponseFutureForTesting(true);
-
-  EngineReloadRequest request;
-  request.set_engine_type(EngineReloadRequest::MOBILE);
-  request.set_file_path("placeholder");  // OK for MockDataLoader
+  engine.SetAlwaysWaitForLoaderResponseFutureForTesting(true);
 
   // Send a request, and get a response with id=1.
-  EXPECT_TRUE(engine.SendEngineReloadRequest(request));
+  EXPECT_TRUE(engine.SendEngineReloadRequest(request1));
 
   EngineReloadResponse response;
   EXPECT_TRUE(engine.MaybeReloadEngine(&response));
 
   EXPECT_EQ(engine.GetDataVersion(), data_version1);
 
-  // Use data_loader_ptr after std::move(engine_build).
-  EXPECT_CALL(*data_loader_ptr, RegisterRequest(_))
-      .WillRepeatedly(Return(2));
-
-  EXPECT_CALL(*data_loader_ptr, Build(2))
+  EXPECT_CALL(*data_loader_ptr, Build(id2))
       .WillOnce(Return(
           std::make_unique<BackgroundFuture<DataLoader::Response>>([&]() {
             absl::SleepFor(absl::Milliseconds(100));
             DataLoader::Response result;
-            result.id = 2;
+            result.id = id2;
             result.response.set_status(EngineReloadResponse::RELOAD_READY);
             result.modules = std::move(modules2);
             return result;
           })));
 
   // Send a request, and get a response with id=2.
-  EXPECT_TRUE(engine.SendEngineReloadRequest(request));
+  EXPECT_TRUE(engine.SendEngineReloadRequest(request2));
   EXPECT_TRUE(engine.MaybeReloadEngine(&response));
   EXPECT_EQ(engine.GetDataVersion(), data_version2);
 }
@@ -240,23 +237,21 @@ TEST(EngineTest, ReloadInvalidDataTest) {
   Engine &engine = *engine_status.value();
   engine.SetDataLoaderForTesting(std::move(data_loader));
 
-  EXPECT_CALL(*data_loader_ptr, RegisterRequest(_)).WillOnce(Return(1));
-
   EngineReloadRequest request;
   request.set_engine_type(EngineReloadRequest::MOBILE);
   request.set_file_path("placeholder");  // OK for MockDataLoader
+  const uint64_t id = data_loader_ptr->GetRequestId(request);
   EXPECT_TRUE(engine.SendEngineReloadRequest(request));
 
-  EXPECT_CALL(*data_loader_ptr, Build(1))
+  EXPECT_CALL(*data_loader_ptr, Build(id))
       .WillOnce(Return(
           std::make_unique<BackgroundFuture<DataLoader::Response>>([&]() {
             absl::SleepFor(absl::Milliseconds(100));
             DataLoader::Response result;
-            result.id = 1;
+            result.id = id;
             result.response.set_status(EngineReloadResponse::DATA_BROKEN);
             return result;
           })));
-  EXPECT_CALL(*data_loader_ptr, UnregisterRequest(1)).WillOnce(Return(0));
 
   // Build() is called, but it returns invalid data, so new data is not used.
   EngineReloadResponse response;
@@ -264,7 +259,6 @@ TEST(EngineTest, ReloadInvalidDataTest) {
 
   // Sends the same request again, but the request is already marked as
   // unregistered.
-  EXPECT_CALL(*data_loader_ptr, RegisterRequest(_)).WillOnce(Return(0));
   EXPECT_TRUE(engine.SendEngineReloadRequest(request));
   EXPECT_FALSE(engine.MaybeReloadEngine(&response));
 }
@@ -288,41 +282,62 @@ TEST(EngineTest, RollbackDataTest) {
   Engine &engine = *engine_status.value();
 
   engine.SetDataLoaderForTesting(std::move(data_loader));
-  engine.SetAlwaysWaitForEngineResponseFutureForTesting(true);
+  engine.SetAlwaysWaitForLoaderResponseFutureForTesting(true);
 
-  EngineReloadRequest request;
-  request.set_engine_type(EngineReloadRequest::MOBILE);
-  request.set_file_path("placeholder");  // OK for MockDataLoader
+  EngineReloadRequest request1_ready;
+  request1_ready.set_engine_type(EngineReloadRequest::MOBILE);
+  request1_ready.set_file_path("placeholder1");  // OK for MockDataLoader
+  const uint64_t id1 = data_loader_ptr->GetRequestId(request1_ready);
+
+  EngineReloadRequest request2_broken;
+  request2_broken.set_engine_type(EngineReloadRequest::MOBILE);
+  request2_broken.set_file_path("placeholder2");  // OK for MockDataLoader
+  const uint64_t id2 = data_loader_ptr->GetRequestId(request2_broken);
+
+  EngineReloadRequest request3_broken;
+  request3_broken.set_engine_type(EngineReloadRequest::MOBILE);
+  request3_broken.set_file_path("placeholder3");  // OK for MockDataLoader
+  const uint64_t id3 = data_loader_ptr->GetRequestId(request3_broken);
 
   // Sends multiple requests three times. 1 -> 2 -> 3.
   // 3 is the latest id.
-  for (int eid = 1; eid <= 3; ++eid) {
-    EXPECT_CALL(*data_loader_ptr, RegisterRequest(_)).WillOnce(Return(eid));
-    ASSERT_TRUE(engine.SendEngineReloadRequest(request));
-  }
+  ASSERT_TRUE(engine.SendEngineReloadRequest(request1_ready));
+  ASSERT_TRUE(engine.SendEngineReloadRequest(request2_broken));
+  ASSERT_TRUE(engine.SendEngineReloadRequest(request3_broken));
+
+  EXPECT_CALL(*data_loader_ptr, Build(id3))
+      .WillOnce(Return(
+          std::make_unique<BackgroundFuture<DataLoader::Response>>([&]() {
+            absl::SleepFor(absl::Milliseconds(100));
+            DataLoader::Response result;
+            result.id = id3;
+            result.response.set_status(EngineReloadResponse::DATA_BROKEN);
+            return result;
+          })));
+  EXPECT_CALL(*data_loader_ptr, Build(id2))
+      .WillOnce(Return(
+          std::make_unique<BackgroundFuture<DataLoader::Response>>([&]() {
+            absl::SleepFor(absl::Milliseconds(100));
+            DataLoader::Response result;
+            result.id = id2;
+            result.response.set_status(EngineReloadResponse::DATA_BROKEN);
+            return result;
+          })));
+  EXPECT_CALL(*data_loader_ptr, Build(id1))
+      .WillOnce(Return(
+          std::make_unique<BackgroundFuture<DataLoader::Response>>([&]() {
+            absl::SleepFor(absl::Milliseconds(100));
+            DataLoader::Response result;
+            result.id = id1;
+            result.response.set_status(EngineReloadResponse::RELOAD_READY);
+            result.modules = std::move(modules);
+            return result;
+          })));
 
   for (int eid = 3; eid >= 1; --eid) {
     // Rollback as 3 -> 2 -> 1.  1 is only valid engine.
-    EXPECT_CALL(*data_loader_ptr, Build(eid))
-        .WillOnce(Return(
-            std::make_unique<BackgroundFuture<DataLoader::Response>>([&]() {
-              absl::SleepFor(absl::Milliseconds(100));
-              DataLoader::Response result;
-              result.id = eid;
-              if (eid == 1) {
-                result.response.set_status(EngineReloadResponse::RELOAD_READY);
-                result.modules = std::move(modules);
-              } else {
-                result.response.set_status(EngineReloadResponse::DATA_BROKEN);
-              }
-              return result;
-            })));
     // Engine of 3, and 2 are unregistered.
     // The second best id (2, and 1) are used.
-    if (eid > 1) {
-      EXPECT_CALL(*data_loader_ptr, UnregisterRequest(eid))
-          .WillOnce(Return(eid - 1));
-    }
     EngineReloadResponse response;
     EXPECT_EQ(engine.MaybeReloadEngine(&response), eid == 1);
   }
diff --git a/src/engine/minimal_engine.cc b/src/engine/minimal_engine.cc
index 02265db61..f4f97a63e 100644
--- a/src/engine/minimal_engine.cc
+++ b/src/engine/minimal_engine.cc
@@ -103,13 +103,13 @@ class MinimalConverter : public ConverterInterface {
  public:
   MinimalConverter() = default;
 
-  bool StartConversionForRequest(const ConversionRequest &request,
-                                 Segments *segments) const override {
+  bool StartConversion(const ConversionRequest &request,
+                       Segments *segments) const override {
     return AddAsIsCandidate(request, segments);
   }
 
-  bool StartConversion(Segments *segments,
-                       const absl::string_view key) const override {
+  bool StartConversionWithKey(Segments *segments,
+                              const absl::string_view key) const override {
     return AddAsIsCandidate(key, segments);
   }
 
@@ -118,43 +118,43 @@ class MinimalConverter : public ConverterInterface {
     return false;
   }
 
-  bool StartPredictionForRequest(const ConversionRequest &request,
-                                 Segments *segments) const override {
+  bool StartPrediction(const ConversionRequest &request,
+                       Segments *segments) const override {
     return AddAsIsCandidate(request, segments);
   }
 
-  bool StartPrediction(Segments *segments,
-                       const absl::string_view key) const override {
+  bool StartPredictionWithKey(Segments *segments,
+                              const absl::string_view key) const override {
     return AddAsIsCandidate(key, segments);
   }
 
-  bool StartSuggestionForRequest(const ConversionRequest &request,
-                                 Segments *segments) const override {
+  bool StartSuggestion(const ConversionRequest &request,
+                       Segments *segments) const override {
     return AddAsIsCandidate(request, segments);
   }
 
-  bool StartSuggestion(Segments *segments,
-                       const absl::string_view key) const override {
+  bool StartSuggestionWithKey(Segments *segments,
+                              const absl::string_view key) const override {
     return AddAsIsCandidate(key, segments);
   }
 
-  bool StartPartialPredictionForRequest(const ConversionRequest &request,
-                                        Segments *segments) const override {
+  bool StartPartialPrediction(const ConversionRequest &request,
+                              Segments *segments) const override {
     return false;
   }
 
-  bool StartPartialPrediction(Segments *segments,
-                              const absl::string_view key) const override {
+  bool StartPartialPredictionWithKey(
+      Segments *segments, const absl::string_view key) const override {
     return false;
   }
 
-  bool StartPartialSuggestionForRequest(const ConversionRequest &request,
-                                        Segments *segments) const override {
+  bool StartPartialSuggestion(const ConversionRequest &request,
+                              Segments *segments) const override {
     return false;
   }
 
-  bool StartPartialSuggestion(Segments *segments,
-                              const absl::string_view key) const override {
+  bool StartPartialSuggestionWithKey(
+      Segments *segments, const absl::string_view key) const override {
     return false;
   }
 
diff --git a/src/engine/modules.cc b/src/engine/modules.cc
index 8c9aa06b3..6fe9bc9a1 100644
--- a/src/engine/modules.cc
+++ b/src/engine/modules.cc
@@ -54,6 +54,7 @@
 #include "dictionary/user_dictionary.h"
 #include "dictionary/user_pos.h"
 #include "prediction/rescorer_interface.h"
+#include "prediction/single_kanji_prediction_aggregator.h"
 #include "prediction/suggestion_filter.h"
 
 using ::mozc::dictionary::DictionaryImpl;
@@ -151,6 +152,26 @@ absl::Status Modules::Init(
     suggestion_filter_ = *std::move(status_or_suggestion_filter);
   }
 
+  if (!single_kanji_prediction_aggregator_) {
+    single_kanji_prediction_aggregator_ =
+        std::make_unique<prediction::SingleKanjiPredictionAggregator>(
+            *data_manager_);
+    RETURN_IF_NULL(single_kanji_prediction_aggregator_);
+  }
+
+  absl::string_view zero_query_token_array_data;
+  absl::string_view zero_query_string_array_data;
+  absl::string_view zero_query_number_token_array_data;
+  absl::string_view zero_query_number_string_array_data;
+  data_manager_->GetZeroQueryData(&zero_query_token_array_data,
+                                  &zero_query_string_array_data,
+                                  &zero_query_number_token_array_data,
+                                  &zero_query_number_string_array_data);
+  zero_query_dict_.Init(zero_query_token_array_data,
+                        zero_query_string_array_data);
+  zero_query_number_dict_.Init(zero_query_number_token_array_data,
+                               zero_query_number_string_array_data);
+
 
     initialized_ = true;
     return absl::Status();
@@ -187,6 +208,14 @@ void Modules::PresetDictionary(
   dictionary_ = std::move(dictionary);
 }
 
+void Modules::PresetSingleKanjiPredictionAggregator(
+    std::unique_ptr<const prediction::SingleKanjiPredictionAggregator>
+        single_kanji_prediction_aggregator) {
+  DCHECK(!initialized_) << "Module is already initialized";
+  single_kanji_prediction_aggregator_ =
+      std::move(single_kanji_prediction_aggregator);
+}
+
 void Modules::PresetRescorer(
     std::unique_ptr<prediction::RescorerInterface> rescorer) {
   DCHECK(!initialized_) << "Module is already initialized";
diff --git a/src/engine/modules.h b/src/engine/modules.h
index adeb15df7..8329d2bee 100644
--- a/src/engine/modules.h
+++ b/src/engine/modules.h
@@ -44,7 +44,9 @@
 #include "dictionary/suppression_dictionary.h"
 #include "engine/spellchecker_interface.h"
 #include "prediction/rescorer_interface.h"
+#include "prediction/single_kanji_prediction_aggregator.h"
 #include "prediction/suggestion_filter.h"
+#include "prediction/zero_query_dict.h"
 
 
 namespace mozc {
@@ -71,6 +73,9 @@ class Modules {
   void PresetDictionary(
       std::unique_ptr<dictionary::DictionaryInterface> dictionary);
   void PresetRescorer(std::unique_ptr<prediction::RescorerInterface> rescorer);
+  void PresetSingleKanjiPredictionAggregator(
+      std::unique_ptr<const prediction::SingleKanjiPredictionAggregator>
+          single_kanji_prediction_aggregator);
 
   const DataManagerInterface &GetDataManager() const {
     // DataManager must be valid.
@@ -102,6 +107,14 @@ class Modules {
   const SuggestionFilter &GetSuggestionFilter() const {
     return suggestion_filter_;
   }
+  const prediction::SingleKanjiPredictionAggregator *
+  GetSingleKanjiPredictionAggregator() const {
+    return single_kanji_prediction_aggregator_.get();
+  }
+  const ZeroQueryDict &GetZeroQueryDict() const { return zero_query_dict_; }
+  const ZeroQueryDict &GetZeroQueryNumberDict() const {
+    return zero_query_number_dict_;
+  }
   const prediction::RescorerInterface *GetRescorer() const {
     return rescorer_.get();
   }
@@ -126,6 +139,10 @@ class Modules {
   std::unique_ptr<dictionary::DictionaryInterface> dictionary_;
   std::unique_ptr<const dictionary::PosGroup> pos_group_;
   SuggestionFilter suggestion_filter_;
+  std::unique_ptr<const prediction::SingleKanjiPredictionAggregator>
+      single_kanji_prediction_aggregator_;
+  ZeroQueryDict zero_query_dict_;
+  ZeroQueryDict zero_query_number_dict_;
   std::unique_ptr<const prediction::RescorerInterface> rescorer_;
 
 
diff --git a/src/prediction/BUILD.bazel b/src/prediction/BUILD.bazel
index 925c8b522..cca54bced 100644
--- a/src/prediction/BUILD.bazel
+++ b/src/prediction/BUILD.bazel
@@ -272,8 +272,8 @@ mozc_cc_test(
     requires_full_emulation = False,
     deps = [
         ":dictionary_prediction_aggregator",
-        ":prediction_aggregator_interface",
         ":result",
+        ":single_kanji_prediction_aggregator",
         ":zero_query_dict",
         "//base:logging",
         "//base:util",
@@ -285,6 +285,7 @@ mozc_cc_test(
         "//converter:converter_mock",
         "//converter:immutable_converter_interface",
         "//converter:segments",
+        "//data_manager:data_manager_interface",
         "//data_manager/testing:mock_data_manager",
         "//dictionary:dictionary_interface",
         "//dictionary:dictionary_mock",
@@ -299,7 +300,6 @@ mozc_cc_test(
         "//testing:gunit_main",
         "//testing:mozctest",
         "//transliteration",
-        "@com_google_absl//absl/memory",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/strings:str_format",
     ],
@@ -358,7 +358,7 @@ mozc_cc_library(
         "single_kanji_prediction_aggregator.cc",
     ],
     hdrs = ["single_kanji_prediction_aggregator.h"],
-    visibility = ["//visibility:private"],
+    visibility = ["//engine:__subpackages__"],
     deps = [
         ":prediction_aggregator_interface",
         ":result",
@@ -469,7 +469,7 @@ mozc_cc_library(
 mozc_cc_library(
     name = "zero_query_dict",
     hdrs = ["zero_query_dict.h"],
-    visibility = ["//visibility:private"],
+    visibility = ["//engine:__subpackages__"],
     deps = [
         "//base/container:serialized_string_array",
         "@com_google_absl//absl/strings",
diff --git a/src/prediction/dictionary_prediction_aggregator.cc b/src/prediction/dictionary_prediction_aggregator.cc
index 95130f522..800ee0a0d 100644
--- a/src/prediction/dictionary_prediction_aggregator.cc
+++ b/src/prediction/dictionary_prediction_aggregator.cc
@@ -34,7 +34,6 @@
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
-#include <memory>
 #include <optional>
 #include <set>
 #include <string>
@@ -57,14 +56,12 @@
 #include "converter/immutable_converter_interface.h"
 #include "converter/node_list_builder.h"
 #include "converter/segments.h"
-#include "data_manager/data_manager_interface.h"
 #include "dictionary/dictionary_interface.h"
 #include "dictionary/dictionary_token.h"
 #include "dictionary/pos_matcher.h"
 #include "engine/modules.h"
 #include "engine/spellchecker_interface.h"
 #include "prediction/number_decoder.h"
-#include "prediction/prediction_aggregator_interface.h"
 #include "prediction/result.h"
 #include "prediction/single_kanji_prediction_aggregator.h"
 #include "prediction/zero_query_dict.h"
@@ -539,17 +536,6 @@ class DictionaryPredictionAggregator::HandwritingLookupCallback
 DictionaryPredictionAggregator::DictionaryPredictionAggregator(
     const engine::Modules &modules, const ConverterInterface *converter,
     const ImmutableConverterInterface *immutable_converter)
-    : DictionaryPredictionAggregator(
-          modules, converter, immutable_converter,
-          std::make_unique<SingleKanjiPredictionAggregator>(
-              modules.GetDataManager())) {
-}
-
-DictionaryPredictionAggregator::DictionaryPredictionAggregator(
-    const engine::Modules &modules, const ConverterInterface *converter,
-    const ImmutableConverterInterface *immutable_converter,
-    std::unique_ptr<PredictionAggregatorInterface>
-        single_kanji_prediction_aggregator)
     : modules_(modules),
       converter_(converter),
       immutable_converter_(immutable_converter),
@@ -561,20 +547,8 @@ DictionaryPredictionAggregator::DictionaryPredictionAggregator(
       zip_code_id_(modules.GetPosMatcher()->GetZipcodeId()),
       number_id_(modules.GetPosMatcher()->GetNumberId()),
       unknown_id_(modules.GetPosMatcher()->GetUnknownId()),
-      single_kanji_prediction_aggregator_(
-          std::move(single_kanji_prediction_aggregator)) {
-  absl::string_view zero_query_token_array_data;
-  absl::string_view zero_query_string_array_data;
-  absl::string_view zero_query_number_token_array_data;
-  absl::string_view zero_query_number_string_array_data;
-  modules.GetDataManager().GetZeroQueryData(
-      &zero_query_token_array_data, &zero_query_string_array_data,
-      &zero_query_number_token_array_data,
-      &zero_query_number_string_array_data);
-  zero_query_dict_.Init(zero_query_token_array_data,
-                        zero_query_string_array_data);
-  zero_query_number_dict_.Init(zero_query_number_token_array_data,
-                               zero_query_number_string_array_data);
+      zero_query_dict_(modules.GetZeroQueryDict()),
+      zero_query_number_dict_(modules.GetZeroQueryNumberDict()) {
 }
 
 std::vector<Result> DictionaryPredictionAggregator::AggregateResults(
@@ -735,8 +709,8 @@ PredictionTypes DictionaryPredictionAggregator::AggregatePrediction(
     // (i.e., Desktop, or Hardware Keyboard in Mobile), since they contain
     // partial results.
     const std::vector<Result> single_kanji_results =
-        single_kanji_prediction_aggregator_->AggregateResults(request,
-                                                              segments);
+        modules_.GetSingleKanjiPredictionAggregator()->AggregateResults(
+            request, segments);
     if (!single_kanji_results.empty()) {
       results->insert(results->end(), single_kanji_results.begin(),
                       single_kanji_results.end());
@@ -870,7 +844,7 @@ bool DictionaryPredictionAggregator::PushBackTopConversionResult(
   // partial candidates.
   tmp_request.set_create_partial_candidates(false);
   tmp_request.set_request_type(ConversionRequest::CONVERSION);
-  if (!converter_->StartConversionForRequest(tmp_request, &tmp_segments)) {
+  if (!converter_->StartConversion(tmp_request, &tmp_segments)) {
     return false;
   }
 
@@ -886,7 +860,7 @@ bool DictionaryPredictionAggregator::PushBackTopConversionResult(
   result->candidate_attributes |= Segment::Candidate::NO_VARIANTS_EXPANSION;
 
   // Concatenate the top candidates.
-  // Note that since StartConversionForRequest() runs in conversion mode, the
+  // Note that since StartConversion() runs in conversion mode, the
   // resulting |tmp_segments| doesn't have inner_segment_boundary. We need to
   // construct it manually here.
   // TODO(noriyukit): This is code duplicate in converter/nbest_generator.cc and
@@ -924,7 +898,7 @@ void DictionaryPredictionAggregator::AggregateRealtimeConversion(
   DCHECK(results);
   // First insert a top conversion result.
   // Note: Do not call actual converter for partial suggestion / prediction.
-  // Converter::StartConversionForRequest() resets conversion key from composer
+  // Converter::StartConversion() resets conversion key from composer
   // rather than using the key in segments.
   if (request.use_actual_converter_for_realtime_conversion() &&
       request.request_type() != ConversionRequest::PARTIAL_SUGGESTION &&
diff --git a/src/prediction/dictionary_prediction_aggregator.h b/src/prediction/dictionary_prediction_aggregator.h
index 3384310a2..64ff6cb2e 100644
--- a/src/prediction/dictionary_prediction_aggregator.h
+++ b/src/prediction/dictionary_prediction_aggregator.h
@@ -42,10 +42,8 @@
 #include "converter/converter_interface.h"
 #include "converter/immutable_converter_interface.h"
 #include "converter/segments.h"
-#include "data_manager/data_manager_interface.h"
 #include "dictionary/dictionary_interface.h"
 #include "dictionary/dictionary_token.h"
-#include "dictionary/pos_matcher.h"
 #include "engine/modules.h"
 #include "prediction/number_decoder.h"
 #include "prediction/prediction_aggregator_interface.h"
@@ -107,13 +105,6 @@ class DictionaryPredictionAggregator : public PredictionAggregatorInterface {
     std::vector<std::string> constraints;
   };
 
-  // For testing
-  DictionaryPredictionAggregator(
-      const engine::Modules &modules, const ConverterInterface *converter,
-      const ImmutableConverterInterface *immutable_converter,
-      std::unique_ptr<PredictionAggregatorInterface>
-          single_kanji_prediction_aggregator);
-
   // Returns the bitfield that indicates what prediction subroutines
   // were used.  NO_PREDICTION means that no prediction was made.
   PredictionTypes AggregatePredictionForTesting(
@@ -309,8 +300,8 @@ class DictionaryPredictionAggregator : public PredictionAggregatorInterface {
   const uint16_t zip_code_id_;
   const uint16_t number_id_;
   const uint16_t unknown_id_;
-  ZeroQueryDict zero_query_dict_;
-  ZeroQueryDict zero_query_number_dict_;
+  const ZeroQueryDict &zero_query_dict_;
+  const ZeroQueryDict &zero_query_number_dict_;
   NumberDecoder number_decoder_;
   std::unique_ptr<PredictionAggregatorInterface>
       single_kanji_prediction_aggregator_;
diff --git a/src/prediction/dictionary_prediction_aggregator_test.cc b/src/prediction/dictionary_prediction_aggregator_test.cc
index 4de73dfd2..3777b52fb 100644
--- a/src/prediction/dictionary_prediction_aggregator_test.cc
+++ b/src/prediction/dictionary_prediction_aggregator_test.cc
@@ -54,6 +54,7 @@
 #include "converter/converter_mock.h"
 #include "converter/immutable_converter_interface.h"
 #include "converter/segments.h"
+#include "data_manager/data_manager_interface.h"
 #include "data_manager/testing/mock_data_manager.h"
 #include "dictionary/dictionary_interface.h"
 #include "dictionary/dictionary_mock.h"
@@ -61,8 +62,8 @@
 #include "dictionary/pos_matcher.h"
 #include "engine/modules.h"
 #include "engine/spellchecker_interface.h"
-#include "prediction/prediction_aggregator_interface.h"
 #include "prediction/result.h"
+#include "prediction/single_kanji_prediction_aggregator.h"
 #include "prediction/zero_query_dict.h"
 #include "protocol/commands.pb.h"
 #include "protocol/config.pb.h"
@@ -84,11 +85,8 @@ class DictionaryPredictionAggregatorTestPeer {
   DictionaryPredictionAggregatorTestPeer(
       const ConverterInterface *converter,
       const ImmutableConverterInterface *immutable_converter,
-      const engine::Modules &modules,
-      std::unique_ptr<PredictionAggregatorInterface>
-          single_kanji_prediction_aggregator)
-      : aggregator_(modules, converter, immutable_converter,
-                    std::move(single_kanji_prediction_aggregator)) {}
+      const engine::Modules &modules)
+      : aggregator_(modules, converter, immutable_converter) {}
   virtual ~DictionaryPredictionAggregatorTestPeer() = default;
 
   PredictionTypes AggregatePredictionForRequest(
@@ -369,9 +367,11 @@ class MockImmutableConverter : public ImmutableConverterInterface {
 };
 
 class MockSingleKanjiPredictionAggregator
-    : public PredictionAggregatorInterface {
+    : public SingleKanjiPredictionAggregator {
  public:
-  MockSingleKanjiPredictionAggregator() = default;
+  explicit MockSingleKanjiPredictionAggregator(
+      const DataManagerInterface &data_manager)
+      : SingleKanjiPredictionAggregator(data_manager) {}
   ~MockSingleKanjiPredictionAggregator() override = default;
   MOCK_METHOD(std::vector<Result>, AggregateResults,
               (const ConversionRequest &request, const Segments &Segments),
@@ -390,20 +390,22 @@ class MockDataAndAggregator {
     mock_dictionary_ = dictionary.get();
     modules_.PresetDictionary(std::move(dictionary));
 
+    auto data_manager = std::make_unique<testing::MockDataManager>();
+
+    auto kanji_aggregator =
+        std::make_unique<MockSingleKanjiPredictionAggregator>(*data_manager);
+    single_kanji_prediction_aggregator_ = kanji_aggregator.get();
+    modules_.PresetSingleKanjiPredictionAggregator(std::move(kanji_aggregator));
+
     if (suffix_dictionary) {
       modules_.PresetSuffixDictionary(std::move(suffix_dictionary));
     }
 
-    CHECK_OK(modules_.Init(std::make_unique<testing::MockDataManager>()));
+    CHECK_OK(modules_.Init(std::move(data_manager)));
     CHECK_NE(modules_.GetSuffixDictionary(), nullptr);
 
-    auto kanji_aggregator =
-        std::make_unique<MockSingleKanjiPredictionAggregator>();
-    single_kanji_prediction_aggregator_ = kanji_aggregator.get();
-
     aggregator_ = std::make_unique<DictionaryPredictionAggregatorTestPeer>(
-        &converter_, &mock_immutable_converter_, modules_,
-        std::move(kanji_aggregator));
+        &converter_, &mock_immutable_converter_, modules_);
   }
 
   MockDictionary *mutable_dictionary() { return mock_dictionary_; }
@@ -617,8 +619,7 @@ TEST_F(DictionaryPredictionAggregatorTest,
   suggestion_convreq_->set_request_type(ConversionRequest::PARTIAL_SUGGESTION);
 
   // StartConversion should not be called for partial.
-  EXPECT_CALL(*data_and_aggregator->mutable_converter(),
-              StartConversionForRequest(_, _))
+  EXPECT_CALL(*data_and_aggregator->mutable_converter(), StartConversion(_, _))
       .Times(0);
   EXPECT_CALL(*data_and_aggregator->mutable_immutable_converter(),
               ConvertForRequest(_, _))
@@ -1624,7 +1625,7 @@ TEST_F(DictionaryPredictionAggregatorTest, AggregateRealtimeConversion) {
     add_segment("なかのです", "Nakanodesu");
 
     EXPECT_CALL(*data_and_aggregator->mutable_converter(),
-                StartConversionForRequest(_, _))
+                StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
   // Set up mock immutable converter
diff --git a/src/rewriter/language_aware_rewriter_test.cc b/src/rewriter/language_aware_rewriter_test.cc
index 624af394d..a1621067f 100644
--- a/src/rewriter/language_aware_rewriter_test.cc
+++ b/src/rewriter/language_aware_rewriter_test.cc
@@ -90,8 +90,7 @@ class LanguageAwareRewriterTest : public testing::TestWithTempUserProfile {
 
     composer::Table table;
     config::Config default_config;
-    table.InitializeWithRequestAndConfig(client_request, default_config,
-                                         data_manager_);
+    table.InitializeWithRequestAndConfig(client_request, default_config);
 
     composer::Composer composer(&table, &client_request, &default_config);
     InsertASCIISequence(key, &composer);
@@ -332,8 +331,7 @@ TEST_F(LanguageAwareRewriterTest, LanguageAwareInputUsageStats) {
 
     composer::Table table;
     config::Config default_config;
-    table.InitializeWithRequestAndConfig(client_request, default_config,
-                                         data_manager_);
+    table.InitializeWithRequestAndConfig(client_request, default_config);
 
     composer::Composer composer(&table, &client_request, &default_config);
     InsertASCIISequence("python", &composer);
@@ -417,7 +415,7 @@ TEST_F(LanguageAwareRewriterTest, IsDisabledInTwelveKeyLayout) {
     config.set_preedit_method(param.preedit_method);
 
     composer::Table table;
-    table.InitializeWithRequestAndConfig(request, config, data_manager_);
+    table.InitializeWithRequestAndConfig(request, config);
 
     composer::Composer composer(&table, &request, &config);
     InsertASCIISequence("query", &composer);
diff --git a/src/rewriter/transliteration_rewriter_test.cc b/src/rewriter/transliteration_rewriter_test.cc
index 1ad0954e8..eb8dd18aa 100644
--- a/src/rewriter/transliteration_rewriter_test.cc
+++ b/src/rewriter/transliteration_rewriter_test.cc
@@ -147,8 +147,7 @@ TEST_F(TransliterationRewriterTest, T13nFromComposerTest) {
       CreateTransliterationRewriter());
 
   composer::Table table;
-  table.InitializeWithRequestAndConfig(default_request(), default_config(),
-                                       mock_data_manager_);
+  table.InitializeWithRequestAndConfig(default_request(), default_config());
   composer::Composer composer(&table, &default_request(), &default_config());
   SetAkann(&composer);
 
@@ -195,8 +194,7 @@ TEST_F(TransliterationRewriterTest, KeyOfT13nFromComposerTest) {
       CreateTransliterationRewriter());
 
   composer::Table table;
-  table.InitializeWithRequestAndConfig(default_request(), default_config(),
-                                       mock_data_manager_);
+  table.InitializeWithRequestAndConfig(default_request(), default_config());
   composer::Composer composer(&table, &default_request(), &default_config());
   InsertASCIISequence("ssh", &composer);
 
@@ -231,8 +229,7 @@ TEST_F(TransliterationRewriterTest, T13nWithMultiSegmentsTest) {
       CreateTransliterationRewriter());
 
   composer::Table table;
-  table.InitializeWithRequestAndConfig(default_request(), default_config(),
-                                       mock_data_manager_);
+  table.InitializeWithRequestAndConfig(default_request(), default_config());
   composer::Composer composer(&table, &default_request(), &default_config());
 
   // Set kamabokoinbou to composer.
@@ -273,8 +270,7 @@ TEST_F(TransliterationRewriterTest, ComposerValidationTest) {
       CreateTransliterationRewriter());
 
   composer::Table table;
-  table.InitializeWithRequestAndConfig(default_request(), default_config(),
-                                       mock_data_manager_);
+  table.InitializeWithRequestAndConfig(default_request(), default_config());
   composer::Composer composer(&table, &default_request(), &default_config());
 
   // Set kan to composer.
@@ -319,8 +315,8 @@ TEST_F(TransliterationRewriterTest, RewriteWithSameComposerTest) {
       CreateTransliterationRewriter());
 
   composer::Table table;
-  table.InitializeWithRequestAndConfig(default_request(), default_config(),
-                                       mock_data_manager_);
+  table.InitializeWithRequestAndConfig(default_request(), default_config());
+
   composer::Composer composer(&table, &default_request(), &default_config());
   SetAkann(&composer);
 
@@ -435,8 +431,7 @@ TEST_F(TransliterationRewriterTest, NoKeyWithComposerTest) {
       CreateTransliterationRewriter());
 
   composer::Table table;
-  table.InitializeWithRequestAndConfig(default_request(), default_config(),
-                                       mock_data_manager_);
+  table.InitializeWithRequestAndConfig(default_request(), default_config());
   composer::Composer composer(&table, &default_request(), &default_config());
   InsertASCIISequence("a", &composer);
 
@@ -462,8 +457,7 @@ TEST_F(TransliterationRewriterTest, NoRewriteTest) {
       CreateTransliterationRewriter());
 
   composer::Table table;
-  table.InitializeWithRequestAndConfig(default_request(), default_config(),
-                                       mock_data_manager_);
+  table.InitializeWithRequestAndConfig(default_request(), default_config());
 
   Segments segments;
   Segment *segment = segments.add_segment();
@@ -501,8 +495,7 @@ TEST_F(TransliterationRewriterTest, MobileT13nTestWith12KeysHiragana) {
   request.set_special_romanji_table(commands::Request::TWELVE_KEYS_TO_HIRAGANA);
 
   composer::Table table;
-  table.InitializeWithRequestAndConfig(request, default_config(),
-                                       mock_data_manager_);
+  table.InitializeWithRequestAndConfig(request, default_config());
   composer::Composer composer(&table, &request, &default_config());
 
   {
@@ -549,8 +542,7 @@ TEST_F(TransliterationRewriterTest, MobileT13nTestWith12KeysToNumber) {
   request.set_special_romanji_table(commands::Request::TWELVE_KEYS_TO_HIRAGANA);
 
   composer::Table table;
-  table.InitializeWithRequestAndConfig(request, default_config(),
-                                       mock_data_manager_);
+  table.InitializeWithRequestAndConfig(request, default_config());
   composer::Composer composer(&table, &request, &default_config());
 
   {
@@ -602,8 +594,7 @@ TEST_F(TransliterationRewriterTest, MobileT13nTestWith12KeysFlick) {
       commands::Request::TOGGLE_FLICK_TO_HIRAGANA);
 
   composer::Table table;
-  table.InitializeWithRequestAndConfig(request, default_config(),
-                                       mock_data_manager_);
+  table.InitializeWithRequestAndConfig(request, default_config());
   composer::Composer composer(&table, &request, &default_config());
 
   {
@@ -652,8 +643,7 @@ TEST_F(TransliterationRewriterTest, MobileT13nTestWithQwertyHiragana) {
 
   const std::string kShi = "し";
   composer::Table table;
-  table.InitializeWithRequestAndConfig(client_request, default_config(),
-                                       mock_data_manager_);
+  table.InitializeWithRequestAndConfig(client_request, default_config());
 
   {
     composer::Composer composer(&table, &client_request, &default_config());
@@ -698,8 +688,7 @@ TEST_F(TransliterationRewriterTest, MobileT13nTestWithGodan) {
   request.set_special_romanji_table(commands::Request::GODAN_TO_HIRAGANA);
 
   composer::Table table;
-  table.InitializeWithRequestAndConfig(request, default_config(),
-                                       mock_data_manager_);
+  table.InitializeWithRequestAndConfig(request, default_config());
   composer::Composer composer(&table, &request, &default_config());
   {
     InsertASCIISequence("<'de", &composer);
@@ -748,8 +737,7 @@ TEST_F(TransliterationRewriterTest, MobileT13nTestValidateGodanT13nTable) {
   request.set_special_romanji_table(commands::Request::GODAN_TO_HIRAGANA);
 
   composer::Table table;
-  table.InitializeWithRequestAndConfig(request, default_config(),
-                                       mock_data_manager_);
+  table.InitializeWithRequestAndConfig(request, default_config());
 
   // Expected t13n of Godan keyboard.
   std::vector<const char *> keycode_to_t13n_map(
@@ -822,8 +810,7 @@ TEST_F(TransliterationRewriterTest, T13nOnSuggestion) {
   const std::string kXtsu = "っ";
 
   composer::Table table;
-  table.InitializeWithRequestAndConfig(client_request, default_config(),
-                                       mock_data_manager_);
+  table.InitializeWithRequestAndConfig(client_request, default_config());
   {
     composer::Composer composer(&table, &client_request, &default_config());
 
@@ -852,8 +839,7 @@ TEST_F(TransliterationRewriterTest, T13nOnPartialSuggestion) {
   const std::string kXtsu = "っ";
 
   composer::Table table;
-  table.InitializeWithRequestAndConfig(client_request, default_config(),
-                                       mock_data_manager_);
+  table.InitializeWithRequestAndConfig(client_request, default_config());
   {
     composer::Composer composer(&table, &client_request, &default_config());
 
diff --git a/src/session/BUILD.bazel b/src/session/BUILD.bazel
index a0d590840..348dbd16a 100644
--- a/src/session/BUILD.bazel
+++ b/src/session/BUILD.bazel
@@ -315,6 +315,7 @@ mozc_cc_library(
         "//testing:friend_test",
         "//usage_stats",
         "@com_google_absl//absl/flags:flag",
+        "@com_google_absl//absl/log",
         "@com_google_absl//absl/random",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/time",
@@ -383,6 +384,7 @@ mozc_cc_test(
         "//testing:gunit_main",
         "//usage_stats:usage_stats_testing_util",
         "@com_google_absl//absl/flags:flag",
+        "@com_google_absl//absl/log:check",
         "@com_google_absl//absl/random",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
diff --git a/src/session/internal/ime_context_test.cc b/src/session/internal/ime_context_test.cc
index cec6c7372..f9986d4a9 100644
--- a/src/session/internal/ime_context_test.cc
+++ b/src/session/internal/ime_context_test.cc
@@ -41,6 +41,7 @@
 #include "protocol/commands.pb.h"
 #include "protocol/config.pb.h"
 #include "session/session_converter.h"
+#include "testing/gmock.h"
 #include "testing/gunit.h"
 #include "testing/testing_util.h"
 
@@ -114,7 +115,7 @@ TEST(ImeContextTest, CopyContext) {
   segment->set_key("あん");
   Segment::Candidate *candidate = segment->add_candidate();
   candidate->value = "庵";
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   {
diff --git a/src/session/session_converter.cc b/src/session/session_converter.cc
index e90fbea4b..2be4de1b7 100644
--- a/src/session/session_converter.cc
+++ b/src/session/session_converter.cc
@@ -186,8 +186,8 @@ bool SessionConverter::ConvertWithPreferences(
   SetConversionPreferences(preferences, &segments_, &conversion_request);
   SetRequestType(ConversionRequest::CONVERSION, &conversion_request);
 
-  if (!converter_->StartConversionForRequest(conversion_request, &segments_)) {
-    LOG(WARNING) << "StartConversionForRequest() failed";
+  if (!converter_->StartConversion(conversion_request, &segments_)) {
+    LOG(WARNING) << "StartConversion() failed";
     ResetState();
     return false;
   }
@@ -490,15 +490,12 @@ bool SessionConverter::SuggestWithPreferences(
   // Start actual suggestion/prediction.
   bool result;
   if (use_partial_composition) {
-    result = converter_->StartPartialPredictionForRequest(conversion_request,
-                                                          &segments_);
+    result = converter_->StartPartialPrediction(conversion_request, &segments_);
   } else {
     if (use_prediction_candidate) {
-      result =
-          converter_->StartPredictionForRequest(conversion_request, &segments_);
+      result = converter_->StartPrediction(conversion_request, &segments_);
     } else {
-      result =
-          converter_->StartSuggestionForRequest(conversion_request, &segments_);
+      result = converter_->StartSuggestion(conversion_request, &segments_);
     }
   }
   if (!result) {
@@ -518,11 +515,11 @@ bool SessionConverter::SuggestWithPreferences(
         CreateIncognitoConversionRequest(conversion_request, incognito_config);
     incognito_segments_.Clear();
     if (use_partial_composition) {
-      result = converter_->StartPartialSuggestionForRequest(
-          incognito_conversion_request, &incognito_segments_);
+      result = converter_->StartPartialSuggestion(incognito_conversion_request,
+                                                  &incognito_segments_);
     } else {
-      result = converter_->StartSuggestionForRequest(
-          incognito_conversion_request, &incognito_segments_);
+      result = converter_->StartSuggestion(incognito_conversion_request,
+                                           &incognito_segments_);
     }
     if (!result) {
       MOZC_VLOG(1)
@@ -584,9 +581,8 @@ bool SessionConverter::PredictWithPreferences(
   segments_.clear_conversion_segments();
 
   if (predict_expand || predict_first) {
-    if (!converter_->StartPredictionForRequest(conversion_request,
-                                               &segments_)) {
-      LOG(WARNING) << "StartPredictionForRequest() failed";
+    if (!converter_->StartPrediction(conversion_request, &segments_)) {
+      LOG(WARNING) << "StartPrediction() failed";
       // TODO(komatsu): Perform refactoring after checking the stability test.
       //
       // If predict_expand is true, it means we have prevous_suggestions_.
diff --git a/src/session/session_converter_test.cc b/src/session/session_converter_test.cc
index 6457aee83..ebba408a1 100644
--- a/src/session/session_converter_test.cc
+++ b/src/session/session_converter_test.cc
@@ -112,8 +112,7 @@ class SessionConverterTest : public testing::TestWithTempUserProfile {
     request_ = std::make_unique<Request>();
 
     table_ = std::make_unique<composer::Table>();
-    table_->InitializeWithRequestAndConfig(*request_, *config_,
-                                           mock_data_manager_);
+    table_->InitializeWithRequestAndConfig(*request_, *config_);
     composer_ = std::make_unique<composer::Composer>(
         table_.get(), request_.get(), config_.get());
   }
@@ -431,7 +430,7 @@ TEST_F(SessionConverterTest, Convert) {
     SetAiueo(&segments);
     composer_->InsertCharacterPreedit("あいうえお");
     FillT13Ns(&segments, composer_.get());
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
 
@@ -494,7 +493,7 @@ TEST_F(SessionConverterTest, ConvertWithSpellingCorrection) {
     FillT13Ns(&segments, composer_.get());
     segments.mutable_conversion_segment(0)->mutable_candidate(0)->attributes |=
         Segment::Candidate::SPELLING_CORRECTION;
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
 
@@ -512,7 +511,7 @@ TEST_F(SessionConverterTest, ConvertToTransliteration) {
     SetAiueo(&segments);
     composer_->InsertCharacterKeyAndPreedit("aiueo", kChars_Aiueo);
     FillT13Ns(&segments, composer_.get());
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
 
@@ -579,7 +578,7 @@ TEST_F(SessionConverterTest, ConvertToTransliterationWithMultipleSegments) {
   {
     Segments segments;
     SetLike(&segments);
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
 
@@ -641,7 +640,7 @@ TEST_F(SessionConverterTest, ConvertToTransliterationWithoutCascadigWindow) {
     composer_->InsertCharacterKeyAndPreedit("dvd", "ｄｖｄ");
     FillT13Ns(&segments, composer_.get());
 
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
 
@@ -706,7 +705,7 @@ TEST_F(SessionConverterTest, MultiSegmentsConversion) {
     SetKamaboko(&segments);
     composer_->InsertCharacterPreedit(kKamabokono + kInbou);
     FillT13Ns(&segments, composer_.get());
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
   EXPECT_TRUE(converter.Convert(*composer_));
@@ -971,7 +970,7 @@ TEST_F(SessionConverterTest, Transliterations) {
     segment->add_candidate()->value = "クマー";
   }
   FillT13Ns(&segments, composer_.get());
-  EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   EXPECT_TRUE(converter.Convert(*composer_));
@@ -1031,7 +1030,7 @@ TEST_F(SessionConverterTest, T13NWithResegmentation) {
 
     InsertASCIISequence("kamabokonoinbou", composer_.get());
     FillT13Ns(&segments, composer_.get());
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
   EXPECT_TRUE(converter.Convert(*composer_));
@@ -1107,7 +1106,7 @@ TEST_F(SessionConverterTest, ConvertToHalfWidth) {
     segment->add_candidate()->value = "あべし";
   }
   FillT13Ns(&segments, composer_.get());
-  EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   EXPECT_TRUE(converter.ConvertToHalfWidth(*composer_));
   expected_indices.push_back(0);
@@ -1190,7 +1189,7 @@ TEST_F(SessionConverterTest, ConvertToHalfWidth2) {
     segment->add_candidate()->value = "q､｡";
   }
   FillT13Ns(&segments, composer_.get());
-  EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   EXPECT_TRUE(converter.ConvertToHalfWidth(*composer_));
   std::vector<int> expected_indices;
@@ -1225,7 +1224,7 @@ TEST_F(SessionConverterTest, SwitchKanaTypeFromCompositionMode) {
     segment->add_candidate()->value = "あべし";
   }
   FillT13Ns(&segments, composer_.get());
-  EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   EXPECT_TRUE(converter.SwitchKanaType(*composer_));
   std::vector<int> expected_indices = {0};
@@ -1290,7 +1289,7 @@ TEST_F(SessionConverterTest, SwitchKanaTypeFromConversionMode) {
     segment->add_candidate()->value = "漢字";
   }
   FillT13Ns(&segments, composer_.get());
-  EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   EXPECT_TRUE(converter.Convert(*composer_));
   std::vector<int> expected_indices = {0};
@@ -1379,7 +1378,7 @@ TEST_F(SessionConverterTest, ResizeSegmentFailedInSwitchKanaType) {
   Segments segments;
   AddSegmentWithSingleCandidate(&segments, "かな", "カナ");
   AddSegmentWithSingleCandidate(&segments, "たいぷ", "タイプ");
-  EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   // Suppose that ResizeSegment() fails for "かな|たいぷ" (UTF8-length is 5).
@@ -1401,7 +1400,7 @@ TEST_F(SessionConverterTest, CommitFirstSegment) {
   SetKamaboko(&segments);
   composer_->InsertCharacterPreedit("かまぼこ");
   FillT13Ns(&segments, composer_.get());
-  EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   const std::string kKamabokono = "かまぼこの";
@@ -1496,7 +1495,7 @@ TEST_F(SessionConverterTest, CommitHeadToFocusedSegments) {
     candidate = segment->add_candidate();
     candidate->value = "頂いた";
 
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
 
@@ -1537,7 +1536,7 @@ TEST_F(SessionConverterTest, CommitHeadToFocusedSegmentsAtLastSegment) {
 
   Segments segments;
   SetKamaboko(&segments);
-  EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   const std::string kKamabokono = "かまぼこの";
@@ -1583,7 +1582,7 @@ TEST_F(SessionConverterTest, CommitConvertedBracketPairText) {
   composer_->InsertCharacterPreedit(kKakko);
 
   // Suggestion
-  EXPECT_CALL(mock_converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   ASSERT_TRUE(converter.Suggest(*composer_));
   std::vector<int> expected_indices = {0};
@@ -1712,7 +1711,7 @@ TEST_F(SessionConverterTest, ClearSegmentsBeforeSuggest) {
 
   // Call Suggest() and sets the segments of converter to the following one.
   const Segments &segments = GetSegmentsTest();
-  EXPECT_CALL(mock_converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   composer_->InsertCharacterPreedit("てすと");
   EXPECT_TRUE(converter.Suggest(*composer_));
@@ -1723,7 +1722,7 @@ TEST_F(SessionConverterTest, ClearSegmentsBeforeSuggest) {
   empty.set_max_history_segments_size(
       converter.conversion_preferences().max_history_size);
   EXPECT_CALL(mock_converter,
-              StartSuggestionForRequest(_, Pointee(EqualsSegments(empty))))
+              StartSuggestion(_, Pointee(EqualsSegments(empty))))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   EXPECT_TRUE(converter.Suggest(*composer_));
 }
@@ -1735,14 +1734,14 @@ TEST_F(SessionConverterTest, PredictIsNotCalledInPredictionState) {
   // Call Predict() and sets the segments of converter to the following one. By
   // calling Predict(), converter enters PREDICTION state.
   const Segments &segments = GetSegmentsTest();
-  EXPECT_CALL(mock_converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartPrediction(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   composer_->InsertCharacterPreedit("てすと");
   EXPECT_TRUE(converter.Predict(*composer_));
   Mock::VerifyAndClearExpectations(&mock_converter);
 
   // Then, call Predict() again. PredictForRequest() is not called.
-  EXPECT_CALL(mock_converter, StartPredictionForRequest(_, _)).Times(0);
+  EXPECT_CALL(mock_converter, StartPrediction(_, _)).Times(0);
   EXPECT_TRUE(converter.Predict(*composer_));
 }
 
@@ -1766,7 +1765,7 @@ TEST_F(SessionConverterTest, CommitSuggestionByIndex) {
   composer_->InsertCharacterPreedit(kChars_Mo);
 
   // Suggestion
-  EXPECT_CALL(mock_converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   ASSERT_TRUE(converter.Suggest(*composer_));
   std::vector<int> expected_indices = {0};
@@ -1846,7 +1845,7 @@ TEST_F(SessionConverterTest, CommitSuggestionById) {
   composer_->InsertCharacterPreedit(kChars_Mo);
 
   // Suggestion
-  EXPECT_CALL(mock_converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   EXPECT_TRUE(converter.Suggest(*composer_));
   Mock::VerifyAndClearExpectations(&mock_converter);
@@ -1942,7 +1941,7 @@ TEST_F(SessionConverterTest, PartialPrediction) {
   composer_->InsertCharacterPreedit(kChars_Kokode + kChars_Hakimonowo);
   composer_->MoveCursorToEnd();
   // Prediction for "ここではきものを".
-  EXPECT_CALL(mock_converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartPrediction(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(suggestion_segments), Return(true)));
   EXPECT_TRUE(converter.Suggest(*composer_));
   Mock::VerifyAndClearExpectations(&mock_converter);
@@ -1955,7 +1954,7 @@ TEST_F(SessionConverterTest, PartialPrediction) {
   composer_->MoveCursorTo(0);
 
   // Prediction for "ここではきものを".
-  EXPECT_CALL(mock_converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartPrediction(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(suggestion_segments), Return(true)));
   EXPECT_TRUE(converter.Suggest(*composer_));
   Mock::VerifyAndClearExpectations(&mock_converter);
@@ -1967,7 +1966,7 @@ TEST_F(SessionConverterTest, PartialPrediction) {
   composer_->MoveCursorTo(3);
 
   // Partial prediction for "ここで"
-  EXPECT_CALL(mock_converter, StartPartialPredictionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartPartialPrediction(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments1), Return(true)));
   EXPECT_TRUE(converter.Suggest(*composer_));
   Mock::VerifyAndClearExpectations(&mock_converter);
@@ -2022,7 +2021,7 @@ TEST_F(SessionConverterTest, SuggestAndPredict) {
   composer_->InsertCharacterPreedit(kChars_Mo);
 
   // Suggestion
-  EXPECT_CALL(mock_converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   EXPECT_TRUE(converter.Suggest(*composer_));
   Mock::VerifyAndClearExpectations(&mock_converter);
@@ -2056,7 +2055,7 @@ TEST_F(SessionConverterTest, SuggestAndPredict) {
 
   // Since Suggest() was called, the converter stores its results internally. In
   // this case, the prediction is not triggered.
-  EXPECT_CALL(mock_converter, StartPredictionForRequest(_, _)).Times(0);
+  EXPECT_CALL(mock_converter, StartPrediction(_, _)).Times(0);
   EXPECT_TRUE(converter.Predict(*composer_));
   Mock::VerifyAndClearExpectations(&mock_converter);
   EXPECT_TRUE(IsCandidateListVisible(converter));
@@ -2110,7 +2109,7 @@ TEST_F(SessionConverterTest, SuggestAndPredict) {
     candidate->value = "モンドリアン";
     candidate->content_key = "もんどりあん";
   }
-  EXPECT_CALL(mock_converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartPrediction(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(mondrian_segments), Return(true)));
   converter.CandidateNext(*composer_);
   Mock::VerifyAndClearExpectations(&mock_converter);
@@ -2164,8 +2163,8 @@ TEST_F(SessionConverterTest, SuggestAndPredict) {
   }
 
   // After commit, the state should be reset. Thus, calling prediction before
-  // suggestion should trigger StartPredictionForRequest().
-  EXPECT_CALL(mock_converter, StartPredictionForRequest(_, _))
+  // suggestion should trigger StartPrediction().
+  EXPECT_CALL(mock_converter, StartPrediction(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(mondrian_segments), Return(true)));
   expected_indices.push_back(0);
   EXPECT_TRUE(converter.Predict(*composer_));
@@ -2219,8 +2218,8 @@ TEST_F(SessionConverterTest, SuggestFillIncognitoCandidateWords) {
     request_->set_fill_incognito_candidate_words(false);
     MockConverter mock_converter;
     SessionConverter converter(&mock_converter, request_.get(), config_.get());
-    EXPECT_CALL(mock_converter, StartSuggestionForRequest(
-                                    IsIncognitoConversionRequest(false), _))
+    EXPECT_CALL(mock_converter,
+                StartSuggestion(IsIncognitoConversionRequest(false), _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     EXPECT_TRUE(converter.Suggest(*composer_));
     commands::Output output;
@@ -2234,11 +2233,11 @@ TEST_F(SessionConverterTest, SuggestFillIncognitoCandidateWords) {
     request_->set_fill_incognito_candidate_words(true);
     MockConverter mock_converter;
     SessionConverter converter(&mock_converter, request_.get(), config_.get());
-    EXPECT_CALL(mock_converter, StartSuggestionForRequest(
-                                    IsIncognitoConversionRequest(false), _))
+    EXPECT_CALL(mock_converter,
+                StartSuggestion(IsIncognitoConversionRequest(false), _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
-    EXPECT_CALL(mock_converter, StartSuggestionForRequest(
-                                    IsIncognitoConversionRequest(true), _))
+    EXPECT_CALL(mock_converter,
+                StartSuggestion(IsIncognitoConversionRequest(true), _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     EXPECT_TRUE(converter.Suggest(*composer_));
     commands::Output output;
@@ -2273,7 +2272,7 @@ TEST_F(SessionConverterTest, OnePhaseSuggestion) {
 
   // Suggestion (internally prediction)
   // Use "prediction" mock as this suggestion uses prediction internally.
-  EXPECT_CALL(mock_converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartPrediction(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   EXPECT_TRUE(converter.Suggest(*composer_));
   Mock::VerifyAndClearExpectations(&mock_converter);
@@ -2302,7 +2301,7 @@ TEST_F(SessionConverterTest, SuppressSuggestionWhenNotRequested) {
   composer_->InsertCharacterPreedit(kChars_Mo);
 
   // Suggestion
-  EXPECT_CALL(mock_converter, StartSuggestionForRequest(_, _)).Times(0);
+  EXPECT_CALL(mock_converter, StartSuggestion(_, _)).Times(0);
   // No candidates should be visible because we are on password field.
 
   ConversionPreferences conversion_preferences =
@@ -2322,7 +2321,7 @@ TEST_F(SessionConverterTest, SuppressSuggestionOnPasswordField) {
   composer_->InsertCharacterPreedit(kChars_Mo);
 
   // Suggestion
-  EXPECT_CALL(mock_converter, StartSuggestionForRequest(_, _)).Times(0);
+  EXPECT_CALL(mock_converter, StartSuggestion(_, _)).Times(0);
 
   // No candidates should be visible because we are on password field.
   EXPECT_FALSE(converter.Suggest(*composer_));
@@ -2523,7 +2522,7 @@ TEST_F(SessionConverterTest, ReloadConfig) {
   SetAiueo(&segments);
   composer_->InsertCharacterPreedit("あいうえお");
   FillT13Ns(&segments, composer_.get());
-  EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   composer_->InsertCharacterPreedit("aiueo");
@@ -2576,7 +2575,7 @@ TEST_F(SessionConverterTest, OutputAllCandidateWords) {
 
   commands::Output output;
 
-  EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   EXPECT_TRUE(converter.Convert(*composer_));
   Mock::VerifyAndClearExpectations(&mock_converter);
@@ -2673,7 +2672,7 @@ TEST_F(SessionConverterTest, GetPreeditAndGetConversion) {
     // PREDICTION
     MockConverter mock_converter;
     SessionConverter converter(&mock_converter, request_.get(), config_.get());
-    EXPECT_CALL(mock_converter, StartPredictionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartPrediction(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     EXPECT_CALL(mock_converter, FocusSegmentValue(_, 0, 1))
         .WillOnce(Return(true));
@@ -2690,7 +2689,7 @@ TEST_F(SessionConverterTest, GetPreeditAndGetConversion) {
     // SUGGESTION
     MockConverter mock_converter;
     SessionConverter converter(&mock_converter, request_.get(), config_.get());
-    EXPECT_CALL(mock_converter, StartSuggestionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartSuggestion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     converter.Suggest(*composer_);
     std::string preedit;
@@ -2717,7 +2716,7 @@ TEST_F(SessionConverterTest, GetPreeditAndGetConversion) {
     // CONVERSION
     MockConverter mock_converter;
     SessionConverter converter(&mock_converter, request_.get(), config_.get());
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     EXPECT_CALL(mock_converter, FocusSegmentValue(_, 0, 1))
         .WillOnce(Return(true));
@@ -2788,7 +2787,7 @@ TEST_F(SessionConverterTest, Clone) {
     Segments segments;
     SetKamaboko(&segments);
 
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
 
     src.set_use_cascading_window(false);
@@ -2835,7 +2834,7 @@ TEST_F(SessionConverterTest, Issue1948334) {
   composer_->InsertCharacterPreedit(kChars_Mo);
 
   // Suggestion
-  EXPECT_CALL(mock_converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartSuggestion(_, _))
       .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
   EXPECT_TRUE(converter.Suggest(*composer_));
   Mock::VerifyAndClearExpectations(&mock_converter);
@@ -2853,7 +2852,7 @@ TEST_F(SessionConverterTest, Issue1948334) {
   composer_->InsertCharacterPreedit("もず");
 
   // Suggestion
-  EXPECT_CALL(mock_converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartSuggestion(_, _))
       .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
   EXPECT_TRUE(converter.Suggest(*composer_));
   Mock::VerifyAndClearExpectations(&mock_converter);
@@ -2921,7 +2920,7 @@ TEST_F(SessionConverterTest, Issue1960362) {
   FillT13Ns(&segments, composer_.get());
   FillT13Ns(&resized_segments, composer_.get());
 
-  EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartConversion(_, _))
       .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
   EXPECT_CALL(mock_converter, ResizeSegment(_, _, _, _))
       .WillRepeatedly(DoAll(SetArgPointee<0>(resized_segments), Return(true)));
@@ -2959,7 +2958,7 @@ TEST_F(SessionConverterTest, Issue1978201) {
   }
 
   // Prediction
-  EXPECT_CALL(mock_converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartPrediction(_, _))
       .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
   EXPECT_TRUE(converter.Predict(*composer_));
   EXPECT_TRUE(converter.IsActive());
@@ -3030,7 +3029,7 @@ TEST_F(SessionConverterTest, Issue2029557) {
   // Prediction (as <tab>)
   Segments segments;
   SetAiueo(&segments);
-  EXPECT_CALL(mock_converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartPrediction(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   EXPECT_TRUE(converter.Predict(*composer_));
   EXPECT_TRUE(converter.IsActive());
@@ -3043,7 +3042,7 @@ TEST_F(SessionConverterTest, Issue2029557) {
   candidate->value = "a";
 
   FillT13Ns(&segments, composer_.get());
-  EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   EXPECT_TRUE(converter.ConvertToTransliteration(*composer_,
                                                  transliteration::HIRAGANA));
@@ -3065,7 +3064,7 @@ TEST_F(SessionConverterTest, Issue2031986) {
     candidate->value = "AAAA";
     candidate = segment->add_candidate();
     candidate->value = "Aaaa";
-    EXPECT_CALL(mock_converter, StartSuggestionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartSuggestion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
   // Get suggestion
@@ -3077,7 +3076,7 @@ TEST_F(SessionConverterTest, Issue2031986) {
     Segments segments;
     Segment *segment = segments.add_segment();
     segment->set_key("aaaaa");
-    EXPECT_CALL(mock_converter, StartSuggestionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartSuggestion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(false)));
   }
   // Hide suggestion
@@ -3101,7 +3100,7 @@ TEST_F(SessionConverterTest, Issue2040116) {
     Segments segments;
     Segment *segment = segments.add_segment();
     segment->set_key("G");
-    EXPECT_CALL(mock_converter, StartPredictionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartPrediction(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(false)));
   }
   // Get prediction
@@ -3117,7 +3116,7 @@ TEST_F(SessionConverterTest, Issue2040116) {
     Segment::Candidate *candidate;
     candidate = segment->add_candidate();
     candidate->value = "GoogleSuggest";
-    EXPECT_CALL(mock_converter, StartPredictionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartPrediction(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
   // Get prediction again
@@ -3143,7 +3142,7 @@ TEST_F(SessionConverterTest, Issue2040116) {
     Segments segments;
     Segment *segment = segments.add_segment();
     segment->set_key("G");
-    EXPECT_CALL(mock_converter, StartPredictionForRequest(_, _)).Times(0);
+    EXPECT_CALL(mock_converter, StartPrediction(_, _)).Times(0);
   }
   // Hide prediction
   EXPECT_CALL(mock_converter, FocusSegmentValue(_, 0, 0));
@@ -3201,7 +3200,7 @@ TEST_F(SessionConverterTest, ZeroQuerySuggestion) {
   segment->set_key("");
   segment->add_candidate()->value = "search";
   segment->add_candidate()->value = "input";
-  EXPECT_CALL(mock_converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   EXPECT_TRUE(composer_->Empty());
@@ -3290,7 +3289,7 @@ TEST_F(SessionConverterTest, CommandCandidate) {
   FillT13Ns(&segments, composer_.get());
   // set COMMAND_CANDIDATE.
   SetCommandCandidate(&segments, 0, 0, Segment::Candidate::DEFAULT_COMMAND);
-  EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   composer_->InsertCharacterPreedit(kChars_Aiueo);
@@ -3315,7 +3314,7 @@ TEST_F(SessionConverterTest, CommandCandidateWithCommitCommands) {
     Segments segments;
     SetKamaboko(&segments);
     SetCommandCandidate(&segments, 0, 0, Segment::Candidate::DEFAULT_COMMAND);
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     converter.Convert(*composer_);
 
@@ -3338,7 +3337,7 @@ TEST_F(SessionConverterTest, CommandCandidateWithCommitCommands) {
     Segments segments;
     SetKamaboko(&segments);
     SetCommandCandidate(&segments, 1, 0, Segment::Candidate::DEFAULT_COMMAND);
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     converter.Convert(*composer_);
 
@@ -3360,7 +3359,7 @@ TEST_F(SessionConverterTest, CommandCandidateWithCommitCommands) {
     Segments segments;
     SetAiueo(&segments);
     SetCommandCandidate(&segments, 0, 0, Segment::Candidate::DEFAULT_COMMAND);
-    EXPECT_CALL(mock_converter, StartSuggestionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartSuggestion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     converter.Suggest(*composer_);
 
@@ -3377,7 +3376,7 @@ TEST_F(SessionConverterTest, CommandCandidateWithCommitCommands) {
     Segments segments;
     SetAiueo(&segments);
     SetCommandCandidate(&segments, 0, 1, Segment::Candidate::DEFAULT_COMMAND);
-    EXPECT_CALL(mock_converter, StartSuggestionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartSuggestion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     converter.Suggest(*composer_);
 
@@ -3399,7 +3398,7 @@ TEST_F(SessionConverterTest, ExecuteCommandCandidate) {
     SetAiueo(&segments);
     SetCommandCandidate(&segments, 0, 0,
                         Segment::Candidate::ENABLE_INCOGNITO_MODE);
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
     composer_->InsertCharacterPreedit(kChars_Aiueo);
@@ -3427,7 +3426,7 @@ TEST_F(SessionConverterTest, ExecuteCommandCandidate) {
     SetAiueo(&segments);
     SetCommandCandidate(&segments, 0, 0,
                         Segment::Candidate::DISABLE_INCOGNITO_MODE);
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
     composer_->InsertCharacterPreedit(kChars_Aiueo);
@@ -3455,7 +3454,7 @@ TEST_F(SessionConverterTest, ExecuteCommandCandidate) {
     SetAiueo(&segments);
     SetCommandCandidate(&segments, 0, 0,
                         Segment::Candidate::ENABLE_PRESENTATION_MODE);
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
     composer_->InsertCharacterPreedit(kChars_Aiueo);
@@ -3483,7 +3482,7 @@ TEST_F(SessionConverterTest, ExecuteCommandCandidate) {
     SetAiueo(&segments);
     SetCommandCandidate(&segments, 0, 0,
                         Segment::Candidate::DISABLE_PRESENTATION_MODE);
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
     composer_->InsertCharacterPreedit(kChars_Aiueo);
@@ -3511,7 +3510,7 @@ TEST_F(SessionConverterTest, PropagateConfigToRenderer) {
     SetAiueo(&segments);
     composer_->InsertCharacterPreedit("あいうえお");
     FillT13Ns(&segments, composer_.get());
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
     commands::Output output;
@@ -3540,7 +3539,7 @@ TEST_F(SessionConverterTest, ConversionFail) {
     // segments doesn't have any candidates.
     Segments segments;
     segments.add_segment()->set_key(kChars_Aiueo);
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(false)));
     composer_->InsertCharacterPreedit(kChars_Aiueo);
 
@@ -3564,7 +3563,7 @@ TEST_F(SessionConverterTest, ConversionFail) {
   {
     Segments segments;
     SetAiueo(&segments);
-    EXPECT_CALL(mock_converter, StartSuggestionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartSuggestion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     composer_->InsertCharacterPreedit(kChars_Aiueo);
 
@@ -3584,7 +3583,7 @@ TEST_F(SessionConverterTest, ConversionFail) {
 
     // segments doesn't have any candidates.
     segments.add_segment()->set_key(kChars_Aiueo);
-    EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(mock_converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(false)));
 
     // Falls back to composition state.
@@ -3815,7 +3814,7 @@ TEST_F(SessionConverterTest, ResultTokens) {
     candidate->lid = 200;
     candidate->rid = 201;
   }
-  EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   composer_->InsertCharacterPreedit("きょうははれ");
@@ -3865,7 +3864,7 @@ TEST_F(SessionConverterTest, ResultTokensWithInnerSegements) {
     // 6, 6, 6, 6 = len("はれ"), len("晴れ"), len("はれ"), len("晴れ")
     candidate->PushBackInnerSegmentBoundary(6, 6, 6, 6);
   }
-  EXPECT_CALL(mock_converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(mock_converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   composer_->InsertCharacterPreedit("きょうははれ");
diff --git a/src/session/session_handler.cc b/src/session/session_handler.cc
index 92ec71936..ae442a44f 100644
--- a/src/session/session_handler.cc
+++ b/src/session/session_handler.cc
@@ -41,6 +41,7 @@
 #include <vector>
 
 #include "absl/flags/flag.h"
+#include "absl/log/log.h"
 #include "absl/random/random.h"
 #include "absl/time/time.h"
 #include "base/clock.h"
@@ -51,7 +52,6 @@
 #include "composer/table.h"
 #include "config/character_form_manager.h"
 #include "config/config_handler.h"
-#include "data_manager/data_manager_interface.h"
 #include "dictionary/user_dictionary_session_handler.h"
 #include "engine/engine_interface.h"
 #include "engine/user_data_manager_interface.h"
@@ -198,11 +198,8 @@ void SessionHandler::UpdateSessions(const config::Config &config,
 
   config_ = std::make_unique<config::Config>(config);
   request_ = std::make_unique<commands::Request>(request);
-  const DataManagerInterface *data_manager = engine_->GetDataManager();
   const composer::Table *table = nullptr;
-  if (data_manager != nullptr) {
-    table = table_manager_->GetTable(*request_, *config_, *data_manager);
-  }
+  table = table_manager_->GetTable(*request_, *config_);
 
   if (!keymap::KeyMapManager::IsSameKeyMapManagerApplicable(*prev_config,
                                                             *config_)) {
@@ -475,11 +472,14 @@ void SessionHandler::MaybeReloadEngine(commands::Command *command) {
     return;
   }
 
-  if (!engine_->MaybeReloadEngine(
-      command->mutable_output()->mutable_engine_reload_response())) {
+  EngineReloadResponse engine_reload_response;
+  if (!engine_->MaybeReloadEngine(&engine_reload_response)) {
+    // Engine is not reloaded. output.engine_reload_response must be empty.
     return;
   }
 
+  *command->mutable_output()->mutable_engine_reload_response() =
+      engine_reload_response;
   table_manager_->ClearCaches();
 }
 
diff --git a/src/session/session_handler_test.cc b/src/session/session_handler_test.cc
index 9097d6c52..27ff361dc 100644
--- a/src/session/session_handler_test.cc
+++ b/src/session/session_handler_test.cc
@@ -41,6 +41,7 @@
 
 #include "absl/flags/declare.h"
 #include "absl/flags/flag.h"
+#include "absl/log/check.h"
 #include "absl/random/random.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
@@ -48,14 +49,13 @@
 #include "absl/time/time.h"
 #include "base/clock.h"
 #include "base/clock_mock.h"
-#include "base/logging.h"
 #include "base/thread.h"
 #include "composer/query.h"
 #include "config/config_handler.h"
 #include "converter/segments.h"
 #include "data_manager/testing/mock_data_manager.h"
-#include "engine/engine.h"
 #include "engine/data_loader.h"
+#include "engine/engine.h"
 #include "engine/engine_mock.h"
 #include "engine/minimal_engine.h"
 #include "engine/mock_data_engine_factory.h"
@@ -86,21 +86,16 @@ using ::testing::Return;
 
 class MockDataLoader : public DataLoader {
  public:
-  MOCK_METHOD(uint64_t, RegisterRequest, (const EngineReloadRequest &),
-              (override));
-  MOCK_METHOD(uint64_t, UnregisterRequest, (uint64_t), (override));
   MOCK_METHOD(std::unique_ptr<ResponseFuture>, Build, (uint64_t),
               (const override));
 };
 
 EngineReloadResponse::Status SendMockEngineReloadRequest(
-    SessionHandler *handler) {
+    SessionHandler *handler, const EngineReloadRequest &request) {
   commands::Command command;
   command.mutable_input()->set_type(
       commands::Input::SEND_ENGINE_RELOAD_REQUEST);
-  auto *request = command.mutable_input()->mutable_engine_reload_request();
-  request->set_engine_type(EngineReloadRequest::MOBILE);
-  request->set_file_path("placeholder");  // OK for MockDataLoader
+  *command.mutable_input()->mutable_engine_reload_request() = request;
   handler->EvalCommand(&command);
   return command.output().engine_reload_response().status();
 }
@@ -625,14 +620,19 @@ TEST_F(SessionHandlerTest, EngineReloadSuccessfulScenarioTest) {
   CHECK_OK(modules->Init(std::move(data_manager)));
 
   auto data_loader = std::make_unique<MockDataLoader>();
-  EXPECT_CALL(*data_loader, RegisterRequest(_)).WillRepeatedly(Return(1));
-  EXPECT_CALL(*data_loader, Build(1))
+
+  EngineReloadRequest request;
+  request.set_engine_type(EngineReloadRequest::MOBILE);
+  request.set_file_path("placeholder");  // OK for MockDataLoader
+  const uint64_t data_id = data_loader->GetRequestId(request);
+
+  EXPECT_CALL(*data_loader, Build(data_id))
       .WillOnce(Return(
           std::make_unique<BackgroundFuture<DataLoader::Response>>([&]() {
             // takes 0.1 seconds to make engine.
             absl::SleepFor(absl::Milliseconds(100));
             DataLoader::Response result;
-            result.id = 1;
+            result.id = data_id;
             result.response.set_status(EngineReloadResponse::RELOAD_READY);
             result.modules = std::move(modules);
             return result;
@@ -644,20 +644,28 @@ TEST_F(SessionHandlerTest, EngineReloadSuccessfulScenarioTest) {
   (*engine_status)->SetDataLoaderForTesting(std::move(data_loader));
   SessionHandler handler(std::move(*engine_status));
 
-  ASSERT_EQ(SendMockEngineReloadRequest(&handler),
+  ASSERT_EQ(SendMockEngineReloadRequest(&handler, request),
             EngineReloadResponse::ACCEPTED);
 
   // A new engine should be built on create session event because the session
   // handler currently holds no session.
-  uint64_t id = 0;
-  ASSERT_TRUE(CreateSession(&handler, &id));
+  commands::Command command;
+  command.mutable_input()->set_type(commands::Input::CREATE_SESSION);
+  handler.EvalCommand(&command);
+  EXPECT_EQ(command.output().error_code(), commands::Output::SESSION_SUCCESS);
+  EXPECT_TRUE(command.output().has_engine_reload_response());
+  EXPECT_EQ(command.output().engine_reload_response().status(),
+            EngineReloadResponse::RELOADED);
+  EXPECT_NE(command.output().id(), 0);
+
   // When the engine is created first, we wait until the engine gets ready.
   EXPECT_EQ(handler.engine().GetDataVersion(), data_version);
 
   // New session is created, but Build is not called as the id is the same.
-  ASSERT_EQ(SendMockEngineReloadRequest(&handler),
+  ASSERT_EQ(SendMockEngineReloadRequest(&handler, request),
             EngineReloadResponse::ACCEPTED);
 
+  uint64_t id = 0;
   ASSERT_TRUE(DeleteSession(&handler, id));
   ASSERT_TRUE(CreateSession(&handler, &id));
   EXPECT_EQ(handler.engine().GetDataVersion(), data_version);
@@ -685,14 +693,22 @@ TEST_F(SessionHandlerTest, EngineUpdateSuccessfulScenarioTest) {
 
   InSequence seq;  // EXPECT_CALL is called sequentially.
 
-  EXPECT_CALL(*data_loader, RegisterRequest(_)).WillRepeatedly(Return(1));
+  EngineReloadRequest request1;
+  request1.set_engine_type(EngineReloadRequest::MOBILE);
+  request1.set_file_path("placeholder1");  // OK for MockDataLoader
+  const uint64_t data_id1 = data_loader->GetRequestId(request1);
 
-  EXPECT_CALL(*data_loader, Build(1))
+  EngineReloadRequest request2;
+  request2.set_engine_type(EngineReloadRequest::MOBILE);
+  request2.set_file_path("placeholder2");  // OK for MockDataLoader
+  const uint64_t data_id2 = data_loader->GetRequestId(request2);
+
+  EXPECT_CALL(*data_loader, Build(data_id1))
       .WillOnce(Return(
           std::make_unique<BackgroundFuture<DataLoader::Response>>([&]() {
             absl::SleepFor(absl::Milliseconds(100));
             DataLoader::Response result;
-            result.id = 1;
+            result.id = data_id1;
             result.response.set_status(EngineReloadResponse::RELOAD_READY);
             result.modules = std::move(modules1);
             return result;
@@ -702,11 +718,11 @@ TEST_F(SessionHandlerTest, EngineUpdateSuccessfulScenarioTest) {
       Engine::CreateMobileEngine(std::make_unique<testing::MockDataManager>());
   EXPECT_OK(engine_status);
   (*engine_status)->SetDataLoaderForTesting(std::move(data_loader));
-  (*engine_status)->SetAlwaysWaitForEngineResponseFutureForTesting(true);
+  (*engine_status)->SetAlwaysWaitForLoaderResponseFutureForTesting(true);
   SessionHandler handler(std::move(*engine_status));
 
   // engine_id = 1
-  ASSERT_EQ(SendMockEngineReloadRequest(&handler),
+  ASSERT_EQ(SendMockEngineReloadRequest(&handler, request1),
             EngineReloadResponse::ACCEPTED);
 
   // build request is called one per new engine reload request.
@@ -715,22 +731,19 @@ TEST_F(SessionHandlerTest, EngineUpdateSuccessfulScenarioTest) {
   EXPECT_EQ(handler.engine().GetDataVersion(), data_version1);
 
   // Use data_loader_ptr after std::move(engine_build).
-  EXPECT_CALL(*data_loader_ptr, RegisterRequest(_))
-      .WillRepeatedly(Return(2));
-
-  EXPECT_CALL(*data_loader_ptr, Build(2))
+  EXPECT_CALL(*data_loader_ptr, Build(data_id2))
       .WillOnce(Return(
           std::make_unique<BackgroundFuture<DataLoader::Response>>([&]() {
             absl::SleepFor(absl::Milliseconds(100));
             DataLoader::Response result;
-            result.id = 2;
+            result.id = data_id2;
             result.response.set_status(EngineReloadResponse::RELOAD_READY);
             result.modules = std::move(modules2);
             return result;
           })));
 
   // engine_id = 2
-  ASSERT_EQ(SendMockEngineReloadRequest(&handler),
+  ASSERT_EQ(SendMockEngineReloadRequest(&handler, request2),
             EngineReloadResponse::ACCEPTED);
 
   ASSERT_TRUE(DeleteSession(&handler, id));
@@ -754,32 +767,40 @@ TEST_F(SessionHandlerTest, EngineReloadInvalidDataTest) {
   (*engine_status)->SetDataLoaderForTesting(std::move(data_loader));
   SessionHandler handler(std::move(*engine_status));
 
-  EXPECT_CALL(*data_loader_ptr, RegisterRequest(_)).WillOnce(Return(1));
-
-  ASSERT_EQ(SendMockEngineReloadRequest(&handler),
+  EngineReloadRequest request;
+  request.set_engine_type(EngineReloadRequest::MOBILE);
+  request.set_file_path("placeholder");  // OK for MockDataLoader
+  const uint64_t data_id = data_loader_ptr->GetRequestId(request);
+  ASSERT_EQ(SendMockEngineReloadRequest(&handler, request),
             EngineReloadResponse::ACCEPTED);
 
-  EXPECT_CALL(*data_loader_ptr, Build(1))
+  EXPECT_CALL(*data_loader_ptr, Build(data_id))
       .WillOnce(Return(
           std::make_unique<BackgroundFuture<DataLoader::Response>>([&]() {
             absl::SleepFor(absl::Milliseconds(100));
             DataLoader::Response result;
-            result.id = 1;
+            result.id = data_id;
             result.response.set_status(EngineReloadResponse::DATA_BROKEN);
             return result;
           })));
-  EXPECT_CALL(*data_loader_ptr, UnregisterRequest(1)).WillOnce(Return(0));
 
   // Build() is called, but it returns invalid data, so new data is not used.
   EXPECT_EQ(&handler.engine(), old_engine_ptr);
-  uint64_t id = 0;
-  ASSERT_TRUE(CreateSession(&handler, &id));
+
+  // CreateSession does not contain engine_reload_response.
+  commands::Command command;
+  command.mutable_input()->set_type(commands::Input::CREATE_SESSION);
+  handler.EvalCommand(&command);
+  EXPECT_EQ(command.output().error_code(), commands::Output::SESSION_SUCCESS);
+  EXPECT_FALSE(command.output().has_engine_reload_response());
+  EXPECT_NE(command.output().id(), 0);
+
   EXPECT_EQ(&handler.engine(), old_engine_ptr);
 
   // Sends the same request again, but the request is already marked as
   // unregistered.
-  EXPECT_CALL(*data_loader_ptr, RegisterRequest(_)).WillOnce(Return(0));
-  ASSERT_EQ(SendMockEngineReloadRequest(&handler),
+  uint64_t id = 0;
+  ASSERT_EQ(SendMockEngineReloadRequest(&handler, request),
             EngineReloadResponse::ACCEPTED);
   ASSERT_TRUE(DeleteSession(&handler, id));
   ASSERT_TRUE(CreateSession(&handler, &id));
@@ -804,39 +825,66 @@ TEST_F(SessionHandlerTest, EngineRollbackDataTest) {
       Engine::CreateMobileEngine(std::make_unique<testing::MockDataManager>());
   EXPECT_OK(engine_status);
   (*engine_status)->SetDataLoaderForTesting(std::move(data_loader));
-  (*engine_status)->SetAlwaysWaitForEngineResponseFutureForTesting(true);
+  (*engine_status)->SetAlwaysWaitForLoaderResponseFutureForTesting(true);
   SessionHandler handler(std::move(*engine_status));
 
+  EngineReloadRequest request1_ready;
+  request1_ready.set_engine_type(EngineReloadRequest::MOBILE);
+  request1_ready.set_file_path("placeholder1");  // OK for MockDataLoader
+  const uint64_t data_id1 = data_loader_ptr->GetRequestId(request1_ready);
+
+  EngineReloadRequest request2_broken;
+  request2_broken.set_engine_type(EngineReloadRequest::MOBILE);
+  request2_broken.set_file_path("placeholder2");  // OK for MockDataLoader
+  const uint64_t data_id2 = data_loader_ptr->GetRequestId(request2_broken);
+
+  EngineReloadRequest request3_broken;
+  request3_broken.set_engine_type(EngineReloadRequest::MOBILE);
+  request3_broken.set_file_path("placeholder3");  // OK for MockDataLoader
+  const uint64_t data_id3 = data_loader_ptr->GetRequestId(request3_broken);
+
   // Sends multiple requests three times. 1 -> 2 -> 3.
   // 3 is the latest id.
-  for (int eid = 1; eid <= 3; ++eid) {
-    EXPECT_CALL(*data_loader_ptr, RegisterRequest(_)).WillOnce(Return(eid));
-    ASSERT_EQ(SendMockEngineReloadRequest(&handler),
-              EngineReloadResponse::ACCEPTED);
-  }
+  ASSERT_EQ(SendMockEngineReloadRequest(&handler, request1_ready),
+            EngineReloadResponse::ACCEPTED);
+  ASSERT_EQ(SendMockEngineReloadRequest(&handler, request2_broken),
+            EngineReloadResponse::ACCEPTED);
+  ASSERT_EQ(SendMockEngineReloadRequest(&handler, request3_broken),
+            EngineReloadResponse::ACCEPTED);
+
+  // Rollback as 3 -> 2 -> 1.  1 is only valid engine.
+  EXPECT_CALL(*data_loader_ptr, Build(data_id3))
+      .WillOnce(Return(
+          std::make_unique<BackgroundFuture<DataLoader::Response>>([&]() {
+            absl::SleepFor(absl::Milliseconds(100));
+            DataLoader::Response result;
+            result.id = data_id3;
+            result.response.set_status(EngineReloadResponse::DATA_BROKEN);
+            return result;
+          })));
+  EXPECT_CALL(*data_loader_ptr, Build(data_id2))
+      .WillOnce(Return(
+          std::make_unique<BackgroundFuture<DataLoader::Response>>([&]() {
+            absl::SleepFor(absl::Milliseconds(100));
+            DataLoader::Response result;
+            result.id = data_id2;
+            result.response.set_status(EngineReloadResponse::DATA_BROKEN);
+            return result;
+          })));
+  EXPECT_CALL(*data_loader_ptr, Build(data_id1))
+      .WillOnce(Return(
+          std::make_unique<BackgroundFuture<DataLoader::Response>>([&]() {
+            absl::SleepFor(absl::Milliseconds(100));
+            DataLoader::Response result;
+            result.id = data_id1;
+            result.response.set_status(EngineReloadResponse::RELOAD_READY);
+            result.modules = std::move(modules);
+            return result;
+          })));
 
   for (int eid = 3; eid >= 1; --eid) {
-    // Rollback as 3 -> 2 -> 1.  1 is only valid engine.
-    EXPECT_CALL(*data_loader_ptr, Build(eid))
-        .WillOnce(Return(
-            std::make_unique<BackgroundFuture<DataLoader::Response>>([&]() {
-              absl::SleepFor(absl::Milliseconds(100));
-              DataLoader::Response result;
-              result.id = eid;
-              if (eid == 1) {
-                result.response.set_status(EngineReloadResponse::RELOAD_READY);
-                result.modules = std::move(modules);
-              } else {
-                result.response.set_status(EngineReloadResponse::DATA_BROKEN);
-              }
-              return result;
-            })));
     // Engine of 3, and 2 are unregistered.
     // The second best id (2, and 1) are used.
-    if (eid > 1) {
-      EXPECT_CALL(*data_loader_ptr, UnregisterRequest(eid))
-          .WillOnce(Return(eid - 1));
-    }
     uint64_t id = 0;
     ASSERT_TRUE(CreateSession(&handler, &id));
     ASSERT_TRUE(DeleteSession(&handler, id));
@@ -861,13 +909,17 @@ TEST_F(SessionHandlerTest, EngineReloadSessionExistsTest) {
 
   auto data_loader = std::make_unique<MockDataLoader>();
 
-  EXPECT_CALL(*data_loader, RegisterRequest(_)).WillOnce(Return(1));
-  EXPECT_CALL(*data_loader, Build(1))
+  EngineReloadRequest request;
+  request.set_engine_type(EngineReloadRequest::MOBILE);
+  request.set_file_path("placeholder1");  // OK for MockDataLoader
+  const uint64_t data_id = data_loader->GetRequestId(request);
+
+  EXPECT_CALL(*data_loader, Build(data_id))
       .WillOnce(Return(
           std::make_unique<BackgroundFuture<DataLoader::Response>>([&]() {
             absl::SleepFor(absl::Milliseconds(100));
             DataLoader::Response result;
-            result.id = 1;
+            result.id = data_id;
             result.response.set_status(EngineReloadResponse::RELOAD_READY);
             result.modules = std::move(modules);
             return result;
@@ -887,7 +939,7 @@ TEST_F(SessionHandlerTest, EngineReloadSessionExistsTest) {
   EXPECT_EQ(&handler.engine(), old_engine_ptr);
   EXPECT_NE(handler.engine().GetDataVersion(), data_version);
 
-  ASSERT_EQ(SendMockEngineReloadRequest(&handler),
+  ASSERT_EQ(SendMockEngineReloadRequest(&handler, request),
             EngineReloadResponse::ACCEPTED);
 
   // Another session is created. Since the handler already holds one session
diff --git a/src/session/session_regression_test.cc b/src/session/session_regression_test.cc
index e321988bb..a688a390b 100644
--- a/src/session/session_regression_test.cc
+++ b/src/session/session_regression_test.cc
@@ -160,7 +160,7 @@ class SessionRegressionTest : public testing::TestWithTempUserProfile {
     session_ = handler_->NewSession();
     commands::Request request;
     table_ = std::make_unique<composer::Table>();
-    table_->InitializeWithRequestAndConfig(request, config_, data_manager_);
+    table_->InitializeWithRequestAndConfig(request, config_);
     session_->SetTable(table_.get());
   }
 
diff --git a/src/session/session_test.cc b/src/session/session_test.cc
index 83fb3729e..ecc4a9fa8 100644
--- a/src/session/session_test.cc
+++ b/src/session/session_test.cc
@@ -488,7 +488,7 @@ class SessionTest : public testing::TestWithTempUserProfile {
     SetComposer(session, &request);
     SetAiueo(&segments);
     FillT13Ns(request, &segments);
-    EXPECT_CALL(*converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(*converter, StartConversion(_, _))
         .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
 
     command.Clear();
@@ -526,7 +526,7 @@ class SessionTest : public testing::TestWithTempUserProfile {
     session->SetRequest(&request);
     table_ = std::make_unique<composer::Table>();
     table_->InitializeWithRequestAndConfig(
-        request, config::ConfigHandler::DefaultConfig(), mock_data_manager_);
+        request, config::ConfigHandler::DefaultConfig());
     session->SetTable(table_.get());
   }
 
@@ -584,7 +584,7 @@ class SessionTest : public testing::TestWithTempUserProfile {
     candidate = segment->add_candidate();
     candidate->key = hiragana;
     candidate->value = kanji;
-    EXPECT_CALL(*converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(*converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
 
@@ -617,7 +617,7 @@ class SessionTest : public testing::TestWithTempUserProfile {
       segment = segments.add_segment();
       segment->set_key("google");
       segment->add_candidate()->value = "GOOGLE";
-      EXPECT_CALL(*mock_converter, StartConversionForRequest(_, _))
+      EXPECT_CALL(*mock_converter, StartConversion(_, _))
           .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
     }
     command.Clear();
@@ -631,7 +631,7 @@ class SessionTest : public testing::TestWithTempUserProfile {
       segment->set_key("");
       AddCandidate("search", "search", segment);
       AddCandidate("input", "input", segment);
-      EXPECT_CALL(*mock_converter, StartSuggestionForRequest(_, _))
+      EXPECT_CALL(*mock_converter, StartSuggestion(_, _))
           .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
     }
 
@@ -643,7 +643,7 @@ class SessionTest : public testing::TestWithTempUserProfile {
       segment->set_key("");
       AddCandidate("search", "search", segment);
       AddCandidate("input", "input", segment);
-      EXPECT_CALL(*mock_converter, StartPredictionForRequest(_, _))
+      EXPECT_CALL(*mock_converter, StartPrediction(_, _))
           .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
     }
   }
@@ -673,7 +673,7 @@ class SessionTest : public testing::TestWithTempUserProfile {
     }
 
     {  // Commit the composition to make an undo context.
-      EXPECT_CALL(*converter, StartConversionForRequest(_, _))
+      EXPECT_CALL(*converter, StartConversion(_, _))
           .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
       command.Clear();
       session->Convert(&command);
@@ -938,7 +938,7 @@ TEST_F(SessionTest, RevertComposition) {
   SetComposer(&session, &request);
   SetAiueo(&segments);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -994,7 +994,7 @@ TEST_F(SessionTest, SelectCandidate) {
   SetComposer(&session, &request);
   SetAiueo(&segments);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -1028,7 +1028,7 @@ TEST_F(SessionTest, HighlightCandidate) {
   SetComposer(&session, &request);
   SetAiueo(&segments);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -1064,7 +1064,7 @@ TEST_F(SessionTest, Conversion) {
   SetComposer(&session, &request);
   SetAiueo(&segments);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   EXPECT_SINGLE_SEGMENT_AND_KEY("あいうえお", "あいうえお", command);
@@ -1099,7 +1099,7 @@ TEST_F(SessionTest, SegmentWidthShrink) {
   SetComposer(&session, &request);
   SetAiueo(&segments);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -1127,7 +1127,7 @@ TEST_F(SessionTest, ConvertPrev) {
   SetComposer(&session, &request);
   SetAiueo(&segments);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -1182,7 +1182,7 @@ TEST_F(SessionTest, ResetFocusedSegmentAfterCommit) {
   candidate->value = "なかのです";
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -1234,7 +1234,7 @@ TEST_F(SessionTest, ResetFocusedSegmentAfterCommit) {
 
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   // "あ[]"
@@ -1270,7 +1270,7 @@ TEST_F(SessionTest, ResetFocusedSegmentAfterCancel) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   // "あい[]"
 
@@ -1325,7 +1325,7 @@ TEST_F(SessionTest, ResetFocusedSegmentAfterCancel) {
   candidate->value = "相";
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -1372,7 +1372,7 @@ TEST_F(SessionTest, KeepFixedCandidateAfterSegmentWidthExpand) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -1451,7 +1451,7 @@ TEST_F(SessionTest, CommitSegment) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -1507,7 +1507,7 @@ TEST_F(SessionTest, CommitSegmentAt2ndSegment) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -1564,7 +1564,7 @@ TEST_F(SessionTest, Transliterations) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -1611,7 +1611,7 @@ TEST_F(SessionTest, ConvertToTransliteration) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -1647,7 +1647,7 @@ TEST_F(SessionTest, ConvertToTransliterationWithMultipleSegments) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   // Convert
@@ -1699,7 +1699,7 @@ TEST_F(SessionTest, ConvertToHalfWidth) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -1736,7 +1736,7 @@ TEST_F(SessionTest, ConvertConsonantsToFullAlphanumeric) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -1782,7 +1782,7 @@ TEST_F(SessionTest, ConvertConsonantsToFullAlphanumericWithoutCascadingWindow) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -1824,7 +1824,7 @@ TEST_F(SessionTest, SwitchKanaType) {
     ConversionRequest request;
     SetComposer(&session, &request);
     FillT13Ns(request, &segments);
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
     command.Clear();
@@ -1862,7 +1862,7 @@ TEST_F(SessionTest, SwitchKanaType) {
     ConversionRequest request;
     SetComposer(&session, &request);
     FillT13Ns(request, &segments);
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
     command.Clear();
@@ -2014,7 +2014,7 @@ TEST_F(SessionTest, UpdatePreferences) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   SetSendKeyCommand("SPACE", &command);
@@ -2095,7 +2095,7 @@ TEST_F(SessionTest, RomajiInput) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   session.ConvertToHiragana(&command);
@@ -2150,7 +2150,7 @@ TEST_F(SessionTest, KanaInput) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -2184,7 +2184,7 @@ TEST_F(SessionTest, ExceededComposition) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -2216,7 +2216,7 @@ TEST_F(SessionTest, OutputAllCandidateWords) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -2298,7 +2298,7 @@ TEST_F(SessionTest, UndoForComposition) {
 
   {  // Undo for CommitFirstSuggestion
     SetAiueo(&segments);
-    EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+    EXPECT_CALL(converter, StartSuggestion(_, _))
         .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
     InsertCharacterChars("ai", &session, &command);
     ConversionRequest request;
@@ -2389,7 +2389,7 @@ TEST_F(SessionTest, UndoForSingleSegment) {
   }
 
   {  // Undo after commitment of composition
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     command.Clear();
     session.Convert(&command);
@@ -2578,7 +2578,7 @@ TEST_F(SessionTest, UndoForMultipleSegments) {
   }
 
   {  // Undo for CommitCandidate
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     command.Clear();
     session.Convert(&command);
@@ -2638,7 +2638,7 @@ TEST_F(SessionTest, UndoForMultipleSegments) {
     segments.mutable_segment(0)->set_segment_type(Segment::FREE);
     segments.mutable_segment(1)->set_segment_type(Segment::FREE);
     segments.mutable_segment(2)->set_segment_type(Segment::FREE);
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     command.Clear();
     session.Convert(&command);
@@ -2741,7 +2741,7 @@ TEST_F(SessionTest, UndoForCommittedBracketPairIssue284235847) {
   }
 
   {  // Commit 1st and 2nd segment
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     command.Clear();
     session.Convert(&command);
@@ -2824,7 +2824,7 @@ TEST_F(SessionTest, MultipleUndo) {
     candidate->value = "cand3-2";
   }
 
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   command.Clear();
   session.Convert(&command);
@@ -2911,7 +2911,7 @@ TEST_F(SessionTest, UndoOrRewindUndo) {
       candidate->value = "AIUEO";
     }
     {
-      EXPECT_CALL(converter, StartConversionForRequest(_, _))
+      EXPECT_CALL(converter, StartConversion(_, _))
           .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
       command.Clear();
       session.Convert(&command);
@@ -2963,7 +2963,7 @@ TEST_F(SessionTest, UndoOrRewindRewind) {
     candidate = segments.mutable_segment(0)->add_candidate();
     candidate->value = "AIUEO";
 
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     command.Clear();
     session.Convert(&command);
@@ -2985,7 +2985,7 @@ TEST_F(SessionTest, UndoOrRewindRewind) {
     AddCandidate("e", "e", segment);
     AddCandidate("e", "E", segment);
   }
-  EXPECT_CALL(converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(converter, StartPrediction(_, _))
       .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   commands::Command command;
@@ -3017,7 +3017,7 @@ TEST_F(SessionTest, StopKeyToggling) {
     segment = segments.add_segment();
     AddCandidate("dummy", "Dummy", segment);
   }
-  EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(converter, StartSuggestion(_, _))
       .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   commands::Command command;
@@ -3075,7 +3075,7 @@ TEST_F(SessionTest, CommitRawText) {
     ConversionRequest request;
     SetComposer(&session, &request);
     FillT13Ns(request, &segments);
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     command.Clear();
     session.Convert(&command);
@@ -3204,7 +3204,7 @@ TEST_F(SessionTest, ConvertNextPagePrevPage) {
             absl::StrFormat("page%d-cand%d", page_index, cand_index);
       }
     }
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
 
@@ -3264,7 +3264,7 @@ TEST_F(SessionTest, NeedlessClearUndoContext) {
     SetAiueo(&segments);
     FillT13Ns(request, &segments);
 
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
     command.Clear();
     session.Convert(&command);
@@ -3352,7 +3352,7 @@ TEST_F(SessionTest, ClearUndoContextAfterDirectInputAfterConversion) {
   FillT13Ns(request, &segments);
 
   // Convert
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   command.Clear();
   session.Convert(&command);
@@ -3508,7 +3508,7 @@ TEST_F(SessionTest, ConvertToFullOrHalfAlphanumericAfterUndo) {
     ASSERT_TRUE(command.output().has_preedit());
     EXPECT_EQ(GetComposition(command), "あいうえお");
 
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     command.Clear();
     session.ConvertToHalfASCII(&command);
@@ -3529,7 +3529,7 @@ TEST_F(SessionTest, ConvertToFullOrHalfAlphanumericAfterUndo) {
     ASSERT_TRUE(command.output().has_preedit());
     EXPECT_EQ(GetComposition(command), "あいうえお");
 
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     command.Clear();
     session.ConvertToFullASCII(&command);
@@ -3670,7 +3670,7 @@ TEST_F(SessionTest, Issue1805239) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   SendSpecialKey(commands::KeyEvent::SPACE, &session, &command);
@@ -3725,7 +3725,7 @@ TEST_F(SessionTest, Issue1816861) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   SendSpecialKey(commands::KeyEvent::SPACE, &session, &command);
@@ -3752,7 +3752,7 @@ TEST_F(SessionTest, Issue1816861) {
   candidate = segment->add_candidate();
   candidate->value = "陰謀説";
 
-  EXPECT_CALL(converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(converter, StartPrediction(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   SendSpecialKey(commands::KeyEvent::TAB, &session, &command);
@@ -3789,7 +3789,7 @@ TEST_F(SessionTest, T13NWithResegmentation) {
     ConversionRequest request;
     SetComposer(&session, &request);
     FillT13Ns(request, &segments);
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
   {
@@ -3866,7 +3866,7 @@ TEST_F(SessionTest, Shortcut) {
     ConversionRequest request(&context.composer(), &context.GetRequest(),
                               &context.GetConfig());
     FillT13Ns(request, &segments);
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
     commands::Command command;
@@ -3902,7 +3902,7 @@ TEST_F(SessionTest, ShortcutWithCapsLockIssue5655743) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   commands::Command command;
@@ -3947,7 +3947,7 @@ TEST_F(SessionTest, ShortcutFromVK) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   commands::Command command;
@@ -4180,7 +4180,7 @@ TEST_F(SessionTest, ExitTemporaryAlphanumModeAfterCommittingSugesstion) {
     ConversionRequest request;
     SetComposer(&session, &request);
     FillT13Ns(request, &segments);
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
     EXPECT_TRUE(session.Convert(&command));
@@ -4214,7 +4214,7 @@ TEST_F(SessionTest, ExitTemporaryAlphanumModeAfterCommittingSugesstion) {
     Segment *segment = segments.add_segment();
     segment->set_key("NFL");
     segment->add_candidate()->value = "NFL";
-    EXPECT_CALL(converter, StartPredictionForRequest(_, _))
+    EXPECT_CALL(converter, StartPrediction(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
     EXPECT_TRUE(session.PredictAndConvert(&command));
@@ -4252,7 +4252,7 @@ TEST_F(SessionTest, ExitTemporaryAlphanumModeAfterCommittingSugesstion) {
     ConversionRequest request;
     SetComposer(&session, &request);
     FillT13Ns(request, &segments);
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
     EXPECT_TRUE(session.ConvertToHalfASCII(&command));
@@ -4412,7 +4412,7 @@ TEST_F(SessionTest, Suggest) {
   commands::Command command;
   SendKey("M", &session, &command);
 
-  EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments_mo), Return(true)));
   SendKey("O", &session, &command);
   ASSERT_TRUE(command.output().has_candidates());
@@ -4420,7 +4420,7 @@ TEST_F(SessionTest, Suggest) {
   EXPECT_EQ(command.output().candidates().candidate(0).value(), "MOCHA");
 
   // moz|
-  EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments_moz), Return(true)));
   SendKey("Z", &session, &command);
   ASSERT_TRUE(command.output().has_candidates());
@@ -4428,7 +4428,7 @@ TEST_F(SessionTest, Suggest) {
   EXPECT_EQ(command.output().candidates().candidate(0).value(), "MOZUKU");
 
   // mo|
-  EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments_mo), Return(true)));
   SendKey("Backspace", &session, &command);
   ASSERT_TRUE(command.output().has_candidates());
@@ -4436,7 +4436,7 @@ TEST_F(SessionTest, Suggest) {
   EXPECT_EQ(command.output().candidates().candidate(0).value(), "MOCHA");
 
   // m|o
-  EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments_mo), Return(true)));
   command.Clear();
   EXPECT_TRUE(session.MoveCursorLeft(&command));
@@ -4445,7 +4445,7 @@ TEST_F(SessionTest, Suggest) {
   EXPECT_EQ(command.output().candidates().candidate(0).value(), "MOCHA");
 
   // mo|
-  EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments_mo), Return(true)));
   command.Clear();
   EXPECT_TRUE(session.MoveCursorToEnd(&command));
@@ -4454,7 +4454,7 @@ TEST_F(SessionTest, Suggest) {
   EXPECT_EQ(command.output().candidates().candidate(0).value(), "MOCHA");
 
   // |mo
-  EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments_mo), Return(true)));
   command.Clear();
   EXPECT_TRUE(session.MoveCursorToBeginning(&command));
@@ -4463,7 +4463,7 @@ TEST_F(SessionTest, Suggest) {
   EXPECT_EQ(command.output().candidates().candidate(0).value(), "MOCHA");
 
   // m|o
-  EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments_mo), Return(true)));
   command.Clear();
   EXPECT_TRUE(session.MoveCursorRight(&command));
@@ -4472,7 +4472,7 @@ TEST_F(SessionTest, Suggest) {
   EXPECT_EQ(command.output().candidates().candidate(0).value(), "MOCHA");
 
   // m|
-  EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments_m), Return(true)));
   command.Clear();
   EXPECT_TRUE(session.Delete(&command));
@@ -4491,12 +4491,12 @@ TEST_F(SessionTest, Suggest) {
   ConversionRequest request_m_conv;
   SetComposer(&session, &request_m_conv);
   FillT13Ns(request_m_conv, &segments_m_conv);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments_m_conv), Return(true)));
   command.Clear();
   EXPECT_TRUE(session.Convert(&command));
 
-  EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments_m), Return(true)));
   command.Clear();
   EXPECT_TRUE(session.ConvertCancel(&command));
@@ -4529,7 +4529,7 @@ TEST_F(SessionTest, CommitCandidateTypingCorrection) {
   InitSessionToPrecomposition(&session, request);
 
   commands::Command command;
-  EXPECT_CALL(converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(converter, StartPrediction(_, _))
       .WillRepeatedly(DoAll(SetArgPointee<1>(segments_jueri), Return(true)));
   InsertCharacterChars("jueri", &session, &command);
 
@@ -4547,7 +4547,7 @@ TEST_F(SessionTest, CommitCandidateTypingCorrection) {
       .WillOnce(SetArgPointee<1>(empty_segments));
   SetSendCommandCommand(commands::SessionCommand::SUBMIT_CANDIDATE, &command);
   command.mutable_input()->mutable_command()->set_id(0);
-  EXPECT_CALL(converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(converter, StartPrediction(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments_jueri), Return(true)));
   session.SendCommand(&command);
   EXPECT_TRUE(command.output().consumed());
@@ -4613,7 +4613,7 @@ TEST_F(SessionTest, MobilePartialPrediction) {
   InitSessionToPrecomposition(&session, request);
 
   commands::Command command;
-  EXPECT_CALL(converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(converter, StartPrediction(_, _))
       .WillRepeatedly(
           DoAll(SetArgPointee<1>(segments_watashino), Return(true)));
   InsertCharacterChars("watashino", &session, &command);
@@ -4622,7 +4622,7 @@ TEST_F(SessionTest, MobilePartialPrediction) {
   EXPECT_EQ(command.output().candidates().candidate(0).value(), "私の");
 
   // partial suggestion for "わた|しの"
-  EXPECT_CALL(converter, StartPartialPredictionForRequest(_, _))
+  EXPECT_CALL(converter, StartPartialPrediction(_, _))
       .WillRepeatedly(DoAll(SetArgPointee<1>(segments_wata), Return(true)));
   command.Clear();
   EXPECT_TRUE(session.MoveCursorLeft(&command));
@@ -4638,7 +4638,7 @@ TEST_F(SessionTest, MobilePartialPrediction) {
       .WillOnce(DoAll(SetArgPointee<0>(segments_wata), Return(true)));
   SetSendCommandCommand(commands::SessionCommand::SUBMIT_CANDIDATE, &command);
   command.mutable_input()->mutable_command()->set_id(0);
-  EXPECT_CALL(converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(converter, StartPrediction(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments_shino), Return(true)));
   session.SendCommand(&command);
   EXPECT_TRUE(command.output().consumed());
@@ -4739,7 +4739,7 @@ TEST_F(SessionTest, ToggleAlphanumericMode) {
     ConversionRequest request;
     SetComposer(&session, &request);
     FillT13Ns(request, &segments);
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
     command.Clear();
@@ -4871,7 +4871,7 @@ TEST_F(SessionTest, InsertSpaceHalfWidth) {
     ConversionRequest request;
     SetComposer(&session, &request);
     FillT13Ns(request, &segments);
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
     command.Clear();
@@ -4916,7 +4916,7 @@ TEST_F(SessionTest, InsertSpaceFullWidth) {
     ConversionRequest request;
     SetComposer(&session, &request);
     FillT13Ns(request, &segments);
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
     command.Clear();
@@ -5761,7 +5761,7 @@ TEST_F(SessionTest, Issue1951385) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(false)));
 
   command.Clear();
@@ -5800,7 +5800,7 @@ TEST_F(SessionTest, Issue1978201) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   EXPECT_TRUE(session.Convert(&command));
 
@@ -5822,7 +5822,7 @@ TEST_F(SessionTest, Issue1975771) {
   // Trigger suggest by pressing "a".
   Segments segments;
   SetAiueo(&segments);
-  EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   commands::Command command;
@@ -5864,7 +5864,7 @@ TEST_F(SessionTest, Issue2029466) {
   // <tab>
   Segments segments;
   SetAiueo(&segments);
-  EXPECT_CALL(converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(converter, StartPrediction(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   command.Clear();
   EXPECT_TRUE(session.PredictAndConvert(&command));
@@ -5906,7 +5906,7 @@ TEST_F(SessionTest, Issue2034943) {
     ConversionRequest request;
     SetComposer(&session, &request);
     FillT13Ns(request, &segments);
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
   // Get conversion
@@ -5940,7 +5940,7 @@ TEST_F(SessionTest, Issue2026354) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -5969,7 +5969,7 @@ TEST_F(SessionTest, Issue2066906) {
   candidate->value = "abc";
   candidate = segment->add_candidate();
   candidate->value = "abcdef";
-  EXPECT_CALL(converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(converter, StartPrediction(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   // Prediction with "a"
@@ -5982,7 +5982,7 @@ TEST_F(SessionTest, Issue2066906) {
   EXPECT_TRUE(session.Commit(&command));
   EXPECT_RESULT("abc", command);
 
-  EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   InsertCharacterChars("a", &session, &command);
   EXPECT_FALSE(command.output().has_result());
@@ -6235,7 +6235,7 @@ TEST_F(SessionTest, Issue2223755) {
       ConversionRequest request;
       SetComposer(&session, &request);
       FillT13Ns(request, &segments);
-      EXPECT_CALL(converter, StartConversionForRequest(_, _))
+      EXPECT_CALL(converter, StartConversion(_, _))
           .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     }
 
@@ -6386,7 +6386,7 @@ TEST_F(SessionTest, Issue2379374) {
     request.set_config(&config);
     SetComposer(&session, &request);
     FillT13Ns(request, &segments);
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
 
@@ -6799,7 +6799,7 @@ TEST_F(SessionTest, InputModeOutputHasCandidates) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   commands::Command command;
@@ -6883,7 +6883,7 @@ TEST_F(SessionTest, PerformedCommand) {
     ConversionRequest request;
     SetComposer(&session, &request);
     FillT13Ns(request, &segments);
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     commands::Command command;
     // SPACE
@@ -6915,7 +6915,7 @@ TEST_F(SessionTest, ResetContext) {
 
   Segments segments;
   segments.add_segment()->add_candidate();  // Stub candidate.
-  EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   EXPECT_TRUE(SendKey("A", &session, &command));
   command.Clear();
@@ -6956,7 +6956,7 @@ TEST_F(SessionTest, ClearUndoOnResetContext) {
   }
 
   {
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     command.Clear();
     session.Convert(&command);
@@ -7033,15 +7033,14 @@ TEST_F(SessionTest, Issue3428520) {
   Segments segments;
   SetAiueo(&segments);
 
-  EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(converter, StartSuggestion(_, _))
       .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
   InsertCharacterChars("aiueo", &session, &command);
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
 
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
-      .WillOnce(Return(true));
+  EXPECT_CALL(converter, StartConversion(_, _)).WillOnce(Return(true));
   command.Clear();
   session.Convert(&command);
   EXPECT_FALSE(command.output().has_result());
@@ -7103,7 +7102,7 @@ TEST_F(SessionTest, AutoConversion) {
   SetAiueo(&segments);
   ConversionRequest default_request;
   FillT13Ns(default_request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   // Auto Off
@@ -7349,7 +7348,7 @@ TEST_F(SessionTest, AlphanumericOfSSH) {
   ConversionRequest request;
   SetComposer(&session, &request);
   FillT13Ns(request, &segments);
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   command.Clear();
@@ -7635,7 +7634,7 @@ TEST_F(SessionTest, CommitCandidateAt2ndOf3Segments) {
     candidate = segment->add_candidate();
     candidate->value = "抜いた";
 
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
 
@@ -7703,7 +7702,7 @@ TEST_F(SessionTest, CommitCandidateAt3rdOf3Segments) {
     candidate = segment->add_candidate();
     candidate->value = "抜いた";
 
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
   }
 
@@ -7743,7 +7742,7 @@ TEST_F(SessionTest, CommitCandidateSuggestion) {
   commands::Command command;
   SendKey("M", &session, &command);
   command.Clear();
-  EXPECT_CALL(converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(converter, StartPrediction(_, _))
       .WillRepeatedly(DoAll(SetArgPointee<1>(segments_mo), Return(true)));
   SendKey("O", &session, &command);
   ASSERT_TRUE(command.output().has_candidates());
@@ -7810,7 +7809,7 @@ TEST_F(SessionTest, CommitCandidateT13N) {
   EXPECT_EQ(segment->candidate(-2).value, "TOK");
   EXPECT_EQ(segment->candidate(-3).value, "Tok");
 
-  EXPECT_CALL(converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(converter, StartPrediction(_, _))
       .WillRepeatedly(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   commands::Command command;
@@ -8146,7 +8145,7 @@ TEST_F(SessionTest, NotZeroQuerySuggest) {
   segment->add_candidate()->value = "input";
 
   // Commit composition and zero query suggest should not be invoked.
-  EXPECT_CALL(converter, StartSuggestionForRequest(_, _)).Times(0);
+  EXPECT_CALL(converter, StartSuggestion(_, _)).Times(0);
   command.Clear();
   session.Commit(&command);
   EXPECT_EQ(command.output().result().value(), "google");
@@ -8235,7 +8234,7 @@ TEST_F(SessionTest, ZeroQuerySuggest) {
       segment = segments.add_segment();
       segment->set_key("");
       segment->add_candidate()->value = "google";
-      EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+      EXPECT_CALL(converter, StartSuggestion(_, _))
           .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     }
 
@@ -8250,7 +8249,7 @@ TEST_F(SessionTest, ZeroQuerySuggest) {
       segment->set_key("");
       segment->add_candidate()->value = "search";
       segment->add_candidate()->value = "input";
-      EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+      EXPECT_CALL(converter, StartSuggestion(_, _))
           .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     }
 
@@ -8417,8 +8416,8 @@ TEST_F(SessionTest, Issue4437420) {
       commands::Request::TWELVE_KEYS_TO_HALFWIDTHASCII);
   session.SetRequest(&request);
   auto table = std::make_unique<composer::Table>();
-  table->InitializeWithRequestAndConfig(
-      request, config::ConfigHandler::DefaultConfig(), mock_data_manager_);
+  table->InitializeWithRequestAndConfig(request,
+                                        config::ConfigHandler::DefaultConfig());
   session.SetTable(table.get());
   // Type "2*" to produce "A".
   SetSendKeyCommand("2", &command);
@@ -8437,8 +8436,8 @@ TEST_F(SessionTest, Issue4437420) {
       commands::Request::TWELVE_KEYS_TO_HALFWIDTHASCII);
   session.SetRequest(&request);
   table = std::make_unique<composer::Table>();
-  table->InitializeWithRequestAndConfig(
-      request, config::ConfigHandler::DefaultConfig(), mock_data_manager_);
+  table->InitializeWithRequestAndConfig(request,
+                                        config::ConfigHandler::DefaultConfig());
   session.SetTable(table.get());
   // Type "2" to produce "Aa".
   SetSendKeyCommand("2", &command);
@@ -8502,7 +8501,7 @@ TEST_F(SessionTest, UndoKeyAction) {
     session.SetRequest(&request);
     composer::Table table;
     table.InitializeWithRequestAndConfig(
-        request, config::ConfigHandler::DefaultConfig(), mock_data_manager_);
+        request, config::ConfigHandler::DefaultConfig());
     session.SetTable(&table);
 
     // Type "2" to produce "a".
@@ -8547,7 +8546,7 @@ TEST_F(SessionTest, UndoKeyAction) {
     session.SetRequest(&request);
     composer::Table table;
     table.InitializeWithRequestAndConfig(
-        request, config::ConfigHandler::DefaultConfig(), mock_data_manager_);
+        request, config::ConfigHandler::DefaultConfig());
     session.SetTable(&table);
     // Type "33{<}{<}" to produce "さ"->"し"->"さ"->"そ".
     SetSendKeyCommand("3", &command);
@@ -8589,7 +8588,7 @@ TEST_F(SessionTest, UndoKeyAction) {
     session.SetRequest(&request);
     composer::Table table;
     table.InitializeWithRequestAndConfig(
-        request, config::ConfigHandler::DefaultConfig(), mock_data_manager_);
+        request, config::ConfigHandler::DefaultConfig());
     session.SetTable(&table);
     // Type "3*{<}*{<}", and composition should change
     // "さ"->"ざ"->(No change)->"さ"->(No change).
@@ -8637,7 +8636,7 @@ TEST_F(SessionTest, UndoKeyAction) {
     session.SetRequest(&request);
     composer::Table table;
     table.InitializeWithRequestAndConfig(
-        request, config::ConfigHandler::DefaultConfig(), mock_data_manager_);
+        request, config::ConfigHandler::DefaultConfig());
     session.SetTable(&table);
     // Type "{<}" and do nothing
     SetSendCommandCommand(commands::SessionCommand::UNDO_OR_REWIND, &command);
@@ -8669,7 +8668,7 @@ TEST_F(SessionTest, UndoKeyAction) {
     candidate = segments.mutable_segment(0)->add_candidate();
     candidate->value = "AIUEO";
 
-    EXPECT_CALL(converter, StartConversionForRequest(_, _))
+    EXPECT_CALL(converter, StartConversion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
     command.Clear();
     session.Convert(&command);
@@ -8718,7 +8717,7 @@ TEST_F(SessionTest, UndoKeyAction) {
     session.SetRequest(&request);
     composer::Table table;
     table.InitializeWithRequestAndConfig(
-        request, config::ConfigHandler::DefaultConfig(), mock_data_manager_);
+        request, config::ConfigHandler::DefaultConfig());
     session.SetTable(&table);
 
     // commit "あ" to push UNDO stack
@@ -8770,7 +8769,7 @@ TEST_F(SessionTest, DedupAfterUndo) {
 
     composer::Table table;
     table.InitializeWithRequestAndConfig(
-        request, config::ConfigHandler::DefaultConfig(), mock_data_manager_);
+        request, config::ConfigHandler::DefaultConfig());
     session.SetTable(&table);
 
     // Type "!" to produce "！".
@@ -9149,8 +9148,8 @@ TEST_F(SessionTest, BackKeyCommitsPreeditInPasswordMode) {
   session.SetRequest(&request);
 
   composer::Table table;
-  table.InitializeWithRequestAndConfig(
-      request, config::ConfigHandler::DefaultConfig(), mock_data_manager_);
+  table.InitializeWithRequestAndConfig(request,
+                                       config::ConfigHandler::DefaultConfig());
   session.SetTable(&table);
 
   SwitchInputFieldType(commands::Context::PASSWORD, &session);
@@ -9209,7 +9208,7 @@ TEST_F(SessionTest, EditCancel) {
     commands::Command command;
     SendKey("M", &session, &command);
 
-    EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+    EXPECT_CALL(converter, StartSuggestion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments_mo), Return(true)));
     SendKey("O", &session, &command);
     ASSERT_TRUE(command.output().has_candidates());
@@ -9233,7 +9232,7 @@ TEST_F(SessionTest, EditCancel) {
     EXPECT_TRUE(session.SendCommand(&command));
 
     command.Clear();
-    EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+    EXPECT_CALL(converter, StartSuggestion(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(segments_mo), Return(true)));
     session.ConvertCancel(&command);
     ASSERT_TRUE(command.output().has_candidates());
@@ -9339,7 +9338,7 @@ TEST_F(SessionTest, EditCancelAndIMEOff) {
     commands::Command command;
     SendKey("M", &session, &command);
 
-    EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+    EXPECT_CALL(converter, StartSuggestion(_, _))
         .WillRepeatedly(DoAll(SetArgPointee<1>(segments_mo), Return(true)));
     SendKey("O", &session, &command);
     ASSERT_TRUE(command.output().has_candidates());
@@ -9394,7 +9393,7 @@ TEST_F(SessionTest, EditCancelAndIMEOff) {
     EXPECT_TRUE(session.SendCommand(&command));
 
     command.Clear();
-    EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+    EXPECT_CALL(converter, StartSuggestion(_, _))
         .WillRepeatedly(DoAll(SetArgPointee<1>(segments_mo), Return(true)));
     session.ConvertCancel(&command);
     ASSERT_TRUE(command.output().has_candidates());
@@ -9696,7 +9695,7 @@ TEST_F(SessionTest, DoNothingOnCompositionKeepingSuggestWindow) {
     segment->add_candidate()->value = "MOCHA";
     segment->add_candidate()->value = "MOZUKU";
   }
-  EXPECT_CALL(converter, StartSuggestionForRequest(_, _))
+  EXPECT_CALL(converter, StartSuggestion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments_mo), Return(true)));
 
   commands::Command command;
@@ -9726,7 +9725,7 @@ TEST_F(SessionTest, ModeChangeOfConvertAtPunctuations) {
     segment->set_key("あ");
     segment->add_candidate()->value = "あ";
   }
-  EXPECT_CALL(converter, StartConversionForRequest(_, _))
+  EXPECT_CALL(converter, StartConversion(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments_a_conv), Return(true)));
 
   commands::Command command;
@@ -9786,7 +9785,7 @@ TEST_F(SessionTest, DeleteHistory) {
   segment->add_candidate()->value = "DeleteHistory";
   ConversionRequest request;
   SetComposer(&session, &request);
-  EXPECT_CALL(converter, StartPredictionForRequest(_, _))
+  EXPECT_CALL(converter, StartPrediction(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(segments), Return(true)));
 
   // Type "del". Preedit = "でｌ".