Remove cullRect() from PaintOpBuffer.

third_party/WebKit/Source/core/paint/InlineTextBoxPainter.cpp

 // Copyright 2014 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/InlineTextBoxPainter.h"
 
 #include "core/editing/CompositionUnderline.h"
 #include "core/editing/Editor.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 688 matching lines @@
       default:
         NOTREACHED();
     }
   }
 }
 
 namespace {
 
 #if !OS(MACOSX)
 
+static const float kMarkerWidth = 4;
+static const float kMarkerHeight = 2;
+
 sk_sp<PaintRecord> RecordMarker(DocumentMarker::MarkerType marker_type) {
   SkColor color = (marker_type == DocumentMarker::kGrammar)
                       ? SkColorSetRGB(0xC0, 0xC0, 0xC0)
                       : SK_ColorRED;
 
   // Record the path equivalent to this legacy pattern:
   //   X o   o X o   o X
   //     o X o   o X o
 
-  static const float kW = 4;
-  static const float kH = 2;
-
   // Adjust the phase such that f' == 0 is "pixel"-centered
   // (for optimal rasterization at native rez).
   SkPath path;
-  path.moveTo(kW * -3 / 8, kH * 3 / 4);
-  path.cubicTo(kW * -1 / 8, kH * 3 / 4,
-               kW * -1 / 8, kH * 1 / 4,
-               kW *  1 / 8, kH * 1 / 4);
-  path.cubicTo(kW * 3 / 8, kH * 1 / 4,
-               kW * 3 / 8, kH * 3 / 4,
-               kW * 5 / 8, kH * 3 / 4);
-  path.cubicTo(kW * 7 / 8, kH * 3 / 4,
-               kW * 7 / 8, kH * 1 / 4,
-               kW * 9 / 8, kH * 1 / 4);
+  path.moveTo(kMarkerWidth * -3 / 8, kMarkerHeight * 3 / 4);
+  path.cubicTo(kMarkerWidth * -1 / 8, kMarkerHeight * 3 / 4,
+               kMarkerWidth * -1 / 8, kMarkerHeight * 1 / 4,
+               kMarkerWidth * 1 / 8, kMarkerHeight * 1 / 4);
+  path.cubicTo(kMarkerWidth * 3 / 8, kMarkerHeight * 1 / 4,
+               kMarkerWidth * 3 / 8, kMarkerHeight * 3 / 4,
+               kMarkerWidth * 5 / 8, kMarkerHeight * 3 / 4);
+  path.cubicTo(kMarkerWidth * 7 / 8, kMarkerHeight * 3 / 4,
+               kMarkerWidth * 7 / 8, kMarkerHeight * 1 / 4,
+               kMarkerWidth * 9 / 8, kMarkerHeight * 1 / 4);
 
   PaintFlags flags;
   flags.setAntiAlias(true);
   flags.setColor(color);
   flags.setStyle(PaintFlags::kStroke_Style);
-  flags.setStrokeWidth(kH * 1 / 2);
+  flags.setStrokeWidth(kMarkerHeight * 1 / 2);
 
   PaintRecorder recorder;
-  recorder.beginRecording(kW, kH);
+  recorder.beginRecording(kMarkerWidth, kMarkerHeight);
   recorder.getRecordingCanvas()->drawPath(path, flags);
 
   return recorder.finishRecordingAsPicture();
 }
 
 #else  // OS(MACOSX)
 
+static const float kMarkerWidth = 4;
+static const float kMarkerHeight = 3;
+
 sk_sp<PaintRecord> RecordMarker(DocumentMarker::MarkerType marker_type) {
   SkColor color = (marker_type == DocumentMarker::kGrammar)
                       ? SkColorSetRGB(0x6B, 0x6B, 0x6B)
                       : SkColorSetRGB(0xFB, 0x2D, 0x1D);
 
   // Match the artwork used by the Mac.
-  static const float kW = 4;
-  static const float kH = 3;
   static const float kR = 1.5f;
 
   // top->bottom translucent gradient.
   const SkColor colors[2] = {
       SkColorSetARGB(0x48,
                      SkColorGetR(color),
                      SkColorGetG(color),
                      SkColorGetB(color)),
       color
   };
   const SkPoint pts[2] = {
       SkPoint::Make(0, 0),
       SkPoint::Make(0, 2 * kR)
   };
 
   PaintFlags flags;
   flags.setAntiAlias(true);
   flags.setColor(color);
   flags.setShader(SkGradientShader::MakeLinear(
       pts, colors, nullptr, ARRAY_SIZE(colors), SkShader::kClamp_TileMode));
   PaintRecorder recorder;
-  recorder.beginRecording(kW, kH);
+  recorder.beginRecording(kMarkerWidth, kMarkerHeight);
   recorder.getRecordingCanvas()->drawCircle(kR, kR, kR, flags);
 
   return recorder.finishRecordingAsPicture();
 }
 
 #endif  // OS(MACOSX)
 
 void DrawDocumentMarker(GraphicsContext& context,
                         const FloatPoint& pt,
                         float width,
                         DocumentMarker::MarkerType marker_type,
                         float zoom) {
   DCHECK(marker_type == DocumentMarker::kSpelling ||
          marker_type == DocumentMarker::kGrammar);
 
   DEFINE_STATIC_LOCAL(PaintRecord*, spelling_marker,
                       (RecordMarker(DocumentMarker::kSpelling).release()));
   DEFINE_STATIC_LOCAL(PaintRecord*, grammar_marker,
                       (RecordMarker(DocumentMarker::kGrammar).release()));
   const auto& marker = marker_type == DocumentMarker::kSpelling
                            ? spelling_marker
                            : grammar_marker;
 
   // Position already includes zoom and device scale factor.
   SkScalar origin_x = WebCoreFloatToSkScalar(pt.X());
   SkScalar origin_y = WebCoreFloatToSkScalar(pt.Y());
 
 #if OS(MACOSX)
   // Make sure to draw only complete dots, and finish inside the marked text.
-  width -= fmodf(width, marker->cullRect().width() * zoom);
+  width -= fmodf(width, kMarkerWidth * zoom);
 #else
   // Offset it vertically by 1 so that there's some space under the text.
   origin_y += 1;
 #endif
 
-  const auto rect = SkRect::MakeWH(width, marker->cullRect().height() * zoom);
+  const auto rect = SkRect::MakeWH(width, kMarkerHeight * zoom);
   const auto local_matrix = SkMatrix::MakeScale(zoom, zoom);
 
   PaintFlags flags;
   flags.setAntiAlias(true);
   flags.setShader(WrapSkShader(MakePaintShaderRecord(
-      sk_ref_sp(marker), SkShader::kRepeat_TileMode, SkShader::kClamp_TileMode,
-      &local_matrix, nullptr)));
+      sk_ref_sp(marker), FloatRect(0, 0, kMarkerWidth, kMarkerHeight),
+      SkShader::kRepeat_TileMode, SkShader::kClamp_TileMode, &local_matrix)));
 
   // Apply the origin translation as a global transform.  This ensures that the
   // shader local matrix depends solely on zoom => Skia can reuse the same
   // cached tile for all markers at a given zoom level.
   GraphicsContextStateSaver saver(context);
   context.Translate(origin_x, origin_y);
   context.DrawRect(rect, flags);
 }
 
 }  // anonymous ns
@@ skipping 347 matching lines @@
 
   LayoutRect box_rect(box_origin, LayoutSize(inline_text_box_.LogicalWidth(),
                                              inline_text_box_.LogicalHeight()));
   context.Clip(FloatRect(box_rect));
   context.DrawHighlightForText(font, run, FloatPoint(box_origin),
                                box_rect.Height().ToInt(), color,
                                paint_offsets.first, paint_offsets.second);
 }
 
 }  // namespace blink