Index: content/shell/renderer/test_runner/mock_spell_check.cc |
diff --git a/content/shell/renderer/test_runner/mock_spell_check.cc b/content/shell/renderer/test_runner/mock_spell_check.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..e4564fba59a71f42b6bfa087126ecebdcf0a5715 |
--- /dev/null |
+++ b/content/shell/renderer/test_runner/mock_spell_check.cc |
@@ -0,0 +1,172 @@ |
+// Copyright 2013 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 "content/shell/renderer/test_runner/mock_spell_check.h" |
+ |
+#include "base/logging.h" |
+#include "content/shell/renderer/test_runner/TestCommon.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* misspelledOffset, |
jochen (gone - plz use gerrit)
2014/07/24 08:47:04
misspelled_offset
Abhishek
2014/07/24 10:08:39
Done.
|
+ int* misspelledLength) { |
+ DCHECK(misspelledOffset); |
+ DCHECK(misspelledLength); |
+ |
+ // Initialize this spellchecker. |
+ InitializeIfNeeded(); |
+ |
+ // Reset the result values as our spellchecker does. |
+ *misspelledOffset = 0; |
+ *misspelledLength = 0; |
+ |
+ // Convert to a base::string16 because we store base::string16 instances in |
+ // misspelled_words_ and blink::WebString has no find(). |
+ base::string16 stringText = text; |
jochen (gone - plz use gerrit)
2014/07/24 08:47:04
string_text (also all other variables)
Abhishek
2014/07/24 10:08:39
Done.
|
+ int skippedLength = 0; |
+ |
+ while (!stringText.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 firstChar = |
+ std::find_if(stringText.begin(), stringText.end(), isASCIIAlpha); |
+ if (firstChar == stringText.end()) |
+ return true; |
+ int wordOffset = std::distance(stringText.begin(), firstChar); |
+ int maxWordLength = static_cast<int>(stringText.length()) - wordOffset; |
+ int wordLength; |
+ 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) { |
+ wordLength = |
+ static_cast<int>(misspelled_words_.at(i).length()) > maxWordLength |
+ ? maxWordLength |
+ : static_cast<int>(misspelled_words_.at(i).length()); |
+ word = stringText.substr(wordOffset, wordLength); |
+ if (word == misspelled_words_.at(i) && |
+ (static_cast<int>(stringText.length()) == wordOffset + wordLength || |
+ isNotASCIIAlpha(stringText[wordOffset + wordLength]))) { |
+ *misspelledOffset = wordOffset + skippedLength; |
+ *misspelledLength = wordLength; |
+ break; |
+ } |
+ } |
+ |
+ if (*misspelledLength > 0) |
+ break; |
+ |
+ base::string16::iterator lastChar = std::find_if( |
+ stringText.begin() + wordOffset, stringText.end(), isNotASCIIAlpha); |
+ if (lastChar == stringText.end()) |
+ wordLength = static_cast<int>(stringText.length()) - wordOffset; |
+ else |
+ wordLength = std::distance(firstChar, lastChar); |
+ |
+ DCHECK_LT(0, wordOffset + wordLength); |
+ stringText = stringText.substr(wordOffset + wordLength); |
+ skippedLength += wordOffset + wordLength; |
+ } |
+ |
+ 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* misspelledWords[] = { |
+ // 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(misspelledWords); ++i) |
+ misspelled_words_.push_back(base::string16( |
+ misspelledWords[i], misspelledWords[i] + strlen(misspelledWords[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 |