test_runner: Migrate MockSpellCheck to Chromium C++ style.

content/shell/renderer/test_runner/mock_spell_check.cc

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