Handle typographical apostrophe with spelling service client

chrome/renderer/spellchecker/spellcheck.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 <algorithm>
+
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/spellcheck_common.h"
 #include "chrome/common/spellcheck_messages.h"
 #include "chrome/common/spellcheck_result.h"
 #include "chrome/renderer/spellchecker/spellcheck_language.h"
 #include "chrome/renderer/spellchecker/spellcheck_provider.h"
 #include "content/public/renderer/render_thread.h"
@@ skipping 369 matching lines @@
   const base::char16* text = line_text.c_str();
   std::vector<WebTextCheckingResult> list;
   for (size_t i = 0; i < spellcheck_results.size(); ++i) {
     SpellCheckResult::Decoration decoration = spellcheck_results[i].decoration;
     int word_location = spellcheck_results[i].location;
     int word_length = spellcheck_results[i].length;
     int misspelling_start = 0;
     int misspelling_length = 0;
     if (decoration == SpellCheckResult::SPELLING &&
         filter == USE_NATIVE_CHECKER) {
+      // Ignore typographical apostrophe misspellings.

[groby-ooo-7-16, 2015/04/20 21:02:22]

Eeew. Are all languages handling typographic apostrophes the same?

[please use gerrit instead, 2015/04/20 23:05:31]

SpellcheckWordIterator says it's using ICU for word iteration, so that's out of
our hands, as far as I understand.

[please use gerrit instead, 2015/04/20 23:40:17]

By the way, we can remove this hack once the server treats typographical
apostrophes correctly. I've filed a bug for that.

+      static const base::char16 kTypographicalApostrophe = 0x2019;
+      static const base::char16 kTypewriterApostrophe = 0x0027;
+      if (line_text.find(kTypographicalApostrophe, word_location) <
+          static_cast<size_t>(word_location + word_length)) {
+        base::string16 no_typographical_apostrophe(line_text, word_location,
+                                                   word_length);
+        std::replace(no_typographical_apostrophe.begin(),
+                     no_typographical_apostrophe.end(),
+                     kTypographicalApostrophe, kTypewriterApostrophe);
+        if (no_typographical_apostrophe == spellcheck_results[i].replacement)
+          continue;
+      }
+
       if (SpellCheckWord(text + word_location, word_length, 0,
                          &misspelling_start, &misspelling_length, NULL)) {
         decoration = SpellCheckResult::GRAMMAR;
       }
     }
+
     if (!custom_dictionary_.SpellCheckWord(
             line_text, word_location, word_length)) {
       list.push_back(WebTextCheckingResult(
           static_cast<WebTextDecorationType>(decoration),
           word_location + line_offset,
           word_length,
           spellcheck_results[i].replacement,
           spellcheck_results[i].hash));
     }
   }
   textcheck_results->assign(list);
 }