Migrate TestCommon to Chromium c++ style and remove un-used header.

content/shell/renderer/test_runner/mock_spell_check.cc

 // Copyright 2014 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 "content/shell/renderer/test_runner/test_common.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)
@@ skipping 30 matching lines @@
 
   while (!string_text.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 first_char =
-        std::find_if(string_text.begin(), string_text.end(), isASCIIAlpha);
+        std::find_if(string_text.begin(), string_text.end(), IsASCIIAlpha);
     if (first_char == string_text.end())
       return true;
     int word_offset = std::distance(string_text.begin(), first_char);
     int max_word_length = static_cast<int>(string_text.length()) - word_offset;
     int word_length;
     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) {
       word_length =
           static_cast<int>(misspelled_words_.at(i).length()) > max_word_length
               ? max_word_length
               : static_cast<int>(misspelled_words_.at(i).length());
       word = string_text.substr(word_offset, word_length);
       if (word == misspelled_words_.at(i) &&
           (static_cast<int>(string_text.length()) ==
                word_offset + word_length ||
-           isNotASCIIAlpha(string_text[word_offset + word_length]))) {
+           IsNotASCIIAlpha(string_text[word_offset + word_length]))) {
         *misspelled_offset = word_offset + skipped_length;
         *misspelled_length = word_length;
         break;
       }
     }
 
     if (*misspelled_length > 0)
       break;
 
     base::string16::iterator last_char = std::find_if(
-        string_text.begin() + word_offset, string_text.end(), isNotASCIIAlpha);
+        string_text.begin() + word_offset, string_text.end(), IsNotASCIIAlpha);
     if (last_char == string_text.end())
       word_length = static_cast<int>(string_text.length()) - word_offset;
     else
       word_length = std::distance(first_char, last_char);
 
     DCHECK_LT(0, word_offset + word_length);
     string_text = string_text.substr(word_offset + word_length);
     skipped_length += word_offset + word_length;
   }
 
@@ skipping 62 matching lines @@
   // 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