Sync user's custom spellcheck dictionary

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/string_number_conversions.h"
 #include "base/string_split.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/spellcheck_messages.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/render_process_host.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;
 
 namespace {
 
+// Filename extension for backup dictionary file.
 const 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.
+enum ChecksumStatus {
+  VALID_CHECKSUM,
+  INVALID_CHECKSUM,
+};
+
+// The result of a dictionary change. Can be used as a bitmap.
+enum ChangeResult {
+  // The change was valid and applied as-is.
+  CHANGE_SUCCEEDED = 0,
+
+  // The change contains words to be added that are not valid.
+  DETECTED_INVALID_WORDS = 1,
+
+  // The change contains words to be added that are already in the
+  // dictionary.
+  DETECTED_DUPLICATE_WORDS = 2,
+
+  // The change contains words to be removed that are not in the dictionary.
+  DETECTED_MISSING_WORDS = 4,
+};
+
 // Loads the lines from the file at |file_path| into the |lines| container. If
-// the file has a valid checksum, then returns |true|. If the file has an
-// invalid checksum, then returns |false| and clears |lines|.
-bool LoadFile(FilePath file_path, std::vector<std::string>* lines) {
+// the file has a valid checksum, then returns ChecksumStatus::VALID. If the
+// file has an invalid checksum, then returns ChecksumStatus::INVALID and clears
+// |lines|.
+ChecksumStatus LoadFile(FilePath file_path, std::vector<std::string>* lines) {

[groby-ooo-7-16, 2013/01/15 01:19:20]

const FilePath&

[please use gerrit instead, 2013/01/16 02:06:05]

Done.

+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK(lines);
   lines->clear();
   std::string contents;
   file_util::ReadFileToString(file_path, &contents);
   size_t pos = contents.rfind(CHECKSUM_PREFIX);
   if (pos != std::string::npos) {
     std::string checksum = contents.substr(pos + strlen(CHECKSUM_PREFIX));
     contents = contents.substr(0, pos);
     if (checksum != base::MD5String(contents))
-      return false;
+      return INVALID_CHECKSUM;
   }
   TrimWhitespaceASCII(contents, TRIM_ALL, &contents);
   base::SplitString(contents, '\n', lines);
-  return true;
-}
-
-bool IsValidWord(const std::string& word) {
-  return IsStringUTF8(word) && word.length() <= 128 && word.length() > 0 &&
-      std::string::npos == word.find_first_of(kWhitespaceASCII);
-}
-
+  return VALID_CHECKSUM;
+}
+
+// Returns true for invalid words and false for valid words. Useful for

[groby-ooo-7-16, 2013/01/15 01:19:20]

Kill "Useful for", save a line :)

[please use gerrit instead, 2013/01/16 02:06:05]

Done.

+// std::remove_if() calls.
 bool IsInvalidWord(const std::string& word) {
-  return !IsValidWord(word);
+  return !IsStringUTF8(word) ||
+      word.length() >
+          chrome::spellcheck_common::MAX_CUSTOM_DICTIONARY_WORD_BYTES ||
+      word.empty() ||
+      word.find_first_of(kWhitespaceASCII) != std::string::npos;
+}
+
+// Loads the custom spellcheck dictionary from |path| into |custom_words|. If
+// the dictionary checksum is not valid, but backup checksum is valid, then
+// restores the backup and loads that into |custom_words| instead. If the backup
+// is invalid too, then clears |custom_words|. Does not take ownership of
+// |custom_words|. Must be called on the file thread.
+void LoadDictionaryFileReliably(WordList* custom_words, const FilePath& path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK(custom_words);
+  // Load the contents and verify the checksum.
+  if (LoadFile(path, custom_words) == VALID_CHECKSUM)
+    return;
+  // Checksum is not valid. See if there's a backup.
+  FilePath backup = path.AddExtension(BACKUP_EXTENSION);
+  if (!file_util::PathExists(backup))
+    return;
+  // Load the backup and verify its checksum.
+  if (LoadFile(backup, custom_words) != VALID_CHECKSUM)
+    return;
+  // Backup checksum is valid. Restore the backup.
+  file_util::CopyFile(backup, path);
+}
+
+// Backs up the original dictionary, saves |custom_words| and its checksum into
+// the custom spellcheck dictionary at |path|. Does not take ownership of
+// |custom_words|.
+void SaveDictionaryFileReliably(
+    const WordList* custom_words,
+    const FilePath& path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK(custom_words);
+  std::stringstream content;
+  for (WordList::const_iterator it = custom_words->begin();
+       it != custom_words->end();
+       ++it) {
+    content << *it << '\n';
+  }
+  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());
+}
+
+// Sanitizes words |to_add| by removing duplicate and invalid words. Assumes
+// that |existing_sorted| is sorted.
+int SanitizeAddData(const WordList& existing_sorted, 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_sorted.begin(),
+                      existing_sorted.end(),
+                      std::back_inserter(new_words));
+  new_words.erase(std::unique(new_words.begin(), new_words.end()),
+               new_words.end());
+  int result = CHANGE_SUCCEEDED;
+  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.
+  std::swap(to_add, new_words);
+  return result;
 }
 
 }  // namespace
 
+
+SpellcheckCustomDictionary::Change::Change() {
+}
+
+SpellcheckCustomDictionary::Change::~Change() {
+}
+
+void SpellcheckCustomDictionary::Change::AddWord(const std::string& word) {
+  to_add_.push_back(word);
+}
+
+void SpellcheckCustomDictionary::Change::AddWords(const WordList& words) {
+  to_add_.insert(to_add_.end(), words.begin(), words.end());
+}
+
+void SpellcheckCustomDictionary::Change::RemoveWord(const std::string& word) {
+  to_remove_.push_back(word);
+}
+
+void SpellcheckCustomDictionary::Change::RemoveWords(const WordList& words) {
+  to_remove_.insert(to_remove_.end(), words.begin(), words.end());
+}
+
+const WordList& SpellcheckCustomDictionary::Change::to_add() const {
+  return to_add_;
+}
+
+WordList& SpellcheckCustomDictionary::Change::to_add() {
+  return to_add_;
+}
+
+const WordList& SpellcheckCustomDictionary::Change::to_remove() const {
+  return to_remove_;
+}
+
+WordList& SpellcheckCustomDictionary::Change::to_remove() {
+  return to_remove_;
+}
+
+bool SpellcheckCustomDictionary::Change::empty() const {
+  return to_add_.empty() && to_remove_.empty();
+}
+
 SpellcheckCustomDictionary::SpellcheckCustomDictionary(Profile* profile)
     : SpellcheckDictionary(profile),
       custom_dictionary_path_(),
-      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      is_loaded_(false) {
   DCHECK(profile);
   custom_dictionary_path_ =
       profile_->GetPath().Append(chrome::kCustomDictionaryFileName);
 }
 
 SpellcheckCustomDictionary::~SpellcheckCustomDictionary() {
 }
 
+const WordList& SpellcheckCustomDictionary::GetWords() const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  return words_;
+}
+
+bool SpellcheckCustomDictionary::AddWord(const std::string& word) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  scoped_ptr<Change> dictionary_change(new Change);
+  dictionary_change->AddWord(word);
+  int result = Apply(dictionary_change.get());
+  Notify(dictionary_change.get());
+  Sync(dictionary_change.get());
+  Save(dictionary_change.Pass());
+  return result == CHANGE_SUCCEEDED;
+}
+
+bool SpellcheckCustomDictionary::RemoveWord(const std::string& word) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  scoped_ptr<Change> dictionary_change(new Change);
+  dictionary_change->RemoveWord(word);
+  int result = Apply(dictionary_change.get());
+  Notify(dictionary_change.get());
+  Sync(dictionary_change.get());
+  Save(dictionary_change.Pass());
+  return result == CHANGE_SUCCEEDED;
+}
+
+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);
+}
+
+bool SpellcheckCustomDictionary::IsLoaded() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  return is_loaded_;
+}
+
+bool SpellcheckCustomDictionary::IsSyncing() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  return !!sync_processor_.get();
+}
+
 void SpellcheckCustomDictionary::Load() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  BrowserThread::PostTaskAndReplyWithResult<WordList*>(
+  BrowserThread::PostTaskAndReplyWithResult<scoped_ptr<WordList> >(
       BrowserThread::FILE,
       FROM_HERE,
-      base::Bind(&SpellcheckCustomDictionary::LoadDictionary,
-                 base::Unretained(this)),
-      base::Bind(&SpellcheckCustomDictionary::SetCustomWordListAndDelete,
+      base::Bind(&SpellcheckCustomDictionary::LoadDictionaryFile,
+                 custom_dictionary_path_),
+      base::Bind(&SpellcheckCustomDictionary::OnLoaded,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-const WordList& SpellcheckCustomDictionary::GetWords() const {
-  return words_;
-}
-
-void SpellcheckCustomDictionary::LoadDictionaryIntoCustomWordList(
-    WordList* custom_words) {
+syncer::SyncMergeResult SpellcheckCustomDictionary::MergeDataAndStartSyncing(
+    syncer::ModelType type,
+    const syncer::SyncDataList& initial_sync_data,
+    scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
+    scoped_ptr<syncer::SyncErrorFactory> sync_error_handler) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!sync_processor_.get());
+  DCHECK(!sync_error_handler_.get());
+  DCHECK(sync_processor.get());
+  DCHECK(sync_error_handler.get());
+  DCHECK_EQ(syncer::DICTIONARY, type);
+  sync_processor_ = sync_processor.Pass();
+  sync_error_handler_ = sync_error_handler.Pass();
+
+  // Add remote words locally.
+  WordList sync_words;
+  std::string word;
+  for (syncer::SyncDataList::const_iterator it = initial_sync_data.begin();
+     it != initial_sync_data.end();
+     ++it) {
+    DCHECK_EQ(syncer::DICTIONARY, it->GetDataType());
+    sync_words.push_back(it->GetSpecifics().dictionary().word());
+  }
+  scoped_ptr<Change> to_change_locally(new Change);
+  to_change_locally->AddWords(sync_words);
+  Apply(to_change_locally.get());
+  Notify(to_change_locally.get());
+  Save(to_change_locally.Pass());
+
+  // Add as many as possible local words remotely.
+  std::sort(words_.begin(), words_.end());
+  std::sort(sync_words.begin(), sync_words.end());
+  Change to_change_remotely;
+  std::set_difference(words_.begin(),
+                      words_.end(),
+                      sync_words.begin(),
+                      sync_words.end(),
+                      std::back_inserter(to_change_remotely.to_add()));
+  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();
+       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;
+}
+
+syncer::SyncError SpellcheckCustomDictionary::ProcessSyncChanges(
+    const tracked_objects::Location& from_here,
+    const syncer::SyncChangeList& change_list) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  scoped_ptr<Change> dictionary_change(new Change);
+  for (syncer::SyncChangeList::const_iterator it = change_list.begin();
+       it != change_list.end();
+       ++it) {
+    DCHECK(it->IsValid());
+    std::string word = it->sync_data().GetSpecifics().dictionary().word();
+    switch (it->change_type()) {
+      case syncer::SyncChange::ACTION_ADD:
+        dictionary_change->AddWord(word);
+        break;
+      case syncer::SyncChange::ACTION_DELETE:
+        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()));
+    }
+  }
+
+  Apply(dictionary_change.get());
+  Notify(dictionary_change.get());
+  Save(dictionary_change.Pass());
+
+  return syncer::SyncError();
+}
+
+// static
+scoped_ptr<WordList> SpellcheckCustomDictionary::LoadDictionaryFile(
+    const FilePath& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-
-  LoadDictionaryFileReliably(custom_words);
+  scoped_ptr<WordList> custom_words(new WordList);

[groby-ooo-7-16, 2013/01/15 01:19:20]

Since we always return custom_words, no need for scoped_ptr. Just return a raw
pointer.

[please use gerrit instead, 2013/01/16 02:06:05]

How about a "WordList SpellcheckCustomDictionary::LoadDictionaryFile(const
FilePath& path)" instead?

+  LoadDictionaryFileReliably(custom_words.get(), path);
   if (custom_words->empty())

[groby-ooo-7-16, 2013/01/15 01:19:20]

I'd pick if(!custom_words.empty()) { Sanitize(); Save(); }

That way, there's only one return path. 

[please use gerrit instead, 2013/01/16 02:06:05]

Done.

+    return custom_words.Pass();
+  SanitizeAddData(WordList(), *custom_words.get());
+  SaveDictionaryFileReliably(custom_words.get(), path);
+  return custom_words.Pass();
+}
+
+// static
+void SpellcheckCustomDictionary::UpdateDictionaryFile(
+    scoped_ptr<SpellcheckCustomDictionary::Change> dictionary_change,
+    const FilePath& path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK(dictionary_change.get());
+  WordList custom_words;
+  LoadDictionaryFileReliably(&custom_words, path);
+
+  // Add words.
+  custom_words.insert(custom_words.end(),
+                      dictionary_change->to_add().begin(),
+                      dictionary_change->to_add().end());
+
+  // Remove words.
+  std::sort(custom_words.begin(), custom_words.end());
+  std::sort(dictionary_change->to_remove().begin(),
+            dictionary_change->to_remove().end());
+  WordList remaining;
+  std::set_difference(custom_words.begin(),
+                      custom_words.end(),
+                      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(scoped_ptr<WordList> custom_words) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(custom_words.get());
+  scoped_ptr<Change> dictionary_change(new Change);
+  dictionary_change->AddWords(*custom_words.get());
+  Apply(dictionary_change.get());
+  Sync(dictionary_change.get());
+  is_loaded_ = true;
+  FOR_EACH_OBSERVER(Observer, observers_, OnCustomDictionaryLoaded());
+}
+
+// TODO(rlp): record metrics on custom word size
+int SpellcheckCustomDictionary::Apply(
+    SpellcheckCustomDictionary::Change* dictionary_change) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(dictionary_change);
+  int result = CHANGE_SUCCEEDED;
+
+  if (!dictionary_change->to_add().empty()) {
+    std::sort(words_.begin(), words_.end());
+    result |= SanitizeAddData(words_, dictionary_change->to_add());
+    words_.insert(words_.end(),
+                  dictionary_change->to_add().begin(),
+                  dictionary_change->to_add().end());
+  }
+
+  if (!dictionary_change->to_remove().empty()) {
+    // Do not remove words that are missing from the dictionary.
+    std::sort(dictionary_change->to_remove().begin(),
+              dictionary_change->to_remove().end());
+    std::sort(words_.begin(), words_.end());
+    WordList to_remove;
+    std::set_intersection(words_.begin(),
+                          words_.end(),
+                          dictionary_change->to_remove().begin(),
+                          dictionary_change->to_remove().end(),
+                          std::back_inserter(to_remove));
+    if (dictionary_change->to_remove().size() > to_remove.size())
+      result |= DETECTED_MISSING_WORDS;
+
+    // Remove the words from the dictionary.
+    WordList updated_words;
+    std::set_difference(words_.begin(),
+                        words_.end(),
+                        to_remove.begin(),
+                        to_remove.end(),
+                        std::back_inserter(updated_words));
+    std::swap(words_, updated_words);
+
+    // Clean up the dictionary change by removing missing words.
+    std::swap(dictionary_change->to_remove(), to_remove);
+  }
+
+  return result;
+}
+
+void SpellcheckCustomDictionary::Save(
+    scoped_ptr<SpellcheckCustomDictionary::Change> dictionary_change) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(dictionary_change.get());
+  BrowserThread::PostTask(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&SpellcheckCustomDictionary::UpdateDictionaryFile,
+                 base::Passed(dictionary_change.Pass()),
+                 custom_dictionary_path_));
+}
+
+syncer::SyncError SpellcheckCustomDictionary::Sync(
+    const SpellcheckCustomDictionary::Change* dictionary_change) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(dictionary_change);
+  syncer::SyncError error;
+  if (!IsSyncing() || dictionary_change->empty())
+    return error;
+
+  // The number of words on the sync server should not exceed the limits.
+  int server_size = static_cast<int>(words_.size()) -
+      static_cast<int>(dictionary_change->to_add().size());
+  int max_upload_size = std::max(
+      0,
+      static_cast<int>(
+          chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS) -
+          server_size);
+  int upload_size = std::min(
+      static_cast<int>(dictionary_change->to_add().size()),
+      max_upload_size);
+
+  syncer::SyncChangeList sync_change_list;
+  std::string word;
+  int i = 0;
+
+  for (WordList::const_iterator it = dictionary_change->to_add().begin();
+       it != dictionary_change->to_add().end() && i < upload_size;
+       ++it, ++i) {
+    word = *it;
+    sync_pb::EntitySpecifics specifics;
+    specifics.mutable_dictionary()->set_word(word);
+    sync_change_list.push_back(syncer::SyncChange(
+        FROM_HERE,
+        syncer::SyncChange::ACTION_ADD,
+        syncer::SyncData::CreateLocalData(word, word, specifics)));
+  }
+
+  for (WordList::const_iterator it = dictionary_change->to_remove().begin();
+       it != dictionary_change->to_remove().end();
+       ++it) {
+    word = *it;
+    sync_pb::EntitySpecifics specifics;
+    specifics.mutable_dictionary()->set_word(word);
+    sync_change_list.push_back(syncer::SyncChange(
+        FROM_HERE,
+        syncer::SyncChange::ACTION_DELETE,
+        syncer::SyncData::CreateLocalData(word, word, specifics)));
+  }
+
+  // Send the changes to the sync processor.
+  error = sync_processor_->ProcessSyncChanges(FROM_HERE, sync_change_list);
+  if (error.IsSet())
+    return error;
+
+  // Turn off syncing of this dictionary if the server already has the maximum
+  // number of words.
+  if (words_.size() > chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS)
+    StopSyncing(syncer::DICTIONARY);
+
+  return error;
+}
+
+void SpellcheckCustomDictionary::Notify(
+    const SpellcheckCustomDictionary::Change* dictionary_change) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(dictionary_change);
+  if (!IsLoaded() || dictionary_change->empty())
     return;
-
-  // Clean up the dictionary file contents by removing duplicates and invalid
-  // words.
-  std::sort(custom_words->begin(), custom_words->end());
-  custom_words->erase(std::unique(custom_words->begin(), custom_words->end()),
-                      custom_words->end());
-  custom_words->erase(std::remove_if(custom_words->begin(),
-                                     custom_words->end(),
-                                     IsInvalidWord),
-                      custom_words->end());
-
-  SaveDictionaryFileReliably(*custom_words);
-}
-
-void SpellcheckCustomDictionary::SetCustomWordList(WordList* custom_words) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  words_.clear();
-  if (custom_words)
-    std::swap(words_, *custom_words);
-
-  FOR_EACH_OBSERVER(Observer, observers_, OnCustomDictionaryLoaded());
-}
-
-bool SpellcheckCustomDictionary::AddWord(const std::string& word) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!IsValidWord(word))
-    return false;
-
-  if (!CustomWordAddedLocally(word))
-    return false;
-
-  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-      base::Bind(&SpellcheckCustomDictionary::WriteWordToCustomDictionary,
-                 base::Unretained(this), word));
-
-  for (content::RenderProcessHost::iterator i(
-          content::RenderProcessHost::AllHostsIterator());
-       !i.IsAtEnd(); i.Advance()) {
-    i.GetCurrentValue()->Send(new SpellCheckMsg_WordAdded(word));
-  }
-
-  FOR_EACH_OBSERVER(Observer, observers_, OnCustomDictionaryWordAdded(word));
-
-  return true;
-}
-
-bool SpellcheckCustomDictionary::CustomWordAddedLocally(
-    const std::string& word) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(IsValidWord(word));
-
-  WordList::iterator it = std::find(words_.begin(), words_.end(), word);
-  if (it == words_.end()) {
-    words_.push_back(word);
-    return true;
-  }
-  return false;
-  // TODO(rlp): record metrics on custom word size
-}
-
-void SpellcheckCustomDictionary::WriteWordToCustomDictionary(
-    const std::string& word) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DCHECK(IsValidWord(word));
-
-  WordList custom_words;
-  LoadDictionaryFileReliably(&custom_words);
-  custom_words.push_back(word);
-  SaveDictionaryFileReliably(custom_words);
-}
-
-bool SpellcheckCustomDictionary::RemoveWord(const std::string& word) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!IsValidWord(word))
-    return false;
-
-  if (!CustomWordRemovedLocally(word))
-    return false;
-
-  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-      base::Bind(&SpellcheckCustomDictionary::EraseWordFromCustomDictionary,
-                 base::Unretained(this), word));
-
-  for (content::RenderProcessHost::iterator i(
-          content::RenderProcessHost::AllHostsIterator());
-       !i.IsAtEnd(); i.Advance()) {
-    i.GetCurrentValue()->Send(new SpellCheckMsg_WordRemoved(word));
-  }
-
-  FOR_EACH_OBSERVER(Observer, observers_, OnCustomDictionaryWordRemoved(word));
-
-  return true;
-}
-
-bool SpellcheckCustomDictionary::CustomWordRemovedLocally(
-    const std::string& word) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(IsValidWord(word));
-
-  WordList::iterator it = std::find(words_.begin(), words_.end(), word);
-  if (it != words_.end()) {
-    words_.erase(it);
-    return true;
-  }
-  return false;
-}
-
-void SpellcheckCustomDictionary::EraseWordFromCustomDictionary(
-    const std::string& word) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DCHECK(IsValidWord(word));
-
-  WordList custom_words;
-  LoadDictionaryFileReliably(&custom_words);
-  if (custom_words.empty())
-    return;
-
-  WordList::iterator it = std::find(custom_words.begin(),
-                                    custom_words.end(),
-                                    word);
-  if (it != custom_words.end())
-    custom_words.erase(it);
-
-  SaveDictionaryFileReliably(custom_words);
-}
-
-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);
-}
-
-WordList* SpellcheckCustomDictionary::LoadDictionary() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-
-  WordList* custom_words = new WordList;
-  LoadDictionaryIntoCustomWordList(custom_words);
-  return custom_words;
-}
-
-void SpellcheckCustomDictionary::SetCustomWordListAndDelete(
-    WordList* custom_words) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  SetCustomWordList(custom_words);
-  delete custom_words;
-}
-
-void SpellcheckCustomDictionary::LoadDictionaryFileReliably(
-    WordList* custom_words) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-
-  // Load the contents and verify the checksum.
-  if (LoadFile(custom_dictionary_path_, custom_words))
-    return;
-
-  // Checksum is not valid. See if there's a backup.
-  FilePath backup = custom_dictionary_path_.AddExtension(BACKUP_EXTENSION);
-  if (!file_util::PathExists(backup))
-    return;
-
-  // Load the backup and verify its checksum.
-  if (!LoadFile(backup, custom_words))
-    return;
-
-  // Backup checksum is valid. Restore the backup.
-  file_util::CopyFile(backup, custom_dictionary_path_);
-}
-
-void SpellcheckCustomDictionary::SaveDictionaryFileReliably(
-    const WordList& custom_words) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-
-  std::stringstream content;
-  for (WordList::const_iterator it = custom_words.begin();
-       it != custom_words.end();
-       ++it) {
-    content << *it << '\n';
-  }
-  std::string checksum = base::MD5String(content.str());
-  content << CHECKSUM_PREFIX << checksum;
-
-  file_util::CopyFile(custom_dictionary_path_,
-                      custom_dictionary_path_.AddExtension(BACKUP_EXTENSION));
-  base::ImportantFileWriter::WriteFileAtomically(custom_dictionary_path_,
-                                                 content.str());
-}
+  FOR_EACH_OBSERVER(Observer,
+                    observers_,
+                    OnCustomDictionaryChanged(dictionary_change));
+}