--- a/dom/base/nsDOMWindowUtils.cpp
+++ b/dom/base/nsDOMWindowUtils.cpp
@@ -2830,18 +2830,18 @@ nsDOMWindowUtils::AreDialogsEnabled(bool
 static nsIDOMBlob*
 GetXPConnectNative(JSContext* aCx, JSObject* aObj) {
   nsCOMPtr<nsIDOMBlob> blob = do_QueryInterface(
     nsContentUtils::XPConnect()->GetNativeOfWrapper(aCx, aObj));
   return blob;
 }
 
 static nsresult
-GetFileOrBlob(const nsAString& aName, const JS::Value& aBlobParts,
-              const JS::Value& aParameters, JSContext* aCx,
+GetFileOrBlob(const nsAString& aName, JS::Handle<JS::Value> aBlobParts,
+              JS::Handle<JS::Value> aParameters, JSContext* aCx,
               uint8_t aOptionalArgCount, nsISupports** aResult)
 {
   if (!nsContentUtils::IsCallerChrome()) {
     return NS_ERROR_DOM_SECURITY_ERR;
   }
 
   nsresult rv;
 
@@ -2853,19 +2853,22 @@ GetFileOrBlob(const nsAString& aName, co
   else {
     rv = nsDOMMultipartFile::NewFile(aName, getter_AddRefs(file));
   }
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsDOMMultipartFile* domFile =
     static_cast<nsDOMMultipartFile*>(static_cast<nsIDOMFile*>(file.get()));
 
-  JS::Value args[2] = { aBlobParts, aParameters };
-
-  rv = domFile->InitBlob(aCx, aOptionalArgCount, args, GetXPConnectNative);
+  JS::AutoValueVector args(aCx);
+  MOZ_ALWAYS_TRUE(args.resize(2));
+  args[0] = aBlobParts;
+  args[1] = aParameters;
+
+  rv = domFile->InitBlob(aCx, aOptionalArgCount, args.begin(), GetXPConnectNative);
   NS_ENSURE_SUCCESS(rv, rv);
 
   file.forget(aResult);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDOMWindowUtils::GetFile(const nsAString& aName, JS::Handle<JS::Value> aBlobParts,

--- a/gfx/layers/opengl/CompositorOGL.cpp
+++ b/gfx/layers/opengl/CompositorOGL.cpp
@@ -904,17 +904,17 @@ CompositorOGL::CreateFBOWithTexture(cons
     bool isFormatCompatibleWithRGBA
         = gl()->IsGLES2() ? (format == LOCAL_GL_RGBA)
                           : true;
 
     if (isFormatCompatibleWithRGBA) {
       mGLContext->fCopyTexImage2D(mFBOTextureTarget,
                                   0,
                                   LOCAL_GL_RGBA,
-                                  aRect.x, aRect.y,
+                                  aRect.x, FlipY(aRect.y + aRect.height),
                                   aRect.width, aRect.height,
                                   0);
     } else {
       // Curses, incompatible formats.  Take a slow path.
 
       // RGBA
       size_t bufferSize = aRect.width * aRect.height * 4;
       nsAutoArrayPtr<uint8_t> buf(new uint8_t[bufferSize]);

--- a/gfx/ots/README.mozilla
+++ b/gfx/ots/README.mozilla
@@ -1,14 +1,10 @@
 This is the Sanitiser for OpenType project, from http://code.google.com/p/ots/.
 
-Current revision: r95
+Our reference repository is https://github.com/khaledhosny/ots/.
+
+Current revision: d7d831edd171054c7974f5e0dec2fc19bf869574
 
 Applied local patches:
-    ots-fix-vc10.patch - workaround for VS10 STL wrappers (bug 602558)
-
-    ots-fix-sparc64.patch - fix alignment error on sparc64 (bug 643137)
-
-    ots-graphite.patch - preserve Graphite layout tables (bug 631479)
-
     ots-visibility.patch - make Process function externally visible for Windows DLL (bug 711079)
 
-Patches from https://bugzilla.mozilla.org/show_bug.cgi?id=670901.
+    ots-woff2 - disable WOFF2 support (bug 941019)

--- a/gfx/ots/include/opentype-sanitiser.h
+++ b/gfx/ots/include/opentype-sanitiser.h
@@ -39,17 +39,17 @@ typedef unsigned __int64 uint64_t;
 #define ntohs(x) _byteswap_ushort (x)
 #define htonl(x) _byteswap_ulong (x)
 #define htons(x) _byteswap_ushort (x)
 #else
 #include <arpa/inet.h>
 #include <stdint.h>
 #endif
 
-#include <algorithm>  // for std::min
+#include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstring>
 
 namespace ots {
 
 // -----------------------------------------------------------------------------
 // This is an interface for an abstract stream class which is used for writing
@@ -76,19 +76,19 @@ class OTSStream {
         std::min(length, static_cast<size_t>(4) - chksum_buffer_offset_);
       std::memcpy(chksum_buffer_ + chksum_buffer_offset_, data, l);
       chksum_buffer_offset_ += l;
       offset += l;
       length -= l;
     }
 
     if (chksum_buffer_offset_ == 4) {
-      uint32_t chksum;
-      std::memcpy(&chksum, chksum_buffer_, 4);
-      chksum_ += ntohl(chksum);
+      uint32_t tmp;
+      std::memcpy(&tmp, chksum_buffer_, 4);
+      chksum_ += ntohl(tmp);
       chksum_buffer_offset_ = 0;
     }
 
     while (length >= 4) {
       uint32_t tmp;
       std::memcpy(&tmp, reinterpret_cast<const uint8_t *>(data) + offset,
         sizeof(uint32_t));
       chksum_ += ntohl(tmp);
@@ -194,37 +194,58 @@ class OTSStream {
   }
 
  protected:
   uint32_t chksum_;
   uint8_t chksum_buffer_[4];
   unsigned chksum_buffer_offset_;
 };
 
-#ifdef MOZ_OTS_REPORT_ERRORS
-// Signature of the function to be provided by the client in order to report errors.
-// The return type is a boolean so that it can be used within an expression,
-// but the actual value is ignored. (Suggested convention is to always return 'false'.)
-typedef bool (*MessageFunc)(void *user_data, const char *format, ...);
-#endif
-
 // -----------------------------------------------------------------------------
 // Process a given OpenType file and write out a sanitised version
 //   output: a pointer to an object implementing the OTSStream interface. The
 //     sanitisied output will be written to this. In the even of a failure,
 //     partial output may have been written.
 //   input: the OpenType file
 //   length: the size, in bytes, of |input|
-//   preserve_graphite_tables: whether to preserve Graphite Layout tables
 // -----------------------------------------------------------------------------
-bool OTS_API Process(OTSStream *output, const uint8_t *input, size_t length,
-#ifdef MOZ_OTS_REPORT_ERRORS
-                     MessageFunc message_func, void *user_data,
+bool OTS_API Process(OTSStream *output, const uint8_t *input, size_t length);
+
+// Signature of the function to be provided by the client in order to report errors.
+// The return type is a boolean so that it can be used within an expression,
+// but the actual value is ignored. (Suggested convention is to always return 'false'.)
+#ifdef __GCC__
+#define MSGFUNC_FMT_ATTR __attribute__((format(printf, 2, 3)))
+#else
+#define MSGFUNC_FMT_ATTR
 #endif
-                     bool preserve_graphite_tables = false);
+typedef bool (*MessageFunc)(void *user_data, const char *format, ...)  MSGFUNC_FMT_ATTR;
+
+// Set a callback function that will be called when OTS is reporting an error.
+void OTS_API SetMessageCallback(MessageFunc func, void *user_data);
+
+enum TableAction {
+  TABLE_ACTION_DEFAULT,  // Use OTS's default action for that table
+  TABLE_ACTION_SANITIZE, // Sanitize the table, potentially droping it
+  TABLE_ACTION_PASSTHRU, // Serialize the table unchanged
+  TABLE_ACTION_DROP      // Drop the table
+};
+
+// Signature of the function to be provided by the client to decide what action
+// to do for a given table.
+typedef TableAction (*TableActionFunc)(uint32_t tag, void *user_data);
+
+// Set a callback function that will be called when OTS needs to decide what to
+// do for a font table.
+void OTS_API SetTableActionCallback(TableActionFunc func, void *user_data);
 
 // Force to disable debug output even when the library is compiled with
 // -DOTS_DEBUG.
 void DisableDebugOutput();
 
+#ifdef MOZ_OTS_WOFF2
+// Enable WOFF2 support(experimental).
+void EnableWOFF2();
+#endif
+
 }  // namespace ots
 
 #endif  // OPENTYPE_SANITISER_H_

--- a/gfx/ots/include/ots-memory-stream.h
+++ b/gfx/ots/include/ots-memory-stream.h
@@ -66,17 +66,17 @@ class ExpandingMemoryStream : public OTS
       if (length_ == limit_)
         return false;
       size_t new_length = (length_ + 1) * 2;
       if (new_length < length_)
         return false;
       if (new_length > limit_)
         new_length = limit_;
       uint8_t* new_buf = new uint8_t[new_length];
-      memcpy(new_buf, ptr_, length_);
+      std::memcpy(new_buf, ptr_, length_);
       length_ = new_length;
       delete[] static_cast<uint8_t*>(ptr_);
       ptr_ = new_buf;
       return WriteRaw(data, length);
     }
     std::memcpy(static_cast<char*>(ptr_) + off_, data, length);
     off_ += length;
     return true;

deleted file mode 100644
--- a/gfx/ots/ots-fix-sparc64.patch
+++ /dev/null
@@ -1,26 +0,0 @@
-diff --git a/gfx/ots/include/opentype-sanitiser.h b/gfx/ots/include/opentype-sanitiser.h
---- a/gfx/ots/include/opentype-sanitiser.h
-+++ b/gfx/ots/include/opentype-sanitiser.h
-@@ -83,18 +83,20 @@ class OTSStream {
-     if (chksum_buffer_offset_ == 4) {
-       uint32_t chksum;
-       std::memcpy(&chksum, chksum_buffer_, 4);
-       chksum_ += ntohl(chksum);
-       chksum_buffer_offset_ = 0;
-     }
- 
-     while (length >= 4) {
--      chksum_ += ntohl(*reinterpret_cast<const uint32_t*>(
--          reinterpret_cast<const uint8_t*>(data) + offset));
-+      uint32_t tmp;
-+      std::memcpy(&tmp, reinterpret_cast<const uint8_t *>(data) + offset,
-+        sizeof(uint32_t));
-+      chksum_ += ntohl(tmp);
-       length -= 4;
-       offset += 4;
-     }
- 
-     if (length) {
-       if (chksum_buffer_offset_ != 0) return false;  // not reached
-       if (length > 4) return false;  // not reached
-       std::memcpy(chksum_buffer_,

deleted file mode 100644
--- a/gfx/ots/ots-fix-vc10.patch
+++ /dev/null
@@ -1,60 +0,0 @@
-diff --git a/gfx/ots/src/gasp.h b/gfx/ots/src/gasp.h
---- a/gfx/ots/src/gasp.h
-+++ b/gfx/ots/src/gasp.h
-@@ -1,15 +1,16 @@
- // 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_GASP_H_
- #define OTS_GASP_H_
- 
-+#include <new>
- #include <utility>  // std::pair
- #include <vector>
- 
- #include "ots.h"
- 
- namespace ots {
- 
- struct OpenTypeGASP {
-diff --git a/gfx/ots/src/glyf.h b/gfx/ots/src/glyf.h
---- a/gfx/ots/src/glyf.h
-+++ b/gfx/ots/src/glyf.h
-@@ -1,15 +1,16 @@
- // 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_GLYF_H_
- #define OTS_GLYF_H_
- 
-+#include <new>
- #include <utility>  // std::pair
- #include <vector>
- 
- #include "ots.h"
- 
- namespace ots {
- 
- struct OpenTypeGLYF {
-diff --git a/gfx/ots/src/metrics.h b/gfx/ots/src/metrics.h
---- a/gfx/ots/src/metrics.h
-+++ b/gfx/ots/src/metrics.h
-@@ -1,15 +1,16 @@
- // Copyright (c) 2011 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_METRICS_H_
- #define OTS_METRICS_H_
- 
-+#include <new>
- #include <utility>  // std::pair
- #include <vector>
- 
- #include "ots.h"
- 
- namespace ots {
- 
- struct OpenTypeMetricsHeader {

deleted file mode 100644
--- a/gfx/ots/ots-graphite.patch
+++ /dev/null
@@ -1,131 +0,0 @@
-diff --git a/gfx/ots/include/opentype-sanitiser.h b/gfx/ots/include/opentype-sanitiser.h
---- a/gfx/ots/include/opentype-sanitiser.h
-+++ b/gfx/ots/include/opentype-sanitiser.h
-@@ -176,18 +176,20 @@ class OTSStream {
- 
- // -----------------------------------------------------------------------------
- // Process a given OpenType file and write out a sanitised version
- //   output: a pointer to an object implementing the OTSStream interface. The
- //     sanitisied output will be written to this. In the even of a failure,
- //     partial output may have been written.
- //   input: the OpenType file
- //   length: the size, in bytes, of |input|
-+//   preserve_graphite_tables: whether to preserve Graphite Layout tables
- // -----------------------------------------------------------------------------
--bool Process(OTSStream *output, const uint8_t *input, size_t length);
-+bool Process(OTSStream *output, const uint8_t *input, size_t length,
-+             bool preserve_graphite_tables = false);
- 
- // Force to disable debug output even when the library is compiled with
- // -DOTS_DEBUG.
- void DisableDebugOutput();
- 
- }  // namespace ots
- 
- #endif  // OPENTYPE_SANITISER_H_
-diff --git a/gfx/ots/src/ots.cc b/gfx/ots/src/ots.cc
---- a/gfx/ots/src/ots.cc
-+++ b/gfx/ots/src/ots.cc
-@@ -138,16 +138,27 @@ const struct {
-   { "GPOS", ots::ots_gpos_parse, ots::ots_gpos_serialise,
-     ots::ots_gpos_should_serialise, ots::ots_gpos_free, false },
-   { "GSUB", ots::ots_gsub_parse, ots::ots_gsub_serialise,
-     ots::ots_gsub_should_serialise, ots::ots_gsub_free, false },
-   { "vhea", ots::ots_vhea_parse, ots::ots_vhea_serialise,
-     ots::ots_vhea_should_serialise, ots::ots_vhea_free, false },
-   { "vmtx", ots::ots_vmtx_parse, ots::ots_vmtx_serialise,
-     ots::ots_vmtx_should_serialise, ots::ots_vmtx_free, false },
-+  // SILGraphite layout tables - not actually parsed, just copied
-+  { "Silf", ots::ots_silf_parse, ots::ots_silf_serialise,
-+    ots::ots_silf_should_serialise, ots::ots_silf_free, false },
-+  { "Sill", ots::ots_sill_parse, ots::ots_sill_serialise,
-+    ots::ots_sill_should_serialise, ots::ots_sill_free, false },
-+  { "Gloc", ots::ots_gloc_parse, ots::ots_gloc_serialise,
-+    ots::ots_gloc_should_serialise, ots::ots_gloc_free, false },
-+  { "Glat", ots::ots_glat_parse, ots::ots_glat_serialise,
-+    ots::ots_glat_should_serialise, ots::ots_glat_free, false },
-+  { "Feat", ots::ots_feat_parse, ots::ots_feat_serialise,
-+    ots::ots_feat_should_serialise, ots::ots_feat_free, false },
-   // TODO(bashi): Support mort, base, and jstf tables.
-   { 0, NULL, NULL, NULL, NULL, false },
- };
- 
- bool IsValidVersionTag(uint32_t tag) {
-   return tag == Tag("\x00\x01\x00\x00") ||
-          // OpenType fonts with CFF data have 'OTTO' tag.
-          tag == Tag("OTTO") ||
-@@ -581,22 +592,25 @@ bool ProcessGeneric(ots::OpenTypeFile *h
- }  // namespace
- 
- namespace ots {
- 
- void DisableDebugOutput() {
-   g_debug_output = false;
- }
- 
--bool Process(OTSStream *output, const uint8_t *data, size_t length) {
-+bool Process(OTSStream *output, const uint8_t *data, size_t length,
-+             bool preserveGraphite) {
-   OpenTypeFile header;
-   if (length < 4) {
-     return OTS_FAILURE();
-   }
- 
-+  header.preserve_graphite = preserveGraphite;
-+
-   bool result;
-   if (data[0] == 'w' && data[1] == 'O' && data[2] == 'F' && data[3] == 'F') {
-     result = ProcessWOFF(&header, output, data, length);
-   } else {
-     result = ProcessTTF(&header, output, data, length);
-   }
- 
-   for (unsigned i = 0; ; ++i) {
-diff --git a/gfx/ots/src/ots.h b/gfx/ots/src/ots.h
---- a/gfx/ots/src/ots.h
-+++ b/gfx/ots/src/ots.h
-@@ -178,17 +178,22 @@ class Buffer {
-   F(maxp, MAXP) \
-   F(name, NAME) \
-   F(os2, OS2) \
-   F(post, POST) \
-   F(prep, PREP) \
-   F(vdmx, VDMX) \
-   F(vorg, VORG) \
-   F(vhea, VHEA) \
--  F(vmtx, VMTX)
-+  F(vmtx, VMTX) \
-+  F(silf, SILF) \
-+  F(sill, SILL) \
-+  F(glat, GLAT) \
-+  F(gloc, GLOC) \
-+  F(feat, FEAT)
- 
- #define F(name, capname) struct OpenType##capname;
- FOR_EACH_TABLE_TYPE
- #undef F
- 
- struct OpenTypeFile {
-   OpenTypeFile() {
- #define F(name, capname) name = NULL;
-@@ -197,16 +202,20 @@ struct OpenTypeFile {
-   }
- 
-   uint32_t version;
-   uint16_t num_tables;
-   uint16_t search_range;
-   uint16_t entry_selector;
-   uint16_t range_shift;
- 
-+  // This is used to tell the relevant parsers whether to preserve the
-+  // Graphite layout tables (currently _without_ any checking)
-+  bool preserve_graphite;
-+
- #define F(name, capname) OpenType##capname *name;
- 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); \

--- a/gfx/ots/ots-visibility.patch
+++ b/gfx/ots/ots-visibility.patch
@@ -32,29 +32,57 @@ diff --git a/gfx/ots/include/opentype-sa
  #if defined(_WIN32)
  #include <stdlib.h>
  typedef signed char int8_t;
  typedef unsigned char uint8_t;
  typedef short int16_t;
  typedef unsigned short uint16_t;
  typedef int int32_t;
  typedef unsigned int uint32_t;
-@@ -178,18 +198,18 @@ class OTSStream {
+@@ -182,45 +202,45 @@ class OTSStream {
+ // -----------------------------------------------------------------------------
  // Process a given OpenType file and write out a sanitised version
  //   output: a pointer to an object implementing the OTSStream interface. The
  //     sanitisied output will be written to this. In the even of a failure,
  //     partial output may have been written.
  //   input: the OpenType file
  //   length: the size, in bytes, of |input|
- //   preserve_graphite_tables: whether to preserve Graphite Layout tables
  // -----------------------------------------------------------------------------
--bool Process(OTSStream *output, const uint8_t *input, size_t length,
--             bool preserve_graphite_tables = false);
-+bool OTS_API Process(OTSStream *output, const uint8_t *input, size_t length,
-+                     bool preserve_graphite_tables = false);
+-bool Process(OTSStream *output, const uint8_t *input, size_t length);
++bool OTS_API Process(OTSStream *output, const uint8_t *input, size_t length);
+ 
+ // Signature of the function to be provided by the client in order to report errors.
+ // The return type is a boolean so that it can be used within an expression,
+ // but the actual value is ignored. (Suggested convention is to always return 'false'.)
+ #ifdef __GCC__
+ #define MSGFUNC_FMT_ATTR __attribute__((format(printf, 2, 3)))
+ #else
+ #define MSGFUNC_FMT_ATTR
+ #endif
+ typedef bool (*MessageFunc)(void *user_data, const char *format, ...)  MSGFUNC_FMT_ATTR;
+ 
+ // Set a callback function that will be called when OTS is reporting an error.
+-void SetMessageCallback(MessageFunc func, void *user_data);
++void OTS_API SetMessageCallback(MessageFunc func, void *user_data);
+ 
+ enum TableAction {
+   TABLE_ACTION_DEFAULT,  // Use OTS's default action for that table
+   TABLE_ACTION_SANITIZE, // Sanitize the table, potentially droping it
+   TABLE_ACTION_PASSTHRU, // Serialize the table unchanged
+   TABLE_ACTION_DROP      // Drop the table
+ };
+ 
+ // Signature of the function to be provided by the client to decide what action
+ // to do for a given table.
+ typedef TableAction (*TableActionFunc)(uint32_t tag, void *user_data);
+ 
+ // Set a callback function that will be called when OTS needs to decide what to
+ // do for a font table.
+-void SetTableActionCallback(TableActionFunc func, void *user_data);
++void OTS_API SetTableActionCallback(TableActionFunc func, void *user_data);
  
  // Force to disable debug output even when the library is compiled with
  // -DOTS_DEBUG.
  void DisableDebugOutput();
  
- }  // namespace ots
+ // Enable WOFF2 support(experimental).
+ void EnableWOFF2();
  
- #endif  // OPENTYPE_SANITISER_H_

new file mode 100644
--- /dev/null
+++ b/gfx/ots/ots-woff2.patch
@@ -0,0 +1,134 @@
+diff --git a/gfx/ots/include/opentype-sanitiser.h b/gfx/ots/include/opentype-sanitiser.h
+--- a/gfx/ots/include/opentype-sanitiser.h
++++ b/gfx/ots/include/opentype-sanitiser.h
+@@ -236,14 +236,16 @@ typedef TableAction (*TableActionFunc)(u
+ // Set a callback function that will be called when OTS needs to decide what to
+ // do for a font table.
+ void OTS_API SetTableActionCallback(TableActionFunc func, void *user_data);
+ 
+ // Force to disable debug output even when the library is compiled with
+ // -DOTS_DEBUG.
+ void DisableDebugOutput();
+ 
++#ifdef MOZ_OTS_WOFF2
+ // Enable WOFF2 support(experimental).
+ void EnableWOFF2();
++#endif
+ 
+ }  // namespace ots
+ 
+ #endif  // OPENTYPE_SANITISER_H_
+diff --git a/gfx/ots/src/ots.cc b/gfx/ots/src/ots.cc
+--- a/gfx/ots/src/ots.cc
++++ b/gfx/ots/src/ots.cc
+@@ -9,25 +9,29 @@
+ 
+ #include <algorithm>
+ #include <cstdlib>
+ #include <cstring>
+ #include <limits>
+ #include <map>
+ #include <vector>
+ 
++#ifdef MOZ_OTS_WOFF2
+ #include "woff2.h"
++#endif
+ 
+ // The OpenType Font File
+ // http://www.microsoft.com/typography/otspec/cmap.htm
+ 
+ namespace {
+ 
+ bool g_debug_output = true;
++#ifdef MOZ_OTS_WOFF2
+ bool g_enable_woff2 = false;
++#endif
+ 
+ ots::MessageFunc  g_message_func = NULL;
+ void             *g_message_user_data = NULL;
+ 
+ ots::TableActionFunc  g_table_action_func = NULL;
+ void                 *g_table_action_user_data = NULL;
+ 
+ // Generate a message with or without a table tag, when 'header' is the OpenTypeFile pointer
+@@ -395,16 +399,17 @@ bool ProcessWOFF(ots::OpenTypeFile *head
+   }
+   if (block_end != ots::Round4(length)) {
+     return OTS_FAILURE_MSG_HDR("file length mismatch (trailing junk?)");
+   }
+ 
+   return ProcessGeneric(header, woff_tag, output, data, length, tables, file);
+ }
+ 
++#ifdef MOZ_OTS_WOFF2
+ 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();
+   }
+   // decompressed font must be <= 30MB
+   if (decompressed_size > 30 * 1024 * 1024) {
+@@ -413,16 +418,17 @@ bool ProcessWOFF2(ots::OpenTypeFile *hea
+ 
+   std::vector<uint8_t> decompressed_buffer(decompressed_size);
+   if (!ots::ConvertWOFF2ToTTF(&decompressed_buffer[0], decompressed_size,
+                               data, length)) {
+     return OTS_FAILURE();
+   }
+   return ProcessTTF(header, output, &decompressed_buffer[0], decompressed_size);
+ }
++#endif
+ 
+ ots::TableAction GetTableAction(uint32_t tag) {
+   ots::TableAction action = ots::TABLE_ACTION_DEFAULT;
+ 
+   if (g_table_action_func != NULL) {
+     action = g_table_action_func(htonl(tag), g_table_action_user_data);
+   }
+ 
+@@ -795,19 +801,21 @@ bool IsValidVersionTag(uint32_t tag) {
+          tag == Tag("true") ||
+          tag == Tag("typ1");
+ }
+ 
+ void DisableDebugOutput() {
+   g_debug_output = false;
+ }
+ 
++#ifdef MOZ_OTS_WOFF2
+ void EnableWOFF2() {
+   g_enable_woff2 = true;
+ }
++#endif
+ 
+ void SetMessageCallback(MessageFunc func, void *user_data) {
+   g_message_func = func;
+   g_message_user_data = user_data;
+ }
+ 
+ void SetTableActionCallback(TableActionFunc func, void *user_data) {
+   g_table_action_func = func;
+@@ -822,20 +830,22 @@ bool Process(OTSStream *output, const ui
+ 
+   if (length < 4) {
+     return OTS_FAILURE_MSG_(&header, "file less than 4 bytes");
+   }
+ 
+   bool result;
+   if (data[0] == 'w' && data[1] == 'O' && data[2] == 'F' && data[3] == 'F') {
+     result = ProcessWOFF(&header, output, data, length);
++#ifdef MOZ_OTS_WOFF2
+   } else if (g_enable_woff2 &&
+              data[0] == 'w' && data[1] == 'O' && data[2] == 'F' &&
+              data[3] == '2') {
+     result = ProcessWOFF2(&header, output, data, length);
++#endif
+   } else {
+     result = ProcessTTF(&header, output, data, length);
+   }
+ 
+   for (unsigned i = 0; ; ++i) {
+     if (table_parsers[i].parse == NULL) break;
+     table_parsers[i].free(&header);
+   }

--- a/gfx/ots/src/cff.cc
+++ b/gfx/ots/src/cff.cc
@@ -1,24 +1,26 @@
 // Copyright (c) 2012 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 "cff.h"
 
 #include <cstring>
-#include <utility>  // std::pair
+#include <utility>
 #include <vector>
 
 #include "cff_type2_charstring.h"
 
 // CFF - PostScript font program (Compact Font Format) table
 // http://www.microsoft.com/typography/otspec/cff.htm
 // http://www.microsoft.com/typography/otspec/cffspec.htm
 
+#define TABLE_NAME "CFF"
+
 namespace {
 
 enum DICT_OPERAND_TYPE {
   DICT_OPERAND_INTEGER,
   DICT_OPERAND_REAL,
   DICT_OPERATOR,
 };
 
@@ -410,32 +412,32 @@ bool ParsePrivateDictData(
         }
         if (operands.back().first >= 1024 * 1024 * 1024) {
           return OTS_FAILURE();
         }
         if (operands.back().first + offset >= table_length) {
           return OTS_FAILURE();
         }
         // parse "16. Local Subrs INDEX"
-        ots::Buffer table(data, table_length);
-        table.set_offset(operands.back().first + offset);
+        ots::Buffer cff_table(data, table_length);
+        cff_table.set_offset(operands.back().first + offset);
         ots::CFFIndex *local_subrs_index = NULL;
         if (type == DICT_DATA_FDARRAY) {
           if (out_cff->local_subrs_per_font.empty()) {
             return OTS_FAILURE();  // not reached.
           }
           local_subrs_index = out_cff->local_subrs_per_font.back();
         } else { // type == DICT_DATA_TOPLEVEL
           if (out_cff->local_subrs) {
             return OTS_FAILURE();  // two or more local_subrs?
           }
           local_subrs_index = new ots::CFFIndex;
           out_cff->local_subrs = local_subrs_index;
         }
-        if (!ParseIndex(&table, local_subrs_index)) {
+        if (!ParseIndex(&cff_table, local_subrs_index)) {
           return OTS_FAILURE();
         }
         break;
       }
 
       // boolean
       case (12U << 8) + 14:  // ForceBold
         if (operands.size() != 1) {
@@ -597,20 +599,20 @@ bool ParseDictData(const uint8_t *data, 
           if (operands.back().first <= 1) {
             break;  // predefined encoding, "Standard" or "Expert", is used.
           }
           if (!CheckOffset(operands.back(), table_length)) {
             return OTS_FAILURE();
           }
 
           // parse sub dictionary INDEX.
-          ots::Buffer table(data, table_length);
-          table.set_offset(operands.back().first);
+          ots::Buffer cff_table(data, table_length);
+          cff_table.set_offset(operands.back().first);
           uint8_t format = 0;
-          if (!table.ReadU8(&format)) {
+          if (!cff_table.ReadU8(&format)) {
             return OTS_FAILURE();
           }
           if (format & 0x80) {
             // supplemental encoding is not supported at the moment.
             return OTS_FAILURE();
           }
           // TODO(yusukes): support & parse supplemental encoding tables.
           break;
@@ -622,20 +624,20 @@ bool ParseDictData(const uint8_t *data, 
           }
           if (operands.size() != 1) {
             return OTS_FAILURE();
           }
           if (!CheckOffset(operands.back(), table_length)) {
             return OTS_FAILURE();
           }
           // parse "14. CharStrings INDEX"
-          ots::Buffer table(data, table_length);
-          table.set_offset(operands.back().first);
+          ots::Buffer cff_table(data, table_length);
+          cff_table.set_offset(operands.back().first);
           ots::CFFIndex *charstring_index = out_cff->char_strings_array.back();
-          if (!ParseIndex(&table, charstring_index)) {
+          if (!ParseIndex(&cff_table, charstring_index)) {
             return OTS_FAILURE();
           }
           if (charstring_index->count < 2) {
             return OTS_FAILURE();
           }
           if (glyphs) {
             return OTS_FAILURE();  // multiple charstring tables?
           }
@@ -650,20 +652,20 @@ bool ParseDictData(const uint8_t *data, 
           if (operands.size() != 1) {
             return OTS_FAILURE();
           }
           if (!CheckOffset(operands.back(), table_length)) {
             return OTS_FAILURE();
           }
 
           // parse sub dictionary INDEX.
-          ots::Buffer table(data, table_length);
-          table.set_offset(operands.back().first);
+          ots::Buffer cff_table(data, table_length);
+          cff_table.set_offset(operands.back().first);
           ots::CFFIndex sub_dict_index;
-          if (!ParseIndex(&table, &sub_dict_index)) {
+          if (!ParseIndex(&cff_table, &sub_dict_index)) {
             return OTS_FAILURE();
           }
           if (!ParseDictData(data, table_length,
                              sub_dict_index, sid_max, DICT_DATA_FDARRAY,
                              out_cff)) {
             return OTS_FAILURE();
           }
           if (out_cff->font_dict_length != 0) {
@@ -680,44 +682,44 @@ bool ParseDictData(const uint8_t *data, 
           if (operands.size() != 1) {
             return OTS_FAILURE();
           }
           if (!CheckOffset(operands.back(), table_length)) {
             return OTS_FAILURE();
           }
 
           // parse FDSelect data structure
-          ots::Buffer table(data, table_length);
-          table.set_offset(operands.back().first);
+          ots::Buffer cff_table(data, table_length);
+          cff_table.set_offset(operands.back().first);
           uint8_t format = 0;
-          if (!table.ReadU8(&format)) {
+          if (!cff_table.ReadU8(&format)) {
             return OTS_FAILURE();
           }
           if (format == 0) {
             for (size_t j = 0; j < glyphs; ++j) {
               uint8_t fd_index = 0;
-              if (!table.ReadU8(&fd_index)) {
+              if (!cff_table.ReadU8(&fd_index)) {
                 return OTS_FAILURE();
               }
               (out_cff->fd_select)[j] = fd_index;
             }
           } else if (format == 3) {
             uint16_t n_ranges = 0;
-            if (!table.ReadU16(&n_ranges)) {
+            if (!cff_table.ReadU16(&n_ranges)) {
               return OTS_FAILURE();
             }
             if (n_ranges == 0) {
               return OTS_FAILURE();
             }
 
             uint16_t last_gid = 0;
             uint8_t fd_index = 0;
             for (unsigned j = 0; j < n_ranges; ++j) {
               uint16_t first = 0;  // GID
-              if (!table.ReadU16(&first)) {
+              if (!cff_table.ReadU16(&first)) {
                 return OTS_FAILURE();
               }
 
               // Sanity checks.
               if ((j == 0) && (first != 0)) {
                 return OTS_FAILURE();
               }
               if ((j != 0) && (last_gid >= first)) {
@@ -729,24 +731,24 @@ bool ParseDictData(const uint8_t *data, 
                 for (uint16_t k = last_gid; k < first; ++k) {
                   if (!out_cff->fd_select.insert(
                           std::make_pair(k, fd_index)).second) {
                     return OTS_FAILURE();
                   }
                 }
               }
 
-              if (!table.ReadU8(&fd_index)) {
+              if (!cff_table.ReadU8(&fd_index)) {
                 return OTS_FAILURE();
               }
               last_gid = first;
               // TODO(yusukes): check GID?
             }
             uint16_t sentinel = 0;
-            if (!table.ReadU16(&sentinel)) {
+            if (!cff_table.ReadU16(&sentinel)) {
               return OTS_FAILURE();
             }
             if (last_gid >= sentinel) {
               return OTS_FAILURE();
             }
             for (uint16_t k = last_gid; k < sentinel; ++k) {
               if (!out_cff->fd_select.insert(
                       std::make_pair(k, fd_index)).second) {
@@ -823,58 +825,58 @@ bool ParseDictData(const uint8_t *data, 
 
       if (font_format == FORMAT_UNKNOWN) {
         font_format = FORMAT_OTHER;
       }
     }
 
     // parse "13. Charsets"
     if (charset_offset) {
-      ots::Buffer table(data, table_length);
-      table.set_offset(charset_offset);
+      ots::Buffer cff_table(data, table_length);
+      cff_table.set_offset(charset_offset);
       uint8_t format = 0;
-      if (!table.ReadU8(&format)) {
+      if (!cff_table.ReadU8(&format)) {
         return OTS_FAILURE();
       }
       switch (format) {
         case 0:
           for (unsigned j = 1 /* .notdef is omitted */; j < glyphs; ++j) {
             uint16_t sid = 0;
-            if (!table.ReadU16(&sid)) {
+            if (!cff_table.ReadU16(&sid)) {
               return OTS_FAILURE();
             }
             if (!have_ros && (sid > sid_max)) {
               return OTS_FAILURE();
             }
             // TODO(yusukes): check CIDs when have_ros is true.
           }
           break;
 
         case 1:
         case 2: {
           uint32_t total = 1;  // .notdef is omitted.
           while (total < glyphs) {
             uint16_t sid = 0;
-            if (!table.ReadU16(&sid)) {
+            if (!cff_table.ReadU16(&sid)) {
               return OTS_FAILURE();
             }
             if (!have_ros && (sid > sid_max)) {
               return OTS_FAILURE();
             }
             // TODO(yusukes): check CIDs when have_ros is true.
 
             if (format == 1) {
               uint8_t left = 0;
-              if (!table.ReadU8(&left)) {
+              if (!cff_table.ReadU8(&left)) {
                 return OTS_FAILURE();
               }
               total += (left + 1);
             } else {
               uint16_t left = 0;
-              if (!table.ReadU16(&left)) {
+              if (!cff_table.ReadU16(&left)) {
                 return OTS_FAILURE();
               }
               total += (left + 1);
             }
           }
           break;
         }
 

--- a/gfx/ots/src/cff_type2_charstring.cc
+++ b/gfx/ots/src/cff_type2_charstring.cc
@@ -33,16 +33,17 @@ bool ExecuteType2CharString(size_t call_
                             const ots::CFFIndex& local_subrs_index,
                             ots::Buffer *cff_table,
                             ots::Buffer *char_string,
                             std::stack<int32_t> *argument_stack,
                             bool *out_found_endchar,
                             bool *out_found_width,
                             size_t *in_out_num_stems);
 
+#ifdef DUMP_T2CHARSTRING
 // Converts |op| to a string and returns it.
 const char *Type2CharStringOperatorToString(ots::Type2CharStringOperator op) {
   switch (op) {
   case ots::kHStem:
     return "HStem";
   case ots::kVStem:
     return "VStem";
   case ots::kVMoveTo:
@@ -82,16 +83,18 @@ const char *Type2CharStringOperatorToStr
   case ots::kHHCurveTo:
     return "HHCurveTo";
   case ots::kCallGSubr:
     return "CallGSubr";
   case ots::kVHCurveTo:
     return "VHCurveTo";
   case ots::kHVCurveTo:
     return "HVCurveTo";
+  case ots::kDotSection:
+    return "DotSection";
   case ots::kAnd:
     return "And";
   case ots::kOr:
     return "Or";
   case ots::kNot:
     return "Not";
   case ots::kAbs:
     return "Abs";
@@ -134,16 +137,17 @@ const char *Type2CharStringOperatorToStr
   case ots::kHFlex1:
     return "HFlex1";
   case ots::kFlex1:
     return "Flex1";
   }
 
   return "UNKNOWN";
 }
+#endif
 
 // Read one or more bytes from the |char_string| buffer and stores the number
 // read on |out_number|. If the number read is an operator (ex 'vstem'), sets
 // true on |out_is_operator|. Returns true if the function read a number.
 bool ReadNextNumberFromType2CharString(ots::Buffer *char_string,
                                        int32_t *out_number,
                                        bool *out_is_operator) {
   uint8_t v = 0;
@@ -519,16 +523,23 @@ bool ExecuteType2CharStringOperator(int3
       // {dxa dxb dyb dyc dyd dxe dye dxf}+ dyf?
       successful = true;
     }
     while (!argument_stack->empty())
       argument_stack->pop();
     return successful ? true : OTS_FAILURE();
   }
 
+  case ots::kDotSection:
+    // Deprecated operator but harmless, we probably should drop it some how.
+    if (stack_size != 0) {
+      return OTS_FAILURE();
+    }
+    return true;
+
   case ots::kAnd:
   case ots::kOr:
   case ots::kEq:
   case ots::kAdd:
   case ots::kSub:
     if (stack_size < 2) {
       return OTS_FAILURE();
     }
@@ -733,29 +744,31 @@ bool ExecuteType2CharString(size_t call_
     int32_t operator_or_operand = 0;
     bool is_operator = false;
     if (!ReadNextNumberFromType2CharString(char_string,
                                            &operator_or_operand,
                                            &is_operator)) {
       return OTS_FAILURE();
     }
 
+#ifdef DUMP_T2CHARSTRING
     /*
       You can dump all operators and operands (except mask bytes for hintmask
       and cntrmask) by the following code:
+    */
 
       if (!is_operator) {
         std::fprintf(stderr, "#%d# ", operator_or_operand);
       } else {
         std::fprintf(stderr, "#%s#\n",
            Type2CharStringOperatorToString(
-               Type2CharStringOperator(operator_or_operand)),
-           operator_or_operand);
+               ots::Type2CharStringOperator(operator_or_operand))
+           );
       }
-    */
+#endif
 
     if (!is_operator) {
       argument_stack->push(operator_or_operand);
       if (argument_stack->size() > kMaxArgumentStack) {
         return OTS_FAILURE();
       }
       continue;
     }

--- a/gfx/ots/src/cff_type2_charstring.h
+++ b/gfx/ots/src/cff_type2_charstring.h
@@ -62,16 +62,17 @@ enum Type2CharStringOperator {
   kVStemHm = 23,
   kRCurveLine = 24,
   kRLineCurve = 25,
   kVVCurveTo = 26,
   kHHCurveTo = 27,
   kCallGSubr = 29,
   kVHCurveTo = 30,
   kHVCurveTo = 31,
+  kDotSection = 12 << 8,
   kAnd = (12 << 8) + 3,
   kOr = (12 << 8) + 4,
   kNot = (12 << 8) + 5,
   kAbs = (12 << 8) + 9,
   kAdd = (12 << 8) + 10,
   kSub = (12 << 8) + 11,
   kDiv = (12 << 8) + 12,
   kNeg = (12 << 8) + 14,
@@ -86,15 +87,14 @@ enum Type2CharStringOperator {
   kDup = (12 << 8) + 27,
   kExch = (12 << 8) + 28,
   kIndex = (12 << 8) + 29,
   kRoll = (12 << 8) + 30,
   kHFlex = (12 << 8) + 34,
   kFlex = (12 << 8) + 35,
   kHFlex1 = (12 << 8) + 36,
   kFlex1 = (12 << 8) + 37,
-  // Operators that are obsoleted or undocumented, such as 'blend', will be
-  // rejected.
+  // Operators that are undocumented, such as 'blend', will be rejected.
 };
 
 }  // namespace ots
 
 #endif  // OTS_CFF_TYPE2_CHARSTRING_H_

--- a/gfx/ots/src/cmap.cc
+++ b/gfx/ots/src/cmap.cc
@@ -8,26 +8,29 @@
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "maxp.h"
 #include "os2.h"
 
 // cmap - Character To Glyph Index Mapping Table
-// http://www.microsoft.com/opentype/otspec/cmap.htm
+// http://www.microsoft.com/typography/otspec/cmap.htm
+
+#define TABLE_NAME "cmap"
 
 namespace {
 
 struct CMAPSubtableHeader {
   uint16_t platform;
   uint16_t encoding;
   uint32_t offset;
   uint16_t format;
   uint32_t length;
+  uint32_t language;
 };
 
 struct Subtable314Range {
   uint16_t start_range;
   uint16_t end_range;
   int16_t id_delta;
   uint16_t id_range_offset;
   uint32_t id_range_offset_offset;
@@ -62,112 +65,112 @@ bool ParseFormat4(ots::OpenTypeFile *fil
               const uint8_t *data, size_t length, uint16_t num_glyphs) {
   ots::Buffer subtable(data, length);
 
   // 0.3.4, 3.0.4 or 3.1.4 subtables are complex and, rather than expanding the
   // whole thing and recompacting it, we validate it and include it verbatim
   // in the output.
 
   if (!file->os2) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Required OS/2 table missing");
   }
 
   if (!subtable.Skip(4)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Can't read 4 bytes at start of cmap format 4 subtable");
   }
   uint16_t language = 0;
   if (!subtable.ReadU16(&language)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Can't read language");
   }
   if (language) {
     // Platform ID 3 (windows) subtables should have language '0'.
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Languages should be 0 (%d)", language);
   }
 
   uint16_t segcountx2, search_range, entry_selector, range_shift;
   segcountx2 = search_range = entry_selector = range_shift = 0;
   if (!subtable.ReadU16(&segcountx2) ||
       !subtable.ReadU16(&search_range) ||
       !subtable.ReadU16(&entry_selector) ||
       !subtable.ReadU16(&range_shift)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to read subcmap structure");
   }
 
   if (segcountx2 & 1 || search_range & 1) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad subcmap structure");
   }
   const uint16_t segcount = segcountx2 >> 1;
   // There must be at least one segment according the spec.
   if (segcount < 1) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Segcount < 1 (%d)", segcount);
   }
 
   // log2segcount is the maximal x s.t. 2^x < segcount
   unsigned log2segcount = 0;
   while (1u << (log2segcount + 1) <= segcount) {
     log2segcount++;
   }
 
   const uint16_t expected_search_range = 2 * 1u << log2segcount;
   if (expected_search_range != search_range) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("expected search range != search range (%d != %d)", expected_search_range, search_range);
   }
 
   if (entry_selector != log2segcount) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("entry selector != log2(segement count) (%d != %d)", entry_selector, log2segcount);
   }
 
   const uint16_t expected_range_shift = segcountx2 - search_range;
   if (range_shift != expected_range_shift) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("unexpected range shift (%d != %d)", range_shift, expected_range_shift);
   }
 
   std::vector<Subtable314Range> ranges(segcount);
 
   for (unsigned i = 0; i < segcount; ++i) {
     if (!subtable.ReadU16(&ranges[i].end_range)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to read segment %d", i);
     }
   }
 
   uint16_t padding;
   if (!subtable.ReadU16(&padding)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to read cmap subtable segment padding");
   }
   if (padding) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Non zero cmap subtable segment padding (%d)", padding);
   }
 
   for (unsigned i = 0; i < segcount; ++i) {
     if (!subtable.ReadU16(&ranges[i].start_range)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to read segment start range %d", i);
     }
   }
   for (unsigned i = 0; i < segcount; ++i) {
     if (!subtable.ReadS16(&ranges[i].id_delta)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to read segment delta %d", i);
     }
   }
   for (unsigned i = 0; i < segcount; ++i) {
     ranges[i].id_range_offset_offset = subtable.offset();
     if (!subtable.ReadU16(&ranges[i].id_range_offset)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to read segment range offset %d", i);
     }
 
     if (ranges[i].id_range_offset & 1) {
       // Some font generators seem to put 65535 on id_range_offset
       // for 0xFFFF-0xFFFF range.
       // (e.g., many fonts in http://www.princexml.com/fonts/)
       if (i == segcount - 1u) {
         OTS_WARNING("bad id_range_offset");
         ranges[i].id_range_offset = 0;
         // The id_range_offset value in the transcoded font will not change
         // since this table is not actually "transcoded" yet.
       } else {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Bad segment offset (%d)", ranges[i].id_range_offset);
       }
     }
   }
 
   // ranges must be ascending order, based on the end_code. Ranges may not
   // overlap.
   for (unsigned i = 1; i < segcount; ++i) {
     if ((i == segcount - 1u) &&
@@ -179,20 +182,20 @@ bool ParseFormat4(ots::OpenTypeFile *fil
       // We'll accept them as an exception.
       OTS_WARNING("multiple 0xffff terminators found");
       continue;
     }
 
     // Note: some Linux fonts (e.g., LucidaSansOblique.ttf, bsmi00lp.ttf) have
     // unsorted table...
     if (ranges[i].end_range <= ranges[i - 1].end_range) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Out of order end range (%d <= %d)", ranges[i].end_range, ranges[i-1].end_range);
     }
     if (ranges[i].start_range <= ranges[i - 1].end_range) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("out of order start range (%d <= %d)", ranges[i].start_range, ranges[i-1].end_range);
     }
 
     // On many fonts, the value of {first, last}_char_index are incorrect.
     // Fix them.
     if (file->os2->first_char_index != 0xFFFF &&
         ranges[i].start_range != 0xFFFF &&
         file->os2->first_char_index > ranges[i].start_range) {
       file->os2->first_char_index = ranges[i].start_range;
@@ -200,48 +203,49 @@ bool ParseFormat4(ots::OpenTypeFile *fil
     if (file->os2->last_char_index != 0xFFFF &&
         ranges[i].end_range != 0xFFFF &&
         file->os2->last_char_index < ranges[i].end_range) {
       file->os2->last_char_index = ranges[i].end_range;
     }
   }
 
   // The last range must end at 0xffff
-  if (ranges[segcount - 1].end_range != 0xffff) {
-    return OTS_FAILURE();
+  if (ranges[segcount - 1].start_range != 0xffff || ranges[segcount - 1].end_range != 0xffff) {
+    return OTS_FAILURE_MSG("Final segment start and end must be 0xFFFF (0x%04X-0x%04X)",
+                           ranges[segcount - 1].start_range, ranges[segcount - 1].end_range);
   }
 
   // A format 4 CMAP subtable is complex. To be safe we simulate a lookup of
   // each code-point defined in the table and make sure that they are all valid
   // glyphs and that we don't access anything out-of-bounds.
   for (unsigned i = 0; i < segcount; ++i) {
     for (unsigned cp = ranges[i].start_range; cp <= ranges[i].end_range; ++cp) {
       const uint16_t code_point = cp;
       if (ranges[i].id_range_offset == 0) {
         // this is explictly allowed to overflow in the spec
         const uint16_t glyph = code_point + ranges[i].id_delta;
         if (glyph >= num_glyphs) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("Range glyph reference too high (%d > %d)", glyph, num_glyphs - 1);
         }
       } else {
         const uint16_t range_delta = code_point - ranges[i].start_range;
         // this might seem odd, but it's true. The offset is relative to the
         // location of the offset value itself.
         const uint32_t glyph_id_offset = ranges[i].id_range_offset_offset +
                                          ranges[i].id_range_offset +
                                          range_delta * 2;
         // We need to be able to access a 16-bit value from this offset
         if (glyph_id_offset + 1 >= length) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("bad glyph id offset (%d > %ld)", glyph_id_offset, length);
         }
         uint16_t glyph;
-        memcpy(&glyph, data + glyph_id_offset, 2);
+        std::memcpy(&glyph, data + glyph_id_offset, 2);
         glyph = ntohs(glyph);
         if (glyph >= num_glyphs) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("Range glyph reference too high (%d > %d)", glyph, num_glyphs - 1);
         }
       }
     }
   }
 
   // We accept the table.
   // TODO(yusukes): transcode the subtable.
   if (platform == 3 && encoding == 0) {
@@ -249,324 +253,329 @@ bool ParseFormat4(ots::OpenTypeFile *fil
     file->cmap->subtable_3_0_4_length = length;
   } else if (platform == 3 && encoding == 1) {
     file->cmap->subtable_3_1_4_data = data;
     file->cmap->subtable_3_1_4_length = length;
   } else if (platform == 0 && encoding == 3) {
     file->cmap->subtable_0_3_4_data = data;
     file->cmap->subtable_0_3_4_length = length;
   } else {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Unknown cmap subtable type (platform=%d, encoding=%d)", platform, encoding);
   }
 
   return true;
 }
 
 bool Parse31012(ots::OpenTypeFile *file,
                 const uint8_t *data, size_t length, uint16_t num_glyphs) {
   ots::Buffer subtable(data, length);
 
   // Format 12 tables are simple. We parse these and fully serialise them
   // later.
 
   if (!subtable.Skip(8)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("failed to skip the first 8 bytes of format 12 subtable");
   }
   uint32_t language = 0;
   if (!subtable.ReadU32(&language)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("can't read format 12 subtable language");
   }
   if (language) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("format 12 subtable language should be zero (%d)", language);
   }
 
   uint32_t num_groups = 0;
   if (!subtable.ReadU32(&num_groups)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("can't read number of format 12 subtable groups");
   }
   if (num_groups == 0 || num_groups > kMaxCMAPGroups) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("bad format 12 subtable group count %d", num_groups);
   }
 
   std::vector<ots::OpenTypeCMAPSubtableRange> &groups
       = file->cmap->subtable_3_10_12;
   groups.resize(num_groups);
 
   for (unsigned i = 0; i < num_groups; ++i) {
     if (!subtable.ReadU32(&groups[i].start_range) ||
         !subtable.ReadU32(&groups[i].end_range) ||
         !subtable.ReadU32(&groups[i].start_glyph_id)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("can't read format 12 subtable group");
     }
 
     if (groups[i].start_range > kUnicodeUpperLimit ||
         groups[i].end_range > kUnicodeUpperLimit ||
         groups[i].start_glyph_id > 0xFFFF) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("bad format 12 subtable group (startCharCode=0x%4X, endCharCode=0x%4X, startGlyphID=%d)",
+                             groups[i].start_range, groups[i].end_range, groups[i].start_glyph_id);
     }
 
     // [0xD800, 0xDFFF] are surrogate code points.
     if (groups[i].start_range >= 0xD800 &&
         groups[i].start_range <= 0xDFFF) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("format 12 subtable out of range group startCharCode (0x%4X)", groups[i].start_range);
     }
     if (groups[i].end_range >= 0xD800 &&
         groups[i].end_range <= 0xDFFF) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("format 12 subtable out of range group endCharCode (0x%4X)", groups[i].end_range);
     }
     if (groups[i].start_range < 0xD800 &&
         groups[i].end_range > 0xDFFF) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("bad format 12 subtable group startCharCode (0x%4X) or endCharCode (0x%4X)",
+                             groups[i].start_range, groups[i].end_range);
     }
 
     // We assert that the glyph value is within range. Because of the range
     // limits, above, we don't need to worry about overflow.
     if (groups[i].end_range < groups[i].start_range) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("format 12 subtable group endCharCode before startCharCode (0x%4X < 0x%4X)",
+                             groups[i].end_range, groups[i].start_range);
     }
     if ((groups[i].end_range - groups[i].start_range) +
         groups[i].start_glyph_id > num_glyphs) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("bad format 12 subtable group startGlyphID (%d)", groups[i].start_glyph_id);
     }
   }
 
   // the groups must be sorted by start code and may not overlap
   for (unsigned i = 1; i < num_groups; ++i) {
     if (groups[i].start_range <= groups[i - 1].start_range) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("out of order format 12 subtable group (startCharCode=0x%4X <= startCharCode=0x%4X of previous group)",
+                             groups[i].start_range, groups[i-1].start_range);
     }
     if (groups[i].start_range <= groups[i - 1].end_range) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("overlapping format 12 subtable groups (startCharCode=0x%4X <= endCharCode=0x%4X of previous group)",
+                             groups[i].start_range, groups[i-1].end_range);
     }
   }
 
   return true;
 }
 
 bool Parse31013(ots::OpenTypeFile *file,
                 const uint8_t *data, size_t length, uint16_t num_glyphs) {
   ots::Buffer subtable(data, length);
 
   // Format 13 tables are simple. We parse these and fully serialise them
   // later.
 
   if (!subtable.Skip(8)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad cmap subtable length");
   }
   uint16_t language = 0;
   if (!subtable.ReadU16(&language)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Can't read cmap subtable language");
   }
   if (language) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Cmap subtable language should be zero but is %d", language);
   }
 
   uint32_t num_groups = 0;
   if (!subtable.ReadU32(&num_groups)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Can't read number of groups in a cmap subtable");
   }
 
   // We limit the number of groups in the same way as in 3.10.12 tables. See
   // the comment there in
   if (num_groups == 0 || num_groups > kMaxCMAPGroups) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad number of groups (%d) in a cmap subtable", num_groups);
   }
 
   std::vector<ots::OpenTypeCMAPSubtableRange> &groups
       = file->cmap->subtable_3_10_13;
   groups.resize(num_groups);
 
   for (unsigned i = 0; i < num_groups; ++i) {
     if (!subtable.ReadU32(&groups[i].start_range) ||
         !subtable.ReadU32(&groups[i].end_range) ||
         !subtable.ReadU32(&groups[i].start_glyph_id)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Can't read subrange structure in a cmap subtable");
     }
 
     // We conservatively limit all of the values to protect some parsers from
     // overflows
     if (groups[i].start_range > kUnicodeUpperLimit ||
         groups[i].end_range > kUnicodeUpperLimit ||
         groups[i].start_glyph_id > 0xFFFF) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Bad subrange with start_range=%d, end_range=%d, start_glyph_id=%d", groups[i].start_range, groups[i].end_range, groups[i].start_glyph_id);
     }
 
     if (groups[i].start_glyph_id >= num_glyphs) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Subrange starting glyph id too high (%d > %d)", groups[i].start_glyph_id, num_glyphs);
     }
   }
 
   // the groups must be sorted by start code and may not overlap
   for (unsigned i = 1; i < num_groups; ++i) {
     if (groups[i].start_range <= groups[i - 1].start_range) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Overlapping subrange starts (%d >= %d)", groups[i]. start_range, groups[i-1].start_range);
     }
     if (groups[i].start_range <= groups[i - 1].end_range) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Overlapping subranges (%d <= %d)", groups[i].start_range, groups[i-1].end_range);
     }
   }
 
   return true;
 }
 
 bool Parse0514(ots::OpenTypeFile *file,
                const uint8_t *data, size_t length, uint16_t num_glyphs) {
   // Unicode Variation Selector table
   ots::Buffer subtable(data, length);
 
   // Format 14 tables are simple. We parse these and fully serialise them
   // later.
 
   // Skip format (USHORT) and length (ULONG)
   if (!subtable.Skip(6)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Can't read start of cmap subtable");
   }
 
   uint32_t num_records = 0;
   if (!subtable.ReadU32(&num_records)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Can't read number of records in cmap subtable");
   }
   if (num_records == 0 || num_records > kMaxCMAPSelectorRecords) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad number of records (%d) in cmap subtable", num_records);
   }
 
   std::vector<ots::OpenTypeCMAPSubtableVSRecord>& records
       = file->cmap->subtable_0_5_14;
   records.resize(num_records);
 
   for (unsigned i = 0; i < num_records; ++i) {
     if (!subtable.ReadU24(&records[i].var_selector) ||
         !subtable.ReadU32(&records[i].default_offset) ||
         !subtable.ReadU32(&records[i].non_default_offset)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Can't read record structure of record %d in cmap subtale", i);
     }
     // Checks the value of variation selector
     if (!((records[i].var_selector >= kMongolianVSStart &&
            records[i].var_selector <= kMongolianVSEnd) ||
           (records[i].var_selector >= kVSStart &&
            records[i].var_selector <= kVSEnd) ||
           (records[i].var_selector >= kIVSStart &&
            records[i].var_selector <= kIVSEnd))) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Bad record variation selector (%04X) in record %i", records[i].var_selector, i);
     }
     if (i > 0 &&
         records[i-1].var_selector >= records[i].var_selector) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Out of order variation selector (%04X >= %04X) in record %d", records[i-1].var_selector, records[i].var_selector, i);
     }
 
     // Checks offsets
     if (!records[i].default_offset && !records[i].non_default_offset) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("No default aoffset in variation selector record %d", i);
     }
     if (records[i].default_offset &&
         records[i].default_offset >= length) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Default offset too high (%d >= %ld) in record %d", records[i].default_offset, length, i);
     }
     if (records[i].non_default_offset &&
         records[i].non_default_offset >= length) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Non default offset too high (%d >= %ld) in record %d", records[i].non_default_offset, length, i);
     }
   }
 
   for (unsigned i = 0; i < num_records; ++i) {
     // Checks default UVS table
     if (records[i].default_offset) {
       subtable.set_offset(records[i].default_offset);
       uint32_t num_ranges = 0;
       if (!subtable.ReadU32(&num_ranges)) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Can't read number of ranges in record %d", i);
       }
       if (!num_ranges || num_ranges > kMaxCMAPGroups) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("number of ranges too high (%d > %d) in record %d", num_ranges, kMaxCMAPGroups, i);
       }
 
       uint32_t last_unicode_value = 0;
       std::vector<ots::OpenTypeCMAPSubtableVSRange>& ranges
           = records[i].ranges;
       ranges.resize(num_ranges);
 
       for (unsigned j = 0; j < num_ranges; ++j) {
         if (!subtable.ReadU24(&ranges[j].unicode_value) ||
             !subtable.ReadU8(&ranges[j].additional_count)) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("Can't read range info in variation selector record %d", i);
         }
         const uint32_t check_value =
             ranges[j].unicode_value + ranges[j].additional_count;
         if (ranges[j].unicode_value == 0 ||
             ranges[j].unicode_value > kUnicodeUpperLimit ||
             check_value > kUVSUpperLimit ||
             (last_unicode_value &&
              ranges[j].unicode_value <= last_unicode_value)) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("Bad Unicode value *%04X) in variation selector range %d record %d", ranges[j].unicode_value, j, i);
         }
         last_unicode_value = check_value;
       }
     }
 
     // Checks non default UVS table
     if (records[i].non_default_offset) {
       subtable.set_offset(records[i].non_default_offset);
       uint32_t num_mappings = 0;
       if (!subtable.ReadU32(&num_mappings)) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Can't read number of mappings in variation selector record %d", i);
       }
       if (!num_mappings || num_mappings > kMaxCMAPGroups) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Number of mappings too high (%d) in variation selector record %d", num_mappings, i);
       }
 
       uint32_t last_unicode_value = 0;
       std::vector<ots::OpenTypeCMAPSubtableVSMapping>& mappings
           = records[i].mappings;
       mappings.resize(num_mappings);
 
       for (unsigned j = 0; j < num_mappings; ++j) {
         if (!subtable.ReadU24(&mappings[j].unicode_value) ||
             !subtable.ReadU16(&mappings[j].glyph_id)) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("Can't read mapping %d in variation selector record %d", j, i);
         }
         if (mappings[j].glyph_id == 0 ||
             mappings[j].unicode_value == 0 ||
             mappings[j].unicode_value > kUnicodeUpperLimit ||
             (last_unicode_value &&
              mappings[j].unicode_value <= last_unicode_value)) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("Bad mapping (%04X -> %d) in mapping %d of variation selector %d", mappings[j].unicode_value, mappings[j].glyph_id, j, i);
         }
         last_unicode_value = mappings[j].unicode_value;
       }
     }
   }
 
   if (subtable.offset() != length) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad subtable offset (%ld != %ld)", subtable.offset(), length);
   }
   file->cmap->subtable_0_5_14_length = subtable.offset();
   return true;
 }
 
 bool Parse100(ots::OpenTypeFile *file, const uint8_t *data, size_t length) {
   // Mac Roman table
   ots::Buffer subtable(data, length);
 
   if (!subtable.Skip(4)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad cmap subtable");
   }
   uint16_t language = 0;
   if (!subtable.ReadU16(&language)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Can't read language in cmap subtable");
   }
   if (language) {
     // simsun.ttf has non-zero language id.
     OTS_WARNING("language id should be zero: %u", language);
   }
 
   file->cmap->subtable_1_0_0.reserve(kFormat0ArraySize);
   for (size_t i = 0; i < kFormat0ArraySize; ++i) {
     uint8_t glyph_id = 0;
     if (!subtable.ReadU8(&glyph_id)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Can't read glyph id at array[%ld] in cmap subtable", i);
     }
     file->cmap->subtable_1_0_0.push_back(glyph_id);
   }
 
   return true;
 }
 
 }  // namespace
@@ -576,113 +585,131 @@ namespace ots {
 bool ots_cmap_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
   Buffer table(data, length);
   file->cmap = new OpenTypeCMAP;
 
   uint16_t version = 0;
   uint16_t num_tables = 0;
   if (!table.ReadU16(&version) ||
       !table.ReadU16(&num_tables)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Can't read structure of cmap");
   }
 
   if (version != 0) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Non zero cmap version (%d)", version);
   }
   if (!num_tables) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("No subtables in cmap!");
   }
 
   std::vector<CMAPSubtableHeader> subtable_headers;
 
   // read the subtable headers
   subtable_headers.reserve(num_tables);
   for (unsigned i = 0; i < num_tables; ++i) {
     CMAPSubtableHeader subt;
 
     if (!table.ReadU16(&subt.platform) ||
         !table.ReadU16(&subt.encoding) ||
         !table.ReadU32(&subt.offset)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Can't read subtable information cmap subtable %d", i);
     }
 
     subtable_headers.push_back(subt);
   }
 
   const size_t data_offset = table.offset();
 
   // make sure that all the offsets are valid.
-  uint32_t last_id = 0;
   for (unsigned i = 0; i < num_tables; ++i) {
     if (subtable_headers[i].offset > 1024 * 1024 * 1024) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Bad subtable offset in cmap subtable %d", i);
     }
     if (subtable_headers[i].offset < data_offset ||
         subtable_headers[i].offset >= length) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Bad subtable offset (%d) in cmap subtable %d", subtable_headers[i].offset, i);
     }
-
-    // check if the table is sorted first by platform ID, then by encoding ID.
-    uint32_t current_id
-        = (subtable_headers[i].platform << 16) + subtable_headers[i].encoding;
-    if ((i != 0) && (last_id >= current_id)) {
-      return OTS_FAILURE();
-    }
-    last_id = current_id;
   }
 
   // the format of the table is the first couple of bytes in the table. The
   // length of the table is stored in a format-specific way.
   for (unsigned i = 0; i < num_tables; ++i) {
     table.set_offset(subtable_headers[i].offset);
     if (!table.ReadU16(&subtable_headers[i].format)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Can't read cmap subtable header format %d", i);
     }
 
     uint16_t len = 0;
+    uint16_t lang = 0;
     switch (subtable_headers[i].format) {
       case 0:
       case 4:
         if (!table.ReadU16(&len)) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("Can't read cmap subtable %d length", i);
+        }
+        if (!table.ReadU16(&lang)) {
+          return OTS_FAILURE_MSG("Can't read cmap subtable %d language", i);
         }
         subtable_headers[i].length = len;
+        subtable_headers[i].language = lang;
         break;
       case 12:
       case 13:
         if (!table.Skip(2)) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("Bad cmap subtable %d structure", i);
         }
         if (!table.ReadU32(&subtable_headers[i].length)) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("Can read cmap subtable %d length", i);
+        }
+        if (!table.ReadU32(&subtable_headers[i].language)) {
+          return OTS_FAILURE_MSG("Can't read cmap subtable %d language", i);
         }
         break;
       case 14:
         if (!table.ReadU32(&subtable_headers[i].length)) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("Can't read cmap subtable %d length", i);
         }
+        subtable_headers[i].language = 0;
         break;
       default:
         subtable_headers[i].length = 0;
+        subtable_headers[i].language = 0;
         break;
     }
   }
 
+  // check if the table is sorted first by platform ID, then by encoding ID.
+  uint32_t last_id = 0;
+  for (unsigned i = 0; i < num_tables; ++i) {
+    uint32_t current_id
+        = (subtable_headers[i].platform << 24)
+        + (subtable_headers[i].encoding << 16)
+        + subtable_headers[i].language;
+    if ((i != 0) && (last_id >= current_id)) {
+      return OTS_FAILURE_MSG("subtable %d with platform ID %d, encoding ID %d, language ID %d "
+                             "following subtable with platform ID %d, encoding ID %d, language ID %d",
+                             i,
+                             (uint8_t)(current_id >> 24), (uint8_t)(current_id >> 16), (uint8_t)(current_id),
+                             (uint8_t)(last_id >> 24), (uint8_t)(last_id >> 16), (uint8_t)(last_id));
+    }
+    last_id = current_id;
+  }
+
   // Now, verify that all the lengths are sane
   for (unsigned i = 0; i < num_tables; ++i) {
     if (!subtable_headers[i].length) continue;
     if (subtable_headers[i].length > 1024 * 1024 * 1024) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Bad cmap subtable %d length", i);
     }
     // We know that both the offset and length are < 1GB, so the following
     // addition doesn't overflow
     const uint32_t end_byte
         = subtable_headers[i].offset + subtable_headers[i].length;
     if (end_byte > length) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Over long cmap subtable %d @ %d for %d", i, subtable_headers[i].offset, subtable_headers[i].length);
     }
   }
 
   // check that the cmap subtables are not overlapping.
   std::set<std::pair<uint32_t, uint32_t> > uniq_checker;
   std::vector<std::pair<uint32_t, uint8_t> > overlap_checker;
   for (unsigned i = 0; i < num_tables; ++i) {
     const uint32_t end_byte
@@ -700,24 +727,24 @@ bool ots_cmap_parse(OpenTypeFile *file, 
     overlap_checker.push_back(
         std::make_pair(end_byte, static_cast<uint8_t>(0) /* end */));
   }
   std::sort(overlap_checker.begin(), overlap_checker.end());
   int overlap_count = 0;
   for (unsigned i = 0; i < overlap_checker.size(); ++i) {
     overlap_count += (overlap_checker[i].second ? 1 : -1);
     if (overlap_count > 1) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Excessive overlap count %d", overlap_count);
     }
   }
 
   // we grab the number of glyphs in the file from the maxp table to make sure
   // that the character map isn't referencing anything beyound this range.
   if (!file->maxp) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("No maxp table in font! Needed by cmap.");
   }
   const uint16_t num_glyphs = file->maxp->num_glyphs;
 
   // We only support a subset of the possible character map tables. Microsoft
   // 'strongly recommends' that everyone supports the Unicode BMP table with
   // the UCS-4 table for non-BMP glyphs. We'll pass the following subtables:
   //   Platform ID   Encoding ID  Format
   //   0             0            4       (Unicode Default)
@@ -747,37 +774,37 @@ bool ots_cmap_parse(OpenTypeFile *file, 
       if ((subtable_headers[i].encoding == 0) &&
           (subtable_headers[i].format == 4)) {
         // parse and output the 0-0-4 table as 3-1-4 table. Sometimes the 0-0-4
         // table actually points to MS symbol data and thus should be parsed as
         // 3-0-4 table (e.g., marqueem.ttf and quixotic.ttf). This error will be
         // recovered in ots_cmap_serialise().
         if (!ParseFormat4(file, 3, 1, data + subtable_headers[i].offset,
                       subtable_headers[i].length, num_glyphs)) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("Failed to parse format 4 cmap subtable %d", i);
         }
       } else if ((subtable_headers[i].encoding == 3) &&
                  (subtable_headers[i].format == 4)) {
         // parse and output the 0-3-4 table as 0-3-4 table.
         if (!ParseFormat4(file, 0, 3, data + subtable_headers[i].offset,
                       subtable_headers[i].length, num_glyphs)) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("Failed to parse format 4 cmap subtable %d", i);
         }
       } else if ((subtable_headers[i].encoding == 3) &&
                  (subtable_headers[i].format == 12)) {
         // parse and output the 0-3-12 table as 3-10-12 table.
         if (!Parse31012(file, data + subtable_headers[i].offset,
                         subtable_headers[i].length, num_glyphs)) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("Failed to parse format 12 cmap subtable %d", i);
         }
       } else if ((subtable_headers[i].encoding == 5) &&
                  (subtable_headers[i].format == 14)) {
         if (!Parse0514(file, data + subtable_headers[i].offset,
                        subtable_headers[i].length, num_glyphs)) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("Failed to parse format 14 cmap subtable %d", i);
         }
       }
     } else if (subtable_headers[i].platform == 1) {
       // Mac platform
 
       if ((subtable_headers[i].encoding == 0) &&
           (subtable_headers[i].format == 0)) {
         // parse and output the 1-0-0 table.

--- a/gfx/ots/src/cvt.cc
+++ b/gfx/ots/src/cvt.cc
@@ -1,35 +1,37 @@
 // 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 "cvt.h"
 
 // cvt - Control Value Table
-// http://www.microsoft.com/opentype/otspec/cvt.htm
+// http://www.microsoft.com/typography/otspec/cvt.htm
+
+#define TABLE_NAME "cvt"
 
 namespace ots {
 
 bool ots_cvt_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
   Buffer table(data, length);
 
   OpenTypeCVT *cvt = new OpenTypeCVT;
   file->cvt = cvt;
 
   if (length >= 128 * 1024u) {
-    return OTS_FAILURE();  // almost all cvt tables are less than 4k bytes.
+    return OTS_FAILURE_MSG("Length (%d) > 120K");  // almost all cvt tables are less than 4k bytes.
   }
 
   if (length % 2 != 0) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Uneven cvt length (%d)", length);
   }
 
   if (!table.Skip(length)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Length too high");
   }
 
   cvt->data = data;
   cvt->length = length;
   return true;
 }
 
 bool ots_cvt_should_serialise(OpenTypeFile *file) {
@@ -38,17 +40,17 @@ bool ots_cvt_should_serialise(OpenTypeFi
   }
   return g_transcode_hints && file->cvt;
 }
 
 bool ots_cvt_serialise(OTSStream *out, OpenTypeFile *file) {
   const OpenTypeCVT *cvt = file->cvt;
 
   if (!out->Write(cvt->data, cvt->length)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to write CVT table");
   }
 
   return true;
 }
 
 void ots_cvt_free(OpenTypeFile *file) {
   delete file->cvt;
 }

--- a/gfx/ots/src/fpgm.cc
+++ b/gfx/ots/src/fpgm.cc
@@ -1,48 +1,50 @@
 // 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 "fpgm.h"
 
 // fpgm - Font Program
-// http://www.microsoft.com/opentype/otspec/fpgm.htm
+// http://www.microsoft.com/typography/otspec/fpgm.htm
+
+#define TABLE_NAME "fpgm"
 
 namespace ots {
 
 bool ots_fpgm_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
   Buffer table(data, length);
 
   OpenTypeFPGM *fpgm = new OpenTypeFPGM;
   file->fpgm = fpgm;
 
   if (length >= 128 * 1024u) {
-    return OTS_FAILURE();  // almost all fpgm tables are less than 5k bytes.
+    return OTS_FAILURE_MSG("length (%ld) > 120", length);  // almost all fpgm tables are less than 5k bytes.
   }
 
   if (!table.Skip(length)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad fpgm length");
   }
 
   fpgm->data = data;
   fpgm->length = length;
   return true;
 }
 
 bool ots_fpgm_should_serialise(OpenTypeFile *file) {
   if (!file->glyf) return false;  // this table is not for CFF fonts.
   return g_transcode_hints && file->fpgm;
 }
 
 bool ots_fpgm_serialise(OTSStream *out, OpenTypeFile *file) {
   const OpenTypeFPGM *fpgm = file->fpgm;
 
   if (!out->Write(fpgm->data, fpgm->length)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to write fpgm");
   }
 
   return true;
 }
 
 void ots_fpgm_free(OpenTypeFile *file) {
   delete file->fpgm;
 }

--- a/gfx/ots/src/gasp.cc
+++ b/gfx/ots/src/gasp.cc
@@ -1,32 +1,38 @@
 // 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 "gasp.h"
 
 // gasp - Grid-fitting And Scan-conversion Procedure
-// http://www.microsoft.com/opentype/otspec/gasp.htm
+// http://www.microsoft.com/typography/otspec/gasp.htm
+
+#define TABLE_NAME "gasp"
 
 #define DROP_THIS_TABLE \
-  do { delete file->gasp; file->gasp = 0; } while (0)
+  do { \
+    delete file->gasp; \
+    file->gasp = 0; \
+    OTS_FAILURE_MSG("Table discarded"); \
+  } while (0)
 
 namespace ots {
 
 bool ots_gasp_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
   Buffer table(data, length);
 
   OpenTypeGASP *gasp = new OpenTypeGASP;
   file->gasp = gasp;
 
   uint16_t num_ranges = 0;
   if (!table.ReadU16(&gasp->version) ||
       !table.ReadU16(&num_ranges)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to read table header");
   }
 
   if (gasp->version > 1) {
     // Lots of Linux fonts have bad version numbers...
     OTS_WARNING("bad version: %u", gasp->version);
     DROP_THIS_TABLE;
     return true;
   }
@@ -38,17 +44,17 @@ bool ots_gasp_parse(OpenTypeFile *file, 
   }
 
   gasp->gasp_ranges.reserve(num_ranges);
   for (unsigned i = 0; i < num_ranges; ++i) {
     uint16_t max_ppem = 0;
     uint16_t behavior = 0;
     if (!table.ReadU16(&max_ppem) ||
         !table.ReadU16(&behavior)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to read subrange %d", i);
     }
     if ((i > 0) && (gasp->gasp_ranges[i - 1].first >= max_ppem)) {
       // The records in the gaspRange[] array must be sorted in order of
       // increasing rangeMaxPPEM value.
       OTS_WARNING("ranges are not sorted");
       DROP_THIS_TABLE;
       return true;
     }
@@ -81,23 +87,23 @@ bool ots_gasp_should_serialise(OpenTypeF
   return file->gasp != NULL;
 }
 
 bool ots_gasp_serialise(OTSStream *out, OpenTypeFile *file) {
   const OpenTypeGASP *gasp = file->gasp;
 
   if (!out->WriteU16(gasp->version) ||
       !out->WriteU16(gasp->gasp_ranges.size())) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("failed to write gasp header");
   }
 
   for (unsigned i = 0; i < gasp->gasp_ranges.size(); ++i) {
     if (!out->WriteU16(gasp->gasp_ranges[i].first) ||
         !out->WriteU16(gasp->gasp_ranges[i].second)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to write gasp subtable %d", i);
     }
   }
 
   return true;
 }
 
 void ots_gasp_free(OpenTypeFile *file) {
   delete file->gasp;

--- a/gfx/ots/src/gasp.h
+++ b/gfx/ots/src/gasp.h
@@ -1,17 +1,17 @@
 // 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_GASP_H_
 #define OTS_GASP_H_
 
 #include <new>
-#include <utility>  // std::pair
+#include <utility>
 #include <vector>
 
 #include "ots.h"
 
 namespace ots {
 
 struct OpenTypeGASP {
   uint16_t version;

--- a/gfx/ots/src/gdef.cc
+++ b/gfx/ots/src/gdef.cc
@@ -25,391 +25,359 @@ const uint16_t kMaxClassDefValue = 0xFFF
 const uint16_t kMaxGlyphClassDefValue = 4;
 // The maximum format number of caret value tables.
 // We don't support format 3 for now. See the comment in
 // ParseLigCaretListTable() for the reason.
 const uint16_t kMaxCaretValueFormat = 2;
 
 bool ParseGlyphClassDefTable(ots::OpenTypeFile *file, const uint8_t *data,
                              size_t length, const uint16_t num_glyphs) {
-  return ots::ParseClassDefTable(data, length, num_glyphs,
+  return ots::ParseClassDefTable(file, data, length, num_glyphs,
                                  kMaxGlyphClassDefValue);
 }
 
 bool ParseAttachListTable(ots::OpenTypeFile *file, const uint8_t *data,
                           size_t length, const uint16_t num_glyphs) {
   ots::Buffer subtable(data, length);
 
   uint16_t offset_coverage = 0;
   uint16_t glyph_count = 0;
   if (!subtable.ReadU16(&offset_coverage) ||
       !subtable.ReadU16(&glyph_count)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to read gdef header");
   }
   const unsigned attach_points_end =
       2 * static_cast<unsigned>(glyph_count) + 4;
   if (attach_points_end > std::numeric_limits<uint16_t>::max()) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad glyph count in gdef");
   }
   if (offset_coverage == 0 || offset_coverage >= length ||
       offset_coverage < attach_points_end) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad coverage offset %d", offset_coverage);
   }
   if (glyph_count > num_glyphs) {
-    OTS_WARNING("bad glyph count: %u", glyph_count);
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad glyph count %u", glyph_count);
   }
 
   std::vector<uint16_t> attach_points;
   attach_points.resize(glyph_count);
   for (unsigned i = 0; i < glyph_count; ++i) {
     if (!subtable.ReadU16(&attach_points[i])) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Can't read attachment point %d", i);
     }
     if (attach_points[i] >= length ||
         attach_points[i] < attach_points_end) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Bad attachment point %d of %d", i, attach_points[i]);
     }
   }
 
   // Parse coverage table
-  if (!ots::ParseCoverageTable(data + offset_coverage,
+  if (!ots::ParseCoverageTable(file, data + offset_coverage,
                                length - offset_coverage, num_glyphs)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad coverage table");
   }
 
   // Parse attach point table
   for (unsigned i = 0; i < attach_points.size(); ++i) {
     subtable.set_offset(attach_points[i]);
     uint16_t point_count = 0;
     if (!subtable.ReadU16(&point_count)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Can't read point count %d", i);
     }
     if (point_count == 0) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("zero point count %d", i);
     }
     uint16_t last_point_index = 0;
     uint16_t point_index = 0;
     for (unsigned j = 0; j < point_count; ++j) {
       if (!subtable.ReadU16(&point_index)) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Can't read point index %d in point %d", j, i);
       }
       // Contour point indeces are in increasing numerical order
       if (last_point_index != 0 && last_point_index >= point_index) {
-        OTS_WARNING("bad contour indeces: %u >= %u",
+        return OTS_FAILURE_MSG("bad contour indeces: %u >= %u",
                     last_point_index, point_index);
-        return OTS_FAILURE();
       }
       last_point_index = point_index;
     }
   }
   return true;
 }
 
 bool ParseLigCaretListTable(ots::OpenTypeFile *file, const uint8_t *data,
                             size_t length, const uint16_t num_glyphs) {
   ots::Buffer subtable(data, length);
   uint16_t offset_coverage = 0;
   uint16_t lig_glyph_count = 0;
   if (!subtable.ReadU16(&offset_coverage) ||
       !subtable.ReadU16(&lig_glyph_count)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Can't read caret structure");
   }
   const unsigned lig_glyphs_end =
       2 * static_cast<unsigned>(lig_glyph_count) + 4;
   if (lig_glyphs_end > std::numeric_limits<uint16_t>::max()) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad caret structure");
   }
   if (offset_coverage == 0 || offset_coverage >= length ||
       offset_coverage < lig_glyphs_end) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad caret coverate offset %d", offset_coverage);
   }
   if (lig_glyph_count > num_glyphs) {
-    OTS_WARNING("bad ligature glyph count: %u", lig_glyph_count);
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("bad ligature glyph count: %u", lig_glyph_count);
   }
 
   std::vector<uint16_t> lig_glyphs;
   lig_glyphs.resize(lig_glyph_count);
   for (unsigned i = 0; i < lig_glyph_count; ++i) {
     if (!subtable.ReadU16(&lig_glyphs[i])) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Can't read ligature glyph location %d", i);
     }
     if (lig_glyphs[i] >= length || lig_glyphs[i] < lig_glyphs_end) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Bad ligature glyph location %d in glyph %d", lig_glyphs[i], i);
     }
   }
 
   // Parse coverage table
-  if (!ots::ParseCoverageTable(data + offset_coverage,
+  if (!ots::ParseCoverageTable(file, data + offset_coverage,
                                length - offset_coverage, num_glyphs)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Can't parse caret coverage table");
   }
 
   // Parse ligature glyph table
   for (unsigned i = 0; i < lig_glyphs.size(); ++i) {
     subtable.set_offset(lig_glyphs[i]);
     uint16_t caret_count = 0;
     if (!subtable.ReadU16(&caret_count)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Can't read caret count for glyph %d", i);
     }
     if (caret_count == 0) {
-      OTS_WARNING("bad caret value count: %u", caret_count);
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("bad caret value count: %u", caret_count);
     }
 
-    std::vector<uint16_t> caret_values;
-    caret_values.resize(caret_count);
-    uint16_t last_offset_caret = 0;
-    unsigned caret_values_end = 2 * static_cast<unsigned>(caret_count) + 2;
+    std::vector<uint16_t> caret_value_offsets;
+    caret_value_offsets.resize(caret_count);
+    unsigned caret_value_offsets_end = 2 * static_cast<unsigned>(caret_count) + 2;
     for (unsigned j = 0; j < caret_count; ++j) {
-      if (!subtable.ReadU16(&caret_values[j])) {
-        return OTS_FAILURE();
+      if (!subtable.ReadU16(&caret_value_offsets[j])) {
+        return OTS_FAILURE_MSG("Can't read caret offset %d for glyph %d", j, i);
       }
-      if (caret_values[j] >= length || caret_values[j] < caret_values_end) {
-        return OTS_FAILURE();
+      if (caret_value_offsets[j] >= length || caret_value_offsets[j] < caret_value_offsets_end) {
+        return OTS_FAILURE_MSG("Bad caret offset %d for caret %d glyph %d", caret_value_offsets[j], j, i);
       }
-      // Caret offsets are in increasing coordinate order
-      if (last_offset_caret != 0 && last_offset_caret >= caret_values[j]) {
-        OTS_WARNING("offset isn't in increasing coordinate order: %u >= %u",
-                    last_offset_caret, caret_values[j]);
-        return OTS_FAILURE();
-      }
-      last_offset_caret = caret_values[j];
     }
 
     // Parse caret values table
     for (unsigned j = 0; j < caret_count; ++j) {
-      subtable.set_offset(lig_glyphs[i] + caret_values[j]);
+      subtable.set_offset(lig_glyphs[i] + caret_value_offsets[j]);
       uint16_t caret_format = 0;
       if (!subtable.ReadU16(&caret_format)) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Can't read caret values table %d in glyph %d", j, i);
       }
       // TODO(bashi): We only support caret value format 1 and 2 for now
       // because there are no fonts which contain caret value format 3
       // as far as we investigated.
       if (caret_format == 0 || caret_format > kMaxCaretValueFormat) {
-        OTS_WARNING("bad caret value format: %u", caret_format);
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("bad caret value format: %u", caret_format);
       }
       // CaretValueFormats contain a 2-byte field which could be
       // arbitrary value.
       if (!subtable.Skip(2)) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Bad caret value table structure %d in glyph %d", j, i);
       }
     }
   }
   return true;
 }
 
 bool ParseMarkAttachClassDefTable(ots::OpenTypeFile *file, const uint8_t *data,
                                   size_t length, const uint16_t num_glyphs) {
-  return ots::ParseClassDefTable(data, length, num_glyphs, kMaxClassDefValue);
+  return ots::ParseClassDefTable(file, data, length, num_glyphs, kMaxClassDefValue);
 }
 
 bool ParseMarkGlyphSetsDefTable(ots::OpenTypeFile *file, const uint8_t *data,
                                 size_t length, const uint16_t num_glyphs) {
   ots::Buffer subtable(data, length);
   uint16_t format = 0;
   uint16_t mark_set_count = 0;
   if (!subtable.ReadU16(&format) ||
       !subtable.ReadU16(&mark_set_count)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Can' read mark glyph table structure");
   }
   if (format != 1) {
-    OTS_WARNING("bad mark glyph set table format: %u", format);
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("bad mark glyph set table format: %u", format);
   }
 
   const unsigned mark_sets_end = 2 * static_cast<unsigned>(mark_set_count) + 4;
   if (mark_sets_end > std::numeric_limits<uint16_t>::max()) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad mark_set %d", mark_sets_end);
   }
   for (unsigned i = 0; i < mark_set_count; ++i) {
     uint32_t offset_coverage = 0;
     if (!subtable.ReadU32(&offset_coverage)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Can't read covrage location for mark set %d", i);
     }
     if (offset_coverage >= length ||
         offset_coverage < mark_sets_end) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Bad coverage location %d for mark set %d", offset_coverage, i);
     }
-    if (!ots::ParseCoverageTable(data + offset_coverage,
+    if (!ots::ParseCoverageTable(file, data + offset_coverage,
                                  length - offset_coverage, num_glyphs)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to parse coverage table for mark set %d", i);
     }
   }
   file->gdef->num_mark_glyph_sets = mark_set_count;
   return true;
 }
 
 }  // namespace
 
-#define DROP_THIS_TABLE \
+#define DROP_THIS_TABLE(msg_) \
   do { \
     file->gdef->data = 0; \
     file->gdef->length = 0; \
-    OTS_FAILURE_MSG("OpenType layout data discarded"); \
+    OTS_FAILURE_MSG(msg_ ", table discarded"); \
   } while (0)
 
 namespace ots {
 
 bool ots_gdef_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
   // Grab the number of glyphs in the file from the maxp table to check
   // GlyphIDs in GDEF table.
   if (!file->maxp) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("No maxp table in font, needed by GDEF");
   }
   const uint16_t num_glyphs = file->maxp->num_glyphs;
 
   Buffer table(data, length);
 
   OpenTypeGDEF *gdef = new OpenTypeGDEF;
   file->gdef = gdef;
 
   uint32_t version = 0;
   if (!table.ReadU32(&version)) {
-    OTS_WARNING("incomplete GDEF table");
-    DROP_THIS_TABLE;
+    DROP_THIS_TABLE("Incomplete table");
     return true;
   }
   if (version < 0x00010000 || version == 0x00010001) {
-    OTS_WARNING("bad GDEF version");
-    DROP_THIS_TABLE;
+    DROP_THIS_TABLE("Bad version");
     return true;
   }
 
   if (version >= 0x00010002) {
     gdef->version_2 = true;
   }
 
   uint16_t offset_glyph_class_def = 0;
   uint16_t offset_attach_list = 0;
   uint16_t offset_lig_caret_list = 0;
   uint16_t offset_mark_attach_class_def = 0;
   if (!table.ReadU16(&offset_glyph_class_def) ||
       !table.ReadU16(&offset_attach_list) ||
       !table.ReadU16(&offset_lig_caret_list) ||
       !table.ReadU16(&offset_mark_attach_class_def)) {
-    OTS_WARNING("incomplete GDEF table");
-    DROP_THIS_TABLE;
+    DROP_THIS_TABLE("Incomplete table");
     return true;
   }
   uint16_t offset_mark_glyph_sets_def = 0;
   if (gdef->version_2) {
     if (!table.ReadU16(&offset_mark_glyph_sets_def)) {
-      OTS_WARNING("incomplete GDEF table");
-      DROP_THIS_TABLE;
+      DROP_THIS_TABLE("Incomplete table");
       return true;
     }
   }
 
-  unsigned gdef_header_end = 8;
+  unsigned gdef_header_end = 4 + 4 * 2;
   if (gdef->version_2)
     gdef_header_end += 2;
 
   // Parse subtables
   if (offset_glyph_class_def) {
     if (offset_glyph_class_def >= length ||
         offset_glyph_class_def < gdef_header_end) {
-      OTS_WARNING("invalid offset to glyph classes");
-      DROP_THIS_TABLE;
+      DROP_THIS_TABLE("Invalid offset to glyph classes");
       return true;
     }
     if (!ParseGlyphClassDefTable(file, data + offset_glyph_class_def,
                                  length - offset_glyph_class_def,
                                  num_glyphs)) {
-      OTS_WARNING("invalid glyph classes");
-      DROP_THIS_TABLE;
+      DROP_THIS_TABLE("Invalid glyph classes");
       return true;
     }
     gdef->has_glyph_class_def = true;
   }
 
   if (offset_attach_list) {
     if (offset_attach_list >= length ||
         offset_attach_list < gdef_header_end) {
-      OTS_WARNING("invalid offset to attachment list");
-      DROP_THIS_TABLE;
+      DROP_THIS_TABLE("Invalid offset to attachment list");
       return true;
     }
     if (!ParseAttachListTable(file, data + offset_attach_list,
                               length - offset_attach_list,
                               num_glyphs)) {
-      OTS_WARNING("invalid attachment list");
-      DROP_THIS_TABLE;
+      DROP_THIS_TABLE("Invalid attachment list");
       return true;
     }
   }
 
   if (offset_lig_caret_list) {
     if (offset_lig_caret_list >= length ||
         offset_lig_caret_list < gdef_header_end) {
-      OTS_WARNING("invalid offset to lig-caret list");
-      DROP_THIS_TABLE;
+      DROP_THIS_TABLE("Invalid offset to ligature caret list");
       return true;
     }
     if (!ParseLigCaretListTable(file, data + offset_lig_caret_list,
                               length - offset_lig_caret_list,
                               num_glyphs)) {
-      OTS_WARNING("invalid ligature caret list");
-      DROP_THIS_TABLE;
+      DROP_THIS_TABLE("Invalid ligature caret list");
       return true;
     }
   }
 
   if (offset_mark_attach_class_def) {
     if (offset_mark_attach_class_def >= length ||
         offset_mark_attach_class_def < gdef_header_end) {
-      OTS_WARNING("invalid offset to mark attachment list");
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Invalid offset to mark attachment list");
     }
     if (!ParseMarkAttachClassDefTable(file,
                                       data + offset_mark_attach_class_def,
                                       length - offset_mark_attach_class_def,
                                       num_glyphs)) {
-      OTS_WARNING("invalid mark attachment list");
-      DROP_THIS_TABLE;
+      DROP_THIS_TABLE("Invalid mark attachment list");
       return true;
     }
     gdef->has_mark_attachment_class_def = true;
   }
 
   if (offset_mark_glyph_sets_def) {
     if (offset_mark_glyph_sets_def >= length ||
         offset_mark_glyph_sets_def < gdef_header_end) {
-      OTS_WARNING("invalid offset to mark glyph sets");
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("invalid offset to mark glyph sets");
     }
     if (!ParseMarkGlyphSetsDefTable(file,
                                     data + offset_mark_glyph_sets_def,
                                     length - offset_mark_glyph_sets_def,
                                     num_glyphs)) {
-      OTS_WARNING("invalid mark glyph sets");
-      DROP_THIS_TABLE;
+      DROP_THIS_TABLE("Invalid mark glyph sets");
       return true;
     }
     gdef->has_mark_glyph_sets_def = true;
   }
   gdef->data = data;
   gdef->length = length;
   return true;
 }
 
 bool ots_gdef_should_serialise(OpenTypeFile *file) {
-  const bool needed_tables_dropped =
-      (file->gsub && file->gsub->data == NULL) ||
-      (file->gpos && file->gpos->data == NULL);
-  return file->gdef != NULL && file->gdef->data != NULL &&
-      !needed_tables_dropped;
+  return file->gdef != NULL && file->gdef->data != NULL;
 }
 
 bool ots_gdef_serialise(OTSStream *out, OpenTypeFile *file) {
   if (!out->Write(file->gdef->data, file->gdef->length)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to write GDEF table");
   }
 
   return true;
 }
 
 void ots_gdef_free(OpenTypeFile *file) {
   delete file->gdef;
 }

--- a/gfx/ots/src/glyf.cc
+++ b/gfx/ots/src/glyf.cc
@@ -7,29 +7,32 @@
 #include <algorithm>
 #include <limits>
 
 #include "head.h"
 #include "loca.h"
 #include "maxp.h"
 
 // glyf - Glyph Data
-// http://www.microsoft.com/opentype/otspec/glyf.htm
+// http://www.microsoft.com/typography/otspec/glyf.htm
+
+#define TABLE_NAME "glyf"
 
 namespace {
 
-bool ParseFlagsForSimpleGlyph(ots::Buffer *table,
+bool ParseFlagsForSimpleGlyph(ots::OpenTypeFile *file,
+                              ots::Buffer *table,
                               uint32_t gly_length,
                               uint32_t num_flags,
                               uint32_t *flags_count_logical,
                               uint32_t *flags_count_physical,
                               uint32_t *xy_coordinates_length) {
   uint8_t flag = 0;
   if (!table->ReadU8(&flag)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Can't read flag");
   }
 
   uint32_t delta = 0;
   if (flag & (1u << 1)) {  // x-Short
     ++delta;
   } else if (!(flag & (1u << 4))) {
     delta += 2;
   }
@@ -37,81 +40,81 @@ bool ParseFlagsForSimpleGlyph(ots::Buffe
   if (flag & (1u << 2)) {  // y-Short
     ++delta;
   } else if (!(flag & (1u << 5))) {
     delta += 2;
   }
 
   if (flag & (1u << 3)) {  // repeat
     if (*flags_count_logical + 1 >= num_flags) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Count too high (%d + 1 >= %d)", *flags_count_logical, num_flags);
     }
     uint8_t repeat = 0;
     if (!table->ReadU8(&repeat)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Can't read repeat value");
     }
     if (repeat == 0) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Zero repeat");
     }
     delta += (delta * repeat);
 
     *flags_count_logical += repeat;
     if (*flags_count_logical >= num_flags) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Count too high (%d >= %d)", *flags_count_logical, num_flags);
     }
     ++(*flags_count_physical);
   }
 
   if ((flag & (1u << 6)) || (flag & (1u << 7))) {  // reserved flags
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad flag value (%d)", flag);
   }
 
   *xy_coordinates_length += delta;
   if (gly_length < *xy_coordinates_length) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Glyph coordinates length too low (%d < %d)", gly_length, *xy_coordinates_length);
   }
 
   return true;
 }
 
 bool ParseSimpleGlyph(ots::OpenTypeFile *file, const uint8_t *data,
                       ots::Buffer *table, int16_t num_contours,
                       uint32_t gly_offset, uint32_t gly_length,
                       uint32_t *new_size) {
   ots::OpenTypeGLYF *glyf = file->glyf;
 
   // read the end-points array
   uint16_t num_flags = 0;
   for (int i = 0; i < num_contours; ++i) {
     uint16_t tmp_index = 0;
     if (!table->ReadU16(&tmp_index)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Can't read contour index %d", i);
     }
     if (tmp_index == 0xffffu) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Bad contour index %d", i);
     }
     // check if the indices are monotonically increasing
     if (i && (tmp_index + 1 <= num_flags)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Decreasing contour index %d + 1 <= %d", tmp_index, num_flags);
     }
     num_flags = tmp_index + 1;
   }
 
   uint16_t bytecode_length = 0;
   if (!table->ReadU16(&bytecode_length)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Can't read bytecode length");
   }
   if ((file->maxp->version_1) &&
       (file->maxp->max_size_glyf_instructions < bytecode_length)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bytecode length too high %d", bytecode_length);
   }
 
   const uint32_t gly_header_length = 10 + num_contours * 2 + 2;
   if (gly_length < (gly_header_length + bytecode_length)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Glyph header length too high %d", gly_header_length);
   }
 
   if (ots::g_transcode_hints) {
     glyf->iov.push_back(std::make_pair(
         data + gly_offset,
         static_cast<size_t>(gly_header_length + bytecode_length)));
   } else {
     // enqueue two vectors: the glyph data up to the bytecode length, then
@@ -119,44 +122,45 @@ bool ParseSimpleGlyph(ots::OpenTypeFile 
     glyf->iov.push_back(std::make_pair(
         data + gly_offset,
         static_cast<size_t>(gly_header_length - 2)));
     glyf->iov.push_back(std::make_pair((const uint8_t*) "\x00\x00",
                                        static_cast<size_t>(2)));
   }
 
   if (!table->Skip(bytecode_length)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Can't skip bytecode of length %d", bytecode_length);
   }
 
   uint32_t flags_count_physical = 0;  // on memory
   uint32_t xy_coordinates_length = 0;
   for (uint32_t flags_count_logical = 0;
        flags_count_logical < num_flags;
        ++flags_count_logical, ++flags_count_physical) {
-    if (!ParseFlagsForSimpleGlyph(table,
+    if (!ParseFlagsForSimpleGlyph(file,
+                                  table,
                                   gly_length,
                                   num_flags,
                                   &flags_count_logical,
                                   &flags_count_physical,
                                   &xy_coordinates_length)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to parse glyph flags %d", flags_count_logical);
     }
   }
 
   if (gly_length < (gly_header_length + bytecode_length +
                     flags_count_physical + xy_coordinates_length)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Glyph too short %d", gly_length);
   }
 
   if (gly_length - (gly_header_length + bytecode_length +
                     flags_count_physical + xy_coordinates_length) > 3) {
     // We allow 0-3 bytes difference since gly_length is 4-bytes aligned,
     // zero-padded length.
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Invalid glyph length %d", gly_length);
   }
 
   glyf->iov.push_back(std::make_pair(
       data + gly_offset + gly_header_length + bytecode_length,
       static_cast<size_t>(flags_count_physical + xy_coordinates_length)));
 
   *new_size
       = gly_header_length + flags_count_physical + xy_coordinates_length;
@@ -170,88 +174,88 @@ bool ParseSimpleGlyph(ots::OpenTypeFile 
 }  // namespace
 
 namespace ots {
 
 bool ots_glyf_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
   Buffer table(data, length);
 
   if (!file->maxp || !file->loca || !file->head) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Missing maxp or loca or head table needed by glyf table");
   }
 
   OpenTypeGLYF *glyf = new OpenTypeGLYF;
   file->glyf = glyf;
 
   const unsigned num_glyphs = file->maxp->num_glyphs;
   std::vector<uint32_t> &offsets = file->loca->offsets;
 
   if (offsets.size() != num_glyphs + 1) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Invalide glyph offsets size %ld != %d", offsets.size(), num_glyphs + 1);
   }
 
   std::vector<uint32_t> resulting_offsets(num_glyphs + 1);
   uint32_t current_offset = 0;
 
   for (unsigned i = 0; i < num_glyphs; ++i) {
     const unsigned gly_offset = offsets[i];
     // The LOCA parser checks that these values are monotonic
     const unsigned gly_length = offsets[i + 1] - offsets[i];
     if (!gly_length) {
       // this glyph has no outline (e.g. the space charactor)
       resulting_offsets[i] = current_offset;
       continue;
     }
 
     if (gly_offset >= length) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Glyph %d offset %d too high %ld", i, gly_offset, length);
     }
     // Since these are unsigned types, the compiler is not allowed to assume
     // that they never overflow.
     if (gly_offset + gly_length < gly_offset) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Glyph %d length (%d < 0)!", i, gly_length);
     }
     if (gly_offset + gly_length > length) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Glyph %d length %d too high", i, gly_length);
     }
 
     table.set_offset(gly_offset);
     int16_t num_contours, xmin, ymin, xmax, ymax;
     if (!table.ReadS16(&num_contours) ||
         !table.ReadS16(&xmin) ||
         !table.ReadS16(&ymin) ||
         !table.ReadS16(&xmax) ||
         !table.ReadS16(&ymax)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Can't read glyph %d header", i);
     }
 
     if (num_contours <= -2) {
       // -2, -3, -4, ... are reserved for future use.
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Bad number of contours %d in glyph %d", num_contours, i);
     }
 
     // workaround for fonts in http://www.princexml.com/fonts/
     if ((xmin == 32767) &&
         (xmax == -32767) &&
         (ymin == 32767) &&
         (ymax == -32767)) {
       OTS_WARNING("bad xmin/xmax/ymin/ymax values");
       xmin = xmax = ymin = ymax = 0;
     }
 
     if (xmin > xmax || ymin > ymax) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Bad bounding box values bl=(%d, %d), tr=(%d, %d) in glyph %d", xmin, ymin, xmax, ymax, i);
     }
 
     unsigned new_size = 0;
     if (num_contours >= 0) {
       // this is a simple glyph and might contain bytecode
       if (!ParseSimpleGlyph(file, data, &table,
                             num_contours, gly_offset, gly_length, &new_size)) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Failed to parse glyph %d", i);
       }
     } else {
       // it's a composite glyph without any bytecode. Enqueue the whole thing
       glyf->iov.push_back(std::make_pair(data + gly_offset,
                                          static_cast<size_t>(gly_length)));
       new_size = gly_length;
     }
 
@@ -286,17 +290,17 @@ bool ots_glyf_should_serialise(OpenTypeF
   return file->glyf != NULL;
 }
 
 bool ots_glyf_serialise(OTSStream *out, OpenTypeFile *file) {
   const OpenTypeGLYF *glyf = file->glyf;
 
   for (unsigned i = 0; i < glyf->iov.size(); ++i) {
     if (!out->Write(glyf->iov[i].first, glyf->iov[i].second)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Falied to write glyph %d", i);
     }
   }
 
   return true;
 }
 
 void ots_glyf_free(OpenTypeFile *file) {
   delete file->glyf;

--- a/gfx/ots/src/glyf.h
+++ b/gfx/ots/src/glyf.h
@@ -1,17 +1,17 @@
 // 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_GLYF_H_
 #define OTS_GLYF_H_
 
 #include <new>
-#include <utility>  // std::pair
+#include <utility>
 #include <vector>
 
 #include "ots.h"
 
 namespace ots {
 
 struct OpenTypeGLYF {
   std::vector<std::pair<const uint8_t*, size_t> > iov;

--- a/gfx/ots/src/gpos.cc
+++ b/gfx/ots/src/gpos.cc
@@ -2,18 +2,16 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpos.h"
 
 #include <limits>
 #include <vector>
 
-#include "gdef.h"
-#include "gsub.h"
 #include "layout.h"
 #include "maxp.h"
 
 // GPOS - The Glyph Positioning Table
 // http://www.microsoft.com/typography/otspec/gpos.htm
 
 #define TABLE_NAME "GPOS"
 
@@ -66,140 +64,142 @@ const ots::LookupSubtableParser::TypePar
   {GPOS_TYPE_MARK_TO_BASE_ATTACHMENT, ParseMarkToBaseAttachment},
   {GPOS_TYPE_MARK_TO_LIGATURE_ATTACHMENT, ParseMarkToLigatureAttachment},
   {GPOS_TYPE_MARK_TO_MARK_ATTACHMENT, ParseMarkToMarkAttachment},
   {GPOS_TYPE_CONTEXT_POSITIONING, ParseContextPositioning},
   {GPOS_TYPE_CHAINED_CONTEXT_POSITIONING, ParseChainedContextPositioning},
   {GPOS_TYPE_EXTENSION_POSITIONING, ParseExtensionPositioning}
 };
 
-// TODO(bashi): Port Chromium's arraysize macro and use it instead of sizeof().
 const ots::LookupSubtableParser kGposLookupSubtableParser = {
-  sizeof(kGposTypeParsers) / sizeof(kGposTypeParsers[0]),
+  arraysize(kGposTypeParsers),
   GPOS_TYPE_EXTENSION_POSITIONING, kGposTypeParsers
 };
 
 // Shared Tables: ValueRecord, Anchor Table, and MarkArray
 
-bool ParseValueRecord(ots::Buffer* subtable, const uint8_t *data,
+bool ParseValueRecord(const ots::OpenTypeFile *file,
+                      ots::Buffer* subtable, const uint8_t *data,
                       const size_t length, const uint16_t value_format) {
   // Check existence of adjustment fields.
   for (unsigned i = 0; i < 4; ++i) {
     if ((value_format >> i) & 0x1) {
       // Just read the field since these fileds could take an arbitrary values.
       if (!subtable->Skip(2)) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Failed to read value reacord component");
       }
     }
   }
 
   // Check existence of offsets to device table.
   for (unsigned i = 0; i < 4; ++i) {
     if ((value_format >> (i + 4)) & 0x1) {
       uint16_t offset = 0;
       if (!subtable->ReadU16(&offset)) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Failed to read value record offset");
       }
       if (offset) {
         // TODO(bashi): Is it possible that device tables locate before
         // this record? No fonts contain such offset AKAIF.
         if (offset >= length) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("Value record offset too high %d >= %ld", offset, length);
         }
-        if (!ots::ParseDeviceTable(data + offset, length - offset)) {
-          return OTS_FAILURE();
+        if (!ots::ParseDeviceTable(file, data + offset, length - offset)) {
+          return OTS_FAILURE_MSG("Failed to parse device table in value record");
         }
       }
     }
   }
   return true;
 }
 
-bool ParseAnchorTable(const uint8_t *data, const size_t length) {
+bool ParseAnchorTable(const ots::OpenTypeFile *file,
+                      const uint8_t *data, const size_t length) {
   ots::Buffer subtable(data, length);
 
   uint16_t format = 0;
   // Read format and skip 2 2-byte fields that could be arbitrary values.
   if (!subtable.ReadU16(&format) ||
       !subtable.Skip(4)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Faled to read anchor table");
   }
 
   if (format == 0 || format > kMaxAnchorFormat) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad Anchor table format %d", format);
   }
 
   // Format 2 and 3 has additional fields.
   if (format == 2) {
     // Format 2 provides an index to a glyph contour point, which will take
     // arbitrary value.
     uint16_t anchor_point = 0;
     if (!subtable.ReadU16(&anchor_point)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to read anchor point in format 2 Anchor Table");
     }
   } else if (format == 3) {
     uint16_t offset_x_device = 0;
     uint16_t offset_y_device = 0;
     if (!subtable.ReadU16(&offset_x_device) ||
         !subtable.ReadU16(&offset_y_device)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to read device table offsets in format 3 anchor table");
     }
     const unsigned format_end = static_cast<unsigned>(10);
     if (offset_x_device) {
       if (offset_x_device < format_end || offset_x_device >= length) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Bad x device table offset %d", offset_x_device);
       }
-      if (!ots::ParseDeviceTable(data + offset_x_device,
+      if (!ots::ParseDeviceTable(file, data + offset_x_device,
                                  length - offset_x_device)) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Failed to parse device table in anchor table");
       }
     }
     if (offset_y_device) {
       if (offset_y_device < format_end || offset_y_device >= length) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Bad y device table offset %d", offset_y_device);
       }
-      if (!ots::ParseDeviceTable(data + offset_y_device,
+      if (!ots::ParseDeviceTable(file, data + offset_y_device,
                                  length - offset_y_device)) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Failed to parse device table in anchor table");
       }
     }
   }
   return true;
 }
 
-bool ParseMarkArrayTable(const uint8_t *data, const size_t length,
+bool ParseMarkArrayTable(const ots::OpenTypeFile *file,
+                         const uint8_t *data, const size_t length,
                          const uint16_t class_count) {
   ots::Buffer subtable(data, length);
 
   uint16_t mark_count = 0;
   if (!subtable.ReadU16(&mark_count)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Can't read mark table length");
   }
 
   // MarkRecord consists of 4-bytes.
   const unsigned mark_records_end = 4 * static_cast<unsigned>(mark_count) + 2;
   if (mark_records_end > std::numeric_limits<uint16_t>::max()) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad mark table length");
   }
   for (unsigned i = 0; i < mark_count; ++i) {
     uint16_t class_value = 0;
     uint16_t offset_mark_anchor = 0;
     if (!subtable.ReadU16(&class_value) ||
         !subtable.ReadU16(&offset_mark_anchor)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Can't read mark table %d", i);
     }
     // |class_value| may take arbitrary values including 0 here so we don't
     // check the value.
     if (offset_mark_anchor < mark_records_end ||
         offset_mark_anchor >= length) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Bad mark anchor offset %d for mark table %d", offset_mark_anchor, i);
     }
-    if (!ParseAnchorTable(data + offset_mark_anchor,
+    if (!ParseAnchorTable(file, data + offset_mark_anchor,
                           length - offset_mark_anchor)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Faled to parse anchor table for mark table %d", i);
     }
   }
 
   return true;
 }
 
 // Lookup Type 1:
 // Single Adjustment Positioning Subtable
@@ -208,170 +208,173 @@ bool ParseSingleAdjustment(const ots::Op
   ots::Buffer subtable(data, length);
 
   uint16_t format = 0;
   uint16_t offset_coverage = 0;
   uint16_t value_format = 0;
   if (!subtable.ReadU16(&format) ||
       !subtable.ReadU16(&offset_coverage) ||
       !subtable.ReadU16(&value_format)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Can't read single adjustment information");
   }
 
   if (format == 1) {
     // Format 1 exactly one value record.
-    if (!ParseValueRecord(&subtable, data, length, value_format)) {
-      return OTS_FAILURE();
+    if (!ParseValueRecord(file, &subtable, data, length, value_format)) {
+      return OTS_FAILURE_MSG("Failed to parse format 1 single adjustment table");
     }
   } else if (format == 2) {
     uint16_t value_count = 0;
     if (!subtable.ReadU16(&value_count)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to parse format 2 single adjustment table");
     }
     for (unsigned i = 0; i < value_count; ++i) {
-      if (!ParseValueRecord(&subtable, data, length, value_format)) {
-        return OTS_FAILURE();
+      if (!ParseValueRecord(file, &subtable, data, length, value_format)) {
+        return OTS_FAILURE_MSG("Failed to parse value record %d in format 2 single adjustment table", i);
       }
     }
   } else {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad format %d in single adjustment table", format);
   }
 
   if (offset_coverage < subtable.offset() || offset_coverage >= length) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad coverage offset %d in single adjustment table", offset_coverage);
   }
 
-  if (!ots::ParseCoverageTable(data + offset_coverage,
+  if (!ots::ParseCoverageTable(file, data + offset_coverage,
                                length - offset_coverage,
                                file->maxp->num_glyphs)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to parse coverage table in single adjustment table");
   }
 
   return true;
 }
 
-bool ParsePairSetTable(const uint8_t *data, const size_t length,
+bool ParsePairSetTable(const ots::OpenTypeFile *file,
+                       const uint8_t *data, const size_t length,
                        const uint16_t value_format1,
                        const uint16_t value_format2,
                        const uint16_t num_glyphs) {
   ots::Buffer subtable(data, length);
 
   uint16_t value_count = 0;
   if (!subtable.ReadU16(&value_count)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to read pair set table structure");
   }
   for (unsigned i = 0; i < value_count; ++i) {
     // Check pair value record.
     uint16_t glyph_id = 0;
     if (!subtable.ReadU16(&glyph_id)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to read glyph in pair value record %d", i);
     }
     if (glyph_id >= num_glyphs) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("glyph id %d too high >= %d", glyph_id, num_glyphs);
     }
-    if (!ParseValueRecord(&subtable, data, length, value_format1)) {
-      return OTS_FAILURE();
+    if (!ParseValueRecord(file, &subtable, data, length, value_format1)) {
+      return OTS_FAILURE_MSG("Failed to parse value record in format 1 pair set table");
     }
-    if (!ParseValueRecord(&subtable, data, length, value_format2)) {
-      return OTS_FAILURE();
+    if (!ParseValueRecord(file, &subtable, data, length, value_format2)) {
+      return OTS_FAILURE_MSG("Failed to parse value record in format 2 pair set table");
     }
   }
   return true;
 }
 
-bool ParsePairPosFormat1(const uint8_t *data, const size_t length,
+bool ParsePairPosFormat1(const ots::OpenTypeFile *file,
+                         const uint8_t *data, const size_t length,
                          const uint16_t value_format1,
                          const uint16_t value_format2,
                          const uint16_t num_glyphs) {
   ots::Buffer subtable(data, length);
 
   // Skip 8 bytes that are already read before.
   if (!subtable.Skip(8)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to read pair pos table structure");
   }
 
   uint16_t pair_set_count = 0;
   if (!subtable.ReadU16(&pair_set_count)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to read pair pos set count");
   }
 
   const unsigned pair_pos_end = 2 * static_cast<unsigned>(pair_set_count) + 10;
   if (pair_pos_end > std::numeric_limits<uint16_t>::max()) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad pair set length %d", pair_pos_end);
   }
   for (unsigned i = 0; i < pair_set_count; ++i) {
     uint16_t pair_set_offset = 0;
     if (!subtable.ReadU16(&pair_set_offset)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to read pair set offset for pair set %d", i);
     }
     if (pair_set_offset < pair_pos_end || pair_set_offset >= length) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Bad pair set offset %d for pair set %d", pair_set_offset, i);
     }
     // Check pair set tables
-    if (!ParsePairSetTable(data + pair_set_offset, length - pair_set_offset,
+    if (!ParsePairSetTable(file, data + pair_set_offset, length - pair_set_offset,
                            value_format1, value_format2,
                            num_glyphs)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to parse pair set table %d", i);
     }
   }
 
   return true;
 }
 
-bool ParsePairPosFormat2(const uint8_t *data, const size_t length,
+bool ParsePairPosFormat2(const ots::OpenTypeFile *file,
+                         const uint8_t *data, const size_t length,
                          const uint16_t value_format1,
                          const uint16_t value_format2,
                          const uint16_t num_glyphs) {
   ots::Buffer subtable(data, length);
 
   // Skip 8 bytes that are already read before.
   if (!subtable.Skip(8)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to read pair pos format 2 structure");
   }
 
   uint16_t offset_class_def1 = 0;
   uint16_t offset_class_def2 = 0;
   uint16_t class1_count = 0;
   uint16_t class2_count = 0;
   if (!subtable.ReadU16(&offset_class_def1) ||
       !subtable.ReadU16(&offset_class_def2) ||
       !subtable.ReadU16(&class1_count) ||
       !subtable.ReadU16(&class2_count)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to read pair pos format 2 data");
   }
 
   // Check class 1 records.
   for (unsigned i = 0; i < class1_count; ++i) {
     // Check class 2 records.
     for (unsigned j = 0; j < class2_count; ++j) {
-      if (value_format1 && !ParseValueRecord(&subtable, data, length,
+      if (value_format1 && !ParseValueRecord(file, &subtable, data, length,
                                              value_format1)) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Failed to parse value record 1 %d and %d", j, i);
       }
-      if (value_format2 && !ParseValueRecord(&subtable, data, length,
+      if (value_format2 && !ParseValueRecord(file, &subtable, data, length,
                                              value_format2)) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Falied to parse value record 2 %d and %d", j, i);
       }
     }
   }
 
   // Check class definition tables.
   if (offset_class_def1 < subtable.offset() || offset_class_def1 >= length ||
       offset_class_def2 < subtable.offset() || offset_class_def2 >= length) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad class definition table offsets %d or %d", offset_class_def1, offset_class_def2);
   }
-  if (!ots::ParseClassDefTable(data + offset_class_def1,
+  if (!ots::ParseClassDefTable(file, data + offset_class_def1,
                                length - offset_class_def1,
                                num_glyphs, kMaxClassDefValue)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to parse class definition table 1");
   }
-  if (!ots::ParseClassDefTable(data + offset_class_def2,
+  if (!ots::ParseClassDefTable(file, data + offset_class_def2,
                                length - offset_class_def2,
                                num_glyphs, kMaxClassDefValue)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to parse class definition table 2");
   }
 
   return true;
 }
 
 // Lookup Type 2:
 // Pair Adjustment Positioning Subtable
 bool ParsePairAdjustment(const ots::OpenTypeFile *file, const uint8_t *data,
@@ -381,40 +384,40 @@ bool ParsePairAdjustment(const ots::Open
   uint16_t format = 0;
   uint16_t offset_coverage = 0;
   uint16_t value_format1 = 0;
   uint16_t value_format2 = 0;
   if (!subtable.ReadU16(&format) ||
       !subtable.ReadU16(&offset_coverage) ||
       !subtable.ReadU16(&value_format1) ||
       !subtable.ReadU16(&value_format2)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to read pair adjustment structure");
   }
 
   if (format == 1) {
-    if (!ParsePairPosFormat1(data, length, value_format1, value_format2,
+    if (!ParsePairPosFormat1(file, data, length, value_format1, value_format2,
                              file->maxp->num_glyphs)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to parse pair pos format 1");
     }
   } else if (format == 2) {
-    if (!ParsePairPosFormat2(data, length, value_format1, value_format2,
+    if (!ParsePairPosFormat2(file, data, length, value_format1, value_format2,
                              file->maxp->num_glyphs)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to parse pair format 2");
     }
   } else {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad pos pair format %d", format);
   }
 
   if (offset_coverage < subtable.offset() || offset_coverage >= length) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad pair pos offset coverage %d", offset_coverage);
   }
-  if (!ots::ParseCoverageTable(data + offset_coverage,
+  if (!ots::ParseCoverageTable(file, data + offset_coverage,
                                length - offset_coverage,
                                file->maxp->num_glyphs)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to parse coverage table");
   }
 
   return true;
 }
 
 // Lookup Type 3
 // Cursive Attachment Positioning Subtable
 bool ParseCursiveAttachment(const ots::OpenTypeFile *file, const uint8_t *data,
@@ -422,125 +425,127 @@ bool ParseCursiveAttachment(const ots::O
   ots::Buffer subtable(data, length);
 
   uint16_t format = 0;
   uint16_t offset_coverage = 0;
   uint16_t entry_exit_count = 0;
   if (!subtable.ReadU16(&format) ||
       !subtable.ReadU16(&offset_coverage) ||
       !subtable.ReadU16(&entry_exit_count)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to read cursive attachment structure");
   }
 
   if (format != 1) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad cursive attachment format %d", format);
   }
 
   // Check entry exit records.
   const unsigned entry_exit_records_end =
       2 * static_cast<unsigned>(entry_exit_count) + 6;
   if (entry_exit_records_end > std::numeric_limits<uint16_t>::max()) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad entry exit record end %d", entry_exit_records_end);
   }
   for (unsigned i = 0; i < entry_exit_count; ++i) {
     uint16_t offset_entry_anchor = 0;
     uint16_t offset_exit_anchor = 0;
     if (!subtable.ReadU16(&offset_entry_anchor) ||
         !subtable.ReadU16(&offset_exit_anchor)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Can't read entry exit record %d", i);
     }
     // These offsets could be NULL.
     if (offset_entry_anchor) {
       if (offset_entry_anchor < entry_exit_records_end ||
           offset_entry_anchor >= length) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Bad entry anchor offset %d in entry exit record %d", offset_entry_anchor, i);
       }
-      if (!ParseAnchorTable(data + offset_entry_anchor,
+      if (!ParseAnchorTable(file, data + offset_entry_anchor,
                             length - offset_entry_anchor)) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Failed to parse entry anchor table in entry exit record %d", i);
       }
     }
     if (offset_exit_anchor) {
       if (offset_exit_anchor < entry_exit_records_end ||
          offset_exit_anchor >= length) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Bad exit anchor offset %d in entry exit record %d", offset_exit_anchor, i);
       }
-      if (!ParseAnchorTable(data + offset_exit_anchor,
+      if (!ParseAnchorTable(file, data + offset_exit_anchor,
                             length - offset_exit_anchor)) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Failed to parse exit anchor table in entry exit record %d", i);
       }
     }
   }
 
   if (offset_coverage < subtable.offset() || offset_coverage >= length) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad coverage offset in cursive attachment %d", offset_coverage);
   }
-  if (!ots::ParseCoverageTable(data + offset_coverage,
+  if (!ots::ParseCoverageTable(file, data + offset_coverage,
                                length - offset_coverage,
                                file->maxp->num_glyphs)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to parse coverage table in cursive attachment");
   }
 
   return true;
 }
 
-bool ParseAnchorArrayTable(const uint8_t *data, const size_t length,
+bool ParseAnchorArrayTable(const ots::OpenTypeFile *file,
+                           const uint8_t *data, const size_t length,
                            const uint16_t class_count) {
   ots::Buffer subtable(data, length);
 
   uint16_t record_count = 0;
   if (!subtable.ReadU16(&record_count)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Can't read anchor array length");
   }
 
   const unsigned anchor_array_end = 2 * static_cast<unsigned>(record_count) *
       static_cast<unsigned>(class_count) + 2;
   if (anchor_array_end > std::numeric_limits<uint16_t>::max()) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad end of anchor array %d", anchor_array_end);
   }
   for (unsigned i = 0; i < record_count; ++i) {
     for (unsigned j = 0; j < class_count; ++j) {
       uint16_t offset_record = 0;
       if (!subtable.ReadU16(&offset_record)) {
-        return OTS_FAILURE();
+        return OTS_FAILURE_MSG("Can't read anchor array record offset for class %d and record %d", j, i);
       }
       // |offset_record| could be NULL.
       if (offset_record) {
         if (offset_record < anchor_array_end || offset_record >= length) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("Bad record offset %d in class %d, record %d", offset_record, j, i);
         }
-        if (!ParseAnchorTable(data + offset_record,
+        if (!ParseAnchorTable(file, data + offset_record,
                               length - offset_record)) {
-          return OTS_FAILURE();
+          return OTS_FAILURE_MSG("Failed to parse anchor table for class %d, record %d", j, i);
         }
       }
     }
   }
   return true;
 }
 
-bool ParseLigatureArrayTable(const uint8_t *data, const size_t length,
+bool ParseLigatureArrayTable(const ots::OpenTypeFile *file,
+                             const uint8_t *data, const size_t length,
                              const uint16_t class_count) {
   ots::Buffer subtable(data, length);
 
   uint16_t ligature_count = 0;
   if (!subtable.ReadU16(&ligature_count)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to read ligature count");
   }
   for (unsigned i = 0; i < ligature_count; ++i) {
     uint16_t offset_ligature_attach = 0;
     if (!subtable.ReadU16(&offset_ligature_attach)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Can't read ligature offset %d", i);
     }
     if (offset_ligature_attach < 2 || offset_ligature_attach >= length) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Bad ligature attachment offset %d in ligature %d", offset_ligature_attach, i);
     }
-    if (!ParseAnchorArrayTable(data + offset_ligature_attach,
+    if (!ParseAnchorArrayTable(file, data + offset_ligature_attach,
                                length - offset_ligature_attach, class_count)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to parse anchor table for ligature %d", i);
     }
   }
   return true;
 }
 
 // Common parser for Lookup Type 4, 5 and 6.
 bool ParseMarkToAttachmentSubtables(const ots::OpenTypeFile *file,
                                     const uint8_t *data, const size_t length,
@@ -554,71 +559,71 @@ bool ParseMarkToAttachmentSubtables(cons
   uint16_t offset_mark_array = 0;
   uint16_t offset_type_specific_array = 0;
   if (!subtable.ReadU16(&format) ||
       !subtable.ReadU16(&offset_coverage1) ||
       !subtable.ReadU16(&offset_coverage2) ||
       !subtable.ReadU16(&class_count) ||
       !subtable.ReadU16(&offset_mark_array) ||
       !subtable.ReadU16(&offset_type_specific_array)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to read mark attachment subtable header");
   }
 
   if (format != 1) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("bad mark attachment subtable format %d", format);
   }
 
   const unsigned header_end = static_cast<unsigned>(subtable.offset());
   if (header_end > std::numeric_limits<uint16_t>::max()) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad mark attachment subtable size ending at %d", header_end);
   }
   if (offset_coverage1 < header_end || offset_coverage1 >= length) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad coverage 1 offset %d", offset_coverage1);
   }
-  if (!ots::ParseCoverageTable(data + offset_coverage1,
+  if (!ots::ParseCoverageTable(file, data + offset_coverage1,
                                length - offset_coverage1,
                                file->maxp->num_glyphs)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to parse converge 1 table");
   }
   if (offset_coverage2 < header_end || offset_coverage2 >= length) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad coverage 2 offset %d", offset_coverage2);
   }
-  if (!ots::ParseCoverageTable(data + offset_coverage2,
+  if (!ots::ParseCoverageTable(file, data + offset_coverage2,
                                length - offset_coverage2,
                                file->maxp->num_glyphs)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to parse coverage table 2");
   }
 
   if (offset_mark_array < header_end || offset_mark_array >= length) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad mark array offset %d", offset_mark_array);
   }
-  if (!ParseMarkArrayTable(data + offset_mark_array,
+  if (!ParseMarkArrayTable(file, data + offset_mark_array,
                            length - offset_mark_array, class_count)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to parse mark array");
   }
 
   if (offset_type_specific_array < header_end ||
       offset_type_specific_array >= length) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad type specific array offset %d", offset_type_specific_array);
   }
   if (type == GPOS_TYPE_MARK_TO_BASE_ATTACHMENT ||
       type == GPOS_TYPE_MARK_TO_MARK_ATTACHMENT) {
-    if (!ParseAnchorArrayTable(data + offset_type_specific_array,
+    if (!ParseAnchorArrayTable(file, data + offset_type_specific_array,
                                length - offset_type_specific_array,
                                class_count)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to parse anchor array");
     }
   } else if (type == GPOS_TYPE_MARK_TO_LIGATURE_ATTACHMENT) {
-    if (!ParseLigatureArrayTable(data + offset_type_specific_array,
+    if (!ParseLigatureArrayTable(file, data + offset_type_specific_array,
                                  length - offset_type_specific_array,
                                  class_count)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed to parse ligature array");
     }
   } else {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Bad attachment type %d", type);
   }
 
   return true;
 }
 
 // Lookup Type 4:
 // MarkToBase Attachment Positioning Subtable
 bool ParseMarkToBaseAttachment(const ots::OpenTypeFile *file,
@@ -642,44 +647,44 @@ bool ParseMarkToMarkAttachment(const ots
   return ParseMarkToAttachmentSubtables(file, data, length,
                                         GPOS_TYPE_MARK_TO_MARK_ATTACHMENT);
 }
 
 // Lookup Type 7:
 // Contextual Positioning Subtables
 bool ParseContextPositioning(const ots::OpenTypeFile *file,
                              const uint8_t *data, const size_t length) {
-  return ots::ParseContextSubtable(data, length, file->maxp->num_glyphs,
+  return ots::ParseContextSubtable(file, data, length, file->maxp->num_glyphs,
                                    file->gpos->num_lookups);
 }
 
 // Lookup Type 8:
 // Chaining Contexual Positioning Subtable
 bool ParseChainedContextPositioning(const ots::OpenTypeFile *file,
                                     const uint8_t *data, const size_t length) {
-  return ots::ParseChainingContextSubtable(data, length,
+  return ots::ParseChainingContextSubtable(file, data, length,
                                            file->maxp->num_glyphs,
                                            file->gpos->num_lookups);
 }
 
 // Lookup Type 9:
 // Extension Positioning
 bool ParseExtensionPositioning(const ots::OpenTypeFile *file,
                                const uint8_t *data, const size_t length) {
   return ots::ParseExtensionSubtable(file, data, length,
                                      &kGposLookupSubtableParser);
 }
 
 }  // namespace
 
-#define DROP_THIS_TABLE \
+#define DROP_THIS_TABLE(msg_) \
   do { \
     file->gpos->data = 0; \
     file->gpos->length = 0; \
-    OTS_FAILURE_MSG("OpenType layout data discarded"); \
+    OTS_FAILURE_MSG(msg_ ", table discarded"); \
   } while (0)
 
 namespace ots {
 
 // As far as I checked, following fonts contain invalid GPOS table and
 // OTS will drop their GPOS table.
 //
 // # invalid delta format in device table
@@ -723,94 +728,84 @@ namespace ots {
 // Padauk.ttf
 //
 // # Contour point indexes aren't sorted
 // Arial Unicode.ttf
 
 bool ots_gpos_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
   // Parsing GPOS table requires num_glyphs which is contained in maxp table.
   if (!file->maxp) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("missing maxp table needed in GPOS");
   }
 
   Buffer table(data, length);
 
   OpenTypeGPOS *gpos = new OpenTypeGPOS;
   file->gpos = gpos;
 
   uint32_t version = 0;
   uint16_t offset_script_list = 0;
   uint16_t offset_feature_list = 0;
   uint16_t offset_lookup_list = 0;
   if (!table.ReadU32(&version) ||
       !table.ReadU16(&offset_script_list) ||
       !table.ReadU16(&offset_feature_list) ||
       !table.ReadU16(&offset_lookup_list)) {
-    OTS_WARNING("incomplete GPOS table");
-    DROP_THIS_TABLE;
+    DROP_THIS_TABLE("Incomplete table");
     return true;
   }
 
   if (version != 0x00010000) {
-    OTS_WARNING("bad GPOS version");
-    DROP_THIS_TABLE;
+    DROP_THIS_TABLE("Bad version");
     return true;
   }
   if ((offset_script_list < kGposHeaderSize ||
        offset_script_list >= length) ||
       (offset_feature_list < kGposHeaderSize ||
        offset_feature_list >= length) ||
       (offset_lookup_list < kGposHeaderSize ||
        offset_lookup_list >= length)) {
-    OTS_WARNING("bad offset in GPOS header");
-    DROP_THIS_TABLE;
+    DROP_THIS_TABLE("Bad offset in table header");
     return true;
   }
 
   if (!ParseLookupListTable(file, data + offset_lookup_list,
                             length - offset_lookup_list,
                             &kGposLookupSubtableParser,
                             &gpos->num_lookups)) {
-    OTS_WARNING("failed to parse lookup list table");
-    DROP_THIS_TABLE;
+    DROP_THIS_TABLE("Failed to parse lookup list table");
     return true;
   }
 
   uint16_t num_features = 0;
-  if (!ParseFeatureListTable(data + offset_feature_list,
+  if (!ParseFeatureListTable(file, data + offset_feature_list,
                              length - offset_feature_list, gpos->num_lookups,
                              &num_features)) {
-    OTS_WARNING("failed to parse feature list table");
-    DROP_THIS_TABLE;
+    DROP_THIS_TABLE("Failed to parse feature list table");
     return true;
   }
 
-  if (!ParseScriptListTable(data + offset_script_list,
+  if (!ParseScriptListTable(file, data + offset_script_list,
                             length - offset_script_list, num_features)) {
-    OTS_WARNING("failed to parse script list table");
-    DROP_THIS_TABLE;
+    DROP_THIS_TABLE("Failed to parse script list table");
     return true;
   }
 
   gpos->data = data;
   gpos->length = length;
   return true;
 }
 
 bool ots_gpos_should_serialise(OpenTypeFile *file) {
-  const bool needed_tables_dropped =
-      (file->gdef && file->gdef->data == NULL) ||
-      (file->gsub && file->gsub->data == NULL);
-  return file->gpos != NULL && file->gpos->data != NULL &&
-      !needed_tables_dropped;
+  return file->gpos != NULL && file->gpos->data != NULL;
 }
 
 bool ots_gpos_serialise(OTSStream *out, OpenTypeFile *file) {
   if (!out->Write(file->gpos->data, file->gpos->length)) {
-    return OTS_FAILURE();
+    return OTS_FAILURE_MSG("Failed to write GPOS table");
   }
 
   return true;
 }
 
 void ots_gpos_free(OpenTypeFile *file) {
   delete file->gpos;
 }

deleted file mode 100644
--- a/gfx/ots/src/graphite.cc
+++ /dev/null
@@ -1,181 +0,0 @@
-// Copyright (c) 2010 Mozilla Foundation. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "graphite.h"
-
-// Support for preserving (NOT sanitizing) the Graphite tables
-
-namespace ots {
-
-// 'Silf'
-bool ots_silf_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
-  Buffer table(data, length);
-
-  OpenTypeSILF *silf = new OpenTypeSILF;
-  file->silf = silf;
-
-  if (!table.Skip(length)) {
-    return OTS_FAILURE();
-  }
-
-  silf->data = data;
-  silf->length = length;
-  return true;
-}
-
-bool ots_silf_should_serialise(OpenTypeFile *file) {
-  return file->preserve_graphite && file->silf;
-}
-
-bool ots_silf_serialise(OTSStream *out, OpenTypeFile *file) {
-  const OpenTypeSILF *silf = file->silf;
-
-  if (!out->Write(silf->data, silf->length)) {
-    return OTS_FAILURE();
-  }
-
-  return true;
-}
-
-void ots_silf_free(OpenTypeFile *file) {
-  delete file->silf;
-}
-
-// 'Sill'
-bool ots_sill_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
-  Buffer table(data, length);
-
-  OpenTypeSILL *sill = new OpenTypeSILL;
-  file->sill = sill;
-
-  if (!table.Skip(length)) {
-    return OTS_FAILURE();
-  }
-
-  sill->data = data;
-  sill->length = length;
-  return true;
-}
-
-bool ots_sill_should_serialise(OpenTypeFile *file) {
-  return file->preserve_graphite && file->sill;
-}
-
-bool ots_sill_serialise(OTSStream *out, OpenTypeFile *file) {
-  const OpenTypeSILL *sill = file->sill;
-
-  if (!out->Write(sill->data, sill->length)) {
-    return OTS_FAILURE();
-  }
-
-  return true;
-}
-
-void ots_sill_free(OpenTypeFile *file) {
-  delete file->sill;
-}
-
-// 'Gloc'
-bool ots_gloc_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
-  Buffer table(data, length);
-
-  OpenTypeGLOC *gloc = new OpenTypeGLOC;
-  file->gloc = gloc;
-
-  if (!table.Skip(length)) {
-    return OTS_FAILURE();
-  }
-
-  gloc->data = data;
-  gloc->length = length;
-  return true;
-}
-
-bool ots_gloc_should_serialise(OpenTypeFile *file) {
-  return file->preserve_graphite && file->gloc;
-}
-
-bool ots_gloc_serialise(OTSStream *out, OpenTypeFile *file) {
-  const OpenTypeGLOC *gloc = file->gloc;
-
-  if (!out->Write(gloc->data, gloc->length)) {
-    return OTS_FAILURE();
-  }
-
-  return true;
-}
-
-void ots_gloc_free(OpenTypeFile *file) {
-  delete file->gloc;
-}
-
-// 'Glat'
-bool ots_glat_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
-  Buffer table(data, length);
-
-  OpenTypeGLAT *glat = new OpenTypeGLAT;
-  file->glat = glat;
-
-  if (!table.Skip(length)) {
-    return OTS_FAILURE();
-  }
-
-  glat->data = data;
-  glat->length = length;
-  return true;
-}
-
-bool ots_glat_should_serialise(OpenTypeFile *file) {
-  return file->preserve_graphite && file->glat;
-}
-
-bool ots_glat_serialise(OTSStream *out, OpenTypeFile *file) {
-  const OpenTypeGLAT *glat = file->glat;
-
-  if (!out->Write(glat->data, glat->length)) {
-    return OTS_FAILURE();
-  }
-
-  return true;
-}
-
-void ots_glat_free(OpenTypeFile *file) {
-  delete file->glat;
-}
-
-// 'Feat'
-bool ots_feat_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
-  Buffer table(data, length);
-
-  OpenTypeFEAT *feat = new OpenTypeFEAT;
-  file->feat = feat;
-
-  if (!table.Skip(length)) {
-    return OTS_FAILURE();
-  }
-
-  feat->data = data;
-  feat->length = length;
-  return true;
-}
-
-bool ots_feat_should_serialise(OpenTypeFile *file) {
-  return file->preserve_graphite && file->feat;
-}
-
-bool ots_feat_serialise(OTSStream *out, OpenTypeFile *file) {
-  const OpenTypeFEAT *feat = file->feat;
-
-  if (!out->Write(feat->data, feat->length)) {
-    return OTS_FAILURE();
-  }
-
-  return true;
-}
-
-void ots_feat_free(OpenTypeFile *file) {
-  delete file->feat;
-}
-
-}  // namespace ots