Avoid one temporary copy on web fonts decoding

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

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 10 matching lines @@
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "platform/fonts/opentype/OpenTypeSanitizer.h"
+#include "platform/fonts/WebFontDecoder.h"
 
-#include "hb.h"
-#include "ots-memory-stream.h"
 #include "platform/Histogram.h"
 #include "platform/SharedBuffer.h"
 #include "platform/TraceEvent.h"
+#include "platform/fonts/FontCache.h"
 #include "public/platform/Platform.h"
+#include "third_party/harfbuzz-ng/src/hb.h"
+#include "third_party/ots/include/ots-memory-stream.h"
+#include "third_party/skia/include/core/SkStream.h"
 #include "wtf/CurrentTime.h"
 
 #include <stdarg.h>
 
 namespace blink {
 
-static void recordDecodeSpeedHistogram(SharedBuffer* buffer, double decodeTime, size_t decodedSize)
-{
-    if (decodeTime <= 0)
-        return;
+namespace {
 
-    double kbPerSecond = decodedSize / (1000 * decodeTime);
-    if (buffer->size() >= 4) {
-        const char* data = buffer->data();
-        if (data[0] == 'w' && data[1] == 'O' && data[2] == 'F' && data[3] == 'F') {
-            DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, woffHistogram, new CustomCountHistogram("WebFont.DecodeSpeed.WOFF", 1000, 300000, 50));
-            woffHistogram.count(kbPerSecond);
-            return;
-        }
+class BlinkOTSContext final : public ots::OTSContext {
+    DISALLOW_NEW();
+public:
 
-        if (data[0] == 'w' && data[1] == 'O' && data[2] == 'F' && data[3] == '2') {
-            DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, woff2Histogram, new CustomCountHistogram("WebFont.DecodeSpeed.WOFF2", 1000, 300000, 50));
-            woff2Histogram.count(kbPerSecond);
-            return;
-        }
-    }
+    void Message(int level, const char *format, ...) override;
+    ots::TableAction GetTableAction(uint32_t tag) override;
+    const String& getErrorString() { return m_errorString; }
 
-    DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, sfntHistogram, new CustomCountHistogram("WebFont.DecodeSpeed.SFNT", 1000, 300000, 50));
-    sfntHistogram.count(kbPerSecond);
-}
-
-PassRefPtr<SharedBuffer> OpenTypeSanitizer::sanitize()
-{
-    if (!m_buffer) {
-        setErrorString("Empty Buffer");
-        return nullptr;
-    }
-
-    // This is the largest web font size which we'll try to transcode.
-    static const size_t maxWebFontSize = 30 * 1024 * 1024; // 30 MB
-    if (m_buffer->size() > maxWebFontSize) {
-        setErrorString("Web font size more than 30MB");
-        return nullptr;
-    }
-
-    // A transcoded font is usually smaller than an original font.
-    // However, it can be slightly bigger than the original one due to
-    // name table replacement and/or padding for glyf table.
-    //
-    // With WOFF fonts, however, we'll be decompressing, so the result can be
-    // much larger than the original.
-
-    ots::ExpandingMemoryStream output(m_buffer->size(), maxWebFontSize);
-    double start = currentTime();
-    BlinkOTSContext otsContext;
-
-    TRACE_EVENT_BEGIN0("blink", "DecodeFont");
-    bool ok = otsContext.Process(&output, reinterpret_cast<const uint8_t*>(m_buffer->data()), m_buffer->size());
-    TRACE_EVENT_END0("blink", "DecodeFont");
-
-    if (!ok) {
-        setErrorString(otsContext.getErrorString());
-        return nullptr;
-    }
-
-    const size_t transcodeLen = output.Tell();
-    recordDecodeSpeedHistogram(m_buffer, currentTime() - start, transcodeLen);
-    return SharedBuffer::create(static_cast<unsigned char*>(output.get()), transcodeLen);
-}
-
-bool OpenTypeSanitizer::supportsFormat(const String& format)
-{
-    return equalIgnoringCase(format, "woff") || equalIgnoringCase(format, "woff2");
-}
+private:
+    String m_errorString;
+};
 
 void BlinkOTSContext::Message(int level, const char *format, ...)
 {
     va_list args;
     va_start(args, format);
 
 #if COMPILER(MSVC)
     int result = _vscprintf(format, args);
 #else
     char ch;
@@ skipping 43 matching lines @@
     case gdefTag:
     case gposTag:
     case gsubTag:
 #endif
         return ots::TABLE_ACTION_PASSTHRU;
     default:
         return ots::TABLE_ACTION_DEFAULT;
     }
 }
 
+void recordDecodeSpeedHistogram(const char* data, size_t length, double decodeTime, size_t decodedSize)
+{
+    if (decodeTime <= 0)
+        return;
+
+    double kbPerSecond = decodedSize / (1000 * decodeTime);
+    if (length >= 4) {
+        if (data[0] == 'w' && data[1] == 'O' && data[2] == 'F' && data[3] == 'F') {
+            DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, woffHistogram, new CustomCountHistogram("WebFont.DecodeSpeed.WOFF", 1000, 300000, 50));
+            woffHistogram.count(kbPerSecond);
+            return;
+        }
+
+        if (data[0] == 'w' && data[1] == 'O' && data[2] == 'F' && data[3] == '2') {
+            DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, woff2Histogram, new CustomCountHistogram("WebFont.DecodeSpeed.WOFF2", 1000, 300000, 50));
+            woff2Histogram.count(kbPerSecond);
+            return;
+        }
+    }
+
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, sfntHistogram, new CustomCountHistogram("WebFont.DecodeSpeed.SFNT", 1000, 300000, 50));
+    sfntHistogram.count(kbPerSecond);
+}
+
+} // namespace
+
+// static
+bool WebFontDecoder::supportsFormat(const String& format)
+{
+    return equalIgnoringCase(format, "woff") || equalIgnoringCase(format, "woff2");
+}
+
+PassRefPtr<SkTypeface> WebFontDecoder::decode(SharedBuffer* buffer)
+{
+    if (!buffer) {
+        setErrorString("Empty Buffer");
+        return nullptr;
+    }
+
+    // This is the largest web font size which we'll try to transcode.
+    // TODO(bashi): 30MB seems low. Update the limit if necessary.
+    static const size_t maxWebFontSize = 30 * 1024 * 1024; // 30 MB
+    if (buffer->size() > maxWebFontSize) {
+        setErrorString("Web font size more than 30MB");
+        return nullptr;
+    }
+
+    // Most web fonts are compressed, so the result can be much larger than
+    // the original.
+    ots::ExpandingMemoryStream output(buffer->size(), maxWebFontSize);
+    double start = currentTime();
+    BlinkOTSContext otsContext;
+    const char* data = buffer->data();
+
+    TRACE_EVENT_BEGIN0("blink", "DecodeFont");
+    bool ok = otsContext.Process(&output, reinterpret_cast<const uint8_t*>(data), buffer->size());
+    TRACE_EVENT_END0("blink", "DecodeFont");
+
+    if (!ok) {
+        setErrorString(otsContext.getErrorString());
+        return nullptr;
+    }
+
+    const size_t decodedLength = output.Tell();
+    recordDecodeSpeedHistogram(data, buffer->size(), currentTime() - start, decodedLength);
+
+    sk_sp<SkData> skData = SkData::MakeWithCopy(output.get(), decodedLength);
+    SkMemoryStream* stream = new SkMemoryStream(skData);
+#if OS(WIN)
+    RefPtr<SkTypeface> typeface = adoptRef(FontCache::fontCache()->fontManager()->createFromStream(stream));
+#else
+    RefPtr<SkTypeface> typeface = adoptRef(SkTypeface::CreateFromStream(stream));
+#endif
+    if (!typeface) {
+        setErrorString("Not a valid font data");
+        return nullptr;
+    }
+
+    return typeface.release();
+}
+
 } // namespace blink