Use woff2 decoder in blink

Source/platform/fonts/opentype/OpenTypeSanitizer.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 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "platform/fonts/opentype/OpenTypeSanitizer.h"
 
 #include "RuntimeEnabledFeatures.h"
 #include "platform/SharedBuffer.h"
 #include "opentype-sanitiser.h"
 #include "ots-memory-stream.h"
+#include "third_party/brotli/src/woff2/woff2_common.h"

[Kunihiko Sakamoto, 2014/06/06 09:41:26]

Is this necessary?

[bashi, 2014/06/06 09:52:15]

That was leftover. Removed.

+#include "third_party/brotli/src/woff2/woff2_dec.h"
+#include "wtf/Vector.h"
 
 namespace WebCore {
 
-PassRefPtr<SharedBuffer> OpenTypeSanitizer::sanitize()
+// This is the largest web font size which we'll try to transcode.
+static const size_t maxWebFontSize = 30 * 1024 * 1024; // 30 MB
+
+static bool isWoff2(SharedBuffer* buffer)
 {
-    if (!m_buffer)
-        return nullptr;
+    static const size_t signatureSize = 4;
+    if (buffer->size() < signatureSize)
+        return false;
 
-    // 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)
-        return nullptr;
+    const char* signature = buffer->data();
+    return signature[0] == 'w' && signature[1] == 'O' && signature[2] == 'F' && signature[3] == '2';
+}
 
-    if (RuntimeEnabledFeatures::woff2Enabled())
-        ots::EnableWOFF2();
-
+static PassRefPtr<SharedBuffer> transcode(const uint8_t* targetData, size_t targetDataSize)
+{
     // 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);
-    if (!ots::Process(&output, reinterpret_cast<const uint8_t*>(m_buffer->data()), m_buffer->size()))
+    ots::ExpandingMemoryStream output(targetDataSize, maxWebFontSize);
+    if (!ots::Process(&output, targetData, targetDataSize))
         return nullptr;
 
     const size_t transcodeLen = output.Tell();
     return SharedBuffer::create(static_cast<unsigned char*>(output.get()), transcodeLen);
 }
 
+PassRefPtr<SharedBuffer> OpenTypeSanitizer::sanitize()
+{
+    if (!m_buffer)
+        return nullptr;
+
+    if (m_buffer->size() > maxWebFontSize)
+        return nullptr;
+
+    const uint8_t* originalData = reinterpret_cast<const uint8_t*>(m_buffer->data());
+    size_t originalDataSize = m_buffer->size();
+    if (RuntimeEnabledFeatures::woff2Enabled() && isWoff2(m_buffer)) {
+        size_t woff2Size = woff2::ComputeWOFF2FinalSize(originalData, originalDataSize);
+        if (woff2Size > maxWebFontSize)
+            return nullptr;
+
+        Vector<uint8_t> woff2Output(woff2Size);
+        if (!woff2::ConvertWOFF2ToTTF(woff2Output.data(), woff2Size, originalData, originalDataSize))
+            return nullptr;
+        return transcode(woff2Output.data(), woff2Size);
+    }
+    return transcode(originalData, originalDataSize);
+}
+
 bool OpenTypeSanitizer::supportsFormat(const String& format)
 {
     return equalIgnoringCase(format, "woff")
         || (RuntimeEnabledFeatures::woff2Enabled() && equalIgnoringCase(format, "woff2"));
 }
 
 } // namespace WebCore