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/EditingUtilities.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 {
+
+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().Build());
+  UChar next_character = next_character_str[0];
+  // Character immediately following the range is not a space
+  if (next_character != kSpaceCharacter &&
+      next_character != kNoBreakSpaceCharacter)
+    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().Build());
+  // Return true if the character immediately before the range is a space, false
+  // otherwise
+  UChar prev_character = prev_character_str[0];
+  return prev_character == kSpaceCharacter ||
+         prev_character == kNoBreakSpaceCharacter;
+}
+
+}  // 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();
+}
+
+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));
+
+  Document& current_document = *GetFrame().GetDocument();
+
+  GetFrame().Selection().SetSelection(
+      SelectionInDOMTree::Builder().SetBaseAndExtent(range_to_delete).Build());
+
+  // FrameSelection::SetSelection() may destroy the frame.
+  if (current_document != GetFrame().GetDocument())
+    return;
+
+  // Dispatch 'beforeinput'.
+  Element* const target = GetFrame().GetEditor().FindEventTargetFromSelection();
+  DataTransfer* const data_transfer = DataTransfer::Create(
+      DataTransfer::DataTransferType::kInsertReplacementText,
+      DataTransferAccessPolicy::kDataTransferReadable,
+      DataObject::CreateFromString(""));
+
+  const bool cancel = DispatchBeforeInputDataTransfer(
+                          target, InputEvent::InputType::kInsertReplacementText,
+                          data_transfer) != DispatchEventResult::kNotCanceled;
+
+  // 'beforeinput' event handler may destroy target frame.
+  if (current_document != GetFrame().GetDocument())
+    return;
+
+  // TODO(editing-dev): The use of updateStyleAndLayoutIgnorePendingStylesheets
+  // needs to be audited.  See http://crbug.com/590369 for more details.
+  GetFrame().GetDocument()->UpdateStyleAndLayoutIgnorePendingStylesheets();
+
+  if (cancel)
+    return;
+  GetFrame().GetEditor().ReplaceSelectionWithText(
+      "", false, false, InputEvent::InputType::kInsertReplacementText);
+
+  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;
+
+  const EphemeralRange marker_range =
+      EphemeralRange(Position(container_node, marker->StartOffset()),
+                     Position(container_node, marker->EndOffset()));
+  const String& misspelled_word = PlainText(marker_range);
+  const String& description = marker->Description();
+
+  suggestion_menu_is_open_ = true;
+  GetFrame().Selection().SetCaretVisible(false);
+  GetDocument().Markers().AddActiveSuggestionMarker(
+      marker_range, SK_ColorTRANSPARENT, StyleableMarker::Thickness::kThin,
+      LayoutTheme::GetTheme().PlatformActiveSpellingMarkerHighlightColor());
+
+  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() {
+  if (!frame_)

[Xiaocheng, 2017/06/14 00:44:38]

This doesn't work because |frame_| won't be set to nullptr when document is
detached.

How about making TextSuggestionController a SynchronousMutationObserver, so that
we can check document availability by checking SMO::LifecycleContext()?

[yosin_UTC9, 2017/06/14 01:17:04]

It is good idea to observe Document shutdown as SMO. However, SMO is performance
sensitive since SMO is called during Node#appendChild() and removeChild().
It is better to introduce DocumentShutdown{Observer,Notifier}. Note: We can't
make SMO to be derived from DocumentShutdownObserver because we can't share
observer list in DocumentShutdownNotifier and SynchronousMutationNotifier.

+    return;
+
+  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