Algorithm for deciding if a frame's selection should be hidden

third_party/WebKit/Source/core/editing/FrameSelection.cpp

 /*
  * Copyright (C) 2004, 2008, 2009, 2010 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 232 matching lines @@
     // "FocusIn", |m_frame| may associate to another document.
     if (!IsAvailable() || GetDocument() != current_document) {
       // Once we get test case to reach here, we should change this
       // if-statement to |DCHECK()|.
       NOTREACHED();
       return;
     }
   }
 
   frame_caret_->StopCaretBlinkTimer();
-  UpdateAppearance(LayoutSelection::PaintHint::kPaint);
+  UpdateAppearance();
 
   // Always clear the x position used for vertical arrow navigation.
   // It will be restored by the vertical arrow navigation code if necessary.
   x_pos_for_vertical_arrow_navigation_ = NoXPosForVerticalArrowNavigation();
 
   // TODO(yosin): Can we move this to at end of this function?
   // This may dispatch a synchronous focus-related events.
   if (!(options & kDoNotSetFocus)) {
     SelectFrameElementInParentIfFullySelected();
     if (!IsAvailable() || GetDocument() != current_document) {
@@ skipping 64 matching lines @@
   // TODO(yosin): We should move to call |TypingCommand::closeTyping()| to
   // |Editor| class.
   if (!GetDocument().IsRunningExecCommand())
     TypingCommand::CloseTyping(frame_);
 }
 
 void FrameSelection::DidChangeFocus() {
   // Hits in
   // virtual/gpu/compositedscrolling/scrollbars/scrollbar-miss-mousemove-disabled.html
   DisableCompositingQueryAsserts disabler;
-
-  // No focused element means document root has focus.
-  const Element* const focus = GetDocument().FocusedElement()
-                                   ? GetDocument().FocusedElement()
-                                   : GetDocument().documentElement();
-
-  // Protection against LayoutTests/editing/selection/selection-crash.html
-  if (!focus) {
-    frame_caret_->ScheduleVisualUpdateForPaintInvalidationIfNeeded();
-    text_control_focused_ = false;
-    return;
-  }
-
-  // Hide the selection when focus goes away from a text-field and into
-  // something that is not a text-field. When focus enters another text-field we
-  // do not need to update appearance; the appearance is updated when the new
-  // selection is set.
-  if (text_control_focused_ && !focus->IsTextControl())
-    UpdateAppearance(LayoutSelection::PaintHint::kHide);
-  text_control_focused_ = focus->IsTextControl();
+  UpdateAppearance();
 }
 
 static DispatchEventResult DispatchSelectStart(
     const VisibleSelection& selection) {
   Node* select_start_target = selection.Extent().ComputeContainerNode();
   if (!select_start_target)
     return DispatchEventResult::kNotCanceled;
 
   return select_start_target->DispatchEvent(
       Event::CreateCancelableBubble(EventTypeNames::selectstart));
@@ skipping 69 matching lines @@
   return true;
 }
 
 void FrameSelection::Clear() {
   granularity_ = kCharacterGranularity;
   if (granularity_strategy_)
     granularity_strategy_->Clear();
   SetSelection(SelectionInDOMTree());
 }
 
+bool FrameSelection::SelectionHasFocus() const {
+  // TODO(editing-dev): Hoist updateStyleAndLayoutIgnorePendingStylesheets

[Xiaocheng, 2017/05/09 18:18:15]

nit: s/update/Update/

+  // to caller. See http://crbug.com/590369 for more details.
+  GetDocument().UpdateStyleAndLayoutIgnorePendingStylesheets();
+  const Node* current =
+      ComputeVisibleSelectionInDOMTree().Start().ComputeContainerNode();
+  if (!current)
+    return false;
+
+  // No focused element means document root has focus.
+  const Element* const focused_element = GetDocument().FocusedElement()
+                                             ? GetDocument().FocusedElement()
+                                             : GetDocument().documentElement();
+  if (!focused_element)
+    return false;
+
+  if (focused_element->IsTextControl())
+    return focused_element->ContainsIncludingHostElements(*current);
+
+  bool has_editable_style = HasEditableStyle(*current);
+  do {
+    // If the selection is within an editable sub tree and that sub tree
+    // doesn't have focus, the selection doesn't have focus either.
+    if (has_editable_style && !HasEditableStyle(*current))
+      return false;
+
+    // Selection has focus if its sub tree has focus.
+    if (current == focused_element)
+      return true;
+    current = current->ParentOrShadowHostNode();
+  } while (current);
+
+  return false;
+}
+
+bool FrameSelection::IsHidden() const {
+  if (SelectionHasFocus())
+    return false;
+
+  const Node* start =
+      ComputeVisibleSelectionInDOMTree().Start().ComputeContainerNode();
+  if (!start)
+    return true;
+
+  // The selection doesn't have focus, so hide everything but range selections.
+  if (!GetSelectionInDOMTree().IsRange())
+    return true;
+
+  // Here we know we have an unfocused range selection. Let's say that
+  // selection resides inside a text control. Since the selection doesn't have
+  // focus neither does the text control. Meaning, if the selection indeed
+  // resides inside a text control, it should be hidden.
+  return EnclosingTextControl(start);
+}
+
 void FrameSelection::DocumentAttached(Document* document) {
   DCHECK(document);
   use_secure_keyboard_entry_when_active_ = false;
   selection_editor_->DocumentAttached(document);
   SetContext(document);
 }
 
 void FrameSelection::ContextDestroyed(Document* document) {
   granularity_ = kCharacterGranularity;
 
@@ skipping 331 matching lines @@
 
 bool FrameSelection::NeedsLayoutSelectionUpdate() const {
   return layout_selection_->HasPendingSelection();
 }
 
 void FrameSelection::CommitAppearanceIfNeeded() {
   return layout_selection_->Commit();
 }
 
 void FrameSelection::DidLayout() {
-  // Upon relayout, a hidden selection must be kept hidden and a visible
-  // selection must be kept visible.
-  UpdateAppearance(LayoutSelection::PaintHint::kKeep);
+  UpdateAppearance();
 }
 
-void FrameSelection::UpdateAppearance(LayoutSelection::PaintHint hint) {
+void FrameSelection::UpdateAppearance() {
   DCHECK(!frame_->ContentLayoutItem().IsNull());
   frame_caret_->ScheduleVisualUpdateForPaintInvalidationIfNeeded();
-  layout_selection_->SetHasPendingSelection(hint);
+  layout_selection_->SetHasPendingSelection();
 }
 
 void FrameSelection::NotifyLayoutObjectOfSelectionChange(
     EUserTriggered user_triggered) {
   TextControlElement* text_control =
       EnclosingTextControl(GetSelectionInDOMTree().Base());
   if (!text_control)
     return;
   text_control->SelectionChanged(user_triggered == kUserTriggered);
 }
@@ skipping 168 matching lines @@
 
   Position start = ComputeVisibleSelectionInDOMTreeDeprecated().Start();
   DCHECK(start.AnchorNode());
   if (start.AnchorNode() && start.AnchorNode()->GetLayoutObject()) {
     // FIXME: This code only handles scrolling the startContainer's layer, but
     // the selection rect could intersect more than just that.
     if (DocumentLoader* document_loader = frame_->Loader().GetDocumentLoader())
       document_loader->GetInitialScrollState().was_scrolled_by_user = true;
     if (start.AnchorNode()->GetLayoutObject()->ScrollRectToVisible(
             rect, alignment, alignment))
-      UpdateAppearance(LayoutSelection::PaintHint::kPaint);
+      UpdateAppearance();
   }
 }
 
 void FrameSelection::SetSelectionFromNone() {
   // Put a caret inside the body if the entire frame is editable (either the
   // entire WebView is editable or designMode is on for this document).
 
   Document* document = frame_->GetDocument();
   if (!ComputeVisibleSelectionInDOMTreeDeprecated().IsNone() ||
       !(blink::HasEditableStyle(*document)))
@@ skipping 178 matching lines @@
 }
 
 void showTree(const blink::FrameSelection* sel) {
   if (sel)
     sel->ShowTreeForThis();
   else
     LOG(INFO) << "Cannot showTree for <null> FrameSelection.";
 }
 
 #endif