Remvoed dictionary sync features. They are no longer used and mantained.

PiperOrigin-RevId: 734589342

Author: taku910

src/dictionary/user_dictionary.cc

@@ -279,16 +279,6 @@ class UserDictionary::UserDictionaryReloader {
       return;
     }
 
-    if (storage.ConvertSyncDictionariesToNormalDictionaries()) {
-      LOG(INFO) << "Syncable dictionaries are converted to normal dictionaries";
-      if (storage.Lock()) {
-        if (absl::Status s = storage.Save(); !s.ok()) {
-          LOG(ERROR) << "Failed to save to storage: " << s;
-        }
-        storage.UnLock();
-      }
-    }
-
     dic_->Load(storage.GetProto());
   }
 

src/dictionary/user_dictionary_storage.cc

@@ -64,9 +64,6 @@ constexpr size_t kDefaultTotalBytesLimit = 512 << 20;
 // saved correctly. Please make the dictionary size smaller"
 constexpr size_t kDefaultWarningTotalBytesLimit = 256 << 20;
 
-constexpr char kDefaultSyncDictionaryName[] = "Sync Dictionary";
-constexpr char kDictionaryNameConvertedFromSyncableDictionary[] = "同期用辞書";
-
 using ::mozc::user_dictionary::UserDictionaryCommandStatus;
 
 }  // namespace
@@ -363,71 +360,6 @@ UserDictionaryStorage::GetLastError() const {
   return last_error_type_;
 }
 
-bool UserDictionaryStorage::ConvertSyncDictionariesToNormalDictionaries() {
-  if (CountSyncableDictionaries(proto_) == 0) {
-    return false;
-  }
-
-  for (int dictionary_index = proto_.dictionaries_size() - 1;
-       dictionary_index >= 0; --dictionary_index) {
-    UserDictionary *dic = proto_.mutable_dictionaries(dictionary_index);
-    if (!dic->syncable()) {
-      continue;
-    }
-
-    // Delete removed entries.
-    for (int i = dic->entries_size() - 1; i >= 0; --i) {
-      if (dic->entries(i).removed()) {
-        for (int j = i + 1; j < dic->entries_size(); ++j) {
-          dic->mutable_entries()->SwapElements(j - 1, j);
-        }
-        dic->mutable_entries()->RemoveLast();
-      }
-    }
-
-    // Delete removed or unused sync dictionaries.
-    if (dic->removed() || dic->entries_size() == 0) {
-      for (int i = dictionary_index + 1; i < proto_.dictionaries_size(); ++i) {
-        proto_.mutable_dictionaries()->SwapElements(i - 1, i);
-      }
-      proto_.mutable_dictionaries()->RemoveLast();
-      continue;
-    }
-
-    if (dic->name() == default_sync_dictionary_name()) {
-      std::string new_dictionary_name =
-          kDictionaryNameConvertedFromSyncableDictionary;
-      int index = 0;
-      while (UserDictionaryUtil::ValidateDictionaryName(proto_,
-                                                        new_dictionary_name) !=
-             UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS) {
-        ++index;
-        new_dictionary_name = absl::StrFormat(
-            "%s_%d", kDictionaryNameConvertedFromSyncableDictionary, index);
-      }
-      dic->set_name(new_dictionary_name);
-    }
-    dic->set_syncable(false);
-  }
-
-  DCHECK_EQ(0, CountSyncableDictionaries(proto_));
-
-  return true;
-}
-
-// static
-int UserDictionaryStorage::CountSyncableDictionaries(
-    const user_dictionary::UserDictionaryStorage &storage) {
-  int num_syncable_dictionaries = 0;
-  for (int i = 0; i < storage.dictionaries_size(); ++i) {
-    const UserDictionary &dict = storage.dictionaries(i);
-    if (dict.syncable()) {
-      ++num_syncable_dictionaries;
-    }
-  }
-  return num_syncable_dictionaries;
-}
-
 // static
 size_t UserDictionaryStorage::max_entry_size() {
   return UserDictionaryUtil::max_entry_size();
@@ -468,8 +400,4 @@ bool UserDictionaryStorage::IsValidDictionaryName(
   ABSL_UNREACHABLE();
 }
 
-std::string UserDictionaryStorage::default_sync_dictionary_name() {
-  return std::string(kDefaultSyncDictionaryName);
-}
-
 }  // namespace mozc

src/dictionary/user_dictionary_storage.h

@@ -128,7 +128,7 @@ class UserDictionaryStorage {
   bool UnLock();
 
   // Export a dictionary to a file in TSV format.
-  bool ExportDictionary(uint64_t dic_id, const std::string & file_name);
+  bool ExportDictionary(uint64_t dic_id, const std::string &file_name);
 
   // Create a new dictionary with a specified name. Returns the id of
   // the new instance via new_dic_id.
@@ -157,26 +157,12 @@ class UserDictionaryStorage {
   // You can obtain the reason of the error of dictionary operation.
   UserDictionaryStorageErrorType GetLastError() const;
 
-  // Converts syncable dictionaries to unsyncable dictionaries.
-  // The name of default sync dictionary is renamed to locale-independent name
-  // like other unsyncable dictionaries.
-  // This method deletes syncable dictionaries which are marked as removed or
-  // don't have any dictionary entries.
-  // Returns true if this method converts some dictionaries.
-  bool ConvertSyncDictionariesToNormalDictionaries();
-
-  // return the number of dictionaries with "synclbe" being true.
-  static int CountSyncableDictionaries(
-      const user_dictionary::UserDictionaryStorage &storage);
-
   // maximum number of dictionaries this storage can hold
   static size_t max_dictionary_size();
 
   // maximum number of entries one dictionary can hold
   static size_t max_entry_size();
 
-  static std::string default_sync_dictionary_name();
-
   user_dictionary::UserDictionaryStorage &GetProto() { return proto_; }
 
   const user_dictionary::UserDictionaryStorage &GetProto() const {

src/dictionary/user_dictionary_storage_test.cc

@@ -295,132 +295,6 @@ TEST_F(UserDictionaryStorageTest, GetUserDictionaryIdTest) {
   EXPECT_EQ(ret_id[1], id[1]);
 }
 
-TEST_F(UserDictionaryStorageTest, ConvertSyncDictionariesToNormalDictionaries) {
-  // "名詞"
-  const UserDictionary::PosType kPos = UserDictionary::NOUN;
-
-  const struct TestData {
-    bool is_sync_dictionary;
-    bool is_removed_dictionary;
-    bool has_normal_entry;
-    bool has_removed_entry;
-    std::string dictionary_name;
-  } test_data[] = {
-      {false, false, false, false, "non-sync dictionary (empty)"},
-      {false, false, true, false, "non-sync dictionary (normal entry)"},
-      {true, false, false, false, "sync dictionary (empty)"},
-      {true, false, false, true, "sync dictionary (removed entry)"},
-      {true, false, true, false, "sync dictionary (normal entry)"},
-      {true, false, true, true, "sync dictionary (normal & removed entries)"},
-      {true, true, false, false, "removed sync dictionary (empty)"},
-      {true, true, false, true, "removed sync dictionary (removed entry)"},
-      {true, true, true, false, "removed sync dictionary (normal entry)"},
-      {true, true, true, true,
-       "removed sync dictionary (normal & removed entries)"},
-      {true, false, true, false,
-       UserDictionaryStorage::default_sync_dictionary_name()},
-  };
-
-  UserDictionaryStorage storage(GetUserDictionaryFile());
-  EXPECT_FALSE(storage.Load().ok())
-      << "At first, we expect there is not user dictionary file.";
-  EXPECT_FALSE(storage.ConvertSyncDictionariesToNormalDictionaries())
-      << "No sync dictionary available.";
-
-  for (size_t i = 0; i < std::size(test_data); ++i) {
-    SCOPED_TRACE(absl::StrFormat("add %d", static_cast<int>(i)));
-    const TestData &data = test_data[i];
-    CHECK(data.is_sync_dictionary ||
-          !(data.is_removed_dictionary || data.has_removed_entry))
-        << "Non-sync dictionary should NOT have removed dictionary / entry.";
-
-    uint64_t dict_id = 0;
-    ASSERT_TRUE(storage.CreateDictionary(data.dictionary_name, &dict_id));
-    UserDictionaryStorage::UserDictionary *dict =
-        storage.GetProto().mutable_dictionaries(
-            storage.GetUserDictionaryIndex(dict_id));
-    dict->set_syncable(data.is_sync_dictionary);
-    dict->set_removed(data.is_removed_dictionary);
-    if (data.has_normal_entry) {
-      UserDictionaryStorage::UserDictionaryEntry *entry = dict->add_entries();
-      entry->set_key("normal");
-      entry->set_value("normal entry");
-      entry->set_pos(kPos);
-    }
-    if (data.has_removed_entry) {
-      UserDictionaryStorage::UserDictionaryEntry *entry = dict->add_entries();
-      entry->set_key("removed");
-      entry->set_value("removed entry");
-      entry->set_pos(kPos);
-      entry->set_removed(true);
-    }
-  }
-  EXPECT_EQ(
-      UserDictionaryStorage::CountSyncableDictionaries(storage.GetProto()), 9);
-
-  ASSERT_TRUE(storage.ConvertSyncDictionariesToNormalDictionaries());
-
-  constexpr char kDictionaryNameConvertedFromSyncableDictionary[] =
-      "同期用辞書";
-  const struct ExpectedData {
-    bool has_normal_entry;
-    std::string dictionary_name;
-  } expected_data[] = {
-      {false, "non-sync dictionary (empty)"},
-      {true, "non-sync dictionary (normal entry)"},
-      {true, "sync dictionary (normal entry)"},
-      {true, "sync dictionary (normal & removed entries)"},
-      {true, kDictionaryNameConvertedFromSyncableDictionary},
-  };
-
-  EXPECT_EQ(
-      0, UserDictionaryStorage::CountSyncableDictionaries(storage.GetProto()));
-  ASSERT_EQ(std::size(expected_data), storage.GetProto().dictionaries_size());
-  for (size_t i = 0; i < std::size(expected_data); ++i) {
-    SCOPED_TRACE(absl::StrFormat("verify %d", static_cast<int>(i)));
-    const ExpectedData &expected = expected_data[i];
-    const UserDictionaryStorage::UserDictionary &dict =
-        storage.GetProto().dictionaries(i);
-
-    EXPECT_EQ(dict.name(), expected.dictionary_name);
-    EXPECT_FALSE(dict.syncable());
-    EXPECT_FALSE(dict.removed());
-    if (expected.has_normal_entry) {
-      ASSERT_EQ(dict.entries_size(), 1);
-      EXPECT_EQ(dict.entries(0).key(), "normal");
-    } else {
-      EXPECT_EQ(dict.entries_size(), 0);
-    }
-  }
-
-  // Test duplicated dictionary name.
-  storage.GetProto().Clear();
-  {
-    uint64_t dict_id = 0;
-    storage.CreateDictionary(
-        UserDictionaryStorage::default_sync_dictionary_name(), &dict_id);
-    storage.CreateDictionary(kDictionaryNameConvertedFromSyncableDictionary,
-                             &dict_id);
-    ASSERT_EQ(2, storage.GetProto().dictionaries_size());
-    UserDictionaryStorage::UserDictionary *dict;
-    dict = storage.GetProto().mutable_dictionaries(0);
-    dict->set_syncable(true);
-    dict->add_entries()->set_key("0");
-    dict = storage.GetProto().mutable_dictionaries(1);
-    dict->set_syncable(false);
-    dict->add_entries()->set_key("1");
-  }
-  ASSERT_TRUE(storage.ConvertSyncDictionariesToNormalDictionaries());
-  EXPECT_EQ(
-      UserDictionaryStorage::CountSyncableDictionaries(storage.GetProto()), 0);
-  EXPECT_EQ(storage.GetProto().dictionaries_size(), 2);
-  EXPECT_EQ(
-      storage.GetProto().dictionaries(0).name(),
-      absl::StrFormat("%s_1", kDictionaryNameConvertedFromSyncableDictionary));
-  EXPECT_EQ(storage.GetProto().dictionaries(1).name(),
-            kDictionaryNameConvertedFromSyncableDictionary);
-}
-
 TEST_F(UserDictionaryStorageTest, Export) {
   constexpr int kDummyDictionaryId = 10;
   TempDirectory temp_dir = testing::MakeTempDirectoryOrDie();

src/gui/dictionary_tool/dictionary_tool.cc

@@ -358,16 +358,6 @@ DictionaryTool::DictionaryTool(QWidget *parent)
     return;
   }
 
-#ifndef ENABLE_CLOUD_SYNC
-  if (session_->mutable_storage()
-          ->ConvertSyncDictionariesToNormalDictionaries()) {
-    LOG(INFO) << "Syncable dictionaries are converted to normal dictionaries";
-    if (absl::Status s = session_->mutable_storage()->Save(); !s.ok()) {
-      LOG(ERROR) << "Failed to save the storage: " << s;
-    }
-  }
-#endif  // !ENABLE_CLOUD_SYNC
-
   // main window
 #ifndef __linux__
   // For some reason setCentralWidget crashes the dictionary_tool on Linux

src/gui/word_register_dialog/word_register_dialog.cc

@@ -144,16 +144,6 @@ WordRegisterDialog::WordRegisterDialog()
     return;
   }
 
-#ifndef ENABLE_CLOUD_SYNC
-  if (session_->mutable_storage()
-          ->ConvertSyncDictionariesToNormalDictionaries()) {
-    LOG(INFO) << "Syncable dictionaries are converted to normal dictionaries";
-    if (absl::Status s = session_->mutable_storage()->Save(); !s.ok()) {
-      LOG(ERROR) << "Failed to save the storage: " << s;
-    }
-  }
-#endif  // !ENABLE_CLOUD_SYNC
-
   // Initialize ComboBox
   const std::vector<std::string> pos_set = pos_list_provider_.GetPosList();
   CHECK(!pos_set.empty());

src/protocol/user_dictionary_storage.proto

@@ -128,11 +128,7 @@ message UserDictionary {
     // "名詞:ja".
     optional string locale = 12 [default = ""];
 
-    // set true if this entry is removed.
-    // This flag is used for cloud sync feature.
-    // Cloud sync feature is already deprecated and this flag is only
-    // used to convert sync dictionary to normal dictionary.
-    optional bool removed = 10 [default = false];
+    reserved 10;  // deprecated removed
 
     // set true if this entry is automatically registered
     // by converter.
@@ -141,16 +137,8 @@ message UserDictionary {
 
   repeated Entry entries = 4;
 
-  // set true if this dictionary is removed.
-  // This flag is used for cloud sync feature.
-  // Cloud sync feature is already deprecated and this flag is only
-  // used to convert sync dictionary to normal dictionary.
-  optional bool removed = 5 [default = false];
-
-  // This flag is used for cloud sync feature.
-  // Cloud sync feature is already deprecated and this flag is only
-  // used to convert sync dictionary to normal dictionary.
-  optional bool syncable = 6 [default = false];
+  reserved 5;  // deprecated removed
+  reserved 6;  // deprecated syncable
 }
 
 message UserDictionaryStorage {
@@ -160,12 +148,7 @@ message UserDictionaryStorage {
   // dictionary body
   repeated UserDictionary dictionaries = 2;
 
-  enum StorageType {
-    SNAPSHOT = 1;  // This storage is a snapshot.
-    UPDATE = 2;    // This storage is a diff of some snapshots.
-  }
-
-  optional StorageType storage_type = 10 [default = SNAPSHOT];
+  reserved 10;  // deprecated storage_type
 }
 
 message UserDictionaryCommand {