Move layouet/LayoutView::setSelection() to editing/LayoutSelection

third_party/WebKit/Source/core/layout/LayoutView.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc.
  *               All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "core/layout/LayoutView.h"
 
 #include <inttypes.h>
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/editing/FrameSelection.h"
+#include "core/editing/LayoutSelection.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLIFrameElement.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutGeometryMap.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/ViewFragmentationContext.h"
 #include "core/layout/api/LayoutAPIShim.h"
 #include "core/layout/api/LayoutPartItem.h"
@@ skipping 42 matching lines @@
  private:
   double start_;
   bool allows_child_frame_content_;
 };
 
 }  // namespace
 
 LayoutView::LayoutView(Document* document)
     : LayoutBlockFlow(document),
       frame_view_(document->View()),
-      selection_start_(nullptr),
-      selection_end_(nullptr),
-      selection_start_pos_(-1),
-      selection_end_pos_(-1),
       layout_state_(nullptr),
       layout_quote_head_(nullptr),
       layout_counter_count_(0),
       hit_test_count_(0),
       hit_test_cache_hits_(0),
       hit_test_cache_(HitTestCache::Create()) {
   // init LayoutObject attributes
   SetInline(false);
 
   min_preferred_logical_width_ = LayoutUnit();
@@ skipping 521 matching lines @@
 static LayoutRect SelectionRectForLayoutObject(const LayoutObject* object) {
   if (!object->IsRooted())
     return LayoutRect();
 
   if (!object->CanUpdateSelectionOnRootLineBoxes())
     return LayoutRect();
 
   return object->SelectionRectInViewCoordinates();
 }
 
-IntRect LayoutView::SelectionBounds() {
+// TODO(yoichio): Move this to LayoutSelection.
+IntRect LayoutSelection::SelectionBounds() {
   // Now create a single bounding box rect that encloses the whole selection.
   LayoutRect sel_rect;
 
   typedef HashSet<const LayoutBlock*> VisitedContainingBlockSet;
   VisitedContainingBlockSet visited_containing_blocks;
 
-  CommitPendingSelection();
+  Commit(*frame_selection_->GetDocument().GetLayoutView());
   LayoutObject* os = selection_start_;
   LayoutObject* stop =
       LayoutObjectAfterPosition(selection_end_, selection_end_pos_);
   while (os && os != stop) {
     if ((os->CanBeSelectionLeaf() || os == selection_start_ ||
          os == selection_end_) &&
         os->GetSelectionState() != SelectionNone) {
       // Blocks are responsible for painting line gaps and margin gaps. They
       // must be examined as well.
       sel_rect.Unite(SelectionRectForLayoutObject(os));
       const LayoutBlock* cb = os->ContainingBlock();
       while (cb && !cb->IsLayoutView()) {
         sel_rect.Unite(SelectionRectForLayoutObject(cb));
         VisitedContainingBlockSet::AddResult add_result =
             visited_containing_blocks.insert(cb);
         if (!add_result.is_new_entry)
           break;
         cb = cb->ContainingBlock();
       }
     }
 
     os = os->NextInPreOrder();
   }
 
   return PixelSnappedIntRect(sel_rect);
 }
 
-void LayoutView::InvalidatePaintForSelection() {
+// TODO(yoichio): Move this to LayoutSelection.
+void LayoutSelection::InvalidatePaintForSelection() {
   LayoutObject* end =
       LayoutObjectAfterPosition(selection_end_, selection_end_pos_);
   for (LayoutObject* o = selection_start_; o && o != end;
        o = o->NextInPreOrder()) {
     if (!o->CanBeSelectionLeaf() && o != selection_start_ &&
         o != selection_end_)
       continue;
     if (o->GetSelectionState() == SelectionNone)
       continue;
 
@@ skipping 19 matching lines @@
     exploring_backwards = !next && (next != stop);
     if (exploring_backwards) {
       next = stop->PreviousInPreOrder();
       continue_exploring = next && !next->IsLayoutView();
     }
   }
 
   return next;
 }
 
-void LayoutView::SetSelection(
+// TODO(yoichio): Move this to LayoutSelection.
+void LayoutSelection::SetSelection(
     LayoutObject* start,
     int start_pos,
     LayoutObject* end,
     int end_pos,
     SelectionPaintInvalidationMode block_paint_invalidation_mode) {
   // This code makes no assumptions as to if the layout tree is up to date or
   // not and will not try to update it. Currently clearSelection calls this
   // (intentionally) without updating the layout tree as it doesn't care.
   // Other callers may want to force recalc style before calling this.
 
@@ skipping 109 matching lines @@
         if (!result.is_new_entry)
           break;
         cb = cb->ContainingBlock();
       }
     }
 
     o = GetNextOrPrevLayoutObjectBasedOnDirection(o, stop, continue_exploring,
                                                   exploring_backwards);
   }
 
-  if (!frame_view_)
+  if (!frame_selection_->GetDocument().GetLayoutView()->GetFrameView())

[dcheng, 2017/04/12 07:20:50]

Nit: add a TODO to try DCHECKing this, just in case this gets pre-empted by
other work =)

[yoichio, 2017/04/12 08:12:19]

Done.

     return;
 
   // Have any of the old selected objects changed compared to the new selection?
   for (SelectedObjectMap::iterator i = old_selected_objects.begin();
        i != old_objects_end; ++i) {
     LayoutObject* obj = i->key;
     SelectionState new_selection_state = obj->GetSelectionState();
     SelectionState old_selection_state = i->value;
     if (new_selection_state != old_selection_state ||
         (selection_start_ == obj && old_start_pos != selection_start_pos_) ||
@@ skipping 24 matching lines @@
   }
 
   // Any new blocks that remain were not found in the old blocks dict, and so
   // they need to be updated.
   SelectedBlockMap::iterator new_blocks_end = new_selected_blocks.end();
   for (SelectedBlockMap::iterator i = new_selected_blocks.begin();
        i != new_blocks_end; ++i)
     i->key->SetShouldInvalidateSelection();
 }
 
-void LayoutView::ClearSelection() {
+// TODO(yoichio): Move this to LayoutSelection.
+void LayoutSelection::ClearSelection() {
   // For querying Layer::compositingState()
   // This is correct, since destroying layout objects needs to cause eager paint
   // invalidations.
   DisableCompositingQueryAsserts disabler;
 
   SetSelection(0, -1, 0, -1, kPaintInvalidationNewMinusOld);
 }
 
+void LayoutView::ClearSelection() {
+  frame_view_->GetFrame().Selection().ClearLayoutSelection();
+}
+
 bool LayoutView::HasPendingSelection() const {
   return frame_view_->GetFrame().Selection().IsAppearanceDirty();
 }
 
 void LayoutView::CommitPendingSelection() {
   TRACE_EVENT0("blink", "LayoutView::commitPendingSelection");
   frame_view_->GetFrame().Selection().CommitAppearanceIfNeeded(*this);
 }
 
 void LayoutView::SelectionStartEnd(int& start_pos, int& end_pos) {
-  CommitPendingSelection();
+  frame_view_->GetFrame().Selection().LayoutSelectionStartEnd(start_pos,
+                                                              end_pos);
+}
+
+// TODO(yoichio): Move this to LayoutSelection.
+void LayoutSelection::SelectionStartEnd(int& start_pos, int& end_pos) {
+  Commit(*frame_selection_->GetDocument().GetLayoutView());
   start_pos = selection_start_pos_;
   end_pos = selection_end_pos_;
 }
 
 bool LayoutView::ShouldUsePrintingLayout() const {
   if (!GetDocument().Printing() || !frame_view_)
     return false;
   return frame_view_->GetFrame().ShouldUsePrintingLayout();
 }
 
@@ skipping 186 matching lines @@
   // Frame scroll corner is painted using LayoutView as the display item client.
   if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled() &&
       (GetFrameView()->HorizontalScrollbar() ||
        GetFrameView()->VerticalScrollbar()))
     return false;
 
   return LayoutBlockFlow::PaintedOutputOfObjectHasNoEffectRegardlessOfSize();
 }
 
 }  // namespace blink