diff options
author | jochen <jochen@chromium.org> | 2015-06-03 03:01:46 -0700 |
---|---|---|
committer | Commit bot <commit-bot@chromium.org> | 2015-06-03 10:02:19 +0000 |
commit | 73e711c4c67eea6ab339493aa7703a0e29a2f5bd (patch) | |
tree | 6a6c870d7367e34b482d2f8a5092582755b95b22 /components/test_runner/mock_spell_check.cc | |
parent | d993e8ec7ba6d3436d780a6ee6350a3a2840dee9 (diff) | |
download | chromium_src-73e711c4c67eea6ab339493aa7703a0e29a2f5bd.zip chromium_src-73e711c4c67eea6ab339493aa7703a0e29a2f5bd.tar.gz chromium_src-73e711c4c67eea6ab339493aa7703a0e29a2f5bd.tar.bz2 |
Move test runner to a component
BUG=478250
R=mkwst@chromium.org,torne@chromium.org,jam@chromium.org
Review URL: https://codereview.chromium.org/1167703002
Cr-Commit-Position: refs/heads/master@{#332583}
Diffstat (limited to 'components/test_runner/mock_spell_check.cc')
-rw-r--r-- | components/test_runner/mock_spell_check.cc | 174 |
1 files changed, 174 insertions, 0 deletions
diff --git a/components/test_runner/mock_spell_check.cc b/components/test_runner/mock_spell_check.cc new file mode 100644 index 0000000..6dc875d --- /dev/null +++ b/components/test_runner/mock_spell_check.cc @@ -0,0 +1,174 @@ +// Copyright 2014 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 "components/test_runner/mock_spell_check.h" + +#include "base/logging.h" +#include "components/test_runner/test_common.h" +#include "third_party/WebKit/public/platform/WebCString.h" + +namespace content { + +namespace { + +void Append(blink::WebVector<blink::WebString>* data, + const blink::WebString& item) { + blink::WebVector<blink::WebString> result(data->size() + 1); + for (size_t i = 0; i < data->size(); ++i) + result[i] = (*data)[i]; + result[data->size()] = item; + data->swap(result); +} + +} // namespace + +MockSpellCheck::MockSpellCheck() : initialized_(false) { +} + +MockSpellCheck::~MockSpellCheck() { +} + +bool MockSpellCheck::SpellCheckWord(const blink::WebString& text, + int* misspelled_offset, + int* misspelled_length) { + DCHECK(misspelled_offset); + DCHECK(misspelled_length); + + // Initialize this spellchecker. + InitializeIfNeeded(); + + // Reset the result values as our spellchecker does. + *misspelled_offset = 0; + *misspelled_length = 0; + + // Convert to a base::string16 because we store base::string16 instances in + // misspelled_words_ and blink::WebString has no find(). + base::string16 string_text = text; + int skipped_length = 0; + + while (!string_text.empty()) { + // Extract the first possible English word from the given string. + // The given string may include non-ASCII characters or numbers. So, we + // should filter out such characters before start looking up our + // misspelled-word table. + // (This is a simple version of our SpellCheckWordIterator class.) + // If the given string doesn't include any ASCII characters, we can treat + // the string as valid one. + base::string16::iterator first_char = + std::find_if(string_text.begin(), string_text.end(), IsASCIIAlpha); + if (first_char == string_text.end()) + return true; + int word_offset = std::distance(string_text.begin(), first_char); + int max_word_length = static_cast<int>(string_text.length()) - word_offset; + int word_length; + base::string16 word; + + // Look up our misspelled-word table to check if the extracted word is a + // known misspelled word, and return the offset and the length of the + // extracted word if this word is a known misspelled word. + // (See the comment in MockSpellCheck::InitializeIfNeeded() why we use a + // misspelled-word table.) + for (size_t i = 0; i < misspelled_words_.size(); ++i) { + word_length = + static_cast<int>(misspelled_words_.at(i).length()) > max_word_length + ? max_word_length + : static_cast<int>(misspelled_words_.at(i).length()); + word = string_text.substr(word_offset, word_length); + if (word == misspelled_words_.at(i) && + (static_cast<int>(string_text.length()) == + word_offset + word_length || + IsNotASCIIAlpha(string_text[word_offset + word_length]))) { + *misspelled_offset = word_offset + skipped_length; + *misspelled_length = word_length; + break; + } + } + + if (*misspelled_length > 0) + break; + + base::string16::iterator last_char = std::find_if( + string_text.begin() + word_offset, string_text.end(), IsNotASCIIAlpha); + if (last_char == string_text.end()) + word_length = static_cast<int>(string_text.length()) - word_offset; + else + word_length = std::distance(first_char, last_char); + + DCHECK_LT(0, word_offset + word_length); + string_text = string_text.substr(word_offset + word_length); + skipped_length += word_offset + word_length; + } + + return false; +} + +bool MockSpellCheck::HasInCache(const blink::WebString& word) { + return word == blink::WebString::fromUTF8("Spell wellcome. Is it broken?") || + word == blink::WebString::fromUTF8("Spell wellcome.\x007F"); +} + +bool MockSpellCheck::IsMultiWordMisspelling( + const blink::WebString& text, + std::vector<blink::WebTextCheckingResult>* results) { + if (text == blink::WebString::fromUTF8("Helllo wordl.")) { + results->push_back(blink::WebTextCheckingResult( + blink::WebTextDecorationTypeSpelling, 0, 6, blink::WebString("Hello"))); + results->push_back(blink::WebTextCheckingResult( + blink::WebTextDecorationTypeSpelling, 7, 5, blink::WebString("world"))); + return true; + } + return false; +} + +void MockSpellCheck::FillSuggestionList( + const blink::WebString& word, + blink::WebVector<blink::WebString>* suggestions) { + if (word == blink::WebString::fromUTF8("wellcome")) + Append(suggestions, blink::WebString::fromUTF8("welcome")); + else if (word == blink::WebString::fromUTF8("upper case")) + Append(suggestions, blink::WebString::fromUTF8("uppercase")); + else if (word == blink::WebString::fromUTF8("Helllo")) + Append(suggestions, blink::WebString::fromUTF8("Hello")); + else if (word == blink::WebString::fromUTF8("wordl")) + Append(suggestions, blink::WebString::fromUTF8("world")); +} + +bool MockSpellCheck::InitializeIfNeeded() { + // Exit if we have already initialized this object. + if (initialized_) + return false; + + // Create a table that consists of misspelled words used in WebKit layout + // tests. + // Since WebKit layout tests don't have so many misspelled words as + // well-spelled words, it is easier to compare the given word with misspelled + // ones than to compare with well-spelled ones. + static const char* misspelled_words[] = { + // These words are known misspelled words in webkit tests. + // If there are other misspelled words in webkit tests, please add them in + // this array. + "foo", "Foo", "baz", "fo", "LibertyF", + "chello", "xxxtestxxx", "XXxxx", "Textx", "blockquoted", + "asd", "Lorem", "Nunc", "Curabitur", "eu", + "adlj", "adaasj", "sdklj", "jlkds", "jsaada", + "jlda", "zz", "contentEditable", + // The following words are used by unit tests. + "ifmmp", "qwertyuiopasd", "qwertyuiopasdf", "upper case", "wellcome"}; + + misspelled_words_.clear(); + for (size_t i = 0; i < arraysize(misspelled_words); ++i) + misspelled_words_.push_back( + base::string16(misspelled_words[i], + misspelled_words[i] + strlen(misspelled_words[i]))); + + // Mark as initialized to prevent this object from being initialized twice + // or more. + initialized_ = true; + + // Since this MockSpellCheck class doesn't download dictionaries, this + // function always returns false. + return false; +} + +} // namespace content |