src/content/shell/renderer/test_runner/mock_spell_check.cc

   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
  11 namespace content {
  12
  13 namespace {
  14
  15 void 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
  26 MockSpellCheck::MockSpellCheck() : initialized_(false) {
  27 }
  28
  29 MockSpellCheck::~MockSpellCheck() {
  30 }
  31
  32 bool 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
 106 bool 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
 111 bool 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
 124 void 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
 137 bool 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