Revert of Handle typographical apostrophe with spelling service client

chrome/renderer/spellchecker/spellcheck_unittest.cc

 // Copyright (c) 2012 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 "chrome/renderer/spellchecker/spellcheck.h"
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/common/spellcheck_common.h"
 #include "chrome/common/spellcheck_result.h"
 #include "chrome/renderer/spellchecker/hunspell_engine.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebTextCheckingCompletion.h"
 #include "third_party/WebKit/public/web/WebTextCheckingResult.h"
 
-#define TYPOGRAPHICAL_APOSTROPHE L"\x2019"
-
 namespace {
 
 base::FilePath GetHunspellDirectory() {
   base::FilePath hunspell_directory;
   if (!PathService::Get(base::DIR_SOURCE_ROOT, &hunspell_directory))
     return base::FilePath();
 
   hunspell_directory = hunspell_directory.AppendASCII("third_party");
   hunspell_directory = hunspell_directory.AppendASCII("hunspell_dictionaries");
   return hunspell_directory;
@@ skipping 43 matching lines @@
 
   ~SpellCheckTest() override {}
 
   SpellCheck* spell_check() { return spell_check_.get(); }
 
   bool CheckSpelling(const std::string& word, int tag) {
     return spell_check_->spellcheck_.platform_spelling_engine_->CheckSpelling(
         base::ASCIIToUTF16(word), tag);
   }
 
-  bool IsValidContraction(const base::string16& word, int tag) {
-    return spell_check_->spellcheck_.IsValidContraction(word, tag);
-  }
-
 #if !defined(OS_MACOSX)
  protected:
   void TestSpellCheckParagraph(
       const base::string16& input,
       const std::vector<SpellCheckResult>& expected) {
     blink::WebVector<blink::WebTextCheckingResult> results;
     spell_check()->SpellCheckParagraph(input,
                                        &results);
 
     EXPECT_EQ(results.size(), expected.size());
@@ skipping 101 matching lines @@
     // Two valid Greek words (meaning "hello") consisting of seven Greek
     // letters
     {L"\x03B3\x03B5\x03B9\x03AC" L" " L"\x03C3\x03BF\x03C5", true},
     // A valid Russian word (meaning "hello") consisting of twelve Cyrillic
     // letters
     {L"\x0437\x0434\x0440\x0430\x0432\x0441"
      L"\x0442\x0432\x0443\x0439\x0442\x0435", true},
     // A valid English contraction
     {L"isn't", true},
     // A valid English contraction with a typographical apostrophe.
-    {L"isn" TYPOGRAPHICAL_APOSTROPHE L"t", true},
+    {L"isn\x2019t", true},
     // A valid English word enclosed with underscores.
     {L"_hello_", true},
 
     // A valid English word with a preceding whitespace
     {L" " L"hello", true},
     // A valid English word with a preceding no-break space
     {L"\xA0" L"hello", true},
     // A valid English word with a preceding ideographic space
     {L"\x3000" L"hello", true},
     // A valid English word with a preceding Chinese word
@@ skipping 918 matching lines @@
     base::string16 text = base::ASCIIToUTF16("zz");
     std::vector<SpellCheckResult> spellcheck_results;
     spellcheck_results.push_back(SpellCheckResult(
         SpellCheckResult::SPELLING, 0, 2, base::string16()));
     blink::WebVector<blink::WebTextCheckingResult> textcheck_results;
     spell_check()->CreateTextCheckingResults(SpellCheck::USE_NATIVE_CHECKER,
                                              0,
                                              text,
                                              spellcheck_results,
                                              &textcheck_results);
-    ASSERT_EQ(spellcheck_results.size(), textcheck_results.size());
+    EXPECT_EQ(spellcheck_results.size(), textcheck_results.size());
     EXPECT_EQ(blink::WebTextDecorationTypeSpelling,
               textcheck_results[0].decoration);
     EXPECT_EQ(spellcheck_results[0].location, textcheck_results[0].location);
     EXPECT_EQ(spellcheck_results[0].length, textcheck_results[0].length);
   }
 
   // Verify that the SpellCheck class replaces the spelling marker added to a
   // contextually-misspelled word "bean" with a grammar marker.
   {
     base::string16 text = base::ASCIIToUTF16("I have bean to USA.");
     std::vector<SpellCheckResult> spellcheck_results;
     spellcheck_results.push_back(SpellCheckResult(
         SpellCheckResult::SPELLING, 7, 4, base::string16()));
     blink::WebVector<blink::WebTextCheckingResult> textcheck_results;
     spell_check()->CreateTextCheckingResults(SpellCheck::USE_NATIVE_CHECKER,
                                              0,
                                              text,
                                              spellcheck_results,
                                              &textcheck_results);
-    ASSERT_EQ(spellcheck_results.size(), textcheck_results.size());
+    EXPECT_EQ(spellcheck_results.size(), textcheck_results.size());
     EXPECT_EQ(blink::WebTextDecorationTypeGrammar,
               textcheck_results[0].decoration);
     EXPECT_EQ(spellcheck_results[0].location, textcheck_results[0].location);
     EXPECT_EQ(spellcheck_results[0].length, textcheck_results[0].length);
   }
-
-  // Verify that the SpellCheck preserves the original apostrophe type in the
-  // checked text, regardless of the type of apostrophe the browser returns.
-  {
-    base::string16 text = base::WideToUTF16(
-        L"Ik've havn" TYPOGRAPHICAL_APOSTROPHE L"t ni'n"
-        TYPOGRAPHICAL_APOSTROPHE L"out-s I've I" TYPOGRAPHICAL_APOSTROPHE
-        L"ve");
-    std::vector<SpellCheckResult> spellcheck_results;
-
-    // All typewriter apostrophe results.
-    spellcheck_results.push_back(SpellCheckResult(
-        SpellCheckResult::SPELLING, 0, 5, base::UTF8ToUTF16("I've")));
-    spellcheck_results.push_back(SpellCheckResult(
-        SpellCheckResult::SPELLING, 6, 6, base::UTF8ToUTF16("haven't")));
-    spellcheck_results.push_back(SpellCheckResult(
-        SpellCheckResult::SPELLING, 13, 10, base::UTF8ToUTF16("in'n'out's")));
-
-    // Replacements that differ only by apostrophe type should be ignored.
-    spellcheck_results.push_back(SpellCheckResult(
-        SpellCheckResult::SPELLING, 24, 4, base::UTF8ToUTF16("I've")));
-    spellcheck_results.push_back(SpellCheckResult(
-        SpellCheckResult::SPELLING, 29, 4, base::UTF8ToUTF16("I've")));
-
-    // All typographical apostrophe results.
-    spellcheck_results.push_back(SpellCheckResult(
-        SpellCheckResult::SPELLING, 0, 5,
-        base::WideToUTF16(L"I" TYPOGRAPHICAL_APOSTROPHE L"ve")));
-    spellcheck_results.push_back(SpellCheckResult(
-        SpellCheckResult::SPELLING, 6, 6,
-        base::WideToUTF16(L"haven" TYPOGRAPHICAL_APOSTROPHE L"t")));
-    spellcheck_results.push_back(SpellCheckResult(
-        SpellCheckResult::SPELLING, 13, 10, base::WideToUTF16(
-            L"in" TYPOGRAPHICAL_APOSTROPHE L"n" TYPOGRAPHICAL_APOSTROPHE L"out"
-            TYPOGRAPHICAL_APOSTROPHE L"s")));
-
-    // Replacements that differ only by apostrophe type should be ignored.
-    spellcheck_results.push_back(SpellCheckResult(
-        SpellCheckResult::SPELLING, 24, 4,
-        base::WideToUTF16(L"I" TYPOGRAPHICAL_APOSTROPHE L"ve")));
-    spellcheck_results.push_back(SpellCheckResult(
-        SpellCheckResult::SPELLING, 29, 4,
-        base::WideToUTF16(L"I" TYPOGRAPHICAL_APOSTROPHE L"ve")));
-
-    blink::WebVector<blink::WebTextCheckingResult> textcheck_results;
-    spell_check()->CreateTextCheckingResults(SpellCheck::USE_NATIVE_CHECKER, 0,
-                                             text, spellcheck_results,
-                                             &textcheck_results);
-
-    static const wchar_t* kExpectedReplacements[] = {
-        L"I've",
-        L"haven" TYPOGRAPHICAL_APOSTROPHE L"t",
-        L"in'n" TYPOGRAPHICAL_APOSTROPHE L"out's",
-        L"I've",
-        L"haven" TYPOGRAPHICAL_APOSTROPHE L"t",
-        L"in'n" TYPOGRAPHICAL_APOSTROPHE L"out" TYPOGRAPHICAL_APOSTROPHE L"s",
-    };
-
-    ASSERT_EQ(arraysize(kExpectedReplacements), textcheck_results.size());
-    for (size_t i = 0; i < arraysize(kExpectedReplacements); ++i) {
-      EXPECT_EQ(base::WideToUTF16(kExpectedReplacements[i]),
-                textcheck_results[i].replacement)
-          << "i=" << i << "\nactual: \""
-          << base::string16(textcheck_results[i].replacement) << "\"";
-    }
-  }
 }
 
 #endif
 
 // Checks some words that should be present in all English dictionaries.
 TEST_F(SpellCheckTest, EnglishWords) {
   static const struct {
     const char* input;
     bool should_pass;
   } kTestCases[] = {
@@ skipping 187 matching lines @@
         strlen(kTestCases[i].misspelled),
         0,
         &misspelling_start,
         &misspelling_length,
         &suggestions));
     EXPECT_GE(suggestions.size(), static_cast<size_t>(1));
     if (suggestions.size() > 0)
       EXPECT_EQ(suggestions[0], base::ASCIIToUTF16(kTestCases[i].suggestion));
   }
 }
-
-// Words with apostrophes should be valid contractions.
-TEST_F(SpellCheckTest, IsValidContraction) {
-  static const char* kLanguages[] = {
-    "en-AU",
-    "en-CA",
-    "en-GB",
-    "en-US",
-  };
-
-  static const wchar_t* kWords[] = {
-    L"in'n'out",
-    L"in" TYPOGRAPHICAL_APOSTROPHE L"n" TYPOGRAPHICAL_APOSTROPHE L"out",
-  };
-
-  for (size_t i = 0; i < arraysize(kLanguages); ++i) {
-    ReinitializeSpellCheck(kLanguages[i]);
-    for (size_t j = 0; j < arraysize(kWords); ++j)
-      EXPECT_TRUE(IsValidContraction(base::WideToUTF16(kWords[j]), 0));
-  }
-}