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\x2019t", true},
+    {L"isn" TYPOGRAPHICAL_APOSTROPHE L"t", 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);
-    EXPECT_EQ(spellcheck_results.size(), textcheck_results.size());
+    ASSERT_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);
-    EXPECT_EQ(spellcheck_results.size(), textcheck_results.size());
+    ASSERT_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));
+  }
+}