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

third_party/WebKit/Source/core/paint/NGTextFragmentPainter.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/paint/NGTextFragmentPainter.h"
 
+#include "core/editing/FrameSelection.h"
 #include "core/frame/LocalFrame.h"
 #include "core/layout/ng/inline/ng_physical_text_fragment.h"
 #include "core/paint/NGTextPainter.h"
 #include "core/paint/PaintInfo.h"
 #include "core/paint/TextPainterBase.h"
 #include "core/style/AppliedTextDecoration.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
 #include "platform/wtf/Optional.h"
 
@@ skipping 51 matching lines @@
   //                                                decoration,
   //                                                overline_offset);
   //  }
   //  // We could instead build a vector of the TextDecoration instances needing
   //  // line-through but this is a rare case so better to avoid vector
   //  overhead. has_line_through_decoration |= ((lines &
   //  kTextDecorationLineThrough) != 0);
   //}
 }
 
+static std::pair<int, int> SelectionStartEnd(

[kojii, 2017/06/16 11:25:57]

Can add explanation what this function does and what the return is?

Shouldn't |int| be |unsigned|? Layout always use unsigned for offset, I'm not
sure about paint though.

[yoichio, 2017/06/21 08:16:43]

This returns 0-origin offset range in NGPhysicalTextFragment to be painted
 as selection.
Yes, this should be unsigned but |selection_start| in 
 NGTextFragmentPainter::Paint is defined as |int|.
I guess because legacy InlineTextBoxPainter defines selection range as 
 int pair, where it uses (-1,-1) as invalid range, and Emil just follows it.

+    const NGPhysicalTextFragment* text_fragment) {
+  const SelectionState& selection_state =
+      text_fragment->GetLayoutObject()->GetSelectionState();
+  if (selection_state == SelectionState::kNone)
+    return {0, 0};
+  if (selection_state == SelectionState::kInside)
+    return {0, text_fragment->Text().length()};

[kojii, 2017/06/16 11:25:57]

why it computes min/max to text_fragment->Start/EndOffset() but this part does
not?

[yoichio, 2017/06/21 08:16:43]

Ah, it should be {text_fragment->StartOffst(),
 text_fragment->EndOffset()}
What is 'it'? Could you explain more?

+
+  const std::pair<int, int> startend_in_ngblockflow =

[kojii, 2017/06/16 11:25:57]

I can't understand how this works...so you get two |int|s from FrameView. What
are they, and why can you subtract text_fragment->StartOffset() from it? Can you
explain?

[yoichio, 2017/06/21 08:16:43]

They are index in NGInlineNodeData.text_content_, but NGTextPainter.paint(start,
end) demands
 offset in NGPhysixalTextFragment.

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

But you get data from Frame, without passing text_fragment. How could it find
the relevant NGInlineNodeData?

+      text_fragment->GetLayoutObject()
+          ->GetFrameView()
+          ->GetFrame()
+          .Selection()
+          .LayoutSelectionStartEnd();
+  int selection_start = std::max<int>(
+      0, startend_in_ngblockflow.first - text_fragment->StartOffset());

[kojii, 2017/06/16 11:25:57]

This might not work, because StartOffset() is unsigned, no?

+  int selection_end = std::min<int>(
+      text_fragment->Text().length(),
+      startend_in_ngblockflow.second - text_fragment->StartOffset());
+
+  switch (selection_state) {
+    case SelectionState::kStart:
+      return {selection_start, text_fragment->Text().length()};
+    case SelectionState::kEnd:
+      return {0, selection_end};
+    case SelectionState::kStartAndEnd:
+      return {selection_start, selection_end};
+  }
+
+  NOTREACHED();
+  return {0, 0};
+}
+
 }  // anonymous namespace
 
 void NGTextFragmentPainter::Paint(const Document& document,
                                   const PaintInfo& paint_info,
                                   const LayoutPoint& paint_offset) {
   // TODO(eae): Move
   static unsigned short kCNoTruncation = USHRT_MAX;
   static unsigned short kCFullTruncation = USHRT_MAX - 1;
 
   const ComputedStyle& style_to_use = text_fragment_->Style();
@@ skipping 27 matching lines @@
   }
 
   // Determine text colors.
   TextPainterBase::Style text_style =
       TextPainterBase::TextPaintingStyle(document, style_to_use, paint_info);
   // TextPainterBase::Style selection_style =
   // TextPainter::SelectionPaintingStyle(
   //    text_fragment_.GetLineLayoutItem(), have_selection, paint_info,
   //    text_style);
   TextPainterBase::Style selection_style = text_style;
+  selection_style.fill_color = Color(1.0f, 0.0f, 0.0f, 1.0f);

[kojii, 2017/06/16 11:25:57]

this is temporary, correct? Can you add TODO comment?

[yoichio, 2017/06/21 08:16:43]

Yes, just for testing. Remove from reviewing.

   bool paint_selected_text_only = (paint_info.phase == kPaintPhaseSelection);
   bool paint_selected_text_separately =
       !paint_selected_text_only && text_style != selection_style;
 
   // Set our font.
   const Font& font = style_to_use.GetFont();
   const SimpleFontData* font_data = font.PrimaryFont();
   DCHECK(font_data);
 
   int ascent = font_data ? font_data->GetFontMetrics().Ascent() : 0;
@@ skipping 16 matching lines @@
     //  else
     //    PaintSelection<InlineTextBoxPainter::PaintOptions::kNormal>(
     //        context, box_rect, style_to_use, font,
     //        selection_style.fill_color);
     //}
   }
 
   // 2. Now paint the foreground, including text and decorations.
   int selection_start = 0;
   int selection_end = 0;
-  // if (paint_selected_text_only || paint_selected_text_separately)
-  //  text_fragment_.SelectionStartEnd(selection_start, selection_end);
+  if (paint_selected_text_only || paint_selected_text_separately) {
+    std::tie(selection_start, selection_end) =
+        SelectionStartEnd(text_fragment_);
+  }
 
   // bool respect_hyphen =
   //    selection_end == static_cast<int>(text_fragment_.Len()) &&
   //    text_fragment_.HasHyphen();
   // if (respect_hyphen)
   //  selection_end = text_run.length();
 
   unsigned length = text_fragment_->Text().length();
 
   bool ltr = true;
@@ skipping 97 matching lines @@
   //  PaintDocumentMarkers(paint_info, box_origin, style_to_use, font,
   //                       DocumentMarkerPaintPhase::kForeground);
 
   if (should_rotate) {
     context.ConcatCTM(TextPainterBase::Rotation(
         box_rect, TextPainterBase::kCounterclockwise));
   }
 }
 
 }  // namespace blink