Add ability to compute text intercepts to Font

third_party/WebKit/Source/platform/fonts/Font.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2006, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (c) 2007, 2008, 2010 Google 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
@@ skipping 389 matching lines @@
   //   2) the glyph buffer is encoded as a single blob, and
   //   3) the blob is not upright/rotated
   if (runInfo.cachedTextBlob && bloberizer.blobCount() == 1 &&
       blob.second == NoRotation) {
     ASSERT(!*runInfo.cachedTextBlob);
     *runInfo.cachedTextBlob = std::move(blob.first);
     ASSERT(*runInfo.cachedTextBlob);
   }
 }
 
+static int getInterceptsFromBloberizer(const GlyphBuffer& glyphBuffer,
+                                       const Font* font,
+                                       const SkPaint& paint,
+                                       float deviceScaleFactor,
+                                       const std::tuple<float, float>& bounds,
+                                       SkScalar* interceptsBuffer) {
+  SkScalar boundsArray[2] = {std::get<0>(bounds), std::get<1>(bounds)};
+  GlyphBufferBloberizer bloberizer(glyphBuffer, font, deviceScaleFactor);
+  std::pair<sk_sp<SkTextBlob>, BlobRotation> blob;
+
+  int numIntervals = 0;
+  while (!bloberizer.done()) {
+    blob = bloberizer.next();
+    DCHECK(blob.first);
+
+    // GlyphBufferBloberizer splits for a new blob rotation, but does not split
+    // for a change in font. A TextBlob can contain runs with differing fonts
+    // and the getTextBlobIntercepts method handles multiple fonts for us. For
+    // upright in vertical blobs we currently have to bail, see crbug.com/655154
+    if (blob.second == BlobRotation::CCWRotation)
+      continue;
+
+    SkScalar* offsetInterceptsBuffer = nullptr;
+    if (interceptsBuffer)
+      offsetInterceptsBuffer = &interceptsBuffer[numIntervals];
+    numIntervals += paint.getTextBlobIntercepts(blob.first.get(), boundsArray,
+                                                interceptsBuffer);

[f(malita), 2016/10/14 15:39:21]

Ah, the bots caught this one: I think we want offsetInterceptsBuffer here :)

+  }
+  return numIntervals;
+}
+
+void Font::getTextIntercepts(const TextRunPaintInfo& runInfo,
+                             float deviceScaleFactor,
+                             const SkPaint& paint,
+                             const std::tuple<float, float>& bounds,
+                             Vector<TextIntercept>& intercepts) const {
+  if (shouldSkipDrawing())
+    return;
+
+  int numIntervals = 0;

[f(malita), 2016/10/14 15:36:48]

nit: no need to decl/initialize numIntervals here AFAICT.

[drott, 2016/10/14 16:36:45]

Yes, moved the second declaration down to line 468.

+
+  if (runInfo.cachedTextBlob && runInfo.cachedTextBlob->get()) {
+    SkScalar boundsArray[2] = {std::get<0>(bounds), std::get<1>(bounds)};
+    int numIntervals = paint.getTextBlobIntercepts(
+        runInfo.cachedTextBlob->get(), boundsArray, nullptr);
+    DCHECK_EQ(numIntervals % 2, 0);
+    intercepts.resize(numIntervals / 2);
+    paint.getTextBlobIntercepts(runInfo.cachedTextBlob->get(), boundsArray,

[f(malita), 2016/10/14 15:36:48]

nit: not sure how common this is in practice, but it's a cheap test -- if
numIntervals == 0, we can skip the second getTextBlobIntercepts call.

(it's probably more interesting to skip the second getInterceptsFromBloberizer
call below)

[drott, 2016/10/14 16:36:45]

Done.

+                                reinterpret_cast<SkScalar*>(intercepts.data()));
+    return;
+  }
+
+  GlyphBuffer glyphBuffer;
+  buildGlyphBuffer(runInfo, glyphBuffer);
+
+  // Get the number of intervals, without copying the actual values by
+  // specifying nullptr for the buffer, following the Skia allocation model for
+  // retrieving text intercepts.
+  numIntervals = getInterceptsFromBloberizer(
+      glyphBuffer, this, paint, deviceScaleFactor, bounds, nullptr);
+  DCHECK_EQ(numIntervals % 2, 0);
+  intercepts.resize(numIntervals / 2);
+
+  getInterceptsFromBloberizer(glyphBuffer, this, paint, deviceScaleFactor,

[f(malita), 2016/10/14 15:36:48]

nit: ditto

[drott, 2016/10/14 16:36:46]

Done here as well.

+                              bounds,
+                              reinterpret_cast<SkScalar*>(intercepts.data()));
+}
+
 static inline FloatRect pixelSnappedSelectionRect(FloatRect rect) {
   // Using roundf() rather than ceilf() for the right edge as a compromise to
   // ensure correct caret positioning.
   float roundedX = roundf(rect.x());
   return FloatRect(roundedX, rect.y(), roundf(rect.maxX() - roundedX),
                    rect.height());
 }
 
 FloatRect Font::selectionRectForText(const TextRun& run,
                                      const FloatPoint& point,
@@ skipping 518 matching lines @@
 
 bool Font::loadingCustomFonts() const {
   return m_fontFallbackList && m_fontFallbackList->loadingCustomFonts();
 }
 
 bool Font::isFallbackValid() const {
   return !m_fontFallbackList || m_fontFallbackList->isValid();
 }
 
 }  // namespace blink