Make UpdateSelectionForMouseDownDispatchingSelectStart() to take SelectionInFlatTree

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  * Copyright (C) 2015 Google 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:
@@ skipping 17 matching lines @@
  */
 
 #include "core/editing/SelectionController.h"
 
 #include "core/HTMLNames.h"
 #include "core/dom/Document.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/Editor.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/RenderedPosition.h"
+#include "core/editing/VisibleSelection.h"
 #include "core/editing/iterators/TextIterator.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/events/Event.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/LocalFrameView.h"
 #include "core/frame/Settings.h"
 #include "core/input/EventHandler.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/page/FocusController.h"
@@ skipping 23 matching lines @@
 namespace {
 
 DispatchEventResult DispatchSelectStart(Node* node) {
   if (!node || !node->GetLayoutObject())
     return DispatchEventResult::kNotCanceled;
 
   return node->DispatchEvent(
       Event::CreateCancelableBubble(EventTypeNames::selectstart));
 }
 
-VisibleSelectionInFlatTree ExpandSelectionToRespectUserSelectAll(
+SelectionInFlatTree ExpandSelectionToRespectUserSelectAll(
     Node* target_node,
     const VisibleSelectionInFlatTree& selection) {
   if (selection.IsNone())
-    return selection;
+    return SelectionInFlatTree();
   Node* const root_user_select_all =
       EditingInFlatTreeStrategy::RootUserSelectAllForNode(target_node);
   if (!root_user_select_all) {
     SelectionInFlatTree::Builder builder;
     if (selection.IsBaseFirst())
       builder.SetBaseAndExtent(selection.Start(), selection.End());
     else
       builder.SetBaseAndExtent(selection.End(), selection.Start());
     builder.SetAffinity(selection.Affinity());
-    return CreateVisibleSelection(builder.Build());
+    return builder.Build();
   }
 
-  return CreateVisibleSelection(
-      SelectionInFlatTree::Builder(selection.AsSelection())
-          .Collapse(MostBackwardCaretPosition(
-              PositionInFlatTree::BeforeNode(*root_user_select_all),
-              kCanCrossEditingBoundary))
-          .Extend(MostForwardCaretPosition(
-              PositionInFlatTree::AfterNode(*root_user_select_all),
-              kCanCrossEditingBoundary))
-          .Build());
+  return SelectionInFlatTree::Builder(selection.AsSelection())
+      .Collapse(MostBackwardCaretPosition(
+          PositionInFlatTree::BeforeNode(*root_user_select_all),
+          kCanCrossEditingBoundary))
+      .Extend(MostForwardCaretPosition(
+          PositionInFlatTree::AfterNode(*root_user_select_all),
+          kCanCrossEditingBoundary))
+      .Build();
 }
 
 static int TextDistance(const PositionInFlatTree& start,
                         const PositionInFlatTree& end) {
   return TextIteratorInFlatTree::RangeLength(
       start, end,
       TextIteratorBehavior::AllVisiblePositionsRangeLengthBehavior());
 }
 
 bool CanMouseDownStartSelect(Node* node) {
@@ skipping 25 matching lines @@
 void SelectionController::ContextDestroyed(Document*) {
   original_base_in_flat_tree_ = VisiblePositionInFlatTree();
 }
 
 static PositionInFlatTree AdjustPositionRespectUserSelectAll(
     Node* inner_node,
     const PositionInFlatTree& selection_start,
     const PositionInFlatTree& selection_end,
     const PositionInFlatTree& position) {
   const VisibleSelectionInFlatTree& selection_in_user_select_all =
-      ExpandSelectionToRespectUserSelectAll(
-          inner_node,
-          position.IsNull()
-              ? VisibleSelectionInFlatTree()
-              : CreateVisibleSelection(
-                    SelectionInFlatTree::Builder().Collapse(position).Build()));
+      CreateVisibleSelection(ExpandSelectionToRespectUserSelectAll(
+          inner_node, position.IsNull() ? VisibleSelectionInFlatTree()
+                                        : CreateVisibleSelection(
+                                              SelectionInFlatTree::Builder()
+                                                  .Collapse(position)
+                                                  .Build())));
   if (!selection_in_user_select_all.IsRange())
     return position;
   if (selection_in_user_select_all.Start().CompareTo(selection_start) < 0)
     return selection_in_user_select_all.Start();
   if (selection_end.CompareTo(selection_in_user_select_all.End()) < 0)
     return selection_in_user_select_all.End();
   return position;
 }
 
 // Updating the selection is considered side-effect of the event and so it
@@ skipping 29 matching lines @@
     const LayoutPoint v_point = view->RootFrameToContents(
         FlooredIntPoint(event.Event().PositionInRootFrame()));
     if (!extend_selection && this->Selection().Contains(v_point)) {
       mouse_down_was_single_click_in_selection_ = true;
       if (!event.Event().FromTouch())
         return false;
 
       if (!this->Selection().IsHandleVisible()) {
         const bool did_select =
             UpdateSelectionForMouseDownDispatchingSelectStart(
-                inner_node, selection, kCharacterGranularity,
+                inner_node, selection.AsSelection(), kCharacterGranularity,
                 HandleVisibility::kVisible);
         if (did_select) {
           frame_->GetEventHandler().ShowNonLocatedContextMenu(nullptr,
                                                               kMenuSourceTouch);
         }
         return false;
       }
     }
   }
 
@@ skipping 21 matching lines @@
         builder.SetBaseAndExtent(start, pos);
       } else {
         const int distance_to_start = TextDistance(start, pos);
         const int distance_to_end = TextDistance(pos, end);
         builder.SetBaseAndExtent(
             distance_to_start <= distance_to_end ? end : start, pos);
       }
     }
 
     UpdateSelectionForMouseDownDispatchingSelectStart(
-        inner_node, CreateVisibleSelection(builder.Build()),
-        this->Selection().Granularity(), HandleVisibility::kNotVisible);
+        inner_node, builder.Build(), this->Selection().Granularity(),
+        HandleVisibility::kNotVisible);
     return false;
   }
 
   if (selection_state_ == SelectionState::kExtendedSelection) {
     UpdateSelectionForMouseDownDispatchingSelectStart(
-        inner_node, selection, kCharacterGranularity,
+        inner_node, selection.AsSelection(), kCharacterGranularity,
         HandleVisibility::kNotVisible);
     return false;
   }
 
   if (visible_pos.IsNull()) {
     UpdateSelectionForMouseDownDispatchingSelectStart(
-        inner_node, VisibleSelectionInFlatTree(), kCharacterGranularity,
+        inner_node, SelectionInFlatTree(), kCharacterGranularity,
         HandleVisibility::kNotVisible);
     return false;
   }
 
   bool is_handle_visible = false;
   if (HasEditableStyle(*inner_node)) {
     const bool is_text_box_empty =
         CreateVisibleSelection(SelectionInFlatTree::Builder()
                                    .SelectAllChildren(*inner_node)
                                    .Build())
@@ skipping 159 matching lines @@
   if (Selection().Granularity() != kCharacterGranularity)
     builder.SetGranularity(Selection().Granularity());
 
   SetNonDirectionalSelectionIfNeeded(builder.Build(), Selection().Granularity(),
                                      kAdjustEndpointsAtBidiBoundary,
                                      HandleVisibility::kNotVisible);
 }
 
 bool SelectionController::UpdateSelectionForMouseDownDispatchingSelectStart(
     Node* target_node,
-    const VisibleSelectionInFlatTree& selection,
+    const SelectionInFlatTree& selection,
     TextGranularity granularity,
     HandleVisibility handle_visibility) {
   if (target_node && target_node->GetLayoutObject() &&
       !target_node->GetLayoutObject()->IsSelectable())
     return false;
 
+  // TODO(editing-dev): We should compute visible selection after dispatching
+  // "selectstart", once we have |SelectionInFlatTree::IsValidFor()|.
+  const VisibleSelectionInFlatTree& visible_selection =
+      CreateVisibleSelection(selection);
+
   if (DispatchSelectStart(target_node) != DispatchEventResult::kNotCanceled)
     return false;
 
   // |dispatchSelectStart()| can change document hosted by |m_frame|.
   if (!this->Selection().IsAvailable())
     return false;
 
-  if (!selection.IsValidFor(this->Selection().GetDocument()))
+  if (!visible_selection.IsValidFor(this->Selection().GetDocument()))
     return false;
 
-  if (selection.IsRange()) {
+  if (visible_selection.IsRange()) {
     selection_state_ = SelectionState::kExtendedSelection;
   } else {
     granularity = kCharacterGranularity;
     selection_state_ = SelectionState::kPlacedCaret;
   }
 
-  SetNonDirectionalSelectionIfNeeded(selection.AsSelection(), granularity,
+  SetNonDirectionalSelectionIfNeeded(selection, granularity,
                                      kDoNotAdjustEndpoints, handle_visibility);
 
   return true;
 }
 
 bool SelectionController::SelectClosestWordFromHitTestResult(
     const HitTestResult& result,
     AppendTrailingWhitespace append_trailing_whitespace,
     SelectInputEventType select_input_event_type) {
   Node* inner_node = result.InnerNode();
@@ skipping 58 matching lines @@
     const HitTestResult& result,
     AppendTrailingWhitespace append_trailing_whitespace) {
   Node* inner_node = result.InnerNode();
 
   if (!inner_node || !inner_node->GetLayoutObject())
     return;
 
   const VisiblePositionInFlatTree& pos = VisiblePositionOfHitTestResult(result);
   if (pos.IsNull()) {
     UpdateSelectionForMouseDownDispatchingSelectStart(
-        inner_node, VisibleSelectionInFlatTree(), kWordGranularity,
+        inner_node, SelectionInFlatTree(), kWordGranularity,
         HandleVisibility::kNotVisible);
     return;
   }
 
   const PositionInFlatTree& marker_position =
       pos.DeepEquivalent().ParentAnchoredEquivalent();
   const DocumentMarker* const marker =
       inner_node->GetDocument().Markers().MarkerAtPosition(
           ToPositionInDOMTree(marker_position),
           DocumentMarker::MisspellingMarkers());
   if (!marker) {
     UpdateSelectionForMouseDownDispatchingSelectStart(
-        inner_node, VisibleSelectionInFlatTree(), kWordGranularity,
+        inner_node, SelectionInFlatTree(), kWordGranularity,
         HandleVisibility::kNotVisible);
     return;
   }
 
   Node* container_node = marker_position.ComputeContainerNode();
   const PositionInFlatTree start(container_node, marker->StartOffset());
   const PositionInFlatTree end(container_node, marker->EndOffset());
   VisibleSelectionInFlatTree new_selection = CreateVisibleSelection(
       SelectionInFlatTree::Builder().Collapse(start).Extend(end).Build());
 
@@ skipping 210 matching lines @@
   const VisiblePositionInFlatTree& visible_hit_pos =
       VisiblePositionOfHitTestResult(hit_test_result);
   const VisiblePositionInFlatTree& visible_pos =
       visible_hit_pos.IsNull()
           ? CreateVisiblePosition(
                 PositionInFlatTree::FirstPositionInOrBeforeNode(inner_node))
           : visible_hit_pos;
 
   if (visible_pos.IsNull()) {
     UpdateSelectionForMouseDownDispatchingSelectStart(
-        inner_node, VisibleSelectionInFlatTree(), kCharacterGranularity,
+        inner_node, SelectionInFlatTree(), kCharacterGranularity,
         HandleVisibility::kVisible);
     return;
   }
   UpdateSelectionForMouseDownDispatchingSelectStart(
       inner_node,
       ExpandSelectionToRespectUserSelectAll(
           inner_node, CreateVisibleSelection(
                           SelectionInFlatTree::Builder()
                               .Collapse(visible_pos.ToPositionWithAffinity())
                               .Build())),
@@ skipping 405 matching lines @@
 
 bool IsExtendingSelection(const MouseEventWithHitTestResults& event) {
   bool is_mouse_down_on_link_or_image =
       event.IsOverLink() || event.GetHitTestResult().GetImage();
   return (event.Event().GetModifiers() & WebInputEvent::Modifiers::kShiftKey) !=
              0 &&
          !is_mouse_down_on_link_or_image;
 }
 
 }  // namespace blink