1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "content/shell/renderer/test_runner/mock_spell_check.h"
6
7#include "base/logging.h"
8#include "content/shell/renderer/test_runner/test_common.h"
9#include "third_party/WebKit/public/platform/WebCString.h"
10
11namespace content {
12
13namespace {
14
15void Append(blink::WebVector<blink::WebString>* data,
16            const blink::WebString& item) {
17  blink::WebVector<blink::WebString> result(data->size() + 1);
18  for (size_t i = 0; i < data->size(); ++i)
19    result[i] = (*data)[i];
20  result[data->size()] = item;
21  data->swap(result);
22}
23
24}  // namespace
25
26MockSpellCheck::MockSpellCheck() : initialized_(false) {
27}
28
29MockSpellCheck::~MockSpellCheck() {
30}
31
32bool MockSpellCheck::SpellCheckWord(const blink::WebString& text,
33                                    int* misspelled_offset,
34                                    int* misspelled_length) {
35  DCHECK(misspelled_offset);
36  DCHECK(misspelled_length);
37
38  // Initialize this spellchecker.
39  InitializeIfNeeded();
40
41  // Reset the result values as our spellchecker does.
42  *misspelled_offset = 0;
43  *misspelled_length = 0;
44
45  // Convert to a base::string16 because we store base::string16 instances in
46  // misspelled_words_ and blink::WebString has no find().
47  base::string16 string_text = text;
48  int skipped_length = 0;
49
50  while (!string_text.empty()) {
51    // Extract the first possible English word from the given string.
52    // The given string may include non-ASCII characters or numbers. So, we
53    // should filter out such characters before start looking up our
54    // misspelled-word table.
55    // (This is a simple version of our SpellCheckWordIterator class.)
56    // If the given string doesn't include any ASCII characters, we can treat
57    // the string as valid one.
58    base::string16::iterator first_char =
59        std::find_if(string_text.begin(), string_text.end(), IsASCIIAlpha);
60    if (first_char == string_text.end())
61      return true;
62    int word_offset = std::distance(string_text.begin(), first_char);
63    int max_word_length = static_cast<int>(string_text.length()) - word_offset;
64    int word_length;
65    base::string16 word;
66
67    // Look up our misspelled-word table to check if the extracted word is a
68    // known misspelled word, and return the offset and the length of the
69    // extracted word if this word is a known misspelled word.
70    // (See the comment in MockSpellCheck::InitializeIfNeeded() why we use a
71    // misspelled-word table.)
72    for (size_t i = 0; i < misspelled_words_.size(); ++i) {
73      word_length =
74          static_cast<int>(misspelled_words_.at(i).length()) > max_word_length
75              ? max_word_length
76              : static_cast<int>(misspelled_words_.at(i).length());
77      word = string_text.substr(word_offset, word_length);
78      if (word == misspelled_words_.at(i) &&
79          (static_cast<int>(string_text.length()) ==
80               word_offset + word_length ||
81           IsNotASCIIAlpha(string_text[word_offset + word_length]))) {
82        *misspelled_offset = word_offset + skipped_length;
83        *misspelled_length = word_length;
84        break;
85      }
86    }
87
88    if (*misspelled_length > 0)
89      break;
90
91    base::string16::iterator last_char = std::find_if(
92        string_text.begin() + word_offset, string_text.end(), IsNotASCIIAlpha);
93    if (last_char == string_text.end())
94      word_length = static_cast<int>(string_text.length()) - word_offset;
95    else
96      word_length = std::distance(first_char, last_char);
97
98    DCHECK_LT(0, word_offset + word_length);
99    string_text = string_text.substr(word_offset + word_length);
100    skipped_length += word_offset + word_length;
101  }
102
103  return false;
104}
105
106bool MockSpellCheck::HasInCache(const blink::WebString& word) {
107  return word == blink::WebString::fromUTF8("Spell wellcome. Is it broken?") ||
108         word == blink::WebString::fromUTF8("Spell wellcome.\x007F");
109}
110
111bool MockSpellCheck::IsMultiWordMisspelling(
112    const blink::WebString& text,
113    std::vector<blink::WebTextCheckingResult>* results) {
114  if (text == blink::WebString::fromUTF8("Helllo wordl.")) {
115    results->push_back(blink::WebTextCheckingResult(
116        blink::WebTextDecorationTypeSpelling, 0, 6, blink::WebString("Hello")));
117    results->push_back(blink::WebTextCheckingResult(
118        blink::WebTextDecorationTypeSpelling, 7, 5, blink::WebString("world")));
119    return true;
120  }
121  return false;
122}
123
124void MockSpellCheck::FillSuggestionList(
125    const blink::WebString& word,
126    blink::WebVector<blink::WebString>* suggestions) {
127  if (word == blink::WebString::fromUTF8("wellcome"))
128    Append(suggestions, blink::WebString::fromUTF8("welcome"));
129  else if (word == blink::WebString::fromUTF8("upper case"))
130    Append(suggestions, blink::WebString::fromUTF8("uppercase"));
131  else if (word == blink::WebString::fromUTF8("Helllo"))
132    Append(suggestions, blink::WebString::fromUTF8("Hello"));
133  else if (word == blink::WebString::fromUTF8("wordl"))
134    Append(suggestions, blink::WebString::fromUTF8("world"));
135}
136
137bool MockSpellCheck::InitializeIfNeeded() {
138  // Exit if we have already initialized this object.
139  if (initialized_)
140    return false;
141
142  // Create a table that consists of misspelled words used in WebKit layout
143  // tests.
144  // Since WebKit layout tests don't have so many misspelled words as
145  // well-spelled words, it is easier to compare the given word with misspelled
146  // ones than to compare with well-spelled ones.
147  static const char* misspelled_words[] = {
148      // These words are known misspelled words in webkit tests.
149      // If there are other misspelled words in webkit tests, please add them in
150      // this array.
151      "foo",    "Foo",           "baz",             "fo",         "LibertyF",
152      "chello", "xxxtestxxx",    "XXxxx",           "Textx",      "blockquoted",
153      "asd",    "Lorem",         "Nunc",            "Curabitur",  "eu",
154      "adlj",   "adaasj",        "sdklj",           "jlkds",      "jsaada",
155      "jlda",   "zz",            "contentEditable",
156      // The following words are used by unit tests.
157      "ifmmp",  "qwertyuiopasd", "qwertyuiopasdf",  "upper case", "wellcome"};
158
159  misspelled_words_.clear();
160  for (size_t i = 0; i < arraysize(misspelled_words); ++i)
161    misspelled_words_.push_back(
162        base::string16(misspelled_words[i],
163                       misspelled_words[i] + strlen(misspelled_words[i])));
164
165  // Mark as initialized to prevent this object from being initialized twice
166  // or more.
167  initialized_ = true;
168
169  // Since this MockSpellCheck class doesn't download dictionaries, this
170  // function always returns false.
171  return false;
172}
173
174}  // namespace content
175