Update OTS to revision a7a3b94

third_party/ots/src/ots.h

 // 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.
 
 #ifndef OTS_H_
 #define OTS_H_
 
 #include <stddef.h>
 #include <cstdarg>
 #include <cstddef>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <limits>
+#include <map>
 
 #include "opentype-sanitiser.h"
 
 // arraysize borrowed from base/basictypes.h
 template <typename T, size_t N>
 char (&ArraySizeHelper(T (&array)[N]))[N];
 #define arraysize(array) (sizeof(ArraySizeHelper(array)))
 
 namespace ots {
 
@@ skipping 23 matching lines @@
 
 // Generate a simple message
 #define OTS_FAILURE_MSG_(otf_,...) \
   (OTS_MESSAGE_(0,otf_,__VA_ARGS__), false)
 
 #define OTS_WARNING_MSG_(otf_,...) \
   OTS_MESSAGE_(1,otf_,__VA_ARGS__)
 
 // Generate a message with an associated table tag
 #define OTS_FAILURE_MSG_TAG_(otf_,msg_,tag_) \
-  (OTS_MESSAGE_(0,otf_,"%4.4s: %s", tag_, msg_), false)
+  (OTS_MESSAGE_(0,otf_,"%c%c%c%c: %s", OTS_UNTAG(tag_), msg_), false)
 
 // Convenience macros for use in files that only handle a single table tag,
 // defined as TABLE_NAME at the top of the file; the 'file' variable is
 // expected to be the current OpenTypeFile pointer.
-#define OTS_FAILURE_MSG(...) OTS_FAILURE_MSG_(file, TABLE_NAME ": " __VA_ARGS__)
+#define OTS_FAILURE_MSG(...) OTS_FAILURE_MSG_(font->file, TABLE_NAME ": " __VA_ARGS__)
 
-#define OTS_WARNING(...) OTS_WARNING_MSG_(file, TABLE_NAME ": " __VA_ARGS__)
+#define OTS_WARNING(...) OTS_WARNING_MSG_(font->file, TABLE_NAME ": " __VA_ARGS__)
 
 // -----------------------------------------------------------------------------
 // Buffer helper class
 //
 // This class perform some trival buffer operations while checking for
 // out-of-bounds errors. As a family they return false if anything is amiss,
 // updating the current offset otherwise.
 // -----------------------------------------------------------------------------
 class Buffer {
  public:
@@ skipping 62 matching lines @@
     std::memcpy(value, buffer_ + offset_, sizeof(uint32_t));
     *value = ntohl(*value);
     offset_ += 4;
     return true;
   }
 
   bool ReadS32(int32_t *value) {
     return ReadU32(reinterpret_cast<uint32_t*>(value));
   }
 
-  bool ReadTag(uint32_t *value) {
-    if (offset_ + 4 > length_) {
-      return OTS_FAILURE();
-    }
-    std::memcpy(value, buffer_ + offset_, sizeof(uint32_t));
-    offset_ += 4;
-    return true;
-  }
-
   bool ReadR64(uint64_t *value) {
     if (offset_ + 8 > length_) {
       return OTS_FAILURE();
     }
     std::memcpy(value, buffer_ + offset_, sizeof(uint64_t));
     offset_ += 8;
     return true;
   }
 
   const uint8_t *buffer() const { return buffer_; }
@@ skipping 51 matching lines @@
   F(prep, PREP) \
   F(vdmx, VDMX) \
   F(vorg, VORG) \
   F(vhea, VHEA) \
   F(vmtx, VMTX)
 
 #define F(name, capname) struct OpenType##capname;
 FOR_EACH_TABLE_TYPE
 #undef F
 
-struct OpenTypeFile {
-  OpenTypeFile() {
-#define F(name, capname) name = NULL;
+struct Font;
+struct OpenTypeFile;
+
+#define F(name, capname) \
+bool ots_##name##_parse(Font *f, const uint8_t *d, size_t l); \
+bool ots_##name##_should_serialise(Font *f); \
+bool ots_##name##_serialise(OTSStream *s, Font *f); \
+void ots_##name##_reuse(Font *f, Font *o);\
+void ots_##name##_free(Font *f);
+FOR_EACH_TABLE_TYPE
+#undef F
+
+struct Font {
+  Font(const OpenTypeFile *f) {
+    file = f;
+#define F(name, capname) \
+    name = NULL; \
+    name##_reused = false;
     FOR_EACH_TABLE_TYPE
 #undef F
   }
 
+  ~Font() {
+#define F(name, capname) \
+    if (!name##_reused) {\
+      ots_##name##_free(this); \
+    }
+    FOR_EACH_TABLE_TYPE
+#undef F
+  }
+
+  const OpenTypeFile *file;
+
   uint32_t version;
   uint16_t num_tables;
   uint16_t search_range;
   uint16_t entry_selector;
   uint16_t range_shift;
 
-  OTSContext *context;
-
-#define F(name, capname) OpenType##capname *name;
+#define F(name, capname) \
+  OpenType##capname *name; \
+  bool name##_reused;
 FOR_EACH_TABLE_TYPE
 #undef F
 };
 
-#define F(name, capname) \
-bool ots_##name##_parse(OpenTypeFile *f, const uint8_t *d, size_t l); \
-bool ots_##name##_should_serialise(OpenTypeFile *f); \
-bool ots_##name##_serialise(OTSStream *s, OpenTypeFile *f); \
-void ots_##name##_free(OpenTypeFile *f);
-// TODO(yusukes): change these function names to follow Chromium coding rule.
-FOR_EACH_TABLE_TYPE
-#undef F
+struct OutputTable {
+  uint32_t tag;
+  size_t offset;
+  size_t length;
+  uint32_t chksum;
+
+  bool operator<(const OutputTable& other) const {
+    return tag < other.tag;
+  }
+};
+
+typedef std::map<uint32_t, std::pair<Font*, OutputTable> > TableMap;
+
+struct OpenTypeFile {
+  OTSContext *context;
+  TableMap tables;
+};
 
 }  // namespace ots
 
+#undef FOR_EACH_TABLE_TYPE
+
 #endif  // OTS_H_