[OTS] Integrate WOFF 2.0 algorithm into OTS

src/ots.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ots.h"
 
 #include <sys/types.h>
 #include <zlib.h>
 
 #include <algorithm>
 #include <cstdlib>
 #include <cstring>
 #include <limits>
 #include <map>
 #include <vector>
 
+#include "woff2.h"
+
 // The OpenType Font File
 // http://www.microsoft.com/typography/otspec/cmap.htm
 
 namespace {
 
 bool g_debug_output = true;
+bool g_enable_woff2 = false;
 
 struct OpenTypeTable {
   uint32_t tag;
   uint32_t chksum;
   uint32_t offset;
   uint32_t length;
   uint32_t uncompressed_length;
 };
 
 // Round a value up to the nearest multiple of 4. Don't round the value in the
@@ skipping 362 matching lines @@
       return OTS_FAILURE();
     }
   }
   if (block_end != Round4(length)) {
     return OTS_FAILURE();
   }
 
   return ProcessGeneric(header, woff_tag, output, data, length, tables, file);
 }
 
+bool ProcessWOFF2(ots::OpenTypeFile *header,
+                  ots::OTSStream *output, const uint8_t *data, size_t length) {
+  size_t decompressed_size = ots::ComputeWOFF2FinalSize(data, length);
+  if (decompressed_size == 0) {
+    return OTS_FAILURE();
+  }
+
+  std::vector<uint8_t> decompressed_buffer(decompressed_size);

[Yusuke Sato, 2013/04/17 18:38:46]

* Do we have to zero-fill the buffer?
* Please define the max decompressed size and return with OTS_FAILURE() when
|decompressed_size| exceeds that. With the current code, I guess drive-by web
can easily crash the renderer by oom.

[Kunihiko Sakamoto, 2013/04/23 06:36:26]

Done.
Good catch, thanks.
I set the limit to 30MB, that is somewhat stricter than other formats where sum
of decompressed tables must be <=30MB.

[Yusuke Sato, 2013/05/07 06:11:27]

std::vector<uint8_t> decompressed_buffer(decompressed_size, 0); and
std::vector<uint8_t> decompressed_buffer(decompressed_size); are the same,
aren't they?

Sorry, I should've been more clear. Please do *NOT* zero-clear the buffer unless
it's really necessary. For example, scoped array and new unit8_t[] may suffice.
 

[Kunihiko Sakamoto, 2013/05/07 10:17:23]

Oh, got it.
We should zero clear this buffer, because ConvertWOFF2ToTTF() does not overwrite
padding-bytes.

+  if (!ots::ConvertWOFF2ToTTF(&decompressed_buffer[0], decompressed_size,
+                              data, length)) {
+    return OTS_FAILURE();
+  }
+  return ProcessTTF(header, output, &decompressed_buffer[0], decompressed_size);
+}
+
 bool ProcessGeneric(ots::OpenTypeFile *header, uint32_t signature,
                     ots::OTSStream *output,
                     const uint8_t *data, size_t length,
                     const std::vector<OpenTypeTable>& tables,
                     ots::Buffer& file) {
   const size_t data_offset = file.offset();
 
   uint32_t uncompressed_sum = 0;
 
   for (unsigned i = 0; i < header->num_tables; ++i) {
@@ skipping 261 matching lines @@
 }
 
 }  // namespace
 
 namespace ots {
 
 void DisableDebugOutput() {
   g_debug_output = false;
 }
 
+void EnableWOFF2() {
+  g_enable_woff2 = true;
+}
+
 bool Process(OTSStream *output, const uint8_t *data, size_t length) {
   OpenTypeFile header;
   if (length < 4) {
     return OTS_FAILURE();
   }
 
   bool result;
   if (data[0] == 'w' && data[1] == 'O' && data[2] == 'F' && data[3] == 'F') {
     result = ProcessWOFF(&header, output, data, length);
+  } else if (g_enable_woff2 &&
+             data[0] == 'w' && data[1] == 'O' && data[2] == 'F' &&
+             data[3] == '2') {
+    result = ProcessWOFF2(&header, output, data, length);
   } else {
     result = ProcessTTF(&header, output, data, length);
   }
 
   for (unsigned i = 0; ; ++i) {
     if (table_parsers[i].parse == NULL) break;
     table_parsers[i].free(&header);
   }
   return result;
 }
@@ skipping 14 matching lines @@
     va_start(va, format);
     std::vfprintf(stderr, format, va);
     va_end(va);
     std::fprintf(stderr, "\n");
     std::fflush(stderr);
   }
 }
 #endif
 
 }  // namespace ots