tools/SkShaper: SkStream->blob

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"
 
 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(SkStreamAsset* assetPtr) {

[bungeman-skia, 2016/07/12 15:31:43]

if this is always going to take ownership of the stream then this should take
std::unique_ptr<SkStreamAsset> to document that, should it not? At some point
SkTypeface::openStream will get around to returning this type.

[hal.canary, 2016/07/12 15:35:03]

Done.

+    std::unique_ptr<SkStreamAsset> asset(assetPtr);
+    size_t size = asset->getLength();
+    std::unique_ptr<hb_blob_t, HBFBlobDel> blob;
+    if (const void* base = asset->getMemoryBase()) {
+        blob.reset(hb_blob_create((char*)base, size,
+                                  HB_MEMORY_MODE_READONLY, asset.release(),
+                                  [](void* p) { delete (SkStreamAsset*)p; }));
+    } else {
+        // SkDebugf("Extra SkStreamAsset copy\n");
+        SkAutoMalloc autoMalloc(size);
+        asset->read(autoMalloc.get(), size);
+        void* ptr = autoMalloc.get();
+        blob.reset(hb_blob_create((char*)autoMalloc.release(), size,
+                                  HB_MEMORY_MODE_READONLY, ptr, sk_free));
+    }
+    SkASSERT(blob);
+    hb_blob_make_immutable(blob.get());
+    return blob;
+}
+}  // namespace
+
 struct SkShaper::Impl {
     struct HBFontDel {
         void operator()(hb_font_t* f) { hb_font_destroy(f); }
     };
     std::unique_ptr<hb_font_t, HBFontDel> fHarfBuzzFont;
     struct HBBufDel {
         void operator()(hb_buffer_t* b) { hb_buffer_destroy(b); }
     };
     std::unique_ptr<hb_buffer_t, HBBufDel> fBuffer;
     sk_sp<SkTypeface> fTypeface;
 };
 
 SkShaper::SkShaper(sk_sp<SkTypeface> tf) : fImpl(new Impl) {
     fImpl->fTypeface = tf ? std::move(tf) : SkTypeface::MakeDefault();
     int index;
-    std::unique_ptr<SkStreamAsset> asset(fImpl->fTypeface->openStream(&index));
-    size_t size = asset->getLength();
-    SkAutoMalloc autoMalloc(size);  // TODO(halcanary): Avoid this malloc+copy.
-    asset->read(autoMalloc.get(), size);
-    asset = nullptr;
-    void* ptr = autoMalloc.get();
-    hb_blob_t* blob = hb_blob_create((char*)autoMalloc.release(), size,
-                                     HB_MEMORY_MODE_READONLY, ptr, sk_free);
-    SkASSERT(blob);
-    hb_blob_make_immutable(blob);
-
+    std::unique_ptr<hb_blob_t, HBFBlobDel> blob(
+            stream_to_blob(fImpl->fTypeface->openStream(&index)));
     struct HBFaceDel {
         void operator()(hb_face_t* f) { hb_face_destroy(f); }
     };
-    std::unique_ptr<hb_face_t, HBFaceDel> face(hb_face_create(blob, (unsigned)index));
-    hb_blob_destroy(blob);
+    std::unique_ptr<hb_face_t, HBFaceDel> face(
+            hb_face_create(blob.get(), (unsigned)index));
     SkASSERT(face);
     if (!face) {
         return;
     }
     hb_face_set_index(face.get(), (unsigned)index);
     hb_face_set_upem(face.get(), fImpl->fTypeface->getUnitsPerEm());
 
     fImpl->fHarfBuzzFont.reset(hb_font_create(face.get()));
     SkASSERT(fImpl->fHarfBuzzFont);
     hb_font_set_scale(fImpl->fHarfBuzzFont.get(), FONT_SIZE_SCALE, FONT_SIZE_SCALE);
@@ skipping 41 matching lines @@
         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);
         x += pos[i].x_advance * textSizeX;
         y += pos[i].y_advance * textSizeY;
     }
     hb_buffer_clear_contents(buffer);
     return (SkScalar)x;
 }