Add support for Android spellcheck menu in Chrome/WebViews

third_party/WebKit/Source/core/editing/suggestion/TextSuggestionController.cpp

+// Copyright 2017 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 "core/editing/suggestion/TextSuggestionController.h"
+
+#include "core/editing/Editor.h"
+#include "core/editing/FrameSelection.h"
+#include "core/editing/PlainTextRange.h"
+#include "core/editing/markers/DocumentMarkerController.h"
+#include "core/editing/markers/SpellCheckMarker.h"
+#include "core/editing/spellcheck/SpellChecker.h"
+#include "core/frame/FrameView.h"
+#include "core/frame/LocalFrame.h"
+#include "public/platform/InterfaceProvider.h"
+
+namespace blink {
+
+namespace {
+
+const double kSuggestionUnderlineAlphaMultiplier = 0.4;
+
+}  // anonymous namespace
+
+TextSuggestionController::TextSuggestionController(LocalFrame& frame)
+    : suggestion_menu_is_open_(false), frame_(&frame) {}
+
+bool TextSuggestionController::IsMenuOpen() const {
+  return suggestion_menu_is_open_;
+}
+
+void TextSuggestionController::HandlePotentialMisspelledWordTap() {
+  Optional<std::pair<Node*, SpellCheckMarker*>> node_and_marker =
+      GetFrame().GetSpellChecker().GetSpellCheckMarkerTouchingSelection();
+  if (!node_and_marker)
+    return;
+
+  if (!text_suggestion_host_) {
+    GetFrame().GetInterfaceProvider()->GetInterface(
+        mojo::MakeRequest(&text_suggestion_host_));
+  }
+
+  text_suggestion_host_->StartSpellCheckMenuTimer();
+}
+
+DEFINE_TRACE(TextSuggestionController) {
+  visitor->Trace(frame_);
+}
+
+void TextSuggestionController::ApplySpellCheckSuggestion(
+    const String& suggestion) {
+  GetFrame().GetSpellChecker().ReplaceMisspelledRange(suggestion);
+  SuggestionMenuClosed();
+}
+
+namespace {
+
+bool ShouldDeleteNextCharacter(const Node* marker_text_node,
+                               const DocumentMarker* marker) {
+  // If the character immediately following the range to be deleted is a space,
+  // delete it if either of these conditions holds:
+  // - We're deleting at the beginning of the editable text (to avoid ending up
+  //   with a space at the beginning)
+  // - The character immediately before the range being deleted is also a space
+  //   (to avoid ending up with two adjacent spaces)
+  const EphemeralRange next_character_range =
+      PlainTextRange(marker->EndOffset(), marker->EndOffset() + 1)
+          .CreateRange(*marker_text_node->parentNode());
+  // No character immediately following the range (so it can't be a space)
+  if (next_character_range.IsNull())
+    return false;
+
+  const String next_character_str = PlainText(
+      next_character_range,
+      TextIteratorBehavior::Builder().SetEmitsSpaceForNbsp(true).Build());
+  // Character immediately following the range is not a space
+  if (!WTF::IsASCIISpace(next_character_str[0]))
+    return false;
+
+  // First case: we're deleting at the beginning of the editable text
+  if (marker->StartOffset() == 0)
+    return true;
+
+  const EphemeralRange prev_character_range =
+      PlainTextRange(marker->StartOffset() - 1, marker->StartOffset())
+          .CreateRange(*marker_text_node->parentNode());
+  // Not at beginning, but there's no character immediately before the range
+  // being deleted (so it can't be a space)
+  if (prev_character_range.IsNull())
+    return false;
+
+  const String prev_character_str = PlainText(
+      prev_character_range,
+      TextIteratorBehavior::Builder().SetEmitsSpaceForNbsp(true).Build());
+  // Return true if the character immediately before the range is space, false
+  // otherwise
+  return WTF::IsASCIISpace(prev_character_str[0]);
+}
+
+}  // namespace
+
+void TextSuggestionController::DeleteActiveSuggestionRange() {
+  Optional<std::pair<Node*, SpellCheckMarker*>> node_and_marker =
+      GetFrame().GetSpellChecker().GetSpellCheckMarkerTouchingSelection();
+  if (!node_and_marker)
+    return;
+
+  Node* const marker_text_node = node_and_marker.value().first;
+  const DocumentMarker* const marker = node_and_marker.value().second;
+
+  const bool delete_next_char =
+      ShouldDeleteNextCharacter(marker_text_node, marker);
+
+  const EphemeralRange range_to_delete = EphemeralRange(
+      Position(marker_text_node, marker->StartOffset()),
+      Position(marker_text_node, marker->EndOffset() + delete_next_char));
+
+  GetFrame().Selection().SetSelection(
+      SelectionInDOMTree::Builder().SetBaseAndExtent(range_to_delete).Build());
+
+  GetFrame().GetEditor().ReplaceSelectionWithText(
+      "", false, false, InputEvent::InputType::kDeleteByComposition);

[yosin_UTC9, 2017/06/08 01:50:09]

Can we use DeleteSelectionCommand instead of ReplaceSelectionWithText?

Do we really need to introduce "deleteByComposition" which we don't want to
introduce[1].

Is it better to use "deleteContent" or "insertReplacementText" as spellchecker?
+chongz@ to discuss about "InputType"


[1] http://crbug.com/652397 ⚐	InputEvent: Support 4 IME related events

[chongz, 2017/06/08 15:49:16]

JS can always figure it out from the empty |data| field.
IMO we should use "insertReplacementText" here as it carries more information
about request source, but you can argue that this is a standalone feature
(separated from spellchecker) and should use "deleteContent".
(assuming we are not talking about IME).

We use "insertReplacementText" for UA/spellchecker initiated requests (e.g. User
didn't type these characters), e.g.
1. Chrome desktop's spellchecker in Context Menu
2. Safari's auto-correction (e.g. Safari will replace 'helo' with 'help'
automatically)
3. Other Context Menu actions such as Substitution, Make Upper Case, etc.
And Web Apps can disable or do something different to these kind of requests.

On the other side "deleteContent" was introduced to cover deletions that cannot
be classified elsewhere, e.g.
1. macOS "Menu Bar Edit -> Delete": It has no direction/granularity, not from a
spellchecker, and user directly issued 'delete' command.

We shouldn't use "deleteByComposition" as it has special usage for IME
re-composition.

[rlanday, 2017/06/08 18:35:41]

Do you want me to use DeleteSelectionCommand directly or to call
Editor::DeleteWithDirection()/DeleteSelectionWithSmartDelete()? Looking at where
DeleteSelectionCommand is currently created, it seems odd to use it directly.

+
+  SuggestionMenuClosed();
+}
+
+void TextSuggestionController::NewWordAddedToDictionary(const String& word) {
+  // Android pops up a dialog to let the user confirm they actually want to add
+  // the word to the dictionary; this method gets called as soon as the dialog
+  // is shown. So the word isn't actually in the dictionary here, even if the
+  // user will end up confirming the dialog, and we shouldn't try to re-run
+  // spellcheck here.
+
+  // Note: this actually matches the behavior in native Android text boxes
+  GetDocument().Markers().RemoveSpellingMarkersUnderWords(
+      Vector<String>({word}));
+  SuggestionMenuClosed();
+}
+
+void TextSuggestionController::SpellCheckMenuTimeoutCallback() {
+  Optional<std::pair<Node*, SpellCheckMarker*>> const node_and_marker =
+      GetFrame().GetSpellChecker().GetSpellCheckMarkerTouchingSelection();
+  if (!node_and_marker)
+    return;
+
+  Node* const container_node = node_and_marker.value().first;
+  SpellCheckMarker* const marker = node_and_marker.value().second;
+
+  Range* marker_range =
+      Range::Create(GetDocument(), container_node, marker->StartOffset(),
+                    container_node, marker->EndOffset());
+
+  const String& misspelled_word = marker_range->GetText();

[yosin_UTC9, 2017/06/08 05:06:50]

Please use PlaintText() instead of using temporary Range.

+  const String& description = marker->Description();
+
+  suggestion_menu_is_open_ = true;
+  GetFrame().Selection().SetCaretVisible(false);
+  GetDocument().Markers().AddActiveSuggestionMarker(
+      EphemeralRange(marker_range), SK_ColorTRANSPARENT,
+      StyleableMarker::Thickness::kThin,
+      Color(SK_ColorRED).CombineWithAlpha(kSuggestionUnderlineAlphaMultiplier));

[yosin_UTC9, 2017/06/08 01:50:09]

Could you move color of marker to InlineTextBoxPainter.cpp, see RecordMarker?

We should take these colors from "::spelling-error"[1] or "::grammar-error"[1]
and
taking default value from LayoutTheme, e.g.
LayoutObject::SelectionBackgroundColor()
which uses LayoutTheme::GetTheme().ActiveSelectionBackgroundColor().

"core/editing" isn't a good place to specify colors.


sk_sp<PaintRecord> RecordMarker(DocumentMarker::MarkerType marker_type) {
  SkColor color = (marker_type == DocumentMarker::kGrammar)
                      ? SkColorSetRGB(0x6B, 0x6B, 0x6B)
                      : SkColorSetRGB(0xFB, 0x2D, 0x1D);


[1] https://drafts.csswg.org/css-pseudo/#highlight-selectors

+
+  Vector<String> suggestions;
+  description.Split('\n', suggestions);
+
+  Vector<mojom::blink::SpellCheckSuggestionPtr> suggestion_ptrs;
+  for (const String& suggestion : suggestions) {
+    mojom::blink::SpellCheckSuggestionPtr info_ptr(
+        mojom::blink::SpellCheckSuggestion::New());
+    info_ptr->suggestion = suggestion;
+    suggestion_ptrs.push_back(std::move(info_ptr));
+  }
+
+  const IntRect& absolute_bounds = GetFrame().Selection().AbsoluteCaretBounds();
+  const IntRect& viewport_bounds =
+      GetFrame().View()->ContentsToViewport(absolute_bounds);
+
+  text_suggestion_host_->ShowSpellCheckSuggestionMenu(
+      viewport_bounds.X(), viewport_bounds.MaxY(), std::move(misspelled_word),
+      std::move(suggestion_ptrs));
+}
+
+void TextSuggestionController::SuggestionMenuClosed() {
+  GetDocument().Markers().RemoveMarkersOfTypes(
+      DocumentMarker::kActiveSuggestion);
+  GetFrame().Selection().SetCaretVisible(true);
+  suggestion_menu_is_open_ = false;
+}
+
+Document& TextSuggestionController::GetDocument() const {
+  DCHECK(IsAvailable());
+  return *GetFrame().GetDocument();
+}
+
+bool TextSuggestionController::IsAvailable() const {
+  return GetFrame().GetDocument();
+}
+
+}  // namespace blink