SkShaper: optionally disable harfbuzz

tools/SkShaper.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
-
-#include <hb-ot.h>
-
 #include "SkShaper.h"
 #include "SkStream.h"
 #include "SkTextBlob.h"
 #include "SkTypeface.h"
 
+#ifdef SK_ENABLE_HARFBUZZ

[bungeman-skia, 2016/08/02 21:38:36]

I know it's a bit more work, but these two implementations appear to share no
code. Can we remove this define, make this current file SkShaper_harfbuzz.cpp,
put the new code in SkShaper_primitive.cpp, and then let the build file pick one
or the other?

[hal.canary, 2016/08/02 23:00:45]

Done.

+
+#include <hb-ot.h>
+
 static const int FONT_SIZE_SCALE = 512;
 
 namespace {
 struct HBFBlobDel {
     void operator()(hb_blob_t* b) { hb_blob_destroy(b); }
 };
 
 std::unique_ptr<hb_blob_t, HBFBlobDel> stream_to_blob(std::unique_ptr<SkStreamAsset> asset) {
     size_t size = asset->getLength();
     std::unique_ptr<hb_blob_t, HBFBlobDel> blob;
@@ skipping 84 matching lines @@
 
     double x = point.x();
     double y = point.y();
 
     double textSizeY = paint.getTextSize() / (double)FONT_SIZE_SCALE;
     double textSizeX = textSizeY * paint.getTextScaleX();
 
     for (unsigned i = 0; i < len; i++) {
         runBuffer.glyphs[i] = info[i].codepoint;
         reinterpret_cast<SkPoint*>(runBuffer.pos)[i] =
-                SkPoint::Make(x + pos[i].x_offset * textSizeX,
-                              y - pos[i].y_offset * textSizeY);
+                SkPoint::Make(SkDoubleToScalar(x + pos[i].x_offset * textSizeX),
+                              SkDoubleToScalar(y - pos[i].y_offset * textSizeY));
         x += pos[i].x_advance * textSizeX;
         y += pos[i].y_advance * textSizeY;
     }
     hb_buffer_clear_contents(buffer);
     return (SkScalar)x;
 }
+
+#else  // !SK_ENABLE_HARFBUZZ
+
+struct SkShaper::Impl {
+    sk_sp<SkTypeface> fTypeface;
+};
+
+SkShaper::SkShaper(sk_sp<SkTypeface> tf) : fImpl(new Impl) {
+    fImpl->fTypeface = tf ? std::move(tf) : SkTypeface::MakeDefault();
+}
+
+SkShaper::~SkShaper() {}
+
+bool SkShaper::good() const { return true; }
+
+SkScalar SkShaper::shape(SkTextBlobBuilder* builder,
+                         const SkPaint& srcPaint,
+                         const char* utf8text,
+                         size_t textBytes,
+                         SkPoint point) const {
+    SkPaint paint(srcPaint);
+    paint.setTypeface(fImpl->fTypeface);
+    paint.setTextEncoding(SkPaint::kUTF8_TextEncoding);
+    int glyphCount = paint.countText(utf8text, textBytes);
+    if (glyphCount <= 0) {
+        return 0;
+    }
+    SkRect bounds;
+    (void)paint.measureText(utf8text, textBytes, &bounds);
+    paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
+    const SkTextBlobBuilder::RunBuffer& runBuffer = builder->allocRunPosH(
+            paint, glyphCount, point.y(), &bounds);
+    paint.setTextEncoding(SkPaint::kUTF8_TextEncoding);
+    (void)paint.textToGlyphs(utf8text, textBytes, runBuffer.glyphs);
+    (void)paint.getTextWidths(utf8text, textBytes, runBuffer.pos);
+    SkScalar x = point.x();
+    for (int i = 0; i < glyphCount; ++i) {
+        SkScalar w = runBuffer.pos[i];
+        runBuffer.pos[i] = x;
+        x += w;
+    }
+    return (SkScalar)x;
+}
+
+#endif  // !SK_ENABLE_HARFBUZZ