[WIP][b:eae_mywip_paint] Paint Selection NG.

third_party/WebKit/Source/core/editing/LayoutSelection.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.
  *
@@ skipping 274 matching lines @@
       new_selected_map.block_map.erase(block);
     }
   }
 
   // Any new blocks that remain were not found in the old blocks dict, and so
   // they need to be updated.
   for (auto layout_object : new_selected_map.block_map.Keys())
     layout_object->SetShouldInvalidateSelection();
 }
 
+static LayoutBlockFlow* MostRecentLayoutBlockFlow(LayoutObject* layout_object) {
+  for (LayoutObject* runner = layout_object; runner && !runner->IsLayoutView();
+       runner = runner->ContainingBlock()) {

[kojii, 2017/06/21 10:10:09]

Parent()

+    if (runner->IsLayoutBlockFlow())
+      return ToLayoutBlockFlow(runner);
+  }
+  return nullptr;
+}
+
+static int GetOffsetInMixedTree(LayoutObject* layout_object, int offset) {
+  LayoutBlockFlow* start_block_flow = MostRecentLayoutBlockFlow(layout_object);
+  if (!start_block_flow || !start_block_flow->IsLayoutNGBlockFlow())
+    return offset;  // Legay. Return DOM offset;
+
+  // TODO(yoichio): How about caching? Create takes
+  // O(<LayoutNGBlockflow.Data.text_content_>).
+  const NGTextOffsetMap& offset_map =
+      NGTextOffsetMap::Create(*ToLayoutNGBlockFlowOrDie(start_block_flow));
+  const Optional<int> ng_offset =
+      offset_map.Get(layout_object->GetNode(), offset);
+  return ng_offset.value();
+}
+
 std::pair<int, int> LayoutSelection::SelectionStartEnd() {
   Commit();
   if (paint_range_.IsNull())
     return std::make_pair(-1, -1);
-  return std::make_pair(paint_range_.StartOffset(), paint_range_.EndOffset());
+  if (!RuntimeEnabledFeatures::LayoutNGEnabled()) {
+    return std::make_pair(paint_range_.StartOffset(), paint_range_.EndOffset());
+  }
+  // Layout NG mapping
+  const int start_offset_mixed = GetOffsetInMixedTree(
+      paint_range_.StartLayoutObject(), paint_range_.StartOffset());
+  const int end_offset_mixed = GetOffsetInMixedTree(
+      paint_range_.EndLayoutObject(), paint_range_.EndOffset());
+  return std::make_pair(start_offset_mixed, end_offset_mixed);
 }
 
 void LayoutSelection::ClearSelection() {
   // For querying Layer::compositingState()
   // This is correct, since destroying layout objects needs to cause eager paint
   // invalidations.
   DisableCompositingQueryAsserts disabler;
 
   // Just return if the selection is already empty.
   if (paint_range_.IsNull())
     return;
 
   for (auto layout_object : paint_range_) {
     const SelectionState old_state = layout_object->GetSelectionState();
     layout_object->SetSelectionStateIfNeeded(SelectionState::kNone);
     if (layout_object->GetSelectionState() == old_state)
       continue;
     layout_object->SetShouldInvalidateSelection();
   }
 
   // Reset selection.
   paint_range_ = SelectionPaintRange();
 }
 
+static SelectionPaintRange CalcSelectionNG(

[yoichio, 2017/06/27 07:54:52]

Its strange that we have 3 code pass for legacy, ng-ng, ng-legacy.
We should unify them to legacy and ng.

+    const FrameSelection& frame_selection) {
+  const SelectionInDOMTree& selection_in_dom =
+      frame_selection.GetSelectionInDOMTree();
+  if (selection_in_dom.IsNone())
+    return SelectionPaintRange();
+
+  // yoichio: Tthis should be on FlatTree.
+  const Position& start = selection_in_dom.ComputeStartPosition();
+  const Position& end = selection_in_dom.ComputeEndPosition();
+  LayoutObject* const start_layout_object =
+      start.AnchorNode()->GetLayoutObject();
+  LayoutObject* const end_layout_object = end.AnchorNode()->GetLayoutObject();
+
+  Node* start_node = nullptr;
+  LayoutObject* paint_range_start = nullptr;
+  int paint_range_start_offset = -1;
+  // Seek the first text node.
+  for (LayoutObject* runner = start_layout_object;
+       runner && runner != end_layout_object->NextInPreOrder();
+       runner = runner->NextInPreOrder()) {
+    if (runner->IsText() && runner->GetNode()->IsTextNode()) {

[yoichio, 2017/06/27 07:54:52]

LayoutText will gone.

+      start_node = runner->GetNode();
+      paint_range_start = runner;
+      if (runner == start_layout_object) {
+        paint_range_start_offset = start.ComputeEditingOffset();
+        break;
+      }
+      paint_range_start_offset = 0;
+      break;
+    }

[yoichio, 2017/06/27 07:54:52]

br is  LayouObject.isText().

+  }
+  DCHECK(paint_range_start);
+  // Should consider block cursor painting.
+  Node* end_node = nullptr;
+  LayoutObject* paint_range_end = nullptr;
+  int paint_range_end_offset = -1;
+  for (LayoutObject* runner = end_layout_object;
+       runner && runner != start_layout_object->PreviousInPreOrder();
+       runner = runner->PreviousInPreOrder()) {
+    if (runner->IsText() && runner->GetNode()->IsTextNode()) {
+      end_node = runner->GetNode();
+      paint_range_end = runner;
+      if (runner == end_layout_object) {
+        paint_range_end_offset = end.ComputeEditingOffset();
+        break;
+      }
+      LayoutText* text = ToLayoutText(runner);
+      paint_range_end_offset = text->TextLength();
+      break;
+    }
+  }
+  DCHECK(paint_range_end);
+
+  return SelectionPaintRange(paint_range_start, paint_range_start_offset,
+                             paint_range_end, paint_range_end_offset);
+}
+
 static SelectionPaintRange CalcSelectionPaintRange(
     const FrameSelection& frame_selection) {
   const SelectionInDOMTree& selection_in_dom =
       frame_selection.GetSelectionInDOMTree();
   if (selection_in_dom.IsNone())
     return SelectionPaintRange();
 
+  if (RuntimeEnabledFeatures::LayoutNGEnabled())
+    return CalcSelectionNG(frame_selection);
+
+  // NGMemo: ComputeVisibleSelectionInFlatTree depends on offsetmapping from
+  // DOM->NG.
   const VisibleSelectionInFlatTree& original_selection =
       frame_selection.ComputeVisibleSelectionInFlatTree();
   // Construct a new VisibleSolution, since visibleSelection() is not
   // necessarily valid, and the following steps assume a valid selection. See
   // <https://bugs.webkit.org/show_bug.cgi?id=69563> and
   // <rdar://problem/10232866>.
   const SelectionInFlatTree& new_selection = CalcSelection(
       original_selection, frame_selection.ShouldShowBlockCursor());
   const VisibleSelectionInFlatTree& selection =
       CreateVisibleSelection(new_selection);
@@ skipping 147 matching lines @@
       int ng_offset = offset_mapping[begin + i - 1];
       builder.Add(text, i, ng_offset);
     }
 
     last_object = layout_object;
   }
   return builder.Build();
 }
 
 }  // namespace blink