Sync user's custom spellcheck dictionary

chrome/browser/sync/test/integration/dictionary_helper.cc

+// Copyright (c) 2011 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/sync/test/integration/dictionary_helper.h"
+
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/spellchecker/spellcheck_factory.h"
+#include "chrome/browser/spellchecker/spellcheck_service.h"
+#include "chrome/browser/sync/profile_sync_service_harness.h"
+#include "chrome/browser/sync/test/integration/dictionary_load_observer.h"
+#include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
+#include "chrome/browser/sync/test/integration/sync_test.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/common/spellcheck_common.h"
+#include "content/public/test/test_utils.h"
+
+namespace dictionary_helper {
+namespace {
+
+bool DictionaryHasWord(
+    const SpellcheckCustomDictionary* dictionary,
+    const std::string& word) {
+  return dictionary->GetWords().end() != std::find(
+      dictionary->GetWords().begin(),
+      dictionary->GetWords().end(),
+      word);
+}
+
+SpellcheckCustomDictionary* GetDictionary(int index) {
+  return SpellcheckServiceFactory::GetForProfile(
+      sync_datatype_helper::test()->GetProfile(index))->GetCustomDictionary();
+}
+
+SpellcheckCustomDictionary* GetVerifierDictionary() {
+  return SpellcheckServiceFactory::GetForProfile(
+      sync_datatype_helper::test()->verifier())->GetCustomDictionary();
+}
+
+bool HaveWord(int index, std::string word) {
+  return DictionaryHasWord(GetDictionary(index), word);
+}
+
+bool HaveWordInVerifier(std::string word) {
+  return DictionaryHasWord(GetVerifierDictionary(), word);
+}
+
+void LoadDictionary(SpellcheckCustomDictionary* dictionary) {
+  if (dictionary->IsLoaded())
+    return;
+  base::RunLoop run_loop;
+  DictionaryLoadObserver observer(content::GetQuitTaskForRunLoop(&run_loop));
+  dictionary->AddObserver(&observer);
+  dictionary->Load();
+  content::RunThisRunLoop(&run_loop);
+  dictionary->RemoveObserver(&observer);
+  ASSERT_TRUE(dictionary->IsLoaded());
+}
+
+bool HaveWordMatches(const std::string& word) {
+  bool reference = sync_datatype_helper::test()->use_verifier() ?
+      HaveWordInVerifier(word) : HaveWord(0, word);
+  for (int i = 0; i < sync_datatype_helper::test()->num_clients(); ++i) {
+    if (reference != HaveWord(i, word)) {
+      LOG(ERROR)
+          << "Word " << word << " is " << (reference ? "missing " : "present ")
+          << "in profile " << i << ".";
+      return false;
+    }
+  }
+  return true;
+}
+
+}  // namespace
+
+void EnableDictionarySync(CommandLine* cl) {
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      switches::kEnableSyncDictionary);
+}
+
+void LoadDictionaries() {
+  for (int i = 0; i < sync_datatype_helper::test()->num_clients(); ++i) {
+    LOG(ERROR) << "Loading dictionary for profile " << i;
+    LoadDictionary(GetDictionary(i));
+  }
+  if (sync_datatype_helper::test()->use_verifier()) {
+    LOG(ERROR) << "Loading dictionary for verifier profile";
+    LoadDictionary(GetVerifierDictionary());
+  }
+}
+
+size_t GetDictionarySize(int index) {
+  return GetDictionary(index)->GetWords().size();
+}
+
+size_t GetVerifierDictionarySize() {
+  return GetVerifierDictionary()->GetWords().size();
+}
+
+bool DictionariesMatch() {
+  chrome::spellcheck_common::WordList reference =
+      sync_datatype_helper::test()->use_verifier() ?
+      GetVerifierDictionary()->GetWords() : GetDictionary(0)->GetWords();
+  for (int i = 0; i < sync_datatype_helper::test()->num_clients(); ++i) {
+    if (reference.size() != GetDictionary(i)->GetWords().size()) {
+      LOG(ERROR)
+          << "Dictionary in profile " << i << " has "
+          << GetDictionary(i)->GetWords().size() << " words, but should have "
+          << reference.size() << ".";
+      return false;
+    }
+  }
+  for (chrome::spellcheck_common::WordList::iterator it = reference.begin();
+       it != reference.end();
+       ++it) {
+    if (!HaveWordMatches(*it))
+      return false;
+  }
+  return true;
+}
+
+bool DictionaryMatchesVerifier(int index) {
+  chrome::spellcheck_common::WordList expected =
+      GetVerifierDictionary()->GetWords();
+  chrome::spellcheck_common::WordList actual = GetDictionary(index)->GetWords();
+  if (expected.size() != actual.size())
+    return false;
+  for (chrome::spellcheck_common::WordList::iterator it = expected.begin();
+       it != expected.end();
+       ++it) {
+    if (actual.end() == std::find(actual.begin(), actual.end(), *it))
+      return false;
+  }
+  return true;
+}
+
+bool AddWord(int index, const std::string& word) {
+  SpellcheckCustomDictionary::Change::Result result1;
+  SpellcheckCustomDictionary::Change::Result result2;
+  result1 = GetDictionary(index)->AddWord(word);
+  if (sync_datatype_helper::test()->use_verifier())
+    result2 = GetVerifierDictionary()->AddWord(word);
+  return !result1.detected_invalid_words() &&
+      !result1.detected_duplicate_words() &&
+      !result2.detected_invalid_words() &&
+      !result2.detected_duplicate_words();
+}
+
+bool CustomWordAddedLocally(int index, const std::string& word) {
+  SpellcheckCustomDictionary::Change::Result result1;
+  SpellcheckCustomDictionary::Change::Result result2;
+  result1 = GetDictionary(index)->CustomWordAddedLocally(word);
+  if (sync_datatype_helper::test()->use_verifier())
+    result2 = GetVerifierDictionary()->CustomWordAddedLocally(word);
+  return !result1.detected_invalid_words() &&
+      !result1.detected_duplicate_words() &&
+      !result2.detected_invalid_words() &&
+      !result2.detected_duplicate_words();
+}
+
+bool RemoveWord(int index, const std::string& word) {
+  SpellcheckCustomDictionary::Change::Result result1;
+  SpellcheckCustomDictionary::Change::Result result2;
+  result1 = GetDictionary(index)->RemoveWord(word);
+  if (sync_datatype_helper::test()->use_verifier())
+    result2 = GetVerifierDictionary()->RemoveWord(word);
+  return !result1.detected_missing_words() && !result2.detected_missing_words();
+}
+
+bool CustomWordRemovedLocally(int index, const std::string& word) {
+  SpellcheckCustomDictionary::Change::Result result1;
+  SpellcheckCustomDictionary::Change::Result result2;
+  result1 = GetDictionary(index)->CustomWordRemovedLocally(word);
+  if (sync_datatype_helper::test()->use_verifier())
+    result2 = GetVerifierDictionary()->CustomWordRemovedLocally(word);
+  return !result1.detected_missing_words() && !result2.detected_missing_words();
+}
+
+}  // namespace dictionary_helper