Home | History | Annotate | Download | only in test_runner 
      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
    175