Add HasWord(string) method to SpellcheckCustomDictionary

chrome/browser/spellchecker/spellcheck_custom_dictionary.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/spellchecker/spellcheck_custom_dictionary.h"
 
 #include <functional>
 
 #include "base/file_util.h"
 #include "base/files/important_file_writer.h"
 #include "base/md5.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "chrome/browser/spellchecker/spellcheck_host_metrics.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/spellcheck_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/protocol/sync.pb.h"
 
 using content::BrowserThread;
 using chrome::spellcheck_common::WordList;
+using chrome::spellcheck_common::WordSet;
 
 namespace {
 
 // Filename extension for backup dictionary file.
 const base::FilePath::CharType BACKUP_EXTENSION[] = FILE_PATH_LITERAL("backup");
 
 // Prefix for the checksum in the dictionary file.
 const char CHECKSUM_PREFIX[] = "checksum_v1 = ";
 
 // The status of the checksum in a custom spellcheck dictionary.
@@ skipping 83 matching lines @@
   }
   std::string checksum = base::MD5String(content.str());
   content << CHECKSUM_PREFIX << checksum;
   file_util::CopyFile(path, path.AddExtension(BACKUP_EXTENSION));
   base::ImportantFileWriter::WriteFileAtomically(path, content.str());
 }
 
 // Removes duplicate and invalid words from |to_add| word list and sorts it.
 // Looks for duplicates in both |to_add| and |existing| word lists. Returns a
 // bitmap of |ChangeSanitationResult| values.
-int SanitizeWordsToAdd(const WordList& existing, WordList& to_add) {
+int SanitizeWordsToAdd(const WordSet& existing, WordList& to_add) {
   // Do not add duplicate words.
   std::sort(to_add.begin(), to_add.end());
   WordList new_words;
   std::set_difference(to_add.begin(),
                       to_add.end(),
                       existing.begin(),
                       existing.end(),
                       std::back_inserter(new_words));
   new_words.erase(std::unique(new_words.begin(), new_words.end()),
                   new_words.end());
   int result = VALID_CHANGE;
   if (to_add.size() != new_words.size())
     result |= DETECTED_DUPLICATE_WORDS;
   // Do not add invalid words.
   size_t size = new_words.size();
   new_words.erase(std::remove_if(new_words.begin(),
                                  new_words.end(),
                                  IsInvalidWord),
                   new_words.end());
   if (size != new_words.size())
     result |= DETECTED_INVALID_WORDS;
   // Save the sanitized words to be added.
   std::swap(to_add, new_words);
   return result;
 }
 
 // Removes word from |to_remove| that are missing from |existing| word list and
 // sorts |to_remove|. Returns a bitmap of |ChangeSanitationResult| values.
-int SanitizeWordsToRemove(const WordList& existing, WordList& to_remove) {
+int SanitizeWordsToRemove(const WordSet& existing, WordList& to_remove) {
   // Do not remove words that are missing from the dictionary.
   std::sort(to_remove.begin(), to_remove.end());
   WordList found_words;
   std::set_intersection(existing.begin(),
                         existing.end(),
                         to_remove.begin(),
                         to_remove.end(),
                         std::back_inserter(found_words));
   int result = VALID_CHANGE;
   if (to_remove.size() > found_words.size())
@@ skipping 23 matching lines @@
 }
 
 void SpellcheckCustomDictionary::Change::AddWord(const std::string& word) {
   to_add_.push_back(word);
 }
 
 void SpellcheckCustomDictionary::Change::RemoveWord(const std::string& word) {
   to_remove_.push_back(word);
 }
 
-int SpellcheckCustomDictionary::Change::Sanitize(const WordList& words) {
+int SpellcheckCustomDictionary::Change::Sanitize(const WordSet& words) {
   int result = VALID_CHANGE;
   if (!to_add_.empty())
     result |= SanitizeWordsToAdd(words, to_add_);
   if (!to_remove_.empty())
     result |= SanitizeWordsToRemove(words, to_remove_);
   return result;
 }
 
 const WordList& SpellcheckCustomDictionary::Change::to_add() const {
   return to_add_;
@@ skipping 12 matching lines @@
     : custom_dictionary_path_(),
       weak_ptr_factory_(this),
       is_loaded_(false) {
   custom_dictionary_path_ =
       path.Append(chrome::kCustomDictionaryFileName);
 }
 
 SpellcheckCustomDictionary::~SpellcheckCustomDictionary() {
 }
 
-const WordList& SpellcheckCustomDictionary::GetWords() const {
+const WordSet& SpellcheckCustomDictionary::GetWords() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return words_;
 }
 
 bool SpellcheckCustomDictionary::AddWord(const std::string& word) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  std::sort(words_.begin(), words_.end());
   Change dictionary_change;
   dictionary_change.AddWord(word);
   int result = dictionary_change.Sanitize(GetWords());
   Apply(dictionary_change);
   Notify(dictionary_change);
   Sync(dictionary_change);
   Save(dictionary_change);
   return result == VALID_CHANGE;
 }
 
 bool SpellcheckCustomDictionary::RemoveWord(const std::string& word) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  std::sort(words_.begin(), words_.end());
   Change dictionary_change;
   dictionary_change.RemoveWord(word);
   int result = dictionary_change.Sanitize(GetWords());
   Apply(dictionary_change);
   Notify(dictionary_change);
   Sync(dictionary_change);
   Save(dictionary_change);
   return result == VALID_CHANGE;
 }
 
+bool SpellcheckCustomDictionary::HasWord(const std::string& word) {
+  return !!words_.count(word);
+}
+
 void SpellcheckCustomDictionary::AddObserver(Observer* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.AddObserver(observer);
 }
 
 void SpellcheckCustomDictionary::RemoveObserver(Observer* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.RemoveObserver(observer);
 }
 
@@ skipping 35 matching lines @@
   // Build a list of words to add locally.
   WordList to_add_locally;
   for (syncer::SyncDataList::const_iterator it = initial_sync_data.begin();
        it != initial_sync_data.end();
        ++it) {
     DCHECK_EQ(syncer::DICTIONARY, it->GetDataType());
     to_add_locally.push_back(it->GetSpecifics().dictionary().word());
   }
 
   // Add remote words locally.
-  std::sort(words_.begin(), words_.end());
   Change to_change_locally(to_add_locally);
   to_change_locally.Sanitize(GetWords());
   Apply(to_change_locally);
   Notify(to_change_locally);
   Save(to_change_locally);
 
   // Add as many as possible local words remotely.
-  std::sort(words_.begin(), words_.end());
   std::sort(to_add_locally.begin(), to_add_locally.end());
   WordList to_add_remotely;
   std::set_difference(words_.begin(),
                       words_.end(),
                       to_add_locally.begin(),
                       to_add_locally.end(),
                       std::back_inserter(to_add_remotely));
 
   // Send local changes to the sync server.
   Change to_change_remotely(to_add_remotely);
   syncer::SyncMergeResult result(type);
   result.set_error(Sync(to_change_remotely));
   return result;
 }
 
 void SpellcheckCustomDictionary::StopSyncing(syncer::ModelType type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(syncer::DICTIONARY, type);
   sync_processor_.reset();
   sync_error_handler_.reset();
 }
 
 syncer::SyncDataList SpellcheckCustomDictionary::GetAllSyncData(
     syncer::ModelType type) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(syncer::DICTIONARY, type);
   syncer::SyncDataList data;
   std::string word;
   size_t i = 0;
-  for (WordList::const_iterator it = words_.begin();
+  for (WordSet::const_iterator it = words_.begin();
        it != words_.end() &&
            i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS;
        ++it, ++i) {
     word = *it;
     sync_pb::EntitySpecifics specifics;
     specifics.mutable_dictionary()->set_word(word);
     data.push_back(syncer::SyncData::CreateLocalData(word, word, specifics));
   }
   return data;
 }
@@ skipping 16 matching lines @@
         dictionary_change.RemoveWord(word);
         break;
       default:
         return sync_error_handler_->CreateAndUploadError(
             FROM_HERE,
             "Processing sync changes failed on change type " +
                 syncer::SyncChange::ChangeTypeToString(it->change_type()));
     }
   }
 
-  std::sort(words_.begin(), words_.end());
   dictionary_change.Sanitize(GetWords());
   Apply(dictionary_change);
   Notify(dictionary_change);
   Save(dictionary_change);
 
   return syncer::SyncError();
 }
 
 // static
 WordList SpellcheckCustomDictionary::LoadDictionaryFile(
     const base::FilePath& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   WordList words;
   LoadDictionaryFileReliably(words, path);
-  if (!words.empty() && VALID_CHANGE != SanitizeWordsToAdd(WordList(), words))
+  if (!words.empty() && VALID_CHANGE != SanitizeWordsToAdd(WordSet(), words))
     SaveDictionaryFileReliably(words, path);
   SpellCheckHostMetrics::RecordCustomWordCountStats(words.size());
   return words;
 }
 
 // static
 void SpellcheckCustomDictionary::UpdateDictionaryFile(
     const SpellcheckCustomDictionary::Change& dictionary_change,
     const base::FilePath& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
@@ skipping 16 matching lines @@
                       dictionary_change.to_remove().begin(),
                       dictionary_change.to_remove().end(),
                       std::back_inserter(remaining));
   std::swap(custom_words, remaining);
 
   SaveDictionaryFileReliably(custom_words, path);
 }
 
 void SpellcheckCustomDictionary::OnLoaded(WordList custom_words) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  std::sort(words_.begin(), words_.end());
   Change dictionary_change(custom_words);
   dictionary_change.Sanitize(GetWords());
   Apply(dictionary_change);
   Sync(dictionary_change);
   is_loaded_ = true;
   FOR_EACH_OBSERVER(Observer, observers_, OnCustomDictionaryLoaded());
 }
 
 void SpellcheckCustomDictionary::Apply(
     const SpellcheckCustomDictionary::Change& dictionary_change) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!dictionary_change.to_add().empty()) {
-    words_.insert(words_.end(),
-                  dictionary_change.to_add().begin(),
+    words_.insert(dictionary_change.to_add().begin(),
                   dictionary_change.to_add().end());
   }
   if (!dictionary_change.to_remove().empty()) {
-    std::sort(words_.begin(), words_.end());
-    WordList updated_words;
+    WordSet updated_words;
     std::set_difference(words_.begin(),
                         words_.end(),
                         dictionary_change.to_remove().begin(),
                         dictionary_change.to_remove().end(),
-                        std::back_inserter(updated_words));
+                        std::inserter(updated_words, updated_words.end()));
     std::swap(words_, updated_words);
   }
 }
 
 void SpellcheckCustomDictionary::Save(
     const SpellcheckCustomDictionary::Change& dictionary_change) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
@@ skipping 63 matching lines @@
 
 void SpellcheckCustomDictionary::Notify(
     const SpellcheckCustomDictionary::Change& dictionary_change) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!IsLoaded() || dictionary_change.empty())
     return;
   FOR_EACH_OBSERVER(Observer,
                     observers_,
                     OnCustomDictionaryChanged(dictionary_change));
 }