diff --git a/sample/subsetter/main.cc b/sample/subsetter/main.cc
index a9e1524..19a3e0e 100644
--- a/sample/subsetter/main.cc
+++ b/sample/subsetter/main.cc
@@ -34,7 +34,7 @@
   }
 
   sfntly::SubsetUtil subset_util;
-  subset_util.subset(argv[1], argv[2]);
+  subset_util.Subset(argv[1], argv[2]);
 
 #ifdef _CRTDBG_MAP_ALLOC
   _CrtDumpMemoryLeaks();
diff --git a/sample/subsetter/subset_util.cc b/sample/subsetter/subset_util.cc
index 013a903..9e4e652 100644
--- a/sample/subsetter/subset_util.cc
+++ b/sample/subsetter/subset_util.cc
@@ -37,7 +37,7 @@
 SubsetUtil::~SubsetUtil() {
 }
 
-void SubsetUtil::subset(const char *input_file_path,
+void SubsetUtil::Subset(const char *input_file_path,
                         const char *output_file_path) {
   UNREFERENCED_PARAMETER(output_file_path);
   ByteVector input_buffer;
@@ -56,10 +56,10 @@
 
   ByteArrayPtr ba = new MemoryByteArray(&(input_buffer[0]), file_size);
   FontFactoryPtr factory;
-  factory.attach(FontFactory::getInstance());
+  factory.Attach(FontFactory::GetInstance());
 
   FontArray font_array;
-  factory->loadFonts(ba, &font_array);
+  factory->LoadFonts(ba, &font_array);
   if (font_array.empty() || font_array[0] == NULL)
     return;
 
@@ -71,25 +71,25 @@
   glyphs.push_back(10);
 
   Ptr<Subsetter> subsetter = new Subsetter(font_array[0], factory);
-  subsetter->setGlyphs(&glyphs);
+  subsetter->SetGlyphs(&glyphs);
   IntegerSet remove_tables;
   remove_tables.insert(Tag::DSIG);
-  subsetter->setRemoveTables(&remove_tables);
+  subsetter->SetRemoveTables(&remove_tables);
 
   FontBuilderPtr font_builder;
-  font_builder.attach(subsetter->subset());
+  font_builder.Attach(subsetter->Subset());
 
   FontPtr new_font;
-  new_font.attach(font_builder->build());
+  new_font.Attach(font_builder->Build());
 
   // TODO(arthurhsu): glyph renumbering/Loca table
   // TODO(arthurhsu): alter CMaps
 
   MemoryOutputStream output_stream;
-  factory->serializeFont(new_font, &output_stream);
+  factory->SerializeFont(new_font, &output_stream);
 
   FILE* output_file = fopen(output_file_path, "wb");
-  fwrite(output_stream.get(), 1, output_stream.size(), output_file);
+  fwrite(output_stream.Get(), 1, output_stream.Size(), output_file);
   fflush(output_file);
   fclose(output_file);
 }
diff --git a/sample/subsetter/subset_util.h b/sample/subsetter/subset_util.h
index bea28b8..109d63a 100644
--- a/sample/subsetter/subset_util.h
+++ b/sample/subsetter/subset_util.h
@@ -24,7 +24,7 @@
   SubsetUtil();
   virtual ~SubsetUtil();
 
-  void subset(const char* input_file_path, const char* output_file_path);
+  void Subset(const char* input_file_path, const char* output_file_path);
 };
 
 }  // namespace sfntly
diff --git a/sfntly/cmap_table.cc b/sfntly/cmap_table.cc
index 8cbc83e..668dc07 100644
--- a/sfntly/cmap_table.cc
+++ b/sfntly/cmap_table.cc
@@ -30,41 +30,43 @@
 /******************************************************************************
  * CMapTable class
  ******************************************************************************/
-CMapTable::CMapTable(Header* header, ReadableFontData* data)
-    : Table(header, data) {}
 CMapTable::~CMapTable() {}
 
-int32_t CMapTable::version() {
-  return data_->readUShort(Offset::kVersion);
+int32_t CMapTable::Version() {
+  return data_->ReadUShort(Offset::kVersion);
 }
 
-int32_t CMapTable::numCMaps() {
-  return data_->readUShort(Offset::kNumTables);
+int32_t CMapTable::NumCMaps() {
+  return data_->ReadUShort(Offset::kNumTables);
 }
 
-int32_t CMapTable::offsetForEncodingRecord(int32_t index) {
+CMapTable::CMapId CMapTable::GetCMapId(int32_t index) {
+  return CMapId(PlatformId(index), EncodingId(index));
+}
+
+int32_t CMapTable::PlatformId(int32_t index) {
+  return data_->ReadUShort(Offset::kEncodingRecordPlatformId +
+                           OffsetForEncodingRecord(index));
+}
+
+int32_t CMapTable::EncodingId(int32_t index) {
+  return data_->ReadUShort(Offset::kEncodingRecordEncodingId +
+                           OffsetForEncodingRecord(index));
+}
+
+int32_t CMapTable::Offset(int32_t index) {
+  return data_->ReadULongAsInt(Offset::kEncodingRecordOffset +
+                               OffsetForEncodingRecord(index));
+}
+
+CMapTable::CMapTable(Header* header, ReadableFontData* data)
+    : Table(header, data) {
+}
+
+int32_t CMapTable::OffsetForEncodingRecord(int32_t index) {
   return Offset::kEncodingRecordStart + index * Offset::kEncodingRecordSize;
 }
 
-CMapTable::CMapId CMapTable::cmapId(int32_t index) {
-  return CMapId(platformId(index), encodingId(index));
-}
-
-int32_t CMapTable::platformId(int32_t index) {
-  return data_->readUShort(Offset::kEncodingRecordPlatformId +
-                           offsetForEncodingRecord(index));
-}
-
-int32_t CMapTable::encodingId(int32_t index) {
-  return data_->readUShort(Offset::kEncodingRecordEncodingId +
-                           offsetForEncodingRecord(index));
-}
-
-int32_t CMapTable::offset(int32_t index) {
-  return data_->readULongAsInt(Offset::kEncodingRecordOffset +
-                               offsetForEncodingRecord(index));
-}
-
 /******************************************************************************
  * CMapTable::CMapId class
  ******************************************************************************/
@@ -76,9 +78,6 @@
     : platform_id_(obj.platform_id_), encoding_id_(obj.encoding_id_) {
 }
 
-int32_t CMapTable::CMapId::platformId() { return platform_id_; }
-int32_t CMapTable::CMapId::encodingId() { return encoding_id_; }
-
 bool CMapTable::CMapId::operator==(const CMapTable::CMapId& obj) {
   return obj.platform_id_ == platform_id_ && obj.encoding_id_ == encoding_id_;
 }
@@ -90,7 +89,7 @@
   return *this;
 }
 
-int CMapTable::CMapId::hashCode() const {
+int CMapTable::CMapId::HashCode() const {
   return platform_id_ << 8 | encoding_id_;
 }
 
@@ -106,7 +105,7 @@
 
 bool CMapTable::CMapIdComparator::operator()(const CMapId& lhs,
                                              const CMapId& rhs) {
-  return lhs.hashCode() > rhs.hashCode();
+  return lhs.HashCode() > rhs.HashCode();
 }
 
 /******************************************************************************
@@ -117,101 +116,102 @@
     : SubTable(data), format_(format), cmap_id_(cmap_id) {
 }
 
-CMapTable::CMap::~CMap() {}
-int32_t CMapTable::CMap::format() { return format_; }
-CMapTable::CMapId CMapTable::CMap::cmapId() { return cmap_id_; }
-int32_t CMapTable::CMap::platformId() { return cmap_id_.platformId(); }
-int32_t CMapTable::CMap::encodingId() { return cmap_id_.encodingId(); }
+CMapTable::CMap::~CMap() {
+}
 
 /******************************************************************************
  * CMapTable::CMap::Builder class
  ******************************************************************************/
+CMapTable::CMap::Builder::~Builder() {
+}
+
+CALLER_ATTACH CMapTable::CMap::Builder*
+    CMapTable::CMap::Builder::GetBuilder(
+        FontDataTableBuilderContainer* container,
+        ReadableFontData* data,
+        int32_t offset,
+        const CMapId& cmap_id) {
+  // NOT IMPLEMENTED: Java enum value validation
+  int32_t format = data->ReadUShort(offset);
+  CMapBuilderPtr builder;
+  switch (format) {
+    case CMapFormat::kFormat0:
+      builder = new CMapFormat0::Builder(container, data, offset, cmap_id);
+      break;
+    case CMapFormat::kFormat2:
+      builder = new CMapFormat0::Builder(container, data, offset, cmap_id);
+      break;
+    default:
+      break;
+  }
+  return builder.Detach();
+}
+
 CMapTable::CMap::Builder::Builder(FontDataTableBuilderContainer* container,
                                   ReadableFontData* data, int32_t format,
                                   const CMapId& cmap_id)
-    : SubTable::Builder(container, data), format_(format), cmap_id_(cmap_id) {
+    : SubTable::Builder(container, data),
+      format_(format),
+      cmap_id_(cmap_id) {
 }
 
 CMapTable::CMap::Builder::Builder(FontDataTableBuilderContainer* container,
                                   WritableFontData* data, int32_t format,
                                   const CMapId& cmap_id)
-    : SubTable::Builder(container, data), format_(format), cmap_id_(cmap_id) {
+    : SubTable::Builder(container, data),
+      format_(format),
+      cmap_id_(cmap_id) {
 }
 
-CMapTable::CMap::Builder::~Builder() {}
-
-CMapTable::CMapId CMapTable::CMap::Builder::cmapId() {
-  return cmap_id_;
+int32_t CMapTable::CMap::Builder::SubSerialize(WritableFontData* new_data) {
+  return InternalReadData()->CopyTo(new_data);
 }
 
-int32_t CMapTable::CMap::Builder::platformId() {
-  return cmap_id_.platformId();
-}
-
-int32_t CMapTable::CMap::Builder::encodingId() {
-  return cmap_id_.encodingId();
-}
-
-int32_t CMapTable::CMap::Builder::subSerialize(WritableFontData* new_data) {
-  return internalReadData()->copyTo(new_data);
-}
-
-bool CMapTable::CMap::Builder::subReadyToSerialize() {
+bool CMapTable::CMap::Builder::SubReadyToSerialize() {
   return true;
 }
 
-int32_t CMapTable::CMap::Builder::subDataSizeToSerialize() {
-  return internalReadData()->length();
+int32_t CMapTable::CMap::Builder::SubDataSizeToSerialize() {
+  return InternalReadData()->Length();
 }
 
-void CMapTable::CMap::Builder::subDataSet() {
+void CMapTable::CMap::Builder::SubDataSet() {
   // NOP
 }
 
-CALLER_ATTACH CMapTable::CMap::Builder* CMapTable::CMap::Builder::getBuilder(
-    FontDataTableBuilderContainer* container, ReadableFontData* data,
-    int32_t offset, const CMapId& cmap_id) {
-  // NOT IMPLEMENTED: Java enum value validation
-  int32_t format = data->readUShort(offset);
-  CMapBuilderPtr builder;
-  switch (format) {
-    case CMapFormat::kFormat0:
-      builder = new CMapFormat0::Builder(container, data, offset, cmap_id);
-    case CMapFormat::kFormat2:
-      builder = new CMapFormat0::Builder(container, data, offset, cmap_id);
-    default:
-      break;
-  }
-  return builder.detach();
+/******************************************************************************
+ * CMapTable::CMapFormat0
+ ******************************************************************************/
+CMapTable::CMapFormat0::~CMapFormat0() {
 }
 
-/******************************************************************************
- * CMapTable::CMapFormat0 and CMapTable::CMapFormat0::Builder
- ******************************************************************************/
+int32_t CMapTable::CMapFormat0::Language() {
+  return 0;
+}
+
+int32_t CMapTable::CMapFormat0::GlyphId(int32_t character) {
+  if (character < 0 || character > 255) {
+    return CMapTable::NOTDEF;
+  }
+  return data_->ReadByte(character + Offset::kFormat0GlyphIdArray);
+}
+
 CMapTable::CMapFormat0::CMapFormat0(ReadableFontData* data,
                                     const CMapId& cmap_id)
     : CMap(data, CMapFormat::kFormat0, cmap_id) {
 }
 
-CMapTable::CMapFormat0::~CMapFormat0() {}
-
-int32_t CMapTable::CMapFormat0::glyphId(int32_t character) {
-  if (character < 0 || character > 255) {
-    return CMapTable::NOTDEF;
-  }
-  return data_->readByte(character + Offset::kFormat0GlyphIdArray);
-}
-
-int32_t CMapTable::CMapFormat0::language() {
-  return 0;
-}
-
+/******************************************************************************
+ * CMapTable::CMapFormat0::Builder
+ ******************************************************************************/
 CMapTable::CMapFormat0::Builder::Builder(
-    FontDataTableBuilderContainer* container, WritableFontData* data,
-    int32_t offset, const CMapId& cmap_id)
+    FontDataTableBuilderContainer* container,
+    WritableFontData* data,
+    int32_t offset,
+    const CMapId& cmap_id)
     : CMapTable::CMap::Builder(container,
                                data ? down_cast<WritableFontData*>(
-                                   data->slice(offset, data->readUShort(
+                                   data->Slice(offset, data->ReadUShort(
                                        offset + Offset::kFormat0Length)))
                                : reinterpret_cast<WritableFontData*>(NULL),
                                CMapFormat::kFormat0, cmap_id) {
@@ -219,101 +219,68 @@
 }
 
 CMapTable::CMapFormat0::Builder::Builder(
-    FontDataTableBuilderContainer* container, ReadableFontData* data,
-    int32_t offset, const CMapId& cmap_id)
+    FontDataTableBuilderContainer* container,
+    ReadableFontData* data,
+    int32_t offset,
+    const CMapId& cmap_id)
     : CMapTable::CMap::Builder(container,
                                data ? down_cast<ReadableFontData*>(
-                                   data->slice(offset, data->readUShort(
+                                   data->Slice(offset, data->ReadUShort(
                                        offset + Offset::kFormat0Length)))
                                : reinterpret_cast<WritableFontData*>(NULL),
                                CMapFormat::kFormat0, cmap_id) {
   // TODO(arthurhsu): FIXIT: heavy lifting and leak, need fix.
 }
 
-CMapTable::CMapFormat0::Builder::~Builder() {}
+CMapTable::CMapFormat0::Builder::~Builder() {
+}
 
-CALLER_ATTACH FontDataTable* CMapTable::CMapFormat0::Builder::subBuildTable(
-    ReadableFontData* data) {
-  FontDataTablePtr table = new CMapFormat0(data, cmapId());
-  return table.detach();
+CALLER_ATTACH FontDataTable*
+    CMapTable::CMapFormat0::Builder::SubBuildTable(ReadableFontData* data) {
+  FontDataTablePtr table = new CMapFormat0(data, cmap_id());
+  return table.Detach();
 }
 
 /******************************************************************************
- * CMapTable::CMapFormat2 and CMapTable::CMapFormat2::Builder
+ * CMapTable::CMapFormat2
  ******************************************************************************/
-CMapTable::CMapFormat2::CMapFormat2(ReadableFontData* data,
-                                    const CMapId& cmap_id)
-    : CMap(data, CMapFormat::kFormat2, cmap_id) {
+CMapTable::CMapFormat2::~CMapFormat2() {
 }
 
-CMapTable::CMapFormat2::~CMapFormat2() {}
-
-int32_t CMapTable::CMapFormat2::subHeaderOffset(int32_t sub_header_index) {
-  return data_->readUShort(Offset::kFormat2SubHeaderKeys + sub_header_index *
-                           DataSize::kUSHORT);
+int32_t CMapTable::CMapFormat2::Language() {
+  return 0;
 }
 
-int32_t CMapTable::CMapFormat2::firstCode(int32_t sub_header_index) {
-  int32_t sub_header_offset = subHeaderOffset(sub_header_index);
-  return data_->readUShort(sub_header_offset + Offset::kFormat2SubHeaderKeys +
-                           Offset::kFormat2SubHeader_firstCode);
-}
-
-int32_t CMapTable::CMapFormat2::entryCount(int32_t sub_header_index) {
-  int32_t sub_header_offset = subHeaderOffset(sub_header_index);
-  return data_->readUShort(sub_header_offset + Offset::kFormat2SubHeaderKeys +
-                           Offset::kFormat2SubHeader_entryCount);
-}
-
-int32_t CMapTable::CMapFormat2::idRangeOffset(int32_t sub_header_index) {
-  int32_t sub_header_offset = subHeaderOffset(sub_header_index);
-  return data_->readUShort(sub_header_offset + Offset::kFormat2SubHeaderKeys +
-                           Offset::kFormat2SubHeader_idRangeOffset);
-}
-
-int32_t CMapTable::CMapFormat2::idDelta(int32_t sub_header_index) {
-  int32_t sub_header_offset = subHeaderOffset(sub_header_index);
-  return data_->readUShort(sub_header_offset + Offset::kFormat2SubHeaderKeys +
-                           Offset::kFormat2SubHeader_idDelta);
-}
-
-int32_t CMapTable::CMapFormat2::bytesConsumed(int32_t character) {
-  uint32_t c = toBE32(character);
-  int32_t high_byte = (c >> 8) & 0xff;
-  int32_t offset = subHeaderOffset(high_byte);
-  return (offset == 0) ? 1 : 2;
-}
-
-int32_t CMapTable::CMapFormat2::glyphId(int32_t character) {
+int32_t CMapTable::CMapFormat2::GlyphId(int32_t character) {
   if (character > 0xffff) {
     return CMapTable::NOTDEF;
   }
 
-  uint32_t c = toBE32(character);
+  uint32_t c = ToBE32(character);
   byte_t high_byte = (c >> 8) & 0xff;
   byte_t low_byte = c & 0xff;
-  int32_t offset = subHeaderOffset(high_byte);
+  int32_t offset = SubHeaderOffset(high_byte);
 
   if (offset == 0) {
     low_byte = high_byte;
     high_byte = 0;
   }
 
-  int32_t first_code = firstCode(high_byte);
-  int32_t entry_count = entryCount(high_byte);
+  int32_t first_code = FirstCode(high_byte);
+  int32_t entry_count = EntryCount(high_byte);
 
   if (low_byte < first_code || low_byte >= first_code + entry_count) {
     return CMapTable::NOTDEF;
   }
 
-  int32_t id_range_offset = idRangeOffset(high_byte);
+  int32_t id_range_offset = IdRangeOffset(high_byte);
 
   // position of idRangeOffset + value of idRangeOffset + index for low byte
   // = firstcode
   int32_t p_location = (offset + Offset::kFormat2SubHeader_idRangeOffset) +
       id_range_offset +
       (low_byte - first_code) * DataSize::kUSHORT;
-  int p = data_->readUShort(p_location);
+  int p = data_->ReadUShort(p_location);
   if (p == 0) {
     return CMapTable::NOTDEF;
   }
@@ -321,20 +288,66 @@
   if (offset == 0) {
     return p;
   }
-  int id_delta = idDelta(high_byte);
+  int id_delta = IdDelta(high_byte);
   return (p + id_delta) % 65536;
 }
 
-int32_t CMapTable::CMapFormat2::language() {
-  return 0;
+int32_t CMapTable::CMapFormat2::BytesConsumed(int32_t character) {
+  uint32_t c = ToBE32(character);
+  int32_t high_byte = (c >> 8) & 0xff;
+  int32_t offset = SubHeaderOffset(high_byte);
+  return (offset == 0) ? 1 : 2;
 }
 
+CMapTable::CMapFormat2::CMapFormat2(ReadableFontData* data,
+                                    const CMapId& cmap_id)
+    : CMap(data, CMapFormat::kFormat2, cmap_id) {
+}
+
+int32_t CMapTable::CMapFormat2::SubHeaderOffset(int32_t sub_header_index) {
+  return data_->ReadUShort(Offset::kFormat2SubHeaderKeys +
+                           sub_header_index * DataSize::kUSHORT);
+}
+
+int32_t CMapTable::CMapFormat2::FirstCode(int32_t sub_header_index) {
+  int32_t sub_header_offset = SubHeaderOffset(sub_header_index);
+  return data_->ReadUShort(sub_header_offset +
+                           Offset::kFormat2SubHeaderKeys +
+                           Offset::kFormat2SubHeader_firstCode);
+}
+
+int32_t CMapTable::CMapFormat2::EntryCount(int32_t sub_header_index) {
+  int32_t sub_header_offset = SubHeaderOffset(sub_header_index);
+  return data_->ReadUShort(sub_header_offset +
+                           Offset::kFormat2SubHeaderKeys +
+                           Offset::kFormat2SubHeader_entryCount);
+}
+
+int32_t CMapTable::CMapFormat2::IdRangeOffset(int32_t sub_header_index) {
+  int32_t sub_header_offset = SubHeaderOffset(sub_header_index);
+  return data_->ReadUShort(sub_header_offset +
+                           Offset::kFormat2SubHeaderKeys +
+                           Offset::kFormat2SubHeader_idRangeOffset);
+}
+
+int32_t CMapTable::CMapFormat2::IdDelta(int32_t sub_header_index) {
+  int32_t sub_header_offset = SubHeaderOffset(sub_header_index);
+  return data_->ReadUShort(sub_header_offset +
+                           Offset::kFormat2SubHeaderKeys +
+                           Offset::kFormat2SubHeader_idDelta);
+}
+
+/******************************************************************************
+ * CMapTable::CMapFormat2::Builder
+ ******************************************************************************/
 CMapTable::CMapFormat2::Builder::Builder(
-    FontDataTableBuilderContainer* container, WritableFontData* data,
-    int32_t offset, const CMapId& cmap_id)
+    FontDataTableBuilderContainer* container,
+    WritableFontData* data,
+    int32_t offset,
+    const CMapId& cmap_id)
     : CMapTable::CMap::Builder(container,
                                data ? down_cast<WritableFontData*>(
-                                   data->slice(offset, data->readUShort(
+                                   data->Slice(offset, data->ReadUShort(
                                        offset + Offset::kFormat0Length)))
                                : reinterpret_cast<WritableFontData*>(NULL),
                                CMapFormat::kFormat2, cmap_id) {
@@ -342,23 +355,26 @@
 }
 
 CMapTable::CMapFormat2::Builder::Builder(
-    FontDataTableBuilderContainer* container, ReadableFontData* data,
-    int32_t offset, const CMapId& cmap_id)
+    FontDataTableBuilderContainer* container,
+    ReadableFontData* data,
+    int32_t offset,
+    const CMapId& cmap_id)
     : CMapTable::CMap::Builder(container,
                                data ? down_cast<ReadableFontData*>(
-                                   data->slice(offset, data->readUShort(
+                                   data->Slice(offset, data->ReadUShort(
                                        offset + Offset::kFormat0Length)))
                                : reinterpret_cast<ReadableFontData*>(NULL),
                                CMapFormat::kFormat2, cmap_id) {
   // TODO(arthurhsu): FIXIT: heavy lifting and leak, need fix.
 }
 
-CMapTable::CMapFormat2::Builder::~Builder() {}
+CMapTable::CMapFormat2::Builder::~Builder() {
+}
 
-CALLER_ATTACH FontDataTable* CMapTable::CMapFormat2::Builder::subBuildTable(
-    ReadableFontData* data) {
-  FontDataTablePtr table = new CMapFormat2(data, cmapId());
-  return table.detach();
+CALLER_ATTACH FontDataTable*
+    CMapTable::CMapFormat2::Builder::SubBuildTable(ReadableFontData* data) {
+  FontDataTablePtr table = new CMapFormat2(data, cmap_id());
+  return table.Detach();
 }
 
 /******************************************************************************
@@ -367,16 +383,16 @@
 CMapTable::CMapIterator::CMapIterator(CMapTable* table, CMapFilter* filter)
     : table_index_(0), filter_(filter), table_(table) {}
 
-bool CMapTable::CMapIterator::hasNext() {
+bool CMapTable::CMapIterator::HasNext() {
   if (!filter_) {
-    if (table_index_ < table_->numCMaps()) {
+    if (table_index_ < table_->NumCMaps()) {
       return true;
     }
     return false;
   }
 
-  for (; table_index_ < table_->numCMaps(); ++table_index_) {
-    if (filter_->accept(table_->cmapId(table_index_))) {
+  for (; table_index_ < table_->NumCMaps(); ++table_index_) {
+    if (filter_->accept(table_->GetCMapId(table_index_))) {
       return true;
     }
   }
@@ -387,105 +403,109 @@
  * CMapTable::Builder class
  ******************************************************************************/
 CMapTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
-                            Header* header, WritableFontData* data)
+                            Header* header,
+                            WritableFontData* data)
     : Table::ArrayElementTableBuilder(font_builder, header, data) {
 }
 
 CMapTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
-                            Header* header, ReadableFontData* data)
+                            Header* header,
+                            ReadableFontData* data)
     : Table::ArrayElementTableBuilder(font_builder, header, data) {
 }
 
-int32_t CMapTable::Builder::subSerialize(WritableFontData* new_data) {
-  int32_t size = new_data->writeUShort(CMapTable::Offset::kVersion,
+CMapTable::Builder::~Builder() {
+}
+
+int32_t CMapTable::Builder::SubSerialize(WritableFontData* new_data) {
+  int32_t size = new_data->WriteUShort(CMapTable::Offset::kVersion,
                                        version_);
-  size += new_data->writeUShort(CMapTable::Offset::kNumTables,
+  size += new_data->WriteUShort(CMapTable::Offset::kNumTables,
                                 cmap_builders_.size());
 
   int32_t index_offset = size;
   size += cmap_builders_.size() * CMapTable::Offset::kEncodingRecordSize;
   for (CMapBuilderMap::iterator it = cmap_builders_.begin(),
-           e = cmap_builders_.end(); it != e; ++it) {
+                                e = cmap_builders_.end(); it != e; ++it) {
     CMapBuilderPtr b = it->second;
     // header entry
-    index_offset += new_data->writeUShort(index_offset, b->platformId());
-    index_offset += new_data->writeUShort(index_offset, b->encodingId());
-    index_offset += new_data->writeULong(index_offset, size);
+    index_offset += new_data->WriteUShort(index_offset, b->platform_id());
+    index_offset += new_data->WriteUShort(index_offset, b->encoding_id());
+    index_offset += new_data->WriteULong(index_offset, size);
 
     // cmap
     FontDataPtr slice;
-    slice.attach(new_data->slice(size));
-    size +=
-        b->subSerialize(down_cast<WritableFontData*>(slice.p_));
+    slice.Attach(new_data->Slice(size));
+    size += b->SubSerialize(down_cast<WritableFontData*>(slice.p_));
   }
   return size;
 }
 
-bool CMapTable::Builder::subReadyToSerialize() {
+bool CMapTable::Builder::SubReadyToSerialize() {
   if (cmap_builders_.empty())
     return false;
 
   // check each table
   for (CMapBuilderMap::iterator it = cmap_builders_.begin(),
-           e = cmap_builders_.end(); it != e; ++it) {
-    if (!it->second->subReadyToSerialize())
+                                e = cmap_builders_.end(); it != e; ++it) {
+    if (!it->second->SubReadyToSerialize())
       return false;
   }
   return true;
 }
 
-int32_t CMapTable::Builder::subDataSizeToSerialize() {
+int32_t CMapTable::Builder::SubDataSizeToSerialize() {
   if (cmap_builders_.empty())
     return 0;
 
   bool variable = false;
   int32_t size = CMapTable::Offset::kEncodingRecordStart +
-      cmap_builders_.size() * CMapTable::Offset::kEncodingRecordSize;
+                 cmap_builders_.size() * CMapTable::Offset::kEncodingRecordSize;
 
   // calculate size of each table
   for (CMapBuilderMap::iterator it = cmap_builders_.begin(),
-           e = cmap_builders_.end(); it != e; ++it) {
-    int32_t cmap_size = it->second->subDataSizeToSerialize();
+                                e = cmap_builders_.end(); it != e; ++it) {
+    int32_t cmap_size = it->second->SubDataSizeToSerialize();
     size += abs(cmap_size);
     variable |= cmap_size <= 0;
   }
   return variable ? -size : size;
 }
 
-void CMapTable::Builder::subDataSet() {
+void CMapTable::Builder::SubDataSet() {
   cmap_builders_.clear();
-  Table::Builder::setModelChanged(false);
+  Table::Builder::set_model_changed(false);
 }
 
-CALLER_ATTACH FontDataTable* CMapTable::Builder::subBuildTable(
-    ReadableFontData* data) {
+CALLER_ATTACH FontDataTable*
+    CMapTable::Builder::SubBuildTable(ReadableFontData* data) {
   FontDataTablePtr table = new CMapTable(header(), data);
-  return table.detach();
+  return table.Detach();
 }
 
-CALLER_ATTACH CMapTable::CMap::Builder* CMapTable::Builder::cmapBuilder(
+CALLER_ATTACH CMapTable::CMap::Builder* CMapTable::Builder::CMapBuilder(
     FontDataTableBuilderContainer* container, ReadableFontData* data,
     int32_t index) {
-  if (index < 0 || index > numCMaps(data))
+  if (index < 0 || index > NumCMaps(data))
     return NULL;
 
   int32_t record_offset = Offset::kEncodingRecordOffset + index *
       Offset::kEncodingRecordSize;
-  int32_t platform_id = data->readUShort(Offset::kEncodingRecordPlatformId +
-                                         record_offset);
-  int32_t encoding_id = data->readUShort(Offset::kEncodingRecordEncodingId +
-                                         record_offset);
+  int32_t platform_id =
+      data->ReadUShort(Offset::kEncodingRecordPlatformId + record_offset);
+  int32_t encoding_id =
+      data->ReadUShort(Offset::kEncodingRecordEncodingId + record_offset);
   CMapId cmap_id(platform_id, encoding_id);
-  int32_t offset = data->readULongAsInt(Offset::kEncodingRecordOffset +
-                                        record_offset);
-  return CMap::Builder::getBuilder(container, data, offset, cmap_id);
+  int32_t offset =
+      data->ReadULongAsInt(Offset::kEncodingRecordOffset + record_offset);
+  return CMap::Builder::GetBuilder(container, data, offset, cmap_id);
 }
 
-int32_t CMapTable::Builder::numCMaps(ReadableFontData* data) {
+int32_t CMapTable::Builder::NumCMaps(ReadableFontData* data) {
   if (data == NULL) {
     return 0;
   }
-  return data->readUShort(Offset::kNumTables);
+  return data->ReadUShort(Offset::kNumTables);
 }
 
 }  // namespace sfntly
diff --git a/sfntly/cmap_table.h b/sfntly/cmap_table.h
index a102b82..cdbcad8 100644
--- a/sfntly/cmap_table.h
+++ b/sfntly/cmap_table.h
@@ -44,6 +44,268 @@
 
 // A CMap table
 class CMapTable : public Table, public RefCounted<CMapTable> {
+public:
+  // CMapTable::CMapId
+  class CMapId {
+   public:
+    CMapId(int32_t platform_id, int32_t encoding_id);
+    CMapId(const CMapId& obj);
+
+    int32_t platform_id() { return platform_id_; }
+    int32_t encoding_id() { return encoding_id_; }
+
+    bool operator==(const CMapId& obj);
+    const CMapId& operator=(const CMapId& obj);
+    int HashCode() const;
+
+    friend class CMapIdComparator;
+
+   private:
+    int32_t platform_id_;
+    int32_t encoding_id_;
+  };
+  static CMapId WINDOWS_BMP;
+  static CMapId WINDOWS_UCS4;
+  static CMapId MAC_ROMAN;
+
+  // CMapTable::CMapIdComparator
+  class CMapIdComparator {
+   public:
+    bool operator()(const CMapId& lhs, const CMapId& rhs);
+  };
+
+  // A filter on cmap
+  // CMapTable::CMapFilter
+  class CMapFilter {
+   public:
+    // Test on whether the cmap is acceptable or not
+    // @param cmap_id the id of the cmap
+    // @return true if the cmap is acceptable; false otherwise
+    virtual bool accept(CMapId cmap_id) = 0;
+    // Make gcc -Wnon-virtual-dtor happy.
+    virtual ~CMapFilter() {}
+  };
+
+  // The abstract base class for all cmaps.
+  //
+  // CMap equality is based on the equality of the (@link {@link CMapId} that
+  // defines the CMap. In the cmap table for a font there can only be one cmap
+  // with a given cmap id (pair of platform and encoding ids) no matter what the
+  // type of the cmap is.
+  //
+  // The cmap implements {@code Iterable<Integer>} to allow iteration over
+  // characters that are mapped by the cmap. This iteration mostly returns the
+  // characters mapped by the cmap. It will return all characters mapped by the
+  // cmap to anything but .notdef <b>but</b> it may return some that are not
+  // mapped or are mapped to .notdef. Various cmap tables provide ranges and
+  // such to describe characters for lookup but without going the full way to
+  // mapping to the glyph id it isn't always possible to tell if a character
+  // will end up with a valid glyph id. So, some of the characters returned from
+  // the iterator may still end up pointing to the .notdef glyph. However, the
+  // number of such characters should be small in most cases with well designed
+  // cmaps.
+  class Builder;
+  class CMap : public SubTable {
+   public:
+    // CMapTable::CMap::Builder
+    class Builder : public SubTable::Builder {
+     public:
+      virtual ~Builder();
+
+      CALLER_ATTACH static Builder*
+          GetBuilder(FontDataTableBuilderContainer* container,
+                     ReadableFontData* data,
+                     int32_t offset,
+                     const CMapId& cmap_id);
+
+      // Note: yes, an object is returned on stack since it's small enough.
+      virtual CMapId cmap_id() { return cmap_id_; }
+      virtual int32_t platform_id() { return cmap_id_.platform_id(); }
+      virtual int32_t encoding_id() { return cmap_id_.encoding_id(); }
+
+     protected:
+      Builder(FontDataTableBuilderContainer* container,
+              ReadableFontData* data,
+              int32_t format,
+              const CMapId& cmap_id);
+      Builder(FontDataTableBuilderContainer* container,
+              WritableFontData* data,
+              int32_t format,
+              const CMapId& cmap_id);
+
+      virtual int32_t SubSerialize(WritableFontData* new_data);
+      virtual bool SubReadyToSerialize();
+      virtual int32_t SubDataSizeToSerialize();
+      virtual void SubDataSet();
+
+     private:
+      int32_t format_;
+      CMapId cmap_id_;
+
+      friend class CMapTable::Builder;
+    };
+
+    CMap(ReadableFontData* data, int32_t format, const CMapId& cmap_id);
+    virtual ~CMap();
+    virtual int32_t format() { return format_; }
+    virtual CMapId cmap_id() { return cmap_id_; }
+    virtual int32_t platform_id() { return cmap_id_.platform_id(); }
+    virtual int32_t encoding_id() { return cmap_id_.encoding_id(); }
+
+    // Get the language of the cmap.
+    //
+    // Note on the language field in 'cmap' subtables: The language field must
+    // be set to zero for all cmap subtables whose platform IDs are other than
+    // Macintosh (platform ID 1). For cmap subtables whose platform IDs are
+    // Macintosh, set this field to the Macintosh language ID of the cmap
+    // subtable plus one, or to zero if the cmap subtable is not
+    // language-specific. For example, a Mac OS Turkish cmap subtable must set
+    // this field to 18, since the Macintosh language ID for Turkish is 17. A
+    // Mac OS Roman cmap subtable must set this field to 0, since Mac OS Roman
+    // is not a language-specific encoding.
+    //
+    // @return the language id
+    virtual int32_t Language() = 0;
+
+    // Gets the glyph id for the character code provided.
+    // The character code provided must be in the encoding used by the cmap
+    // table.
+    virtual int32_t GlyphId(int32_t character) = 0;
+
+   private:
+    int32_t format_;
+    CMapId cmap_id_;
+  };
+  typedef Ptr<CMap::Builder> CMapBuilderPtr;
+  typedef std::map<CMapId, CMapBuilderPtr, CMapIdComparator> CMapBuilderMap;
+
+  // A cmap format 0 sub table
+  class CMapFormat0 : public CMap, public RefCounted<CMapFormat0> {
+   public:
+    // CMapTable::CMapFormat0::Builder
+    class Builder : public CMap::Builder,
+                    public RefCounted<Builder> {
+     public:
+      Builder(FontDataTableBuilderContainer* container,
+              ReadableFontData* data,
+              int32_t offset,
+              const CMapId& cmap_id);
+      Builder(FontDataTableBuilderContainer* container,
+              WritableFontData* data,
+              int32_t offset,
+              const CMapId& cmap_id);
+      virtual ~Builder();
+
+     protected:
+      virtual CALLER_ATTACH FontDataTable*
+          SubBuildTable(ReadableFontData* data);
+    };
+
+    virtual ~CMapFormat0();
+    virtual int32_t Language();
+    virtual int32_t GlyphId(int32_t character);
+
+   private:
+    CMapFormat0(ReadableFontData* data, const CMapId& cmap_id);
+  };
+
+  // A cmap format 2 sub table
+  // The format 2 cmap is used for multi-byte encodings such as SJIS,
+  // EUC-JP/KR/CN, Big5, etc.
+  class CMapFormat2 : public CMap, public RefCounted<CMapFormat2> {
+   public:
+    // CMapTable::CMapFormat2::Builder
+    class Builder : public CMap::Builder,
+                    public RefCounted<Builder> {
+     public:
+      Builder(FontDataTableBuilderContainer* container,
+              ReadableFontData* data,
+              int32_t offset,
+              const CMapId& cmap_id);
+      Builder(FontDataTableBuilderContainer* container,
+              WritableFontData* data,
+              int32_t offset,
+              const CMapId& cmap_id);
+      virtual ~Builder();
+
+     protected:
+      virtual CALLER_ATTACH FontDataTable*
+          SubBuildTable(ReadableFontData* data);
+    };
+
+    virtual ~CMapFormat2();
+    virtual int32_t Language();
+    virtual int32_t GlyphId(int32_t character);
+
+    // Returns how many bytes would be consumed by a lookup of this character
+    // with this cmap. This comes about because the cmap format 2 table is
+    // designed around multi-byte encodings such as SJIS, EUC-JP, Big5, etc.
+    // return the number of bytes consumed from this "character" - either 1 or 2
+    virtual int32_t BytesConsumed(int32_t character);
+
+   private:
+    CMapFormat2(ReadableFontData* data, const CMapId& cmap_id);
+
+    int32_t SubHeaderOffset(int32_t sub_header_index);
+    int32_t FirstCode(int32_t sub_header_index);
+    int32_t EntryCount(int32_t sub_header_index);
+    int32_t IdRangeOffset(int32_t sub_header_index);
+    int32_t IdDelta(int32_t sub_header_index);
+  };
+
+  // CMapTable::Builder
+  class Builder : public Table::ArrayElementTableBuilder,
+                  public RefCounted<Builder> {
+   public:
+    // Constructor scope altered to public because C++ does not allow base
+    // class to instantiate derived class with protected constructors.
+    Builder(FontDataTableBuilderContainer* font_builder,
+            Header* header,
+            WritableFontData* data);
+    Builder(FontDataTableBuilderContainer* font_builder,
+            Header* header,
+            ReadableFontData* data);
+    virtual ~Builder();
+
+    virtual int32_t SubSerialize(WritableFontData* new_data);
+    virtual bool SubReadyToSerialize();
+    virtual int32_t SubDataSizeToSerialize();
+    virtual void SubDataSet();
+    virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
+
+   protected:
+    static CALLER_ATTACH CMap::Builder*
+        CMapBuilder(FontDataTableBuilderContainer* container,
+                    ReadableFontData* data,
+                    int32_t index);
+
+   private:
+    static int32_t NumCMaps(ReadableFontData* data);
+
+    int32_t version_;
+    CMapBuilderMap cmap_builders_;
+  };
+
+  virtual ~CMapTable();
+
+  // Get the table version.
+  virtual int32_t Version();
+
+  // Get the number of cmaps within the CMap table.
+  virtual int32_t NumCMaps();
+
+  // Get the cmap id for the cmap with the given index.
+  // Note: yes, an object is returned on stack since it's small enough.
+  //       This function is renamed from cmapId to GetCMapId().
+  virtual CMapId GetCMapId(int32_t index);
+
+  virtual int32_t PlatformId(int32_t index);
+  virtual int32_t EncodingId(int32_t index);
+
+  // Get the offset in the table data for the cmap table with the given index.
+  // The offset is from the beginning of the table.
+  virtual int32_t Offset(int32_t index);
+
  private:
   static const int32_t NOTDEF;
 
@@ -158,238 +420,12 @@
     };
   };
 
- public:
-  // CMapTable::CMapId
-  class CMapId {
-   public:
-    CMapId(int32_t platform_id, int32_t encoding_id);
-    CMapId(const CMapId& obj);
-    int32_t platformId();
-    int32_t encodingId();
-    bool operator==(const CMapId& obj);
-    const CMapId& operator=(const CMapId& obj);
-    int hashCode() const;
-
-    friend class CMapIdComparator;
-
-   private:
-    int32_t platform_id_;
-    int32_t encoding_id_;
-  };
-  static CMapId WINDOWS_BMP;
-  static CMapId WINDOWS_UCS4;
-  static CMapId MAC_ROMAN;
-
-  // CMapTable::CMapIdComparator
-  class CMapIdComparator {
-   public:
-    bool operator()(const CMapId& lhs, const CMapId& rhs);
-  };
-
-  // A filter on cmap
-  // CMapTable::CMapFilter
-  class CMapFilter {
-   public:
-    // Test on whether the cmap is acceptable or not
-    // @param cmap_id the id of the cmap
-    // @return true if the cmap is acceptable; false otherwise
-    virtual bool accept(CMapId cmap_id) = 0;
-    // Make gcc -Wnon-virtual-dtor happy.
-    virtual ~CMapFilter() {}
-  };
-
-  // The abstract base class for all cmaps.
-  //
-  // CMap equality is based on the equality of the (@link {@link CMapId} that
-  // defines the CMap. In the cmap table for a font there can only be one cmap
-  // with a given cmap id (pair of platform and encoding ids) no matter what the
-  // type of the cmap is.
-  //
-  // The cmap implements {@code Iterable<Integer>} to allow iteration over
-  // characters that are mapped by the cmap. This iteration mostly returns the
-  // characters mapped by the cmap. It will return all characters mapped by the
-  // cmap to anything but .notdef <b>but</b> it may return some that are not
-  // mapped or are mapped to .notdef. Various cmap tables provide ranges and
-  // such to describe characters for lookup but without going the full way to
-  // mapping to the glyph id it isn't always possible to tell if a character
-  // will end up with a valid glyph id. So, some of the characters returned from
-  // the iterator may still end up pointing to the .notdef glyph. However, the
-  // number of such characters should be small in most cases with well designed
-  // cmaps.
-  class Builder;
-  class CMap : public SubTable {
-   public:
-    CMap(ReadableFontData* data, int32_t format, const CMapId& cmap_id);
-    virtual ~CMap();
-    virtual int32_t format();
-    virtual CMapId cmapId();
-    virtual int32_t platformId();
-    virtual int32_t encodingId();
-
-    // Get the language of the cmap.
-    //
-    // Note on the language field in 'cmap' subtables: The language field must
-    // be set to zero for all cmap subtables whose platform IDs are other than
-    // Macintosh (platform ID 1). For cmap subtables whose platform IDs are
-    // Macintosh, set this field to the Macintosh language ID of the cmap
-    // subtable plus one, or to zero if the cmap subtable is not
-    // language-specific. For example, a Mac OS Turkish cmap subtable must set
-    // this field to 18, since the Macintosh language ID for Turkish is 17. A
-    // Mac OS Roman cmap subtable must set this field to 0, since Mac OS Roman
-    // is not a language-specific encoding.
-    //
-    // @return the language id
-    virtual int32_t language() = 0;
-
-    // Gets the glyph id for the character code provided.
-    // The character code provided must be in the encoding used by the cmap
-    // table.
-    virtual int32_t glyphId(int32_t character) = 0;
-
-   public:
-    // CMapTable::CMap::Builder
-    class Builder : public SubTable::Builder {
-     public:
-      friend class CMapTable::Builder;
-
-     protected:
-      Builder(FontDataTableBuilderContainer* container, ReadableFontData* data,
-              int32_t format, const CMapId& cmap_id);
-      Builder(FontDataTableBuilderContainer* container, WritableFontData* data,
-              int32_t format, const CMapId& cmap_id);
-
-     public:
-      virtual ~Builder();
-      CALLER_ATTACH static Builder*
-          getBuilder(FontDataTableBuilderContainer* container,
-                     ReadableFontData* data, int32_t offset,
-                     const CMapId& cmap_id);
-
-      // Note: yes, an object is returned on stack since it's small enough.
-      virtual CMapId cmapId();
-      virtual int32_t platformId();
-      virtual int32_t encodingId();
-
-     protected:
-      virtual int32_t subSerialize(WritableFontData* new_data);
-      virtual bool subReadyToSerialize();
-      virtual int32_t subDataSizeToSerialize();
-      virtual void subDataSet();
-
-     private:
-      int32_t format_;
-      CMapId cmap_id_;
-    };
-
-   private:
-    int32_t format_;
-    CMapId cmap_id_;
-  };
-  typedef Ptr<CMap::Builder> CMapBuilderPtr;
-  typedef std::map<CMapId, CMapBuilderPtr, CMapIdComparator> CMapBuilderMap;
-
-  // A cmap format 0 sub table
-  class CMapFormat0 : public CMap, public RefCounted<CMapFormat0> {
-   protected:
-    CMapFormat0(ReadableFontData* data, const CMapId& cmap_id);
-
-   public:
-    virtual ~CMapFormat0();
-    virtual int32_t language();
-    virtual int32_t glyphId(int32_t character);
-
-    // CMapTable::CMapFormat0::Builder
-    class Builder : public CMap::Builder,
-                    public RefCounted<Builder> {
-     public:
-      Builder(FontDataTableBuilderContainer* container, ReadableFontData* data,
-        int32_t offset, const CMapId& cmap_id);
-      Builder(FontDataTableBuilderContainer* container, WritableFontData* data,
-        int32_t offset, const CMapId& cmap_id);
-      virtual ~Builder();
-     protected:
-      virtual CALLER_ATTACH FontDataTable*
-          subBuildTable(ReadableFontData* data);
-    };
-  };
-
-  // A cmap format 2 sub table
-  // The format 2 cmap is used for multi-byte encodings such as SJIS,
-  // EUC-JP/KR/CN, Big5, etc.
-  class CMapFormat2 : public CMap, public RefCounted<CMapFormat2> {
-   protected:
-    CMapFormat2(ReadableFontData* data, const CMapId& cmap_id);
-
-   public:
-    virtual ~CMapFormat2();
-    virtual int32_t language();
-    virtual int32_t glyphId(int32_t character);
-
-    // Returns how many bytes would be consumed by a lookup of this character
-    // with this cmap. This comes about because the cmap format 2 table is
-    // designed around multi-byte encodings such as SJIS, EUC-JP, Big5, etc.
-    // return the number of bytes consumed from this "character" - either 1 or 2
-    virtual int32_t bytesConsumed(int32_t character);
-
-   private:
-    int32_t subHeaderOffset(int32_t sub_header_index);
-    int32_t firstCode(int32_t sub_header_index);
-    int32_t entryCount(int32_t sub_header_index);
-    int32_t idRangeOffset(int32_t sub_header_index);
-    int32_t idDelta(int32_t sub_header_index);
-
-    // CMapTable::CMapFormat2::Builder
-    class Builder : public CMap::Builder,
-                    public RefCounted<Builder> {
-     public:
-      Builder(FontDataTableBuilderContainer* container, ReadableFontData* data,
-        int32_t offset, const CMapId& cmap_id);
-      Builder(FontDataTableBuilderContainer* container, WritableFontData* data,
-        int32_t offset, const CMapId& cmap_id);
-      virtual ~Builder();
-     protected:
-      virtual CALLER_ATTACH FontDataTable*
-          subBuildTable(ReadableFontData* data);
-    };
-  };
-
-  // CMapTable::Builder
-  class Builder : public Table::ArrayElementTableBuilder,
-                  public RefCounted<Builder> {
-   public:
-    // Constructor scope altered to public because C++ does not allow base
-    // class to instantiate derived class with protected constructors.
-    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
-      WritableFontData* data);
-    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
-      ReadableFontData* data);
-
-    virtual int32_t subSerialize(WritableFontData* new_data);
-    virtual bool subReadyToSerialize();
-    virtual int32_t subDataSizeToSerialize();
-    virtual void subDataSet();
-    virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
-
-   protected:
-    static CALLER_ATTACH CMap::Builder* cmapBuilder(
-        FontDataTableBuilderContainer* container, ReadableFontData* data,
-        int32_t index);
-
-   private:
-    static int32_t numCMaps(ReadableFontData* data);
-
-   private:
-    int32_t version_;
-    CMapBuilderMap cmap_builders_;
-  };
-
- private:
   class CMapIterator {
    public:
     // If filter is NULL, filter through all tables.
     CMapIterator(CMapTable* table, CMapFilter* filter);
-    bool hasNext();
-    CMap* next();
+    bool HasNext();
+    CMap* Next();
 
    private:
     int32_t table_index_;
@@ -397,33 +433,11 @@
     CMapTable* table_;
   };
 
- private:
   CMapTable(Header* header, ReadableFontData* data);
 
- public:
-  virtual ~CMapTable();
-
-  // Get the table version.
-  virtual int32_t version();
-
-  // Get the number of cmaps within the CMap table.
-  virtual int32_t numCMaps();
-
-  // Get the cmap id for the cmap with the given index.
-  // Note: yes, an object is returned on stack since it's small enough.
-  virtual CMapId cmapId(int32_t index);
-
-  virtual int32_t platformId(int32_t index);
-  virtual int32_t encodingId(int32_t index);
-
-  // Get the offset in the table data for the cmap table with the given index.
-  // The offset is from the beginning of the table.
-  virtual int32_t offset(int32_t index);
-
- private:
   // Get the offset in the table data for the encoding record for the cmap with
   // the given index. The offset is from the beginning of the table.
-  int32_t offsetForEncodingRecord(int32_t index);
+  int32_t OffsetForEncodingRecord(int32_t index);
 };
 typedef std::vector<CMapTable::CMapId> CMapIdList;
 typedef Ptr<CMapTable> CMapTablePtr;
diff --git a/sfntly/data/byte_array.cc b/sfntly/data/byte_array.cc
index b8c3717..5502185 100644
--- a/sfntly/data/byte_array.cc
+++ b/sfntly/data/byte_array.cc
@@ -14,52 +14,38 @@
  * limitations under the License.
  */
 
+#include "sfntly/data/byte_array.h"
+
 #include <algorithm>
 
-#include "sfntly/data/byte_array.h"
 #include "sfntly/port/exception_type.h"
 
 namespace sfntly {
 
 const int32_t ByteArray::COPY_BUFFER_SIZE = 8192;
 
-void ByteArray::init(int32_t filled_length, int32_t storage_length,
-                     bool growable) {
-  storage_length_ = storage_length;
-  growable_ = growable;
-  setFilledLength(filled_length);
-}
-
-ByteArray::ByteArray(int32_t filled_length, int32_t storage_length,
-                     bool growable) {
-  init(filled_length, storage_length, growable);
-}
-
-ByteArray::ByteArray(int32_t filled_length, int32_t storage_length) {
-  init(filled_length, storage_length, false);
-}
-
 ByteArray::~ByteArray() {}
 
-int32_t ByteArray::length() { return filled_length_; }
-int32_t ByteArray::size() { return storage_length_; }
-bool ByteArray::growable() { return growable_; }
+int32_t ByteArray::Length() { return filled_length_; }
+int32_t ByteArray::Size() { return storage_length_; }
 
-int32_t ByteArray::setFilledLength(int32_t filled_length) {
+int32_t ByteArray::SetFilledLength(int32_t filled_length) {
   filled_length_ = std::min<int32_t>(filled_length, storage_length_);
   return filled_length_;
 }
 
-byte_t ByteArray::get(int32_t index) {
-  return internalGet(index);
+byte_t ByteArray::Get(int32_t index) {
+  return InternalGet(index);
 }
 
-int32_t ByteArray::get(int32_t index, ByteVector* b) {
+int32_t ByteArray::Get(int32_t index, ByteVector* b) {
   assert(b);
-  return get(index, b, 0, b->size());
+  return Get(index, b, 0, b->size());
 }
 
-int32_t ByteArray::get(int32_t index, ByteVector* b, int32_t offset,
+int32_t ByteArray::Get(int32_t index,
+                       ByteVector* b,
+                       int32_t offset,
                        int32_t length) {
   assert(b);
   if (index < 0 || index >= filled_length_) {
@@ -69,47 +55,49 @@
   if (actual_length < 0) {
       return -1;
   }
-  return internalGet(index, b, offset, actual_length);
+  return InternalGet(index, b, offset, actual_length);
 }
 
-bool ByteArray::put(int32_t index, byte_t b) {
-  if (index < 0 || index >= size()) {
+bool ByteArray::Put(int32_t index, byte_t b) {
+  if (index < 0 || index >= Size()) {
     return false;
   }
-  bool result = internalPut(index, b);
+  bool result = InternalPut(index, b);
   filled_length_ = std::max<int32_t>(filled_length_, index + 1);
   return result;
 }
 
-int32_t ByteArray::put(int index, ByteVector* b) {
+int32_t ByteArray::Put(int index, ByteVector* b) {
   assert(b);
-  return put(index, b, 0, b->size());
+  return Put(index, b, 0, b->size());
 }
 
-int32_t ByteArray::put(int32_t index, ByteVector* b, int32_t offset,
+int32_t ByteArray::Put(int32_t index,
+                       ByteVector* b,
+                       int32_t offset,
                        int32_t length) {
   assert(b);
-  if (index < 0 || index >= size()) {
+  if (index < 0 || index >= Size()) {
     return 0;
   }
-  int32_t actual_length = std::min<int32_t>(length, size() - index);
-  int32_t bytes_written = internalPut(index, b, offset, actual_length);
+  int32_t actual_length = std::min<int32_t>(length, Size() - index);
+  int32_t bytes_written = InternalPut(index, b, offset, actual_length);
   filled_length_ = std::max<int32_t>(filled_length_, index + bytes_written);
   return bytes_written;
 }
 
-int32_t ByteArray::copyTo(ByteArray* array) {
-  return copyTo(array, 0, length());
+int32_t ByteArray::CopyTo(ByteArray* array) {
+  return CopyTo(array, 0, Length());
 }
 
-int32_t ByteArray::copyTo(ByteArray* array, int32_t offset, int32_t length) {
-  return copyTo(0, array, offset, length);
+int32_t ByteArray::CopyTo(ByteArray* array, int32_t offset, int32_t length) {
+  return CopyTo(0, array, offset, length);
 }
 
-int32_t ByteArray::copyTo(int32_t dst_offset, ByteArray* array,
+int32_t ByteArray::CopyTo(int32_t dst_offset, ByteArray* array,
                           int32_t src_offset, int32_t length) {
   assert(array);
-  if (array->size() < dst_offset + length) {  // insufficient space
+  if (array->Size() < dst_offset + length) {  // insufficient space
     return -1;
   }
 
@@ -118,8 +106,8 @@
   int32_t index = 0;
   int32_t remaining_length = length;
   int32_t buffer_length = std::min<int32_t>(COPY_BUFFER_SIZE, length);
-  while ((bytes_read = get(index + src_offset, &b, 0, buffer_length)) > 0) {
-    int bytes_written = array->put(index + dst_offset, &b, 0, bytes_read);
+  while ((bytes_read = Get(index + src_offset, &b, 0, buffer_length)) > 0) {
+    int bytes_written = array->Put(index + dst_offset, &b, 0, bytes_read);
     if (bytes_written != bytes_read) {
 #if defined (SFNTLY_NO_EXCEPTION)
       return 0;
@@ -134,31 +122,30 @@
   return index;
 }
 
-int32_t ByteArray::copyTo(OutputStream* os) {
-    return copyTo(os, 0, length());
+int32_t ByteArray::CopyTo(OutputStream* os) {
+    return CopyTo(os, 0, Length());
 }
 
-int32_t ByteArray::copyTo(OutputStream* os, int32_t offset, int32_t length) {
+int32_t ByteArray::CopyTo(OutputStream* os, int32_t offset, int32_t length) {
   ByteVector b(COPY_BUFFER_SIZE);
   int32_t bytes_read = 0;
   int32_t index = 0;
   int32_t buffer_length = std::min<int32_t>(COPY_BUFFER_SIZE, length);
-  while ((bytes_read = get(index + offset, &b, 0, buffer_length)) > 0) {
-    os->write(&b, 0, bytes_read);
+  while ((bytes_read = Get(index + offset, &b, 0, buffer_length)) > 0) {
+    os->Write(&b, 0, bytes_read);
     index += bytes_read;
     buffer_length = std::min<int32_t>(b.size(), length - index);
   }
   return index;
 }
 
-bool ByteArray::copyFrom(InputStream* is, int32_t length) {
+bool ByteArray::CopyFrom(InputStream* is, int32_t length) {
   ByteVector b(COPY_BUFFER_SIZE);
   int32_t bytes_read = 0;
   int32_t index = 0;
   int32_t buffer_length = std::min<int32_t>(COPY_BUFFER_SIZE, length);
-  while ((bytes_read =
-          is->read(&b, 0, buffer_length)) > 0) {
-    if (put(index, &b, 0, bytes_read) != bytes_read) {
+  while ((bytes_read = is->Read(&b, 0, buffer_length)) > 0) {
+    if (Put(index, &b, 0, bytes_read) != bytes_read) {
 #if defined (SFNTLY_NO_EXCEPTION)
       return 0;
 #else
@@ -172,14 +159,13 @@
   return true;
 }
 
-bool ByteArray::copyFrom(InputStream* is) {
+bool ByteArray::CopyFrom(InputStream* is) {
   ByteVector b(COPY_BUFFER_SIZE);
   int32_t bytes_read = 0;
   int32_t index = 0;
   int32_t buffer_length = COPY_BUFFER_SIZE;
-  while ((bytes_read =
-          is->read(&b, 0, buffer_length)) > 0) {
-    if (put(index, &b, 0, bytes_read) != bytes_read) {
+  while ((bytes_read = is->Read(&b, 0, buffer_length)) > 0) {
+    if (Put(index, &b, 0, bytes_read) != bytes_read) {
 #if defined (SFNTLY_NO_EXCEPTION)
       return 0;
 #else
@@ -191,4 +177,22 @@
   return true;
 }
 
+ByteArray::ByteArray(int32_t filled_length,
+                     int32_t storage_length,
+                     bool growable) {
+  Init(filled_length, storage_length, growable);
+}
+
+ByteArray::ByteArray(int32_t filled_length, int32_t storage_length) {
+  Init(filled_length, storage_length, false);
+}
+
+void ByteArray::Init(int32_t filled_length,
+                     int32_t storage_length,
+                     bool growable) {
+  storage_length_ = storage_length;
+  growable_ = growable;
+  SetFilledLength(filled_length);
+}
+
 }  // namespace sfntly
diff --git a/sfntly/data/byte_array.h b/sfntly/data/byte_array.h
index edb4633..9ac56c0 100644
--- a/sfntly/data/byte_array.h
+++ b/sfntly/data/byte_array.h
@@ -29,38 +29,27 @@
 // C++ port of this class assumes that the data are stored in a linear region
 // like std::vector.
 class ByteArray : virtual public RefCount {
- protected:
-  // filledLength the length that is "filled" and readable counting from offset
-  // storageLength the maximum storage size of the underlying data
-  // growable is the storage growable - storageLength is the max growable size
-  ByteArray(int32_t filled_length, int32_t storage_length, bool growable);
-  ByteArray(int32_t filled_length, int32_t storage_length);
-  void init(int32_t filled_length, int32_t storage_length, bool growable);
-
-  static const int32_t COPY_BUFFER_SIZE;
-
  public:
   virtual ~ByteArray();
 
   // Get the current filled and readable length of the array.
-  int32_t length();
+  int32_t Length();
 
   // Get the maximum size of the array. This is the maximum number of bytes that
   // the array can hold and all of it may not be filled with data or even fully
   // allocated yet.
-  int32_t size();
+  int32_t Size();
 
-  bool growable();
-  int32_t setFilledLength(int32_t filled_length);
+  bool growable() { return growable_; }
+  int32_t SetFilledLength(int32_t filled_length);
 
- public:
   // Get the byte from the given index.
-  virtual byte_t get(int32_t index);
+  virtual byte_t Get(int32_t index);
 
   // Get the bytes from the given index and fill the buffer with them. As many
   // bytes as will fit into the buffer are read unless that would go past the
   // end of the array.
-  virtual int32_t get(int32_t index, ByteVector* b);
+  virtual int32_t Get(int32_t index, ByteVector* b);
 
   // Get the bytes from the given index and fill the buffer with them starting
   // at the offset given. As many bytes as the specified length are read unless
@@ -70,17 +59,19 @@
   // @param offset the location in the buffer to start putting the bytes
   // @param length the number of bytes to put into the buffer
   // @return the number of bytes put into the buffer
-  virtual int32_t get(int32_t index, ByteVector* b, int32_t offset,
+  virtual int32_t Get(int32_t index,
+                      ByteVector* b,
+                      int32_t offset,
                       int32_t length);
 
   // Put the specified byte into the array at the given index unless that would
   // be beyond the length of the array and it isn't growable.
-  virtual bool put(int32_t index, byte_t b);
+  virtual bool Put(int32_t index, byte_t b);
 
   // Put the specified bytes into the array at the given index. The entire
   // buffer is put into the array unless that would extend beyond the length and
   // the array isn't growable.
-  virtual int32_t put(int32_t index, ByteVector* b);
+  virtual int32_t Put(int32_t index, ByteVector* b);
 
   // Put the specified bytes into the array at the given index. All of the bytes
   // specified are put into the array unless that would extend beyond the length
@@ -91,19 +82,21 @@
   // @param offset the offset in the bytes to start copying from
   // @param length the number of bytes to copy into the array
   // @return the number of bytes actually written
-  virtual int32_t put(int32_t index, ByteVector* b, int32_t offset,
+  virtual int32_t Put(int32_t index,
+                      ByteVector* b,
+                      int32_t offset,
                       int32_t length);
 
   // Fully copy this ByteArray to another ByteArray to the extent that the
   // destination array has storage for the data copied.
-  virtual int32_t copyTo(ByteArray* array);
+  virtual int32_t CopyTo(ByteArray* array);
 
   // Copy a segment of this ByteArray to another ByteArray.
   // @param array the destination
   // @param offset the offset in this ByteArray to start copying from
   // @param length the maximum length in bytes to copy
   // @return the number of bytes copied
-  virtual int32_t copyTo(ByteArray* array, int32_t offset, int32_t length);
+  virtual int32_t CopyTo(ByteArray* array, int32_t offset, int32_t length);
 
   // Copy this ByteArray to another ByteArray.
   // @param dstOffset the offset in the destination array to start copying to
@@ -111,25 +104,40 @@
   // @param srcOffset the offset in this ByteArray to start copying from
   // @param length the maximum length in bytes to copy
   // @return the number of bytes copied
-  virtual int32_t copyTo(int32_t dst_offset, ByteArray* array,
-                         int32_t src_offset, int32_t length);
+  virtual int32_t CopyTo(int32_t dst_offset,
+                         ByteArray* array,
+                         int32_t src_offset,
+                         int32_t length);
 
-  virtual int32_t copyTo(OutputStream* os);
-  virtual int32_t copyTo(OutputStream* os, int32_t offset, int32_t length);
-  virtual bool copyFrom(InputStream* is, int32_t length);
-  virtual bool copyFrom(InputStream* is);
+  virtual int32_t CopyTo(OutputStream* os);
+  virtual int32_t CopyTo(OutputStream* os, int32_t offset, int32_t length);
+  virtual bool CopyFrom(InputStream* is, int32_t length);
+  virtual bool CopyFrom(InputStream* is);
 
  protected:
-  virtual bool internalPut(int32_t index, byte_t b) = 0;
-  virtual int32_t internalPut(int32_t index, ByteVector* b, int32_t offset,
-                              int32_t length) = 0;
-  virtual byte_t internalGet(int32_t index) = 0;
-  virtual int32_t internalGet(int32_t index, ByteVector* b, int32_t offset,
-                              int32_t length) = 0;
-  virtual void close() = 0;
+  // filledLength the length that is "filled" and readable counting from offset.
+  // storageLength the maximum storage size of the underlying data.
+  // growable is the storage growable - storageLength is the max growable size.
+  ByteArray(int32_t filled_length, int32_t storage_length, bool growable);
+  ByteArray(int32_t filled_length, int32_t storage_length);
+  void Init(int32_t filled_length, int32_t storage_length, bool growable);
 
-  // C++ port only, raw pointer to the first element of storage
-  virtual byte_t* begin() = 0;
+  virtual bool InternalPut(int32_t index, byte_t b) = 0;
+  virtual int32_t InternalPut(int32_t index,
+                              ByteVector* b,
+                              int32_t offset,
+                              int32_t length) = 0;
+  virtual byte_t InternalGet(int32_t index) = 0;
+  virtual int32_t InternalGet(int32_t index,
+                              ByteVector* b,
+                              int32_t offset,
+                              int32_t length) = 0;
+  virtual void Close() = 0;
+
+  // C++ port only, raw pointer to the first element of storage.
+  virtual byte_t* Begin() = 0;
+
+  static const int32_t COPY_BUFFER_SIZE;
 
  private:
   int32_t filled_length_;
diff --git a/sfntly/data/font_data.cc b/sfntly/data/font_data.cc
index fdba5f8..437a810 100644
--- a/sfntly/data/font_data.cc
+++ b/sfntly/data/font_data.cc
@@ -22,30 +22,12 @@
 
 namespace sfntly {
 
-FontData::~FontData() {}
-
-void FontData::init(ByteArray* ba) {
-  array_ = ba;
-  bound_offset_ = 0;
-  bound_length_ = INT_MAX;
+int32_t FontData::Size() const {
+  return std::min<int32_t>(array_->Size() - bound_offset_, bound_length_);
 }
 
-FontData::FontData(ByteArray* ba) {
-  init(ba);
-}
-
-FontData::FontData(FontData* data, int32_t offset, int32_t length) {
-  init(data->array_);
-  bound(data->bound_offset_ + offset, length);
-}
-
-FontData::FontData(FontData* data, int32_t offset) {
-  init(data->array_);
-  bound(offset);
-}
-
-bool FontData::bound(int32_t offset, int32_t length) {
-  if (offset + length > size() || offset < 0 || length < 0)
+bool FontData::Bound(int32_t offset, int32_t length) {
+  if (offset + length > Size() || offset < 0 || length < 0)
     return false;
 
   bound_offset_ += offset;
@@ -53,27 +35,45 @@
   return true;
 }
 
-bool FontData::bound(int32_t offset) {
-if (offset > size() || offset < 0)
+bool FontData::Bound(int32_t offset) {
+if (offset > Size() || offset < 0)
     return false;
 
   bound_offset_ += offset;
   return true;
 }
 
-int32_t FontData::length() const {
-  return std::min<int32_t>(array_->length() - bound_offset_, bound_length_);
+int32_t FontData::Length() const {
+  return std::min<int32_t>(array_->Length() - bound_offset_, bound_length_);
 }
 
-int32_t FontData::size() const {
-  return std::min<int32_t>(array_->size() - bound_offset_, bound_length_);
+FontData::FontData(ByteArray* ba) {
+  Init(ba);
 }
 
-int32_t FontData::boundOffset(int32_t offset) {
+FontData::FontData(FontData* data, int32_t offset, int32_t length) {
+  Init(data->array_);
+  Bound(data->bound_offset_ + offset, length);
+}
+
+FontData::FontData(FontData* data, int32_t offset) {
+  Init(data->array_);
+  Bound(offset);
+}
+
+FontData::~FontData() {}
+
+void FontData::Init(ByteArray* ba) {
+  array_ = ba;
+  bound_offset_ = 0;
+  bound_length_ = INT_MAX;
+}
+
+int32_t FontData::BoundOffset(int32_t offset) {
   return offset + bound_offset_;
 }
 
-int32_t FontData::boundLength(int32_t offset, int32_t length) {
+int32_t FontData::BoundLength(int32_t offset, int32_t length) {
   return std::min<int32_t>(length, bound_length_ - offset);
 }
 
diff --git a/sfntly/data/font_data.h b/sfntly/data/font_data.h
index 6bcdb73..ab5cf54 100644
--- a/sfntly/data/font_data.h
+++ b/sfntly/data/font_data.h
@@ -18,6 +18,7 @@
 #define TYPOGRAPHY_FONT_SFNTLY_SRC_SFNTLY_DATA_FONT_DATA_H_
 
 #include <vector>
+
 #include "sfntly/port/type.h"
 #include "sfntly/data/byte_array.h"
 #include "sfntly/port/refcount.h"
@@ -51,13 +52,13 @@
   // that the font data can hold and all of it may not be filled with data or
   // even fully allocated yet.
   // @return the size of this array
-  virtual int32_t size() const;
+  virtual int32_t Size() const;
 
   // Sets limits on the size of the FontData. The font data is
   // @param offset the start of the new bounds
   // @param length the number of bytes in the bounded array
   // @return true if the bounding range was successful; false otherwise
-  virtual bool bound(int32_t offset, int32_t length);
+  virtual bool Bound(int32_t offset, int32_t length);
 
   // Sets limits on the size of the FontData. This is a offset bound only so if
   // the FontData is writable and growable then there is no limit to that growth
@@ -65,28 +66,25 @@
   // @param offset the start of the new bounds which must be within the current
   //        size of the FontData
   // @return true if the bounding range was successful; false otherwise
-  virtual bool bound(int32_t offset);
+  virtual bool Bound(int32_t offset);
 
   // Makes a slice of this FontData. The returned slice will share the data with
   // the original FontData.
   // @param offset the start of the slice
   // @param length the number of bytes in the slice
   // @return a slice of the original FontData
-  virtual CALLER_ATTACH FontData* slice(int32_t offset, int32_t length) = 0;
+  virtual CALLER_ATTACH FontData* Slice(int32_t offset, int32_t length) = 0;
 
   // Makes a bottom bound only slice of this array. The returned slice will
   // share the data with the original FontData.
   // @param offset the start of the slice
   // @return a slice of the original FontData
-  virtual CALLER_ATTACH FontData* slice(int32_t offset) = 0;
+  virtual CALLER_ATTACH FontData* Slice(int32_t offset) = 0;
 
   // Get the length of the data.
-  virtual int32_t length() const;
-
+  virtual int32_t Length() const;
 
  protected:
-  virtual ~FontData();
-
   // Constructor.
   // @param ba the byte array to use for the backing data
   explicit FontData(ByteArray* ba);
@@ -101,12 +99,13 @@
   // @param data the data to wrap
   // @param offset the offset to start the wrap from
   FontData(FontData* data, int32_t offset);
+  virtual ~FontData();
 
-  void init(ByteArray* ba);
-  int32_t boundOffset(int32_t offset);
-  int32_t boundLength(int32_t offset, int32_t length);
+  void Init(ByteArray* ba);
+  int32_t BoundOffset(int32_t offset);
+  int32_t BoundLength(int32_t offset, int32_t length);
 
- protected:
+  // TODO(arthurhsu): style guide violation: refactor this protected member
   ByteArrayPtr array_;
 
  private:
diff --git a/sfntly/data/font_input_stream.cc b/sfntly/data/font_input_stream.cc
index b9eccdb..a1fbe44 100644
--- a/sfntly/data/font_input_stream.cc
+++ b/sfntly/data/font_input_stream.cc
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <algorithm>
-
 #include "sfntly/data/font_input_stream.h"
 
+#include <algorithm>
+
 namespace sfntly {
 
 FontInputStream::FontInputStream(InputStream* is)
@@ -32,50 +32,50 @@
   // Do not close here, underlying InputStream will close themselves.
 }
 
-int32_t FontInputStream::available() {
+int32_t FontInputStream::Available() {
   if (stream_) {
-    return stream_->available();
+    return stream_->Available();
   }
   return 0;
 }
 
-void FontInputStream::close() {
+void FontInputStream::Close() {
   if (stream_) {
-    stream_->close();
+    stream_->Close();
   }
 }
 
-void FontInputStream::mark(int32_t readlimit) {
+void FontInputStream::Mark(int32_t readlimit) {
   if (stream_) {
-    stream_->mark(readlimit);
+    stream_->Mark(readlimit);
   }
 }
 
-bool FontInputStream::markSupported() {
+bool FontInputStream::MarkSupported() {
   if (stream_) {
-    return stream_->markSupported();
+    return stream_->MarkSupported();
   }
   return false;
 }
 
-void FontInputStream::reset() {
+void FontInputStream::Reset() {
   if (stream_) {
-    stream_->reset();
+    stream_->Reset();
   }
 }
 
-int32_t FontInputStream::read() {
+int32_t FontInputStream::Read() {
   if (!stream_ || (bounded_ && position_ >= length_)) {
     return -1;
   }
-  int32_t b = stream_->read();
+  int32_t b = stream_->Read();
   if (b >= 0) {
     position_++;
   }
   return b;
 }
 
-int32_t FontInputStream::read(ByteVector* b, int32_t offset, int32_t length) {
+int32_t FontInputStream::Read(ByteVector* b, int32_t offset, int32_t length) {
   if (!stream_ || offset < 0 || length < 0 ||
       (bounded_ && position_ >= length_)) {
     return -1;
@@ -83,59 +83,55 @@
   int32_t bytes_to_read =
       bounded_ ? std::min<int32_t>(length, (int32_t)(length_ - position_)) :
                  length;
-  int32_t bytes_read = stream_->read(b, offset, bytes_to_read);
+  int32_t bytes_read = stream_->Read(b, offset, bytes_to_read);
   position_ += bytes_read;
   return bytes_read;
 }
 
-int32_t FontInputStream::read(ByteVector* b) {
-  return read(b, 0, b->size());
+int32_t FontInputStream::Read(ByteVector* b) {
+  return Read(b, 0, b->size());
 }
 
-int64_t FontInputStream::position() {
-  return position_;
+int32_t FontInputStream::ReadChar() {
+  return Read();
 }
 
-int32_t FontInputStream::readChar() {
-  return read();
+int32_t FontInputStream::ReadUShort() {
+  return 0xffff & (Read() << 8 | Read());
 }
 
-int32_t FontInputStream::readUShort() {
-  return 0xffff & (read() << 8 | read());
+int32_t FontInputStream::ReadShort() {
+  return ((Read() << 8 | Read()) << 16) >> 16;
 }
 
-int32_t FontInputStream::readShort() {
-  return ((read() << 8 | read()) << 16) >> 16;
+int32_t FontInputStream::ReadUInt24() {
+  return 0xffffff & (Read() << 16 | Read() << 8 | Read());
 }
 
-int32_t FontInputStream::readUInt24() {
-  return 0xffffff & (read() << 16 | read() << 8 | read());
+int64_t FontInputStream::ReadULong() {
+  return 0xffffffffL & ReadLong();
 }
 
-int64_t FontInputStream::readULong() {
-  return 0xffffffffL & readLong();
-}
-
-int32_t FontInputStream::readULongAsInt() {
-  int64_t ulong = readULong();
+int32_t FontInputStream::ReadULongAsInt() {
+  int64_t ulong = ReadULong();
   return ((int32_t)ulong) & ~0x80000000;
 }
 
-int32_t FontInputStream::readLong() {
-  return read() << 24 | read() << 16 | read() << 8 | read();
+int32_t FontInputStream::ReadLong() {
+  return Read() << 24 | Read() << 16 | Read() << 8 | Read();
 }
 
-int32_t FontInputStream::readFixed() {
-  return readLong();
+int32_t FontInputStream::ReadFixed() {
+  return ReadLong();
 }
 
-int64_t FontInputStream::readDateTimeAsLong() {
-  return (int64_t)readULong() << 32 | readULong();
+int64_t FontInputStream::ReadDateTimeAsLong() {
+  return (int64_t)ReadULong() << 32 | ReadULong();
 }
 
-int64_t FontInputStream::skip(int64_t n) {
+int64_t FontInputStream::Skip(int64_t n) {
   if (stream_) {
-    int64_t skipped = stream_->skip(n);
+    int64_t skipped = stream_->Skip(n);
     position_ += skipped;
     return skipped;
   }
diff --git a/sfntly/data/font_input_stream.h b/sfntly/data/font_input_stream.h
index ed8d364..7404825 100644
--- a/sfntly/data/font_input_stream.h
+++ b/sfntly/data/font_input_stream.h
@@ -33,33 +33,33 @@
   FontInputStream(InputStream* is, size_t length);
   virtual ~FontInputStream();
 
-  virtual int32_t available();
-  virtual void close();
-  virtual void mark(int32_t readlimit);
-  virtual bool markSupported();
-  virtual void reset();
+  virtual int32_t Available();
+  virtual void Close();
+  virtual void Mark(int32_t readlimit);
+  virtual bool MarkSupported();
+  virtual void Reset();
 
-  virtual int32_t read();
-  virtual int32_t read(ByteVector* buffer);
-  virtual int32_t read(ByteVector* buffer, int32_t offset, int32_t length);
+  virtual int32_t Read();
+  virtual int32_t Read(ByteVector* buffer);
+  virtual int32_t Read(ByteVector* buffer, int32_t offset, int32_t length);
 
-  virtual int64_t position();
+  virtual int64_t position() { return position_; }
 
-  virtual int32_t readChar();
-  virtual int32_t readUShort();
-  virtual int32_t readShort();
-  virtual int32_t readUInt24();
-  virtual int64_t readULong();
-  virtual int32_t readULongAsInt();
-  virtual int32_t readLong();
-  virtual int32_t readFixed();
-  virtual int64_t readDateTimeAsLong();
-  virtual int64_t skip(int64_t n);  // n can be negative
+  virtual int32_t ReadChar();
+  virtual int32_t ReadUShort();
+  virtual int32_t ReadShort();
+  virtual int32_t ReadUInt24();
+  virtual int64_t ReadULong();
+  virtual int32_t ReadULongAsInt();
+  virtual int32_t ReadLong();
+  virtual int32_t ReadFixed();
+  virtual int64_t ReadDateTimeAsLong();
+  virtual int64_t Skip(int64_t n);  // n can be negative.
 
  private:
   InputStream* stream_;
   int64_t position_;
-  int64_t length_;  // bound on length of data to read
+  int64_t length_;  // Bound on length of data to read.
   bool bounded_;
 };
 
diff --git a/sfntly/data/font_output_stream.cc b/sfntly/data/font_output_stream.cc
index f0f4744..a88a29e 100644
--- a/sfntly/data/font_output_stream.cc
+++ b/sfntly/data/font_output_stream.cc
@@ -14,95 +14,91 @@
  * limitations under the License.
  */
 
-#include <algorithm>
-
 #include "sfntly/data/font_output_stream.h"
-#include "sfntly/port/endian.h"
+
+#include <algorithm>
 
 namespace sfntly {
 
 FontOutputStream::FontOutputStream(OutputStream* os)
-    : stream_(os), position_(0) {
+    : stream_(os),
+      position_(0) {
 }
 
 FontOutputStream::~FontOutputStream() {
   // Do not close, underlying stream shall clean up themselves.
 }
 
-size_t FontOutputStream::position() {
-  return position_;
-}
-
-void FontOutputStream::write(byte_t b) {
+void FontOutputStream::Write(byte_t b) {
   if (stream_) {
-    stream_->write(b);
+    stream_->Write(b);
     position_++;
   }
 }
 
-void FontOutputStream::write(ByteVector* b) {
+void FontOutputStream::Write(ByteVector* b) {
   if (b) {
-    write(b, 0, b->size());
+    Write(b, 0, b->size());
     position_ += b->size();
   }
 }
 
-void FontOutputStream::write(ByteVector* b, int32_t offset, int32_t length) {
+void FontOutputStream::Write(ByteVector* b, int32_t offset, int32_t length) {
   if (stream_ && b) {
-    stream_->write(b, offset, length);
+    stream_->Write(b, offset, length);
     position_ += length;
   }
 }
 
-void FontOutputStream::writeChar(byte_t c) {
-  write(c);
+void FontOutputStream::WriteChar(byte_t c) {
+  Write(c);
 }
 
-void FontOutputStream::writeUShort(int32_t us) {
-  write((byte_t)((us >> 8) & 0xff));
-  write((byte_t)(us & 0xff));
+void FontOutputStream::WriteUShort(int32_t us) {
+  Write((byte_t)((us >> 8) & 0xff));
+  Write((byte_t)(us & 0xff));
 }
 
-void FontOutputStream::writeShort(int32_t s) {
-  writeUShort(s);
+void FontOutputStream::WriteShort(int32_t s) {
+  WriteUShort(s);
 }
 
-void FontOutputStream::writeUInt24(int32_t ui) {
-  write((byte_t)(ui >> 16) & 0xff);
-  write((byte_t)(ui >> 8) & 0xff);
-  write((byte_t)ui & 0xff);
+void FontOutputStream::WriteUInt24(int32_t ui) {
+  Write((byte_t)(ui >> 16) & 0xff);
+  Write((byte_t)(ui >> 8) & 0xff);
+  Write((byte_t)ui & 0xff);
 }
 
-void FontOutputStream::writeULong(int64_t ul) {
-  write((byte_t)((ul >> 24) & 0xff));
-  write((byte_t)((ul >> 16) & 0xff));
-  write((byte_t)((ul >> 8) & 0xff));
-  write((byte_t)(ul & 0xff));
+void FontOutputStream::WriteULong(int64_t ul) {
+  Write((byte_t)((ul >> 24) & 0xff));
+  Write((byte_t)((ul >> 16) & 0xff));
+  Write((byte_t)((ul >> 8) & 0xff));
+  Write((byte_t)(ul & 0xff));
 }
 
-void FontOutputStream::writeLong(int64_t l) {
-  writeULong(l);
+void FontOutputStream::WriteLong(int64_t l) {
+  WriteULong(l);
 }
 
-void FontOutputStream::writeFixed(int32_t f) {
-  writeULong(f);
+void FontOutputStream::WriteFixed(int32_t f) {
+  WriteULong(f);
 }
 
-void FontOutputStream::writeDateTime(int64_t date) {
-  writeULong((date >> 32) & 0xffffffff);
-  writeULong(date & 0xffffffff);
+void FontOutputStream::WriteDateTime(int64_t date) {
+  WriteULong((date >> 32) & 0xffffffff);
+  WriteULong(date & 0xffffffff);
 }
 
-void FontOutputStream::flush() {
+void FontOutputStream::Flush() {
   if (stream_) {
-    stream_->flush();
+    stream_->Flush();
   }
 }
 
-void FontOutputStream::close() {
+void FontOutputStream::Close() {
   if (stream_) {
-    stream_->flush();
-    stream_->close();
+    stream_->Flush();
+    stream_->Close();
     position_ = 0;
   }
 }
diff --git a/sfntly/data/font_output_stream.h b/sfntly/data/font_output_stream.h
index 4bb923d..6938b66 100644
--- a/sfntly/data/font_output_stream.h
+++ b/sfntly/data/font_output_stream.h
@@ -32,22 +32,22 @@
   explicit FontOutputStream(OutputStream* os);
   virtual ~FontOutputStream();
 
-  virtual size_t position();
+  virtual size_t position() { return position_; }
 
-  virtual void write(byte_t b);
-  virtual void write(ByteVector* b);
-  virtual void write(ByteVector* b, int32_t offset, int32_t len);
-  virtual void writeChar(byte_t c);
-  virtual void writeUShort(int32_t us);
-  virtual void writeShort(int32_t s);
-  virtual void writeUInt24(int32_t ui);
-  virtual void writeULong(int64_t ul);
-  virtual void writeLong(int64_t l);
-  virtual void writeFixed(int32_t l);
-  virtual void writeDateTime(int64_t date);
+  virtual void Write(byte_t b);
+  virtual void Write(ByteVector* b);
+  virtual void Write(ByteVector* b, int32_t offset, int32_t len);
+  virtual void WriteChar(byte_t c);
+  virtual void WriteUShort(int32_t us);
+  virtual void WriteShort(int32_t s);
+  virtual void WriteUInt24(int32_t ui);
+  virtual void WriteULong(int64_t ul);
+  virtual void WriteLong(int64_t l);
+  virtual void WriteFixed(int32_t l);
+  virtual void WriteDateTime(int64_t date);
 
-  virtual void flush();
-  virtual void close();
+  virtual void Flush();
+  virtual void Close();
 
  private:
   OutputStream* stream_;
diff --git a/sfntly/data/growable_memory_byte_array.cc b/sfntly/data/growable_memory_byte_array.cc
index 0821321..9e1a043 100644
--- a/sfntly/data/growable_memory_byte_array.cc
+++ b/sfntly/data/growable_memory_byte_array.cc
@@ -14,11 +14,12 @@
  * limitations under the License.
  */
 
-#include <limits.h>
-#include <algorithm>
-
 #include "sfntly/data/growable_memory_byte_array.h"
 
+#include <limits.h>
+
+#include <algorithm>
+
 namespace sfntly {
 
 GrowableMemoryByteArray::GrowableMemoryByteArray()
@@ -27,40 +28,46 @@
 
 GrowableMemoryByteArray::~GrowableMemoryByteArray() {}
 
-bool GrowableMemoryByteArray::internalPut(int32_t index, byte_t b) {
+bool GrowableMemoryByteArray::InternalPut(int32_t index, byte_t b) {
   if ((size_t)index >= b_.capacity()) {
-    b_.resize((size_t)(index + 1) << 2);  // grow exponentially
+    b_.resize((size_t)(index + 1) << 2);  // Grow exponentially.
   }
   b_[index] = b;
   return true;
 }
 
-int32_t GrowableMemoryByteArray::internalPut(int32_t index, ByteVector* b,
-                                             int32_t offset, int32_t length) {
+int32_t GrowableMemoryByteArray::InternalPut(int32_t index,
+                                             ByteVector* b,
+                                             int32_t offset,
+                                             int32_t length) {
   if ((size_t)index + length >= b_.capacity()) {
     b_.resize((size_t)(index + length + 1) << 2);
   }
-  std::copy(b->begin() + offset, b->begin() + (offset + length),
+  std::copy(b->begin() + offset,
+            b->begin() + (offset + length),
             b_.begin() + index);
   return length;
 }
 
-byte_t GrowableMemoryByteArray::internalGet(int32_t index) {
+byte_t GrowableMemoryByteArray::InternalGet(int32_t index) {
   return b_[index];
 }
 
-int32_t GrowableMemoryByteArray::internalGet(int32_t index, ByteVector* b,
-                                             int32_t offset, int32_t length) {
-  std::copy(b_.begin() + index, b_.begin() + (index + length),
+int32_t GrowableMemoryByteArray::InternalGet(int32_t index,
+                                             ByteVector* b,
+                                             int32_t offset,
+                                             int32_t length) {
+  std::copy(b_.begin() + index,
+            b_.begin() + (index + length),
             b->begin() + offset);
   return length;
 }
 
-void GrowableMemoryByteArray::close() {
+void GrowableMemoryByteArray::Close() {
   b_.clear();
 }
 
-byte_t* GrowableMemoryByteArray::begin() {
+byte_t* GrowableMemoryByteArray::Begin() {
   return &(b_[0]);
 }
 
diff --git a/sfntly/data/growable_memory_byte_array.h b/sfntly/data/growable_memory_byte_array.h
index 3c9d4f0..dc59f62 100644
--- a/sfntly/data/growable_memory_byte_array.h
+++ b/sfntly/data/growable_memory_byte_array.h
@@ -30,14 +30,18 @@
   virtual ~GrowableMemoryByteArray();
 
  protected:
-  virtual bool internalPut(int32_t index, byte_t b);
-  virtual int32_t internalPut(int32_t index, ByteVector* b, int32_t offset,
+  virtual bool InternalPut(int32_t index, byte_t b);
+  virtual int32_t InternalPut(int32_t index,
+                              ByteVector* b,
+                              int32_t offset,
                               int32_t length);
-  virtual byte_t internalGet(int32_t index);
-  virtual int32_t internalGet(int32_t index, ByteVector* b, int32_t offset,
+  virtual byte_t InternalGet(int32_t index);
+  virtual int32_t InternalGet(int32_t index,
+                              ByteVector* b,
+                              int32_t offset,
                               int32_t length);
-  virtual void close();
-  virtual byte_t* begin();
+  virtual void Close();
+  virtual byte_t* Begin();
 
  private:
   ByteVector b_;
diff --git a/sfntly/data/memory_byte_array.cc b/sfntly/data/memory_byte_array.cc
index 528979a..0138b21 100644
--- a/sfntly/data/memory_byte_array.cc
+++ b/sfntly/data/memory_byte_array.cc
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-#include <string.h>
-
 #include "sfntly/data/memory_byte_array.h"
 
+#include <string.h>
+
 namespace sfntly {
 
-// Note: this constructor can fail under low-memory situation
+// Note: this constructor can fail under low-memory situation.
 MemoryByteArray::MemoryByteArray(int32_t length)
     : ByteArray(0, length), b_(NULL), allocated_(true) {
 }
@@ -29,56 +29,61 @@
     : ByteArray(buffer_length, buffer_length), b_(b), allocated_(false) {
 }
 
-MemoryByteArray::MemoryByteArray(byte_t* b, int32_t buffer_length,
+MemoryByteArray::MemoryByteArray(byte_t* b,
+                                 int32_t buffer_length,
                                  int32_t filled_length)
     : ByteArray(filled_length, buffer_length), b_(b), allocated_(false) {
 }
 
 MemoryByteArray::~MemoryByteArray() {
-  close();
+  Close();
 }
 
-void MemoryByteArray::init() {
+void MemoryByteArray::Init() {
   if (allocated_ && b_ == NULL) {
-    b_ = new byte_t[size()];
-    memset(b_, 0, size());
+    b_ = new byte_t[Size()];
+    memset(b_, 0, Size());
   }
 }
 
-bool MemoryByteArray::internalPut(int32_t index, byte_t b) {
-  init();
+bool MemoryByteArray::InternalPut(int32_t index, byte_t b) {
+  Init();
   b_[index] = b;
   return true;
 }
 
-int32_t MemoryByteArray::internalPut(int32_t index, ByteVector* b,
-                                     int32_t offset, int32_t length) {
-  init();
+int32_t MemoryByteArray::InternalPut(int32_t index,
+                                     ByteVector* b,
+                                     int32_t offset,
+                                     int32_t length) {
+  Init();
   memcpy(b_ + index, &((*b)[offset]), length);
   return length;
 }
 
-byte_t MemoryByteArray::internalGet(int32_t index) {
-  init();
+byte_t MemoryByteArray::InternalGet(int32_t index) {
+  Init();
   return b_[index];
 }
 
-int32_t MemoryByteArray::internalGet(int32_t index, ByteVector* b,
-                                     int32_t offset, int32_t length) {
-  init();
+int32_t MemoryByteArray::InternalGet(int32_t index,
+                                     ByteVector* b,
+                                     int32_t offset,
+                                     int32_t length) {
+  Init();
   memcpy(&((*b)[offset]), b_ + index, length);
   return length;
 }
 
-void MemoryByteArray::close() {
+void MemoryByteArray::Close() {
   if (allocated_ && b_) {
     delete[] b_;
   }
   b_ = NULL;
 }
 
-byte_t* MemoryByteArray::begin() {
-  init();
+byte_t* MemoryByteArray::Begin() {
+  Init();
   return b_;
 }
 
diff --git a/sfntly/data/memory_byte_array.h b/sfntly/data/memory_byte_array.h
index 34b26a6..171dcc7 100644
--- a/sfntly/data/memory_byte_array.h
+++ b/sfntly/data/memory_byte_array.h
@@ -29,17 +29,21 @@
   virtual ~MemoryByteArray();
 
  protected:
-  virtual bool internalPut(int32_t index, byte_t b);
-  virtual int32_t internalPut(int32_t index, ByteVector* b, int32_t offset,
+  virtual bool InternalPut(int32_t index, byte_t b);
+  virtual int32_t InternalPut(int32_t index,
+                              ByteVector* b,
+                              int32_t offset,
                               int32_t length);
-  virtual byte_t internalGet(int32_t index);
-  virtual int32_t internalGet(int32_t index, ByteVector* b, int32_t offset,
+  virtual byte_t InternalGet(int32_t index);
+  virtual int32_t InternalGet(int32_t index,
+                              ByteVector* b,
+                              int32_t offset,
                               int32_t length);
-  virtual void close();
-  virtual byte_t* begin();
+  virtual void Close();
+  virtual byte_t* Begin();
 
  private:
-  void init();  // C++ port only, used to allocate memory outside constructor.
+  void Init();  // C++ port only, used to allocate memory outside constructor.
 
   byte_t* b_;
   bool allocated_;
diff --git a/sfntly/data/readable_font_data.cc b/sfntly/data/readable_font_data.cc
index fa7279e..5f8478d 100644
--- a/sfntly/data/readable_font_data.cc
+++ b/sfntly/data/readable_font_data.cc
@@ -20,27 +20,148 @@
 
 namespace sfntly {
 
+ReadableFontData::ReadableFontData(ByteArray* array)
+    : FontData(array),
+      checksum_set_(false),
+      checksum_(0) {
+}
+
 ReadableFontData::~ReadableFontData() {}
 
-ReadableFontData::ReadableFontData(ByteArray* array)
-    : FontData(array), checksum_set_(false), checksum_(0) {
+int64_t ReadableFontData::Checksum() {
+  // TODO(arthurhsu): IMPLEMENT: atomicity
+  if (!checksum_set_) {
+    ComputeChecksum();
+  }
+  return checksum_;
+}
+
+void ReadableFontData::SetCheckSumRanges(const IntegerList& ranges) {
+  checksum_range_ = ranges;
+  checksum_set_ = false;  // UNIMPLEMENTED: atomicity
+}
+
+int32_t ReadableFontData::ReadUByte(int32_t index) {
+  return 0xff & array_->Get(BoundOffset(index));
+}
+
+int32_t ReadableFontData::ReadByte(int32_t index) {
+  return (array_->Get(BoundOffset(index)) << 24) >> 24;
+}
+
+int32_t ReadableFontData::ReadBytes(int32_t index,
+                                    ByteVector* b,
+                                    int32_t offset,
+                                    int32_t length) {
+  return array_->Get(BoundOffset(index), b, offset, BoundLength(index, length));
+}
+
+int32_t ReadableFontData::ReadChar(int32_t index) {
+  return ReadUByte(index);
+}
+
+int32_t ReadableFontData::ReadUShort(int32_t index) {
+  return 0xffff & (ReadUByte(index) << 8 | ReadUByte(index + 1));
+}
+
+int32_t ReadableFontData::ReadShort(int32_t index) {
+  return ((ReadByte(index) << 8 | ReadUByte(index + 1)) << 16) >> 16;
+}
+
+int32_t ReadableFontData::ReadUInt24(int32_t index) {
+  return 0xffffff & (ReadUByte(index) << 16 |
+                     ReadUByte(index + 1) << 8 |
+                     ReadUByte(index + 2));
+}
+
+int64_t ReadableFontData::ReadULong(int32_t index) {
+  return 0xffffffffL & (ReadUByte(index) << 24 |
+                        ReadUByte(index + 1) << 16 |
+                        ReadUByte(index + 2) << 8 |
+                        ReadUByte(index + 3));
+}
+
+int32_t ReadableFontData::ReadULongAsInt(int32_t index) {
+  int64_t ulong = ReadULong(index);
+#if !defined (SFNTLY_NO_EXCEPTION)
+  if ((ulong & 0x80000000) == 0x80000000) {
+    throw ArithmeticException("Long value too large to fit into an integer.");
+  }
+#endif
+  return ((int32_t)ulong) & ~0x80000000;
+}
+
+int32_t ReadableFontData::ReadLong(int32_t index) {
+  return ReadByte(index) << 24 |
+         ReadUByte(index + 1) << 16 |
+         ReadUByte(index + 2) << 8 |
+         ReadUByte(index + 3);
+}
+
+int32_t ReadableFontData::ReadFixed(int32_t index) {
+  return ReadLong(index);
+}
+
+int64_t ReadableFontData::ReadDateTimeAsLong(int32_t index) {
+  return (int64_t)ReadULong(index) << 32 | ReadULong(index + 4);
+}
+
+int32_t ReadableFontData::ReadFWord(int32_t index) {
+  return ReadShort(index);
+}
+
+int32_t ReadableFontData::ReadFUFWord(int32_t index) {
+  return ReadUShort(index);
+}
+
+int32_t ReadableFontData::CopyTo(OutputStream* os) {
+  return array_->CopyTo(os, BoundOffset(0), Length());
+}
+
+int32_t ReadableFontData::CopyTo(WritableFontData* wfd) {
+  return array_->CopyTo(wfd->BoundOffset(0),
+                        wfd->array_,
+                        BoundOffset(0),
+                        Length());
+}
+
+int32_t ReadableFontData::CopyTo(ByteArray* ba) {
+  return array_->CopyTo(ba, BoundOffset(0), Length());
+}
+
+CALLER_ATTACH FontData* ReadableFontData::Slice(int32_t offset,
+                                                int32_t length) {
+  if (offset < 0 || offset + length > Size()) {
+    return NULL;
+  }
+  FontDataPtr slice = new ReadableFontData(this, offset, length);
+  // Note: exception not ported because the condition is always false in C++.
+  // if (slice == null) { throw new IndexOutOfBoundsException( ...
+  return slice.Detach();
+}
+
+CALLER_ATTACH FontData* ReadableFontData::Slice(int32_t offset) {
+  if (offset < 0 || offset > Size()) {
+    return NULL;
+  }
+  FontDataPtr slice = new ReadableFontData(this, offset);
+  // Note: exception not ported because the condition is always false in C++.
+  // if (slice == null) { throw new IndexOutOfBoundsException( ...
+  return slice.Detach();
 }
 
 ReadableFontData::ReadableFontData(ReadableFontData* data, int32_t offset)
-    : FontData(data, offset), checksum_set_(false), checksum_(0) {
+    : FontData(data, offset),
+      checksum_set_(false),
+      checksum_(0) {
 }
 
-ReadableFontData::ReadableFontData(ReadableFontData* data, int32_t offset,
+ReadableFontData::ReadableFontData(ReadableFontData* data,
+                                   int32_t offset,
                                    int32_t length)
-    : FontData(data, offset, length), checksum_set_(false), checksum_(0) {
-}
-
-int64_t ReadableFontData::checksum() {
-  // TODO(arthurhsu): IMPLEMENT: atomicity
-  if (!checksum_set_) {
-    computeChecksum();
-  }
-  return checksum_;
+    : FontData(data, offset, length),
+      checksum_set_(false),
+      checksum_(0) {
 }
 
 /* OpenType checksum
@@ -54,19 +175,19 @@
 return Sum;
 }
 */
-void ReadableFontData::computeChecksum() {
+void ReadableFontData::ComputeChecksum() {
   // TODO(arthurhsu): IMPLEMENT: synchronization/atomicity
   int64_t sum = 0;
   if (checksum_range_.empty()) {
-    sum = computeCheckSum(0, length());
+    sum = ComputeCheckSum(0, Length());
   } else {
     for (uint32_t low_bound_index = 0; low_bound_index < checksum_range_.size();
          low_bound_index += 2) {
       int32_t low_bound = checksum_range_[low_bound_index];
       int32_t high_bound = (low_bound_index == checksum_range_.size() - 1) ?
-                                length() :
+                                Length() :
                                 checksum_range_[low_bound_index + 1];
-      sum += computeCheckSum(low_bound, high_bound);
+      sum += ComputeCheckSum(low_bound, high_bound);
     }
   }
 
@@ -74,126 +195,21 @@
   checksum_set_ = true;
 }
 
-int64_t ReadableFontData::computeCheckSum(int32_t low_bound,
+int64_t ReadableFontData::ComputeCheckSum(int32_t low_bound,
                                           int32_t high_bound) {
   int64_t sum = 0;
   for (int32_t i = low_bound; i < high_bound; i += 4) {
-    int32_t b3 = readUByte(i);
+    int32_t b3 = ReadUByte(i);
     b3 = (b3 == -1) ? 0 : b3;
-    int32_t b2 = readUByte(i + 1);
+    int32_t b2 = ReadUByte(i + 1);
     b2 = (b2 == -1) ? 0 : b2;
-    int32_t b1 = readUByte(i + 2);
+    int32_t b1 = ReadUByte(i + 2);
     b1 = (b1 == -1) ? 0 : b1;
-    int32_t b0 = readUByte(i + 3);
+    int32_t b0 = ReadUByte(i + 3);
     b0 = (b0 == -1) ? 0 : b0;
     sum += (b3 << 24) | (b2 << 16) | (b1 << 8) | b0;
   }
   return sum;
 }
 
-void ReadableFontData::setCheckSumRanges(const IntegerList& ranges) {
-  checksum_range_ = ranges;
-  checksum_set_ = false;  // UNIMPLEMENTED: atomicity
-}
-
-int32_t ReadableFontData::readUByte(int32_t index) {
-  return 0xff & array_->get(boundOffset(index));
-}
-
-int32_t ReadableFontData::readByte(int32_t index) {
-  return (array_->get(boundOffset(index)) << 24) >> 24;
-}
-
-int32_t ReadableFontData::readBytes(int32_t index, ByteVector* b,
-                                    int32_t offset, int32_t length) {
-  return array_->get(boundOffset(index), b, offset, boundLength(index, length));
-}
-
-int32_t ReadableFontData::readChar(int32_t index) {
-  return readUByte(index);
-}
-
-int32_t ReadableFontData::readUShort(int32_t index) {
-  return 0xffff & (readUByte(index) << 8 | readUByte(index + 1));
-}
-
-int32_t ReadableFontData::readShort(int32_t index) {
-  return ((readByte(index) << 8 | readUByte(index + 1)) << 16) >> 16;
-}
-
-int32_t ReadableFontData::readUInt24(int32_t index) {
-  return 0xffffff & (readUByte(index) << 16 |
-                     readUByte(index + 1) << 8 | readUByte(index + 2));
-}
-
-int64_t ReadableFontData::readULong(int32_t index) {
-  return 0xffffffffL & (readUByte(index) << 24 | readUByte(index + 1) << 16 |
-                        readUByte(index + 2) << 8 | readUByte(index + 3));
-}
-
-int32_t ReadableFontData::readULongAsInt(int32_t index) {
-  int64_t ulong = readULong(index);
-#if !defined (SFNTLY_NO_EXCEPTION)
-  if ((ulong & 0x80000000) == 0x80000000) {
-    throw ArithmeticException("Long value too large to fit into an integer.");
-  }
-#endif
-  return ((int32_t)ulong) & ~0x80000000;
-}
-
-int32_t ReadableFontData::readLong(int32_t index) {
-  return readByte(index) << 24 | readUByte(index + 1) << 16 |
-         readUByte(index + 2) << 8 | readUByte(index + 3);
-}
-
-int32_t ReadableFontData::readFixed(int32_t index) {
-  return readLong(index);
-}
-
-int64_t ReadableFontData::readDateTimeAsLong(int32_t index) {
-  return (int64_t)readULong(index) << 32 | readULong(index + 4);
-}
-
-int32_t ReadableFontData::readFWord(int32_t index) {
-  return readShort(index);
-}
-
-int32_t ReadableFontData::readFUFWord(int32_t index) {
-  return readUShort(index);
-}
-
-int32_t ReadableFontData::copyTo(OutputStream* os) {
-  return array_->copyTo(os, boundOffset(0), length());
-}
-
-int32_t ReadableFontData::copyTo(WritableFontData* wfd) {
-  return array_->copyTo(wfd->boundOffset(0), wfd->array_, boundOffset(0),
-                        length());
-}
-
-int32_t ReadableFontData::copyTo(ByteArray* ba) {
-  return array_->copyTo(ba, boundOffset(0), length());
-}
-
-CALLER_ATTACH FontData* ReadableFontData::slice(int32_t offset,
-                                                int32_t length) {
-  if (offset < 0 || offset + length > size()) {
-    return NULL;
-  }
-  FontDataPtr slice = new ReadableFontData(this, offset, length);
-  // Note: exception not ported because the condition is always false in C++.
-  // if (slice == null) { throw new IndexOutOfBoundsException( ...
-  return slice.detach();
-}
-
-CALLER_ATTACH FontData* ReadableFontData::slice(int32_t offset) {
-  if (offset < 0 || offset > size()) {
-    return NULL;
-  }
-  FontDataPtr slice = new ReadableFontData(this, offset);
-  // Note: exception not ported because the condition is always false in C++.
-  // if (slice == null) { throw new IndexOutOfBoundsException( ...
-  return slice.detach();
-}
-
 }  // namespace sfntly
diff --git a/sfntly/data/readable_font_data.h b/sfntly/data/readable_font_data.h
index be466de..b1ca846 100644
--- a/sfntly/data/readable_font_data.h
+++ b/sfntly/data/readable_font_data.h
@@ -30,6 +30,69 @@
   explicit ReadableFontData(ByteArray* array);
   virtual ~ReadableFontData();
 
+  // Get a computed checksum for the data. This checksum uses the OpenType spec
+  // calculation. Every ULong value (32 bit unsigned) in the data is summed and
+  // the resulting value is truncated to 32 bits. If the data length in bytes is
+  // not an integral multiple of 4 then any remaining bytes are treated as the
+  // start of a 4 byte sequence whose remaining bytes are zero.
+  // @return the checksum
+  int64_t Checksum();
+
+  // Sets the bounds to use for computing the checksum. These bounds are in
+  // begin and end pairs. If an odd number is given then the final range is
+  // assumed to extend to the end of the data. The lengths of each range must be
+  // a multiple of 4.
+  // @param ranges the range bounds to use for the checksum
+  void SetCheckSumRanges(const IntegerList& ranges);
+
+  virtual int32_t ReadUByte(int32_t index);
+  virtual int32_t ReadByte(int32_t index);
+  virtual int32_t ReadBytes(int32_t index, ByteVector* b, int32_t offset,
+                            int32_t length);
+  virtual int32_t ReadChar(int32_t index);
+  virtual int32_t ReadUShort(int32_t index);
+  virtual int32_t ReadShort(int32_t index);
+  virtual int32_t ReadUInt24(int32_t index);
+  virtual int64_t ReadULong(int32_t index);
+  virtual int32_t ReadULongAsInt(int32_t index);
+  virtual int32_t ReadLong(int32_t index);
+  virtual int32_t ReadFixed(int32_t index);
+  virtual int64_t ReadDateTimeAsLong(int32_t index);
+
+  virtual int32_t ReadFWord(int32_t index);
+  virtual int32_t ReadFUFWord(int32_t index);
+
+  virtual int32_t CopyTo(OutputStream* os);
+  virtual int32_t CopyTo(WritableFontData* wfd);
+  virtual int32_t CopyTo(ByteArray* ba);
+
+  // TODO(arthurhsu): IMPLEMENT
+  /*
+  virtual int32_t ReadFUnit(int32_t index);
+  virtual int64_t ReadF2Dot14(int32_t index);
+  virtual int64_t ReadLongDateTime(int32_t index);
+  virtual int32_t SearchUShort(int32_t start, int32_t length, int32_t key);
+  virtual int32_t SearchUShort(int32_t start_index, int32_t start_offset,
+                               int32_t count_index, int32_t count_offset,
+                               int32_t length, int32_t key);
+  virtual int32_t SearchULong(int32_t start_index, int32_t start_offset,
+                              int32_t end_index, int32_t end_offset,
+                              int32_t length, int32_t key);
+  */
+
+  // Makes a slice of this FontData. The returned slice will share the data with
+  // the original FontData.
+  // @param offset the start of the slice
+  // @param length the number of bytes in the slice
+  // @return a slice of the original FontData
+  virtual CALLER_ATTACH FontData* Slice(int32_t offset, int32_t length);
+
+  // Makes a bottom bound only slice of this array. The returned slice will
+  // share the data with the original FontData.
+  // @param offset the start of the slice
+  // @return a slice of the original FontData
+  virtual CALLER_ATTACH FontData* Slice(int32_t offset);
+
  protected:
   // Constructor. Creates a bounded wrapper of another ReadableFontData from the
   // given offset until the end of the original ReadableFontData.
@@ -44,76 +107,10 @@
   ReadableFontData(ReadableFontData* data, int32_t offset, int32_t length);
 
  private:
-  void computeChecksum();
-  int64_t computeCheckSum(int32_t low_bound, int32_t high_bound);
+  void ComputeChecksum();
+  int64_t ComputeCheckSum(int32_t low_bound, int32_t high_bound);
 
- public:
-  // Get a computed checksum for the data. This checksum uses the OpenType spec
-  // calculation. Every ULong value (32 bit unsigned) in the data is summed and
-  // the resulting value is truncated to 32 bits. If the data length in bytes is
-  // not an integral multiple of 4 then any remaining bytes are treated as the
-  // start of a 4 byte sequence whose remaining bytes are zero.
-  // @return the checksum
-  int64_t checksum();
-
-  // Sets the bounds to use for computing the checksum. These bounds are in
-  // begin and end pairs. If an odd number is given then the final range is
-  // assumed to extend to the end of the data. The lengths of each range must be
-  // a multiple of 4.
-  // @param ranges the range bounds to use for the checksum
-  void setCheckSumRanges(const IntegerList& ranges);
-
- public:
-  virtual int32_t readUByte(int32_t index);
-  virtual int32_t readByte(int32_t index);
-  virtual int32_t readBytes(int32_t index, ByteVector* b, int32_t offset,
-                            int32_t length);
-  virtual int32_t readChar(int32_t index);
-  virtual int32_t readUShort(int32_t index);
-  virtual int32_t readShort(int32_t index);
-  virtual int32_t readUInt24(int32_t index);
-  virtual int64_t readULong(int32_t index);
-  virtual int32_t readULongAsInt(int32_t index);
-  virtual int32_t readLong(int32_t index);
-  virtual int32_t readFixed(int32_t index);
-  virtual int64_t readDateTimeAsLong(int32_t index);
-
-  virtual int32_t readFWord(int32_t index);
-  virtual int32_t readFUFWord(int32_t index);
-
-  virtual int32_t copyTo(OutputStream* os);
-  virtual int32_t copyTo(WritableFontData* wfd);
-  virtual int32_t copyTo(ByteArray* ba);
-
-  // TODO(arthurhsu): IMPLEMENT
-  /*
-  virtual int32_t readFUnit(int32_t index);
-  virtual int64_t readF2Dot14(int32_t index);
-  virtual int64_t readLongDateTime(int32_t index);
-  virtual int32_t searchUShort(int32_t start, int32_t length, int32_t key);
-  virtual int32_t searchUShort(int32_t start_index, int32_t start_offset,
-                               int32_t count_index, int32_t count_offset,
-                               int32_t length, int32_t key);
-  virtual int32_t searchULong(int32_t start_index, int32_t start_offset,
-                              int32_t end_index, int32_t end_offset,
-                              int32_t length, int32_t key);
-  */
-
-  // Makes a slice of this FontData. The returned slice will share the data with
-  // the original FontData.
-  // @param offset the start of the slice
-  // @param length the number of bytes in the slice
-  // @return a slice of the original FontData
-  virtual CALLER_ATTACH FontData* slice(int32_t offset, int32_t length);
-
-  // Makes a bottom bound only slice of this array. The returned slice will
-  // share the data with the original FontData.
-  // @param offset the start of the slice
-  // @return a slice of the original FontData
-  virtual CALLER_ATTACH FontData* slice(int32_t offset);
-
- private:
-  bool checksum_set_;  // TODO(arthurhsu): IMPLEMENT: must be set atomically
+  bool checksum_set_;  // TODO(arthurhsu): IMPLEMENT: must be set atomically.
   int64_t checksum_;
   IntegerList checksum_range_;
 };
diff --git a/sfntly/data/writable_font_data.cc b/sfntly/data/writable_font_data.cc
index 8588acb..586acc1 100644
--- a/sfntly/data/writable_font_data.cc
+++ b/sfntly/data/writable_font_data.cc
@@ -18,111 +18,116 @@
 
 namespace sfntly {
 
+WritableFontData::WritableFontData(ByteArray* ba) : ReadableFontData(ba) {
+}
+
 WritableFontData::~WritableFontData() {}
 
-WritableFontData::WritableFontData(ByteArray* ba) : ReadableFontData(ba) {
+int32_t WritableFontData::WriteByte(int32_t index, byte_t b) {
+  array_->Put(BoundOffset(index), b);
+  return 1;
+}
+
+int32_t WritableFontData::WriteBytes(int32_t offset,
+                                     ByteVector* b,
+                                     int32_t index,
+                                     int32_t length) {
+  return array_->Put(BoundOffset(offset),
+                     b,
+                     index,
+                     BoundLength(offset, length));
+}
+
+int32_t WritableFontData::WriteBytes(int32_t index, ByteVector* b) {
+  return WriteBytes(index, b, 0, b->size());
+}
+
+int32_t WritableFontData::WriteChar(int32_t index, byte_t c) {
+  return WriteByte(index, c);
+}
+
+int32_t WritableFontData::WriteUShort(int32_t index, int32_t us) {
+  WriteByte(index, (byte_t)((us >> 8) & 0xff));
+  WriteByte(index + 1, (byte_t)(us & 0xff));
+  return 2;
+}
+
+int32_t WritableFontData::WriteUShortLE(int32_t index, int32_t us) {
+  WriteByte(index, (byte_t)(us & 0xff));
+  WriteByte(index + 1, (byte_t)((us >> 8) & 0xff));
+  return 2;
+}
+
+int32_t WritableFontData::WriteShort(int32_t index, int32_t s) {
+  return WriteUShort(index, s);
+}
+
+int32_t WritableFontData::WriteUInt24(int32_t index, int32_t ui) {
+  WriteByte(index, (byte_t)((ui >> 16) & 0xff));
+  WriteByte(index + 1, (byte_t)((ui >> 8) & 0xff));
+  WriteByte(index + 2, (byte_t)(ui & 0xff));
+  return 3;
+}
+
+int32_t WritableFontData::WriteULong(int32_t index, int64_t ul) {
+  WriteByte(index, (byte_t)((ul >> 24) & 0xff));
+  WriteByte(index + 1, (byte_t)((ul >> 16) & 0xff));
+  WriteByte(index + 2, (byte_t)((ul >> 8) & 0xff));
+  WriteByte(index + 3, (byte_t)(ul & 0xff));
+  return 4;
+}
+
+int32_t WritableFontData::WriteULongLE(int32_t index, int64_t ul) {
+  WriteByte(index, (byte_t)(ul & 0xff));
+  WriteByte(index + 1, (byte_t)((ul >> 8) & 0xff));
+  WriteByte(index + 2, (byte_t)((ul >> 16) & 0xff));
+  WriteByte(index + 3, (byte_t)((ul >> 24) & 0xff));
+  return 4;
+}
+
+int32_t WritableFontData::WriteLong(int32_t index, int64_t l) {
+  return WriteULong(index, l);
+}
+
+int32_t WritableFontData::WriteFixed(int32_t index, int32_t l) {
+  return WriteLong(index, l);
+}
+
+int32_t WritableFontData::WriteDateTime(int32_t index, int64_t date) {
+  WriteULong(index, (date >> 32) & 0xffffffff);
+  WriteULong(index + 4, date & 0xffffffff);
+  return 8;
+}
+
+CALLER_ATTACH FontData* WritableFontData::Slice(int32_t offset,
+                                                int32_t length) {
+  if (offset < 0 || offset + length > Size()) {
+    return NULL;
+  }
+  FontDataPtr slice = new WritableFontData(this, offset, length);
+  // Note: exception not ported because the condition is always false in C++.
+  // if (slice == null) { throw new IndexOutOfBoundsException( ...
+  return slice.Detach();
+}
+
+CALLER_ATTACH FontData* WritableFontData::Slice(int32_t offset) {
+  if (offset > Size()) {
+    return NULL;
+  }
+  FontDataPtr slice = new WritableFontData(this, offset);
+  // Note: exception not ported because the condition is always false in C++.
+  // if (slice == null) { throw new IndexOutOfBoundsException( ...
+  return slice.Detach();
 }
 
 WritableFontData::WritableFontData(WritableFontData* data, int32_t offset)
     : ReadableFontData(data, offset) {
 }
 
-WritableFontData::WritableFontData(WritableFontData* data, int32_t offset,
+WritableFontData::WritableFontData(WritableFontData* data,
+                                   int32_t offset,
                                    int32_t length)
     : ReadableFontData(data, offset, length) {
 }
 
-int32_t WritableFontData::writeByte(int32_t index, byte_t b) {
-  array_->put(boundOffset(index), b);
-  return 1;
-}
-
-int32_t WritableFontData::writeBytes(int32_t offset, ByteVector* b,
-                                     int32_t index, int32_t length) {
-  return array_->put(boundOffset(offset), b, index,
-                     boundLength(offset, length));
-}
-
-int32_t WritableFontData::writeBytes(int32_t index, ByteVector* b) {
-  return writeBytes(index, b, 0, b->size());
-}
-
-int32_t WritableFontData::writeChar(int32_t index, byte_t c) {
-  return writeByte(index, c);
-}
-
-int32_t WritableFontData::writeUShort(int32_t index, int32_t us) {
-  writeByte(index, (byte_t)((us >> 8) & 0xff));
-  writeByte(index + 1, (byte_t)(us & 0xff));
-  return 2;
-}
-
-int32_t WritableFontData::writeUShortLE(int32_t index, int32_t us) {
-  writeByte(index, (byte_t)(us & 0xff));
-  writeByte(index + 1, (byte_t)((us >> 8) & 0xff));
-  return 2;
-}
-
-int32_t WritableFontData::writeShort(int32_t index, int32_t s) {
-  return writeUShort(index, s);
-}
-
-int32_t WritableFontData::writeUInt24(int32_t index, int32_t ui) {
-  writeByte(index, (byte_t)((ui >> 16) & 0xff));
-  writeByte(index + 1, (byte_t)((ui >> 8) & 0xff));
-  writeByte(index + 2, (byte_t)(ui & 0xff));
-  return 3;
-}
-
-int32_t WritableFontData::writeULong(int32_t index, int64_t ul) {
-  writeByte(index, (byte_t)((ul >> 24) & 0xff));
-  writeByte(index + 1, (byte_t)((ul >> 16) & 0xff));
-  writeByte(index + 2, (byte_t)((ul >> 8) & 0xff));
-  writeByte(index + 3, (byte_t)(ul & 0xff));
-  return 4;
-}
-
-int32_t WritableFontData::writeULongLE(int32_t index, int64_t ul) {
-  writeByte(index, (byte_t)(ul & 0xff));
-  writeByte(index + 1, (byte_t)((ul >> 8) & 0xff));
-  writeByte(index + 2, (byte_t)((ul >> 16) & 0xff));
-  writeByte(index + 3, (byte_t)((ul >> 24) & 0xff));
-  return 4;
-}
-
-int32_t WritableFontData::writeLong(int32_t index, int64_t l) {
-  return writeULong(index, l);
-}
-
-int32_t WritableFontData::writeFixed(int32_t index, int32_t l) {
-  return writeLong(index, l);
-}
-
-int32_t WritableFontData::writeDateTime(int32_t index, int64_t date) {
-  writeULong(index, (date >> 32) & 0xffffffff);
-  writeULong(index + 4, date & 0xffffffff);
-  return 8;
-}
-
-CALLER_ATTACH FontData* WritableFontData::slice(int32_t offset,
-                                                int32_t length) {
-  if (offset < 0 || offset + length > size()) {
-    return NULL;
-  }
-  FontDataPtr slice = new WritableFontData(this, offset, length);
-  // Note: exception not ported because the condition is always false in C++.
-  // if (slice == null) { throw new IndexOutOfBoundsException( ...
-  return slice.detach();
-}
-
-CALLER_ATTACH FontData* WritableFontData::slice(int32_t offset) {
-  if (offset > size()) {
-    return NULL;
-  }
-  FontDataPtr slice = new WritableFontData(this, offset);
-  // Note: exception not ported because the condition is always false in C++.
-  // if (slice == null) { throw new IndexOutOfBoundsException( ...
-  return slice.detach();
-}
-
 }  // namespace sfntly
diff --git a/sfntly/data/writable_font_data.h b/sfntly/data/writable_font_data.h
index 9542cd0..98c9204 100644
--- a/sfntly/data/writable_font_data.h
+++ b/sfntly/data/writable_font_data.h
@@ -26,38 +26,39 @@
   explicit WritableFontData(ByteArray* ba);
   virtual ~WritableFontData();
 
- private:
-  WritableFontData(WritableFontData* data, int32_t offset);
-  WritableFontData(WritableFontData* data, int32_t offset, int32_t length);
-
- public:
-  virtual int32_t writeByte(int32_t index, byte_t b);
-  virtual int32_t writeBytes(int32_t offset, ByteVector* b, int32_t index,
+  virtual int32_t WriteByte(int32_t index, byte_t b);
+  virtual int32_t WriteBytes(int32_t offset,
+                             ByteVector* b,
+                             int32_t index,
                              int32_t length);
-  virtual int32_t writeBytes(int32_t index, ByteVector* b);
-  virtual int32_t writeChar(int32_t index, byte_t c);
-  virtual int32_t writeUShort(int32_t index, int32_t us);
-  virtual int32_t writeUShortLE(int32_t index, int32_t us);
-  virtual int32_t writeShort(int32_t index, int32_t s);
-  virtual int32_t writeUInt24(int32_t index, int32_t ui);
-  virtual int32_t writeULong(int32_t index, int64_t ul);
-  virtual int32_t writeULongLE(int32_t index, int64_t ul);
-  virtual int32_t writeLong(int32_t index, int64_t l);
-  virtual int32_t writeFixed(int32_t index, int32_t l);
-  virtual int32_t writeDateTime(int32_t index, int64_t date);
+  virtual int32_t WriteBytes(int32_t index, ByteVector* b);
+  virtual int32_t WriteChar(int32_t index, byte_t c);
+  virtual int32_t WriteUShort(int32_t index, int32_t us);
+  virtual int32_t WriteUShortLE(int32_t index, int32_t us);
+  virtual int32_t WriteShort(int32_t index, int32_t s);
+  virtual int32_t WriteUInt24(int32_t index, int32_t ui);
+  virtual int32_t WriteULong(int32_t index, int64_t ul);
+  virtual int32_t WriteULongLE(int32_t index, int64_t ul);
+  virtual int32_t WriteLong(int32_t index, int64_t l);
+  virtual int32_t WriteFixed(int32_t index, int32_t l);
+  virtual int32_t WriteDateTime(int32_t index, int64_t date);
 
   // Makes a slice of this FontData. The returned slice will share the data with
   // the original FontData.
   // @param offset the start of the slice
   // @param length the number of bytes in the slice
   // @return a slice of the original FontData
-  virtual CALLER_ATTACH FontData* slice(int32_t offset, int32_t length);
+  virtual CALLER_ATTACH FontData* Slice(int32_t offset, int32_t length);
 
   // Makes a bottom bound only slice of this array. The returned slice will
   // share the data with the original FontData.
   // @param offset the start of the slice
   // @return a slice of the original FontData
-  virtual CALLER_ATTACH FontData* slice(int32_t offset);
+  virtual CALLER_ATTACH FontData* Slice(int32_t offset);
+
+ private:
+  WritableFontData(WritableFontData* data, int32_t offset);
+  WritableFontData(WritableFontData* data, int32_t offset, int32_t length);
 };
 typedef Ptr<WritableFontData> WritableFontDataPtr;
 
diff --git a/sfntly/font.cc b/sfntly/font.cc
index bd5614f..fefa17e 100644
--- a/sfntly/font.cc
+++ b/sfntly/font.cc
@@ -14,95 +14,85 @@
  * limitations under the License.
  */
 
+#include "sfntly/font.h"
+
 #include <functional>
 #include <algorithm>
 #include <map>
 #include <typeinfo>
 
-#include "sfntly/font.h"
+#include "sfntly/data/font_input_stream.h"
 #include "sfntly/font_factory.h"
-#include "sfntly/tag.h"
 #include "sfntly/math/fixed1616.h"
 #include "sfntly/math/font_math.h"
-#include "sfntly/data/font_input_stream.h"
 #include "sfntly/font_header_table.h"
 #include "sfntly/horizontal_header_table.h"
 #include "sfntly/horizontal_metrics_table.h"
-#include "sfntly/maximum_profile_table.h"
 #include "sfntly/loca_table.h"
+#include "sfntly/maximum_profile_table.h"
 #include "sfntly/port/exception_type.h"
+#include "sfntly/tag.h"
 
 namespace sfntly {
 
-const int32_t SFNTVERSION_1 = Fixed1616::fixed(1, 0);
+const int32_t SFNTVERSION_1 = Fixed1616::Fixed(1, 0);
 
 /******************************************************************************
  * Font class
  ******************************************************************************/
 Font::~Font() {}
 
+bool Font::HasTable(int32_t tag) {
+  TableMap::const_iterator result = tables_.find(tag);
+  TableMap::const_iterator end = tables_.end();
+  return (result != end);
+}
+
+Table* Font::GetTable(int32_t tag) {
+  if (!HasTable(tag)) {
+    return NULL;
+  }
+  return tables_[tag];
+}
+
+TableMap* Font::Tables() {
+  return &tables_;
+}
+
+void Font::Serialize(OutputStream* os, IntegerList* table_ordering) {
+  assert(table_ordering);
+  IntegerList final_table_ordering;
+  TableOrdering(table_ordering, &final_table_ordering);
+  TableHeaderList table_records;
+  BuildTableHeadersForSerialization(&final_table_ordering, &table_records);
+
+  FontOutputStream fos(os);
+  SerializeHeader(&fos, &table_records);
+  SerializeTables(&fos, &table_records);
+}
+
+CALLER_ATTACH WritableFontData* Font::GetNewData(int32_t size) {
+  return factory_->GetNewData(size);
+}
+
 Font::Font(FontFactory* factory, int32_t sfnt_version, ByteVector* digest,
            TableMap* tables)
-    : factory_(factory), sfnt_version_(sfnt_version) {
+    : factory_(factory),
+      sfnt_version_(sfnt_version) {
   // non-trivial assignments that makes debugging hard if placed in
   // initialization list
   digest_ = *digest;
   tables_ = *tables;
 }
 
-int32_t Font::version() {
-  return sfnt_version_;
-}
-
-ByteVector* Font::digest() {
-  return &digest_;
-}
-
-int64_t Font::checksum() {
-  return checksum_;
-}
-
-int32_t Font::numTables() {
-  return (int32_t)tables_.size();
-}
-
-bool Font::hasTable(int32_t tag) {
-  TableMap::const_iterator result = tables_.find(tag);
-  TableMap::const_iterator end = tables_.end();
-  return (result != end);
-}
-
-Table* Font::table(int32_t tag) {
-  if (!hasTable(tag)) {
-    return NULL;
-  }
-  return tables_[tag];
-}
-
-TableMap* Font::tables() {
-  return &tables_;
-}
-
-void Font::serialize(OutputStream* os, IntegerList* table_ordering) {
-  assert(table_ordering);
-  IntegerList final_table_ordering;
-  tableOrdering(table_ordering, &final_table_ordering);
-  TableHeaderList table_records;
-  buildTableHeadersForSerialization(&final_table_ordering, &table_records);
-
-  FontOutputStream fos(os);
-  serializeHeader(&fos, &table_records);
-  serializeTables(&fos, &table_records);
-}
-
-void Font::buildTableHeadersForSerialization(IntegerList* table_ordering,
+void Font::BuildTableHeadersForSerialization(IntegerList* table_ordering,
                                              TableHeaderList* table_headers) {
   assert(table_headers);
   assert(table_ordering);
 
   IntegerList final_table_ordering;
-  tableOrdering(table_ordering, &final_table_ordering);
-  int32_t table_offset = Offset::kTableRecordBegin + numTables() *
+  TableOrdering(table_ordering, &final_table_ordering);
+  int32_t table_offset = Offset::kTableRecordBegin + num_tables() *
                          Offset::kTableRecordSize;
   for (IntegerList::iterator tag = final_table_ordering.begin(),
                              tag_end = final_table_ordering.end();
@@ -110,42 +100,42 @@
     TablePtr table = tables_[*tag];
     if (table != NULL) {
       TableHeaderPtr header =
-          new Table::Header(*tag, table->calculatedChecksum(), table_offset,
-                            table->length());
+          new Table::Header(*tag, table->CalculatedChecksum(), table_offset,
+                            table->Length());
       table_headers->push_back(header);
-      table_offset += (table->length() + 3) & ~3;
+      table_offset += (table->Length() + 3) & ~3;
     }
   }
 }
 
-void Font::serializeHeader(FontOutputStream* fos,
+void Font::SerializeHeader(FontOutputStream* fos,
                            TableHeaderList* table_headers) {
-  fos->writeFixed(sfnt_version_);
-  fos->writeUShort(table_headers->size());
-  int32_t log2_of_max_power_of_2 = FontMath::log2(table_headers->size());
+  fos->WriteFixed(sfnt_version_);
+  fos->WriteUShort(table_headers->size());
+  int32_t log2_of_max_power_of_2 = FontMath::Log2(table_headers->size());
   int32_t search_range = 2 << (log2_of_max_power_of_2 - 1 + 4);
-  fos->writeUShort(search_range);
-  fos->writeUShort(log2_of_max_power_of_2);
-  fos->writeUShort((table_headers->size() * 16) - search_range);
+  fos->WriteUShort(search_range);
+  fos->WriteUShort(log2_of_max_power_of_2);
+  fos->WriteUShort((table_headers->size() * 16) - search_range);
 
   for (TableHeaderList::iterator record = table_headers->begin(),
                                  record_end = table_headers->end();
                                  record != record_end; ++record) {
-    fos->writeULong((*record)->tag());
-    fos->writeULong((int32_t)((*record)->checksum()));
-    fos->writeULong((*record)->offset());
-    fos->writeULong((*record)->length());
+    fos->WriteULong((*record)->tag());
+    fos->WriteULong((int32_t)((*record)->checksum()));
+    fos->WriteULong((*record)->offset());
+    fos->WriteULong((*record)->length());
   }
 }
 
-void Font::serializeTables(FontOutputStream* fos,
+void Font::SerializeTables(FontOutputStream* fos,
                            TableHeaderList* table_headers) {
   ByteVector SERIALIZATION_FILLER(3);
   std::fill(SERIALIZATION_FILLER.begin(), SERIALIZATION_FILLER.end(), 0);
   for (TableHeaderList::iterator record = table_headers->begin(),
                                  end_of_headers = table_headers->end();
                                  record != end_of_headers; ++record) {
-    TablePtr target_table = table((*record)->tag());
+    TablePtr target_table = GetTable((*record)->tag());
     if (target_table == NULL) {
 #if defined (SFNTLY_NO_EXCEPTION)
       return;
@@ -153,22 +143,22 @@
       throw IOException("Table out of sync with font header.");
 #endif
     }
-    int32_t table_size = target_table->serialize(fos);
+    int32_t table_size = target_table->Serialize(fos);
     if (table_size != (*record)->length()) {
       assert(false);
     }
     int32_t filler_size = ((table_size + 3) & ~3) - table_size;
-    fos->write(&SERIALIZATION_FILLER, 0, filler_size);
+    fos->Write(&SERIALIZATION_FILLER, 0, filler_size);
   }
 }
 
-void Font::tableOrdering(IntegerList* default_table_ordering,
+void Font::TableOrdering(IntegerList* default_table_ordering,
                          IntegerList* table_ordering) {
   assert(default_table_ordering);
   assert(table_ordering);
   table_ordering->clear();
   if (default_table_ordering->empty()) {
-    defaultTableOrdering(default_table_ordering);
+    DefaultTableOrdering(default_table_ordering);
   }
 
   typedef std::map<int32_t, bool> Int2Bool;
@@ -181,7 +171,7 @@
   for (IntegerList::iterator tag = default_table_ordering->begin(),
                              tag_end = default_table_ordering->end();
                              tag != tag_end; ++tag) {
-    if (hasTable(*tag)) {
+    if (HasTable(*tag)) {
       table_ordering->push_back(*tag);
       tables_in_font[*tag] = true;
     }
@@ -194,10 +184,10 @@
   }
 }
 
-void Font::defaultTableOrdering(IntegerList* default_table_ordering) {
+void Font::DefaultTableOrdering(IntegerList* default_table_ordering) {
   assert(default_table_ordering);
   default_table_ordering->clear();
-  if (hasTable(Tag::CFF)) {
+  if (HasTable(Tag::CFF)) {
     default_table_ordering->resize(CFF_TABLE_ORDERING_SIZE);
     std::copy(CFF_TABLE_ORDERING, CFF_TABLE_ORDERING + CFF_TABLE_ORDERING_SIZE,
               default_table_ordering->begin());
@@ -209,62 +199,32 @@
             default_table_ordering->begin());
 }
 
-CALLER_ATTACH WritableFontData* Font::getNewData(int32_t size) {
-  return factory_->getNewData(size);
-}
-
 /******************************************************************************
  * Font::Builder class
  ******************************************************************************/
 Font::Builder::~Builder() {}
 
-Font::Builder::Builder(FontFactory* factory)
-    : factory_(factory), sfnt_version_(SFNTVERSION_1) {
-}
-
-void Font::Builder::loadFont(InputStream* is) {
-  // Note: we do not throw exception here for is.  This is more of an assertion.
-  assert(is);
-  FontInputStream font_is(is);
-  TableHeaderSortedSet records;
-  readHeader(&font_is, &records);
-  loadTableData(&records, &font_is, &data_blocks_);
-  buildAllTableBuilders(&data_blocks_, &table_builders_);
-  font_is.close();
-}
-
-void Font::Builder::loadFont(ByteArray* ba,
-                             int32_t offset_to_offset_table) {
-  // Note: we do not throw exception here for is.  This is more of an assertion.
-  assert(ba);
-  WritableFontDataPtr fd = new WritableFontData(ba);
-  TableHeaderSortedSet records;
-  readHeader(fd, offset_to_offset_table, &records);
-  loadTableData(&records, fd, &data_blocks_);
-  buildAllTableBuilders(&data_blocks_, &table_builders_);
-}
-
-CALLER_ATTACH Font::Builder* Font::Builder::getOTFBuilder(
+CALLER_ATTACH Font::Builder* Font::Builder::GetOTFBuilder(
     FontFactory* factory, InputStream* is) {
   FontBuilderPtr builder = new Builder(factory);
-  builder->loadFont(is);
-  return builder.detach();
+  builder->LoadFont(is);
+  return builder.Detach();
 }
 
-CALLER_ATTACH Font::Builder* Font::Builder::getOTFBuilder(
+CALLER_ATTACH Font::Builder* Font::Builder::GetOTFBuilder(
     FontFactory* factory, ByteArray* ba, int32_t offset_to_offset_table) {
   FontBuilderPtr builder = new Builder(factory);
-  builder->loadFont(ba, offset_to_offset_table);
-  return builder.detach();
+  builder->LoadFont(ba, offset_to_offset_table);
+  return builder.Detach();
 }
 
-CALLER_ATTACH Font::Builder* Font::Builder::getOTFBuilder(
+CALLER_ATTACH Font::Builder* Font::Builder::GetOTFBuilder(
     FontFactory* factory) {
   FontBuilderPtr builder = new Builder(factory);
-  return builder.detach();
+  return builder.Detach();
 }
 
-bool Font::Builder::readyToBuild() {
+bool Font::Builder::ReadyToBuild() {
   // just read in data with no manipulation
   if (table_builders_.empty() && !data_blocks_.empty()) {
     return true;
@@ -275,73 +235,69 @@
                                  table_builder_end = table_builders_.end();
                                  table_builder != table_builder_end;
                                  ++table_builder) {
-    if (!table_builder->second->readyToBuild())
+    if (!table_builder->second->ReadyToBuild())
       return false;
   }
   return true;
 }
 
-CALLER_ATTACH Font* Font::Builder::build() {
+CALLER_ATTACH Font* Font::Builder::Build() {
   TableMap tables;
   if (!table_builders_.empty()) {
-    buildTablesFromBuilders(&table_builders_, &tables);
+    BuildTablesFromBuilders(&table_builders_, &tables);
   }
   FontPtr font = new Font(factory_, sfnt_version_, &digest_, &tables);
   table_builders_.clear();
   data_blocks_.clear();
-  return font.detach();
+  return font.Detach();
 }
 
-CALLER_ATTACH WritableFontData* Font::Builder::getNewData(int32_t capacity) {
-  return factory_->getNewData(capacity);
+CALLER_ATTACH WritableFontData* Font::Builder::GetNewData(int32_t capacity) {
+  return factory_->GetNewData(capacity);
 }
 
-CALLER_ATTACH WritableFontData* Font::Builder::getNewGrowableData(
+CALLER_ATTACH WritableFontData* Font::Builder::GetNewGrowableData(
     ReadableFontData* src_data) {
-  return factory_->getNewGrowableData(src_data);
+  return factory_->GetNewGrowableData(src_data);
 }
 
-void Font::Builder::setDigest(ByteVector* digest) {
+void Font::Builder::SetDigest(ByteVector* digest) {
   digest_.clear();
   digest_ = *digest;
 }
 
-void Font::Builder::cleanTableBuilders() {
+void Font::Builder::CleanTableBuilders() {
   table_builders_.clear();
 }
 
-bool Font::Builder::hasTableBuilder(int32_t tag) {
+bool Font::Builder::HasTableBuilder(int32_t tag) {
   return (table_builders_.find(tag) != table_builders_.end());
 }
 
-Table::Builder* Font::Builder::getTableBuilder(int32_t tag) {
-  if (hasTableBuilder(tag))
+Table::Builder* Font::Builder::GetTableBuilder(int32_t tag) {
+  if (HasTableBuilder(tag))
     return table_builders_[tag];
   return NULL;
 }
 
-CALLER_ATTACH Table::Builder* Font::Builder::newTableBuilder(int32_t tag) {
+CALLER_ATTACH Table::Builder* Font::Builder::NewTableBuilder(int32_t tag) {
   TableHeaderPtr header = new Table::Header(tag);
-  TableBuilderPtr builder = Table::Builder::getBuilder(this, header, NULL);
+  TableBuilderPtr builder = Table::Builder::GetBuilder(this, header, NULL);
   table_builders_.insert(TableBuilderEntry(header->tag(), builder));
   return builder;
 }
 
-CALLER_ATTACH Table::Builder* Font::Builder::newTableBuilder(
-    int32_t tag, ReadableFontData* src_data) {
+CALLER_ATTACH Table::Builder*
+    Font::Builder::NewTableBuilder(int32_t tag, ReadableFontData* src_data) {
   WritableFontDataPtr data;
-  data.attach(getNewGrowableData(src_data));
+  data.Attach(GetNewGrowableData(src_data));
   TableHeaderPtr header = new Table::Header(tag);
-  TableBuilderPtr builder = Table::Builder::getBuilder(this, header, data);
+  TableBuilderPtr builder = Table::Builder::GetBuilder(this, header, data);
   table_builders_.insert(TableBuilderEntry(tag, builder));
   return builder;
 }
 
-TableBuilderMap* Font::Builder::tableBuilders() {
-  return &table_builders_;
-}
-
-void Font::Builder::tableBuilderTags(IntegerSet* key_set) {
+void Font::Builder::TableBuilderTags(IntegerSet* key_set) {
   assert(key_set);
   key_set->clear();
   for (TableBuilderMap::iterator i = table_builders_.begin(),
@@ -350,53 +306,76 @@
   }
 }
 
-void Font::Builder::removeTableBuilder(int32_t tag) {
+void Font::Builder::RemoveTableBuilder(int32_t tag) {
   TableBuilderMap::iterator target = table_builders_.find(tag);
   if (target != table_builders_.end()) {
     table_builders_.erase(target);
   }
 }
 
-int32_t Font::Builder::numberOfTableBuilders() {
-  return (int32_t)table_builders_.size();
+Font::Builder::Builder(FontFactory* factory)
+    : factory_(factory), sfnt_version_(SFNTVERSION_1) {
 }
 
-int32_t Font::Builder::sfntWrapperSize() {
+void Font::Builder::LoadFont(InputStream* is) {
+  // Note: we do not throw exception here for is.  This is more of an assertion.
+  assert(is);
+  FontInputStream font_is(is);
+  TableHeaderSortedSet records;
+  ReadHeader(&font_is, &records);
+  LoadTableData(&records, &font_is, &data_blocks_);
+  BuildAllTableBuilders(&data_blocks_, &table_builders_);
+  font_is.Close();
+}
+
+void Font::Builder::LoadFont(ByteArray* ba,
+                             int32_t offset_to_offset_table) {
+  // Note: we do not throw exception here for is.  This is more of an assertion.
+  assert(ba);
+  WritableFontDataPtr fd = new WritableFontData(ba);
+  TableHeaderSortedSet records;
+  ReadHeader(fd, offset_to_offset_table, &records);
+  LoadTableData(&records, fd, &data_blocks_);
+  BuildAllTableBuilders(&data_blocks_, &table_builders_);
+}
+
+int32_t Font::Builder::SfntWrapperSize() {
   return Offset::kSfntHeaderSize +
          (Offset::kTableRecordSize * table_builders_.size());
 }
 
-void Font::Builder::buildAllTableBuilders(DataBlockMap* table_data,
+void Font::Builder::BuildAllTableBuilders(DataBlockMap* table_data,
                                           TableBuilderMap* builder_map) {
   for (DataBlockMap::iterator record = table_data->begin(),
                               record_end = table_data->end();
                               record != record_end; ++record) {
     TableBuilderPtr builder;
-    builder.attach(getTableBuilder(record->first.p_, record->second.p_));
+    builder.Attach(GetTableBuilder(record->first.p_, record->second.p_));
     builder_map->insert(TableBuilderEntry(record->first->tag(), builder));
   }
-  interRelateBuilders(&table_builders_);
+  InterRelateBuilders(&table_builders_);
 }
 
-CALLER_ATTACH Table::Builder* Font::Builder::getTableBuilder(
-    Table::Header* header, WritableFontData* data) {
-  return Table::Builder::getBuilder(this, header, data);
+CALLER_ATTACH Table::Builder*
+    Font::Builder::GetTableBuilder(Table::Header* header,
+                                   WritableFontData* data) {
+  return Table::Builder::GetBuilder(this, header, data);
 }
 
-void Font::Builder::buildTablesFromBuilders(TableBuilderMap* builder_map,
+void Font::Builder::BuildTablesFromBuilders(TableBuilderMap* builder_map,
                                             TableMap* table_map) {
-  interRelateBuilders(builder_map);
+  InterRelateBuilders(builder_map);
 
   // Now build all the tables.
   for (TableBuilderMap::iterator builder = builder_map->begin(),
                                  builder_end = builder_map->end();
                                  builder != builder_end; ++builder) {
     TablePtr table;
-    if (builder->second->readyToBuild()) {
+    if (builder->second->ReadyToBuild()) {
 #if !defined (SFNTLY_NO_EXCEPTION)
       try {
 #endif
-        table.attach(down_cast<Table*>(builder->second->build()));
+        table.Attach(down_cast<Table*>(builder->second->Build()));
 #if !defined (SFNTLY_NO_EXCEPTION)
       } catch(IOException& e) {
         std::string builder_string = "Unable to build table - ";
@@ -419,7 +398,7 @@
   }
 }
 
-void Font::Builder::interRelateBuilders(TableBuilderMap* builder_map) {
+void Font::Builder::InterRelateBuilders(TableBuilderMap* builder_map) {
   FontHeaderTableBuilderPtr header_table_builder =
       down_cast<FontHeaderTable::Builder*>((*builder_map)[Tag::head].p_);
   HorizontalHeaderTableBuilderPtr horizontal_header_builder =
@@ -435,87 +414,89 @@
   // set the inter table data required to build certain tables
   if (horizontal_metrics_builder != NULL) {
     if (max_profile_builder != NULL) {
-      horizontal_metrics_builder->setNumGlyphs(
-          max_profile_builder->numGlyphs());
+      horizontal_metrics_builder->SetNumGlyphs(
+          max_profile_builder->NumGlyphs());
     }
     if (horizontal_header_builder != NULL) {
-      horizontal_metrics_builder->setNumberOfHMetrics(
-          horizontal_header_builder->numberOfHMetrics());
+      horizontal_metrics_builder->SetNumberOfHMetrics(
+          horizontal_header_builder->NumberOfHMetrics());
     }
   }
 
   if (loca_table_builder != NULL) {
     if (max_profile_builder != NULL) {
-      loca_table_builder->setNumGlyphs(max_profile_builder->numGlyphs());
+      loca_table_builder->SetNumGlyphs(max_profile_builder->NumGlyphs());
     }
     if (header_table_builder != NULL) {
-      loca_table_builder->setFormatVersion(
-          header_table_builder->indexToLocFormat());
+      loca_table_builder->SetFormatVersion(
+          header_table_builder->IndexToLocFormat());
     }
   }
 }
 
-void Font::Builder::readHeader(FontInputStream* is,
+void Font::Builder::ReadHeader(FontInputStream* is,
                                TableHeaderSortedSet* records) {
   assert(records);
-  sfnt_version_ = is->readFixed();
-  num_tables_ = is->readUShort();
-  search_range_ = is->readUShort();
-  entry_selector_ = is->readUShort();
-  range_shift_ = is->readUShort();
+  sfnt_version_ = is->ReadFixed();
+  num_tables_ = is->ReadUShort();
+  search_range_ = is->ReadUShort();
+  entry_selector_ = is->ReadUShort();
+  range_shift_ = is->ReadUShort();
 
   for (int32_t table_number = 0; table_number < num_tables_; ++table_number) {
     // Need to use temporary vars here.  C++ evaluates function parameters from
     // right to left and thus breaks the order of input stream.
-    int32_t tag = is->readULongAsInt();
-    int64_t checksum = is->readULong();
-    int32_t offset = is->readULongAsInt();
-    int32_t length = is->readULongAsInt();
+    int32_t tag = is->ReadULongAsInt();
+    int64_t checksum = is->ReadULong();
+    int32_t offset = is->ReadULongAsInt();
+    int32_t length = is->ReadULongAsInt();
     TableHeaderPtr table = new Table::Header(tag, checksum, offset, length);
     records->insert(table);
   }
 }
 
-void Font::Builder::loadTableData(TableHeaderSortedSet* headers,
+void Font::Builder::ReadHeader(ReadableFontData* fd,
+                               int32_t offset,
+                               TableHeaderSortedSet* records) {
+  assert(records);
+  sfnt_version_ = fd->ReadFixed(offset + Offset::kSfntVersion);
+  num_tables_ = fd->ReadUShort(offset + Offset::kNumTables);
+  search_range_ = fd->ReadUShort(offset + Offset::kSearchRange);
+  entry_selector_ = fd->ReadUShort(offset + Offset::kEntrySelector);
+  range_shift_ = fd->ReadUShort(offset + Offset::kRangeShift);
+
+  int32_t table_offset = offset + Offset::kTableRecordBegin;
+  for (int32_t table_number = 0;
+       table_number < num_tables_;
+       table_number++, table_offset += Offset::kTableRecordSize) {
+    int32_t tag = fd->ReadULongAsInt(table_offset + Offset::kTableTag);
+    int64_t checksum = fd->ReadULong(table_offset + Offset::kTableCheckSum);
+    int32_t offset = fd->ReadULongAsInt(table_offset + Offset::kTableOffset);
+    int32_t length = fd->ReadULongAsInt(table_offset + Offset::kTableLength);
+    TableHeaderPtr table = new Table::Header(tag, checksum, offset, length);
+    records->insert(table);
+  }
+}
+
+void Font::Builder::LoadTableData(TableHeaderSortedSet* headers,
                                   FontInputStream* is,
                                   DataBlockMap* table_data) {
   assert(table_data);
   for (TableHeaderSortedSet::iterator
            table_header = headers->begin(), table_end = headers->end();
            table_header != table_end; ++table_header) {
-    is->skip((*table_header)->offset() - is->position());
+    is->Skip((*table_header)->offset() - is->position());
     FontInputStream table_is(is, (*table_header)->length());
     int32_t roundup_length = ((*table_header)->length() + 3) & ~3;
-    ByteArrayPtr array = factory_->getNewArray(roundup_length);
-    array->copyFrom(&table_is, (*table_header)->length());
+    ByteArrayPtr array;
+    array.Attach(factory_->GetNewArray(roundup_length));
+    array->CopyFrom(&table_is, (*table_header)->length());
     WritableFontDataPtr data = new WritableFontData(array);
     table_data->insert(DataBlockEntry(*table_header, data));
   }
 }
 
-void Font::Builder::readHeader(ReadableFontData* fd, int32_t offset,
-                               TableHeaderSortedSet* records) {
-  assert(records);
-  sfnt_version_ = fd->readFixed(offset + Offset::kSfntVersion);
-  num_tables_ = fd->readUShort(offset + Offset::kNumTables);
-  search_range_ = fd->readUShort(offset + Offset::kSearchRange);
-  entry_selector_ = fd->readUShort(offset + Offset::kEntrySelector);
-  range_shift_ = fd->readUShort(offset + Offset::kRangeShift);
-
-  int32_t table_offset = offset + Offset::kTableRecordBegin;
-  for (int32_t table_number = 0;
-       table_number < num_tables_;
-       table_number++, table_offset += Offset::kTableRecordSize) {
-    int32_t tag = fd->readULongAsInt(table_offset + Offset::kTableTag);
-    int64_t checksum = fd->readULong(table_offset + Offset::kTableCheckSum);
-    int32_t offset = fd->readULongAsInt(table_offset + Offset::kTableOffset);
-    int32_t length = fd->readULongAsInt(table_offset + Offset::kTableLength);
-    TableHeaderPtr table = new Table::Header(tag, checksum, offset, length);
-    records->insert(table);
-  }
-}
-
-void Font::Builder::loadTableData(TableHeaderSortedSet* headers,
+void Font::Builder::LoadTableData(TableHeaderSortedSet* headers,
                                   WritableFontData* fd,
                                   DataBlockMap* table_data) {
   for (TableHeaderSortedSet::iterator
@@ -523,7 +504,7 @@
            table_header != table_end; ++table_header) {
     int32_t roundup_length = ((*table_header)->length() + 3) & ~3;
     FontDataPtr sliced_data;
-    sliced_data.attach(fd->slice((*table_header)->offset(), roundup_length));
+    sliced_data.Attach(fd->Slice((*table_header)->offset(), roundup_length));
     WritableFontDataPtr data = down_cast<WritableFontData*>(sliced_data.p_);
     table_data->insert(DataBlockEntry(*table_header, data));
   }
diff --git a/sfntly/font.h b/sfntly/font.h
index cbd9607..5ce7f17 100644
--- a/sfntly/font.h
+++ b/sfntly/font.h
@@ -122,13 +122,132 @@
 
 class FontFactory;
 class Font : public RefCounted<Font> {
+ public:
+  class Builder : public FontDataTableBuilderContainer,
+                  public RefCounted<Builder> {
+   public:
+    virtual ~Builder();
+
+    static CALLER_ATTACH Builder*
+        GetOTFBuilder(FontFactory* factory, InputStream* is);
+    static CALLER_ATTACH Builder*
+        GetOTFBuilder(FontFactory* factory,
+                      ByteArray* ba,
+                      int32_t offset_to_offset_table);
+    static CALLER_ATTACH Builder* GetOTFBuilder(FontFactory* factory);
+    virtual bool ReadyToBuild();
+    virtual CALLER_ATTACH Font* Build();
+    virtual CALLER_ATTACH WritableFontData* GetNewData(int32_t capacity);
+    virtual CALLER_ATTACH WritableFontData*
+        GetNewGrowableData(ReadableFontData* data);
+    virtual void SetDigest(ByteVector* digest);
+    virtual void CleanTableBuilders();
+    virtual bool HasTableBuilder(int32_t tag);
+    virtual Table::Builder* GetTableBuilder(int32_t tag);
+
+    // Creates a new table builder for the table type given by the table id tag.
+    // This new table has been added to the font and will replace any existing
+    // builder for that table.
+    // @return new empty table of the type specified by tag; if tag is not known
+    //         then a generic OpenTypeTable is returned
+    virtual CALLER_ATTACH Table::Builder* NewTableBuilder(int32_t tag);
+    virtual CALLER_ATTACH Table::Builder*
+        NewTableBuilder(int32_t tag, ReadableFontData* src_data);
+    virtual TableBuilderMap* table_builders() { return &table_builders_; }
+    virtual void TableBuilderTags(IntegerSet* key_set);
+    // Note: different from Java: we don't return object in removeTableBuilder
+    virtual void RemoveTableBuilder(int32_t tag);
+    virtual int32_t number_of_table_builders() {
+      return (int32_t)table_builders_.size();
+    }
+
+   private:
+    explicit Builder(FontFactory* factory);
+    virtual void LoadFont(InputStream* is);
+    virtual void LoadFont(ByteArray* buffer, int32_t offset_to_offset_table);
+    int32_t SfntWrapperSize();
+    void BuildAllTableBuilders(DataBlockMap* table_data,
+                               TableBuilderMap* builder_map);
+    CALLER_ATTACH Table::Builder*
+        GetTableBuilder(Table::Header* header, WritableFontData* data);
+    void BuildTablesFromBuilders(TableBuilderMap* builder_map,
+                                 TableMap* tables);
+    static void InterRelateBuilders(TableBuilderMap* builder_map);
+    void ReadHeader(FontInputStream* is, TableHeaderSortedSet* records);
+    void ReadHeader(ReadableFontData* fd,
+                    int32_t offset,
+                    TableHeaderSortedSet* records);
+    void LoadTableData(TableHeaderSortedSet* headers,
+                       FontInputStream* is,
+                       DataBlockMap* table_data);
+    void LoadTableData(TableHeaderSortedSet* headers,
+                       WritableFontData* fd,
+                       DataBlockMap* table_data);
+
+    TableBuilderMap table_builders_;
+    FontFactory* factory_;  // dumb pointer, avoid circular refcounting
+    int32_t sfnt_version_;
+    int32_t num_tables_;
+    int32_t search_range_;
+    int32_t entry_selector_;
+    int32_t range_shift_;
+    DataBlockMap data_blocks_;
+    ByteVector digest_;
+  };
+
+  virtual ~Font();
+
+  // Gets the sfnt version set in the sfnt wrapper of the font.
+  int32_t version() { return sfnt_version_; }
+
+  // Gets a copy of the fonts digest that was created when the font was read. If
+  // no digest was set at creation time then the return result will be null.
+  ByteVector* digest() { return &digest_; }
+
+  // Get the checksum for this font.
+  int64_t checksum() { return checksum_; }
+
+  // Get the number of tables in this font.
+  int32_t num_tables() { return (int32_t)tables_.size(); }
+
+  // Whether the font has a particular table.
+  bool HasTable(int32_t tag);
+
+  // UNIMPLEMENTED: public Iterator<? extends Table> iterator
+
+  // Get the table in this font with the specified id.
+  // @param tag the identifier of the table
+  // @return the table specified if it exists; null otherwise
+  // C++ port: rename table() to GetTable()
+  Table* GetTable(int32_t tag);
+
+  // Get a map of the tables in this font accessed by table tag.
+  // @return an unmodifiable view of the tables in this font
+  TableMap* Tables();
+
+  // Serialize the font to the output stream.
+  // @param os the destination for the font serialization
+  // @param tableOrdering the table ordering to apply
+  void Serialize(OutputStream* os, IntegerList* table_ordering);
+
+  // Get a new data object. The size is a request for a data object and the
+  // returned data object will support at least that amount. A value greater
+  // than zero for the size is a request for a fixed size data object. A
+  // negative or zero value for the size is a request for a variable sized data
+  // object with the absolute value of the size being an estimate of the space
+  // required.
+  // @param size greater than zero is a request for a fixed size data object of
+  //        the given size; less than or equal to zero is a request for a
+  //        variable size data object with the absolute size as an estimate
+  CALLER_ATTACH WritableFontData* GetNewData(int32_t size);
+
  private:
   // Offsets to specific elements in the underlying data. These offsets are
   // relative to the start of the table or the start of sub-blocks within the
   // table.
   struct Offset {
     enum {
-    // Offsets within the main directory
+      // Offsets within the main directory
       kSfntVersion = 0,
       kNumTables = 4,
       kSearchRange = 6,
@@ -137,7 +256,7 @@
       kTableRecordBegin = 12,
       kSfntHeaderSize = 12,
 
-    // Offsets within a specific table record
+      // Offsets within a specific table record
       kTableTag = 0,
       kTableCheckSum = 4,
       kTableOffset = 8,
@@ -150,139 +269,17 @@
 //  static const int32_t CFF_TABLE_ORDERING[];
 //  static const int32_t TRUE_TYPE_TABLE_ORDERING[];
 
- public:
-  virtual ~Font();
-
- private:
   Font(FontFactory* factory, int32_t sfnt_version, ByteVector* digest,
        TableMap* tables);
 
- public:
-  // Gets the sfnt version set in the sfnt wrapper of the font.
-  virtual int32_t version();
+  void BuildTableHeadersForSerialization(IntegerList* table_ordering,
+                                         TableHeaderList* table_headers);
+  void SerializeHeader(FontOutputStream* fos, TableHeaderList* table_headers);
+  void SerializeTables(FontOutputStream* fos, TableHeaderList* table_headers);
+  void TableOrdering(IntegerList* default_table_ordering,
+                     IntegerList* table_ordering);
+  void DefaultTableOrdering(IntegerList* default_table_ordering);
 
-  // Gets a copy of the fonts digest that was created when the font was read. If
-  // no digest was set at creation time then the return result will be null.
-  virtual ByteVector* digest();
-
-  // Get the checksum for this font.
-  virtual int64_t checksum();
-
-  // Get the number of tables in this font.
-  virtual int32_t numTables();
-
-  // Whether the font has a particular table.
-  virtual bool hasTable(int32_t tag);
-
-  // UNIMPLEMENTED: public Iterator<? extends Table> iterator
-
-  // Get the table in this font with the specified id.
-  // @param tag the identifier of the table
-  // @return the table specified if it exists; null otherwise
-  virtual Table* table(int32_t tag);
-
-  // Get a map of the tables in this font accessed by table tag.
-  // @return an unmodifiable view of the tables in this font
-  virtual TableMap* tables();
-
-  // Serialize the font to the output stream.
-  // @param os the destination for the font serialization
-  // @param tableOrdering the table ordering to apply
-  virtual void serialize(OutputStream* os, IntegerList* table_ordering);
-
- private:
-  void buildTableHeadersForSerialization(IntegerList* table_ordering,
-    TableHeaderList* table_headers);
-  void serializeHeader(FontOutputStream* fos, TableHeaderList* table_headers);
-  void serializeTables(FontOutputStream* fos, TableHeaderList* table_headers);
-  void tableOrdering(IntegerList* default_table_ordering,
-    IntegerList* table_ordering);
-  void defaultTableOrdering(IntegerList* default_table_ordering);
-
- public:
-  class Builder : public FontDataTableBuilderContainer,
-                  public RefCounted<Builder> {
-   public:
-    virtual ~Builder();
-
-   private:
-    explicit Builder(FontFactory* factory);
-    virtual void loadFont(InputStream* is);
-    virtual void loadFont(ByteArray* buffer, int32_t offset_to_offset_table);
-
-   public:
-    static CALLER_ATTACH Builder*
-        getOTFBuilder(FontFactory* factory, InputStream* is);
-    static CALLER_ATTACH Builder*
-        getOTFBuilder(FontFactory* factory, ByteArray* ba,
-                      int32_t offset_to_offset_table);
-    static CALLER_ATTACH Builder* getOTFBuilder(FontFactory* factory);
-    virtual bool readyToBuild();
-    virtual CALLER_ATTACH Font* build();
-    virtual CALLER_ATTACH WritableFontData* getNewData(int32_t capacity);
-    virtual CALLER_ATTACH WritableFontData*
-        getNewGrowableData(ReadableFontData* data);
-    virtual void setDigest(ByteVector* digest);
-    virtual void cleanTableBuilders();
-    virtual bool hasTableBuilder(int32_t tag);
-    virtual Table::Builder* getTableBuilder(int32_t tag);
-
-    // Creates a new table builder for the table type given by the table id tag.
-    // This new table has been added to the font and will replace any existing
-    // builder for that table.
-    // @return new empty table of the type specified by tag; if tag is not known
-    //         then a generic OpenTypeTable is returned
-    virtual CALLER_ATTACH Table::Builder* newTableBuilder(int32_t tag);
-    virtual CALLER_ATTACH Table::Builder*
-        newTableBuilder(int32_t tag, ReadableFontData* src_data);
-    virtual TableBuilderMap* tableBuilders();
-    virtual void tableBuilderTags(IntegerSet* key_set);
-    // Note: different from Java: we don't return object in removeTableBuilder
-    virtual void removeTableBuilder(int32_t tag);
-    virtual int32_t numberOfTableBuilders();
-
-   private:
-    int32_t sfntWrapperSize();
-    void buildAllTableBuilders(DataBlockMap* table_data,
-                               TableBuilderMap* builder_map);
-    CALLER_ATTACH Table::Builder*
-        getTableBuilder(Table::Header* header, WritableFontData* data);
-    void buildTablesFromBuilders(TableBuilderMap* builder_map,
-                                 TableMap* tables);
-    static void interRelateBuilders(TableBuilderMap* builder_map);
-    void readHeader(FontInputStream* is, TableHeaderSortedSet* records);
-    void loadTableData(TableHeaderSortedSet* headers, FontInputStream* is,
-                       DataBlockMap* table_data);
-    void readHeader(ReadableFontData* fd, int32_t offset,
-                    TableHeaderSortedSet* records);
-    void loadTableData(TableHeaderSortedSet* headers, WritableFontData* fd,
-                       DataBlockMap* table_data);
-
-   private:
-    TableBuilderMap table_builders_;
-    FontFactory* factory_;  // dumb pointer, avoid circular refcounting
-    int32_t sfnt_version_;
-    int32_t num_tables_;
-    int32_t search_range_;
-    int32_t entry_selector_;
-    int32_t range_shift_;
-    DataBlockMap data_blocks_;
-    ByteVector digest_;
-  };
-
- public:
-  // Get a new data object. The size is a request for a data object and the
-  // returned data object will support at least that amount. A value greater
-  // than zero for the size is a request for a fixed size data object. A
-  // negative or zero value for the size is a request for a variable sized data
-  // object with the absolute value of the size being an estimate of the space
-  // required.
-  // @param size greater than zero is a request for a fixed size data object of
-  //        the given size; less than or equal to zero is a request for a
-  //        variable size data object with the absolute size as an estimate
-  CALLER_ATTACH WritableFontData* getNewData(int32_t size);
-
- private:
   FontFactory* factory_;  // dumb pointer, avoid circular ref-counting
   int32_t sfnt_version_;
   ByteVector digest_;
diff --git a/sfntly/font_data_table.cc b/sfntly/font_data_table.cc
index 9896b24..1f9d1cc 100644
--- a/sfntly/font_data_table.cc
+++ b/sfntly/font_data_table.cc
@@ -15,6 +15,7 @@
  */
 
 #include "sfntly/font_data_table.h"
+
 #include "sfntly/data/font_output_stream.h"
 
 namespace sfntly {
@@ -29,158 +30,142 @@
 
 FontDataTable::~FontDataTable() {}
 
-ReadableFontData* FontDataTable::readFontData() {
+ReadableFontData* FontDataTable::ReadFontData() {
   return data_;
 }
 
-int32_t FontDataTable::length() {
-  return data_->length();
+int32_t FontDataTable::Length() {
+  return data_->Length();
 }
 
-int32_t FontDataTable::padding() {
+int32_t FontDataTable::Padding() {
   return -1;
 }
 
-int32_t FontDataTable::dataLength() {
-  int32_t paddings = padding();
-  return (paddings == -1) ? length() : length() - paddings;
+int32_t FontDataTable::DataLength() {
+  int32_t paddings = Padding();
+  return (paddings == -1) ? Length() : Length() - paddings;
 }
 
-int32_t FontDataTable::serialize(OutputStream* os) {
-  return data_->copyTo(os);
+int32_t FontDataTable::Serialize(OutputStream* os) {
+  return data_->CopyTo(os);
 }
 
 /******************************************************************************
  * FontDataTable::Builder class
  ******************************************************************************/
-void FontDataTable::Builder::init(FontDataTableBuilderContainer* container) {
-  container_ = container;
-  model_changed_ = false;
-  data_changed_ = false;
+CALLER_ATTACH WritableFontData* FontDataTable::Builder::Data() {
+  WritableFontDataPtr new_data;
+  if (model_changed_) {
+    if (!SubReadyToSerialize()) {
+      return NULL;
+    }
+    int32_t size = SubDataSizeToSerialize();
+    new_data.Attach(container_->GetNewData(size));
+    SubSerialize(new_data);
+  } else {
+    ReadableFontDataPtr data = InternalReadData();
+    new_data.Attach(container_->GetNewData(data != NULL ? data->Length() : 0));
+    data->CopyTo(new_data);
+  }
+  return new_data.Detach();
+}
+
+void FontDataTable::Builder::SetData(ReadableFontData* data) {
+  InternalSetData(data, true);
+}
+
+
+CALLER_ATTACH FontDataTable* FontDataTable::Builder::Build() {
+  ReadableFontDataPtr data = InternalReadData();
+  if (model_changed_) {
+    // Let subclass serialize from model.
+    if (!SubReadyToSerialize()) {
+      return NULL;
+    }
+    int32_t size = SubDataSizeToSerialize();
+    WritableFontDataPtr new_data;
+    new_data.Attach(container_->GetNewData(size));
+    SubSerialize(new_data);
+    data = new_data;
+  }
+  FontDataTablePtr table = SubBuildTable(data);
+  NotifyPostTableBuild(table);
+  return table;
+}
+
+bool FontDataTable::Builder::ReadyToBuild() {
+  return true;
+}
+
+ReadableFontData* FontDataTable::Builder::InternalReadData() {
+  return (r_data_ != NULL) ? r_data_.p_ :
+                             static_cast<ReadableFontData*>(w_data_.p_);
+}
+
+WritableFontData* FontDataTable::Builder::InternalWriteData() {
+  if (w_data_ == NULL) {
+    WritableFontDataPtr new_data;
+    new_data.Attach(container_->GetNewData(r_data_->Length()));
+    r_data_->CopyTo(new_data);
+    InternalSetData(new_data, false);
+  }
+  return w_data_.p_;
+}
+
+CALLER_ATTACH WritableFontData*
+    FontDataTable::Builder::InternalNewData(int32_t size) {
+  return container_->GetNewData(size);
 }
 
 FontDataTable::Builder::Builder(FontDataTableBuilderContainer* container) {
-  init(container);
+  Init(container);
 }
 
 FontDataTable::Builder::Builder(FontDataTableBuilderContainer* container,
                                 WritableFontData* data) {
-  init(container);
+  Init(container);
   w_data_ = data;
 }
 
 FontDataTable::Builder::Builder(FontDataTableBuilderContainer* container,
                                 ReadableFontData* data) {
-  init(container);
+  Init(container);
   r_data_ = data;
 }
 
 FontDataTable::Builder::~Builder() {
 }
 
-WritableFontData* FontDataTable::Builder::data() {
-  WritableFontDataPtr new_data;
-  if (model_changed_) {
-    if (!subReadyToSerialize()) {
-      return NULL;
-    }
-    int32_t size = subDataSizeToSerialize();
-    new_data.attach(container_->getNewData(size));
-    subSerialize(new_data);
-  } else {
-    ReadableFontDataPtr data = internalReadData();
-    new_data.attach(container_->getNewData(data != NULL ? data->length() : 0));
-    data->copyTo(new_data);
-  }
-  return new_data.detach();
+void FontDataTable::Builder::Init(FontDataTableBuilderContainer* container) {
+  container_ = container;
+  model_changed_ = false;
+  data_changed_ = false;
 }
 
-void FontDataTable::Builder::setData(ReadableFontData* data) {
-  internalSetData(data, true);
+void FontDataTable::Builder::NotifyPostTableBuild(FontDataTable* table) {
+  // Default: NOP.
+  UNREFERENCED_PARAMETER(table);
 }
 
-void FontDataTable::Builder::internalSetData(WritableFontData* data,
+void FontDataTable::Builder::InternalSetData(WritableFontData* data,
                                              bool data_changed) {
   w_data_ = data;
   r_data_ = NULL;
   if (data_changed) {
     data_changed_ = true;
-    subDataSet();
+    SubDataSet();
   }
 }
 
-void FontDataTable::Builder::internalSetData(ReadableFontData* data,
+void FontDataTable::Builder::InternalSetData(ReadableFontData* data,
                                              bool data_changed) {
   w_data_ = NULL;
   r_data_ = data;
   if (data_changed) {
     data_changed_ = true;
-    subDataSet();
+    SubDataSet();
   }
 }
 
-CALLER_ATTACH FontDataTable* FontDataTable::Builder::build() {
-  ReadableFontDataPtr data = internalReadData();
-  if (model_changed_) {
-    // Let subclass serialize from model.
-    if (!subReadyToSerialize()) {
-      return NULL;
-    }
-    int32_t size = subDataSizeToSerialize();
-    WritableFontDataPtr new_data;
-    new_data.attach(container_->getNewData(size));
-    subSerialize(new_data);
-    data = new_data;
-  }
-  FontDataTablePtr table = subBuildTable(data);
-  notifyPostTableBuild(table);
-  return table;
-}
-
-bool FontDataTable::Builder::readyToBuild() {
-  return true;
-}
-
-ReadableFontData* FontDataTable::Builder::internalReadData() {
-  return (r_data_ != NULL) ? r_data_.p_ :
-                             static_cast<ReadableFontData*>(w_data_.p_);
-}
-
-WritableFontData* FontDataTable::Builder::internalWriteData() {
-  if (w_data_ == NULL) {
-    WritableFontDataPtr new_data;
-    new_data.attach(container_->getNewData(r_data_->length()));
-    r_data_->copyTo(new_data);
-    internalSetData(new_data, false);
-  }
-  return w_data_.p_;
-}
-
-WritableFontData* FontDataTable::Builder::internalNewData(int32_t size) {
-  return container_->getNewData(size);
-}
-
-bool FontDataTable::Builder::dataChanged() {
-  return data_changed_;
-}
-
-bool FontDataTable::Builder::modelChanged() {
-  return model_changed_;
-}
-
-bool FontDataTable::Builder::setModelChanged() {
-  return setModelChanged(true);
-}
-
-bool FontDataTable::Builder::setModelChanged(bool changed) {
-  bool old = model_changed_;
-  model_changed_ = changed;
-  return old;
-}
-
-void FontDataTable::Builder::notifyPostTableBuild(FontDataTable* table) {
-  // default: NOP
-  UNREFERENCED_PARAMETER(table);
-}
-
 }  // namespace sfntly
diff --git a/sfntly/font_data_table.h b/sfntly/font_data_table.h
index 28bec15..9b3b467 100644
--- a/sfntly/font_data_table.h
+++ b/sfntly/font_data_table.h
@@ -25,75 +25,58 @@
 
 class FontDataTable : virtual public RefCount {
  public:
-  explicit FontDataTable(ReadableFontData* data);
-  virtual ~FontDataTable();
-
-  // Get the readable font data for this table.
-  ReadableFontData* readFontData();
-
-  // Get the length of the data for this table in bytes. This is the full
-  // allocated length of the data and may or may not include any padding.
-  virtual int32_t length();
-
-  // Get the number of bytes of padding used in the table. The padding bytes are
-  // used to align the table length to a 4 byte boundary.
-  virtual int32_t padding();
-
-  // Return the number of bytes of non-padded data in the table. If the padding
-  // is unknown or unknowable then the total number of bytes of data in the
-  // tables is returned.
-  virtual int32_t dataLength();
-
-  virtual int32_t serialize(OutputStream* os);
-
- public:
   // Note: original version is abstract Builder<T extends FontDataTable>
   //       C++ template is not designed that way so plain class is chosen.
   class Builder : virtual public RefCount {
-   protected:
-    explicit Builder(FontDataTableBuilderContainer* container);
-    Builder(FontDataTableBuilderContainer* container, WritableFontData* data);
-    Builder(FontDataTableBuilderContainer* container, ReadableFontData* data);
-    virtual ~Builder();
-
-    void init(FontDataTableBuilderContainer* container);
-
    public:
     // Get a snapshot copy of the internal data of the builder.
     // This causes any internal data structures to be serialized to a new data
     // object. This data object belongs to the caller and must be properly
     // disposed of. No changes are made to the builder and any changes to the
     // data directly do not affect the internal state. To do that a subsequent
-    // call must be made to {@link #setData(WritableFontData)}.
+    // call must be made to {@link #SetData(WritableFontData)}.
     // @return a copy of the internal data of the builder
-    WritableFontData* data();
-    virtual void setData(ReadableFontData* data);
+    CALLER_ATTACH WritableFontData* Data();
+    virtual void SetData(ReadableFontData* data);
 
-   private:
-    void internalSetData(WritableFontData* data, bool data_changed);
-    void internalSetData(ReadableFontData* data, bool data_changed);
+    // Note: changed from protected to avoid accessibility error in C++
+    virtual CALLER_ATTACH FontDataTable* Build();
+    virtual bool ReadyToBuild();
 
-   public:  // Note: changed from protected to avoid accessibility error in C++
-    virtual FontDataTable* build();
-    virtual bool readyToBuild();
-    virtual ReadableFontData* internalReadData();
-    virtual WritableFontData* internalWriteData();
-    virtual WritableFontData* internalNewData(int32_t size);
-    virtual bool dataChanged();
-    virtual bool modelChanged();
-    virtual bool setModelChanged();
-    virtual bool setModelChanged(bool changed);
+    ReadableFontData* InternalReadData();
+    WritableFontData* InternalWriteData();
+    CALLER_ATTACH WritableFontData* InternalNewData(int32_t size);
 
-   protected:  // subclass API
-    virtual void notifyPostTableBuild(FontDataTable* table);
-    virtual int32_t subSerialize(WritableFontData* new_data) = 0;
-    virtual bool subReadyToSerialize() = 0;
-    virtual int32_t subDataSizeToSerialize() = 0;
-    virtual void subDataSet() = 0;
+    bool data_changed() { return data_changed_; }
+    bool modelChanged() { return model_changed_; }
+    bool set_model_changed() { return set_model_changed(true); }
+    bool set_model_changed(bool changed) {
+      bool old = model_changed_;
+      model_changed_ = changed;
+      return old;
+    }
+
+   protected:
+    explicit Builder(FontDataTableBuilderContainer* container);
+    Builder(FontDataTableBuilderContainer* container, WritableFontData* data);
+    Builder(FontDataTableBuilderContainer* container, ReadableFontData* data);
+    virtual ~Builder();
+
+    void Init(FontDataTableBuilderContainer* container);
+
+    // subclass API
+    virtual void NotifyPostTableBuild(FontDataTable* table);
+    virtual int32_t SubSerialize(WritableFontData* new_data) = 0;
+    virtual bool SubReadyToSerialize() = 0;
+    virtual int32_t SubDataSizeToSerialize() = 0;
+    virtual void SubDataSet() = 0;
     virtual CALLER_ATTACH FontDataTable*
-        subBuildTable(ReadableFontData* data) = 0;
+        SubBuildTable(ReadableFontData* data) = 0;
 
    private:
+    void InternalSetData(WritableFontData* data, bool data_changed);
+    void InternalSetData(ReadableFontData* data, bool data_changed);
+
     FontDataTableBuilderContainer* container_;  // avoid circular ref-counting
     WritableFontDataPtr w_data_;
     ReadableFontDataPtr r_data_;
@@ -101,7 +84,29 @@
     bool data_changed_;
   };
 
+  explicit FontDataTable(ReadableFontData* data);
+  virtual ~FontDataTable();
+
+  // Get the readable font data for this table.
+  ReadableFontData* ReadFontData();
+
+  // Get the length of the data for this table in bytes. This is the full
+  // allocated length of the data and may or may not include any padding.
+  virtual int32_t Length();
+
+  // Get the number of bytes of padding used in the table. The padding bytes are
+  // used to align the table length to a 4 byte boundary.
+  virtual int32_t Padding();
+
+  // Return the number of bytes of non-padded data in the table. If the padding
+  // is unknown or unknowable then the total number of bytes of data in the
+  // tables is returned.
+  virtual int32_t DataLength();
+
+  virtual int32_t Serialize(OutputStream* os);
+
  protected:
+  // TODO(arthurhsu): style guide violation: protected member, need refactoring
   ReadableFontDataPtr data_;
 };
 typedef Ptr<FontDataTable> FontDataTablePtr;
diff --git a/sfntly/font_data_table_builder_container.h b/sfntly/font_data_table_builder_container.h
index 7866a36..f3ccf61 100644
--- a/sfntly/font_data_table_builder_container.h
+++ b/sfntly/font_data_table_builder_container.h
@@ -23,7 +23,7 @@
 
 class FontDataTableBuilderContainer {
  public:
-  virtual WritableFontData* getNewData(int32_t size) = 0;
+  virtual WritableFontData* GetNewData(int32_t size) = 0;
   // Make gcc -Wnon-virtual-dtor happy.
   virtual ~FontDataTableBuilderContainer() {}
 };
diff --git a/sfntly/font_factory.cc b/sfntly/font_factory.cc
index b741f0a..d5b2397 100644
--- a/sfntly/font_factory.cc
+++ b/sfntly/font_factory.cc
@@ -14,229 +14,233 @@
  * limitations under the License.
  */
 
+#include "sfntly/font_factory.h"
+
 #include <string.h>
 
-#include "sfntly/font_factory.h"
 #include "sfntly/tag.h"
 #include "sfntly/data/memory_byte_array.h"
 #include "sfntly/data/growable_memory_byte_array.h"
 
 namespace sfntly {
 
-FontFactory::FontFactory() : fingerprint_(false) {
-}
-
 FontFactory::~FontFactory() {
 }
 
-CALLER_ATTACH FontFactory* FontFactory::getInstance() {
+CALLER_ATTACH FontFactory* FontFactory::GetInstance() {
   FontFactoryPtr instance = new FontFactory();
-  return instance.detach();
+  return instance.Detach();
 }
 
-void FontFactory::fingerprintFont(bool fingerprint) {
+void FontFactory::FingerprintFont(bool fingerprint) {
   fingerprint_ = fingerprint;
 }
 
-bool FontFactory::fingerprintFont() {
+bool FontFactory::FingerprintFont() {
   return fingerprint_;
 }
 
-void FontFactory::loadFonts(InputStream* is, FontArray* output) {
+void FontFactory::LoadFonts(InputStream* is, FontArray* output) {
   assert(output);
   PushbackInputStream* pbis = down_cast<PushbackInputStream*>(is);
-  if (isCollection(pbis)) {
-    loadCollection(pbis, output);
+  if (IsCollection(pbis)) {
+    LoadCollection(pbis, output);
     return;
   }
-  FontPtr font = loadSingleOTF(pbis);
+  FontPtr font = LoadSingleOTF(pbis);
   if (font) {
     output->push_back(font);
   }
 }
 
-void FontFactory::loadFontsForBuilding(InputStream* is,
+void FontFactory::LoadFonts(ByteArray* ba, FontArray* output) {
+  if (IsCollection(ba)) {
+    LoadCollection(ba, output);
+    return;
+  }
+  FontPtr font;
+  font.Attach(LoadSingleOTF(ba));
+  if (font) {
+    output->push_back(font);
+  }
+}
+
+void FontFactory::LoadFontsForBuilding(InputStream* is,
                                        FontBuilderArray* output) {
   PushbackInputStream* pbis = down_cast<PushbackInputStream*>(is);
-  if (isCollection(pbis)) {
-    loadCollectionForBuilding(pbis, output);
+  if (IsCollection(pbis)) {
+    LoadCollectionForBuilding(pbis, output);
     return;
   }
   FontBuilderPtr builder;
-  builder.attach(loadSingleOTFForBuilding(pbis));
+  builder.Attach(LoadSingleOTFForBuilding(pbis));
   if (builder) {
     output->push_back(builder);
   }
 }
 
-Font* FontFactory::loadSingleOTF(InputStream* is) {
+void FontFactory::LoadFontsForBuilding(ByteArray* ba,
+                                       FontBuilderArray* output) {
+  if (IsCollection(ba)) {
+    LoadCollectionForBuilding(ba, output);
+    return;
+  }
   FontBuilderPtr builder;
-  builder.attach(loadSingleOTFForBuilding(is));
-  return builder->build();
+  builder.Attach(LoadSingleOTFForBuilding(ba, 0));
+  if (builder) {
+    output->push_back(builder);
+  }
 }
 
-void FontFactory::loadCollection(InputStream* is, FontArray* output) {
+CALLER_ATTACH WritableFontData* FontFactory::GetNewData(int32_t capacity) {
+  // UNIMPLMENTED: if (capacity > 0) { this.GetNewFixedData(capacity); }
+  // Seems a no-op.
+  return GetNewGrowableData(capacity);
+}
+
+CALLER_ATTACH WritableFontData* FontFactory::GetNewFixedData(int32_t capacity) {
+  ByteArrayPtr buffer;
+  buffer.Attach(GetNewArray(capacity));
+  WritableFontDataPtr new_fixed_data = new WritableFontData(buffer);
+  return new_fixed_data.Detach();
+}
+
+CALLER_ATTACH WritableFontData* FontFactory::GetNewGrowableData(
+    int32_t capacity) {
+  ByteArrayPtr buffer;
+  buffer.Attach(GetNewGrowableArray(capacity));
+  WritableFontDataPtr new_growable_data = new WritableFontData(buffer);
+  return new_growable_data.Detach();
+}
+
+CALLER_ATTACH WritableFontData* FontFactory::GetNewGrowableData(
+    ReadableFontData* src_data) {
+  WritableFontDataPtr data;
+  data.Attach(GetNewGrowableData(src_data->Length()));
+  src_data->CopyTo(data);
+  return data.Detach();
+}
+
+CALLER_ATTACH ByteArray* FontFactory::GetNewArray(int32_t length) {
+  ByteArrayPtr new_fixed_array = new MemoryByteArray(length);
+  return new_fixed_array.Detach();
+}
+
+CALLER_ATTACH ByteArray* FontFactory::GetNewGrowableArray(int32_t length) {
+  UNREFERENCED_PARAMETER(length);
+  ByteArrayPtr new_growable_array = new GrowableMemoryByteArray();
+  return new_growable_array.Detach();
+}
+
+void FontFactory::SerializeFont(Font* font, OutputStream* os) {
+  font->Serialize(os, &table_ordering_);
+}
+
+void FontFactory::SetSerializationTableOrdering(
+    const IntegerList& table_ordering) {
+  table_ordering_ = table_ordering;
+}
+
+CALLER_ATTACH Font::Builder* FontFactory::NewFontBuilder() {
+  return Font::Builder::GetOTFBuilder(this);
+}
+
+CALLER_ATTACH Font* FontFactory::LoadSingleOTF(InputStream* is) {
+  FontBuilderPtr builder;
+  builder.Attach(LoadSingleOTFForBuilding(is));
+  return builder->Build();
+}
+
+CALLER_ATTACH Font* FontFactory::LoadSingleOTF(ByteArray* ba) {
+  FontBuilderPtr builder;
+  builder.Attach(LoadSingleOTFForBuilding(ba, 0));
+  return builder->Build();
+}
+
+void FontFactory::LoadCollection(InputStream* is, FontArray* output) {
   FontBuilderArray ba;
-  loadCollectionForBuilding(is, &ba);
+  LoadCollectionForBuilding(is, &ba);
   output->reserve(ba.size());
   for (FontBuilderArray::iterator builder = ba.begin(), builders_end = ba.end();
                                   builder != builders_end; ++builder) {
       FontPtr font;
-      font.attach((*builder)->build());
+      font.Attach((*builder)->Build());
       output->push_back(font);
   }
 }
 
-Font::Builder* FontFactory::loadSingleOTFForBuilding(InputStream* is) {
-  // UNIMPLEMENTED: SHA-1 hash checking via Java DigestStream
-  Font::Builder* builder = Font::Builder::getOTFBuilder(this, is);
-  // UNIMPLEMENTED: setDigest
-  return builder;
-}
-
-void FontFactory::loadCollectionForBuilding(InputStream* is,
-                                            FontBuilderArray* builders) {
-  ByteArrayPtr ba = new GrowableMemoryByteArray();
-  ba->copyFrom(is);
-  loadCollectionForBuilding(ba, builders);
-}
-
-bool FontFactory::isCollection(PushbackInputStream* pbis) {
-  ByteVector tag(4);
-  pbis->read(&tag);
-  pbis->unread(&tag);
-  return Tag::ttcf == generate_tag(tag[0], tag[1], tag[2], tag[3]);
-}
-
-void FontFactory::loadFonts(ByteArray* ba, FontArray* output) {
-  if (isCollection(ba)) {
-    loadCollection(ba, output);
-    return;
-  }
-  FontPtr font;
-  font.attach(loadSingleOTF(ba));
-  if (font) {
-    output->push_back(font);
-  }
-}
-
-void FontFactory::loadFontsForBuilding(ByteArray* ba,
-                                       FontBuilderArray* output) {
-  if (isCollection(ba)) {
-    loadCollectionForBuilding(ba, output);
-    return;
-  }
-  FontBuilderPtr builder;
-  builder.attach(loadSingleOTFForBuilding(ba, 0));
-  if (builder) {
-    output->push_back(builder);
-  }
-}
-
-Font* FontFactory::loadSingleOTF(ByteArray* ba) {
-  FontBuilderPtr builder;
-  builder.attach(loadSingleOTFForBuilding(ba, 0));
-  return builder->build();
-}
-
-void FontFactory::loadCollection(ByteArray* ba, FontArray* output) {
+void FontFactory::LoadCollection(ByteArray* ba, FontArray* output) {
   FontBuilderArray builders;
-  loadCollectionForBuilding(ba, &builders);
-  output->reserve(ba->size());
+  LoadCollectionForBuilding(ba, &builders);
+  output->reserve(ba->Size());
   for (FontBuilderArray::iterator
-       builder = builders.begin(), builders_end = builders.end();
+           builder = builders.begin(), builders_end = builders.end();
        builder != builders_end; ++builder) {
     FontPtr font;
-    font.attach((*builder)->build());
+    font.Attach((*builder)->Build());
     output->push_back(font);
   }
 }
 
-Font::Builder* FontFactory::loadSingleOTFForBuilding(ByteArray* ba,
-    int32_t offset_to_offset_table) {
+CALLER_ATTACH Font::Builder*
+    FontFactory::LoadSingleOTFForBuilding(InputStream* is) {
   // UNIMPLEMENTED: SHA-1 hash checking via Java DigestStream
-  Font::Builder* builder =
-      Font::Builder::getOTFBuilder(this, ba, offset_to_offset_table);
+  Font::Builder* builder = Font::Builder::GetOTFBuilder(this, is);
   // UNIMPLEMENTED: setDigest
   return builder;
 }
 
-void FontFactory::loadCollectionForBuilding(ByteArray* ba,
+CALLER_ATTACH Font::Builder*
+    FontFactory::LoadSingleOTFForBuilding(ByteArray* ba,
+                                          int32_t offset_to_offset_table) {
+  // UNIMPLEMENTED: SHA-1 hash checking via Java DigestStream
+  Font::Builder* builder =
+      Font::Builder::GetOTFBuilder(this, ba, offset_to_offset_table);
+  // UNIMPLEMENTED: setDigest
+  return builder;
+}
+
+void FontFactory::LoadCollectionForBuilding(InputStream* is,
+                                            FontBuilderArray* builders) {
+  ByteArrayPtr ba = new GrowableMemoryByteArray();
+  ba->CopyFrom(is);
+  LoadCollectionForBuilding(ba, builders);
+}
+
+void FontFactory::LoadCollectionForBuilding(ByteArray* ba,
                                             FontBuilderArray* builders) {
   ReadableFontDataPtr rfd = new ReadableFontData(ba);
-  int32_t ttc_tag = rfd->readULongAsInt(Offset::kTTCTag);
+  int32_t ttc_tag = rfd->ReadULongAsInt(Offset::kTTCTag);
   UNREFERENCED_PARAMETER(ttc_tag);
-  int32_t version = rfd->readFixed(Offset::kVersion);
+  int32_t version = rfd->ReadFixed(Offset::kVersion);
   UNREFERENCED_PARAMETER(version);
-  int32_t num_fonts = rfd->readULongAsInt(Offset::kNumFonts);
+  int32_t num_fonts = rfd->ReadULongAsInt(Offset::kNumFonts);
 
   builders->reserve(num_fonts);
   int32_t offset_table_offset = Offset::kOffsetTable;
   for (int32_t font_number = 0; font_number < num_fonts;
        font_number++, offset_table_offset += DataSize::kULONG) {
-    int32_t offset = rfd->readULongAsInt(offset_table_offset);
+    int32_t offset = rfd->ReadULongAsInt(offset_table_offset);
     FontBuilderPtr builder;
-    builder.attach(loadSingleOTFForBuilding(ba, offset));
+    builder.Attach(LoadSingleOTFForBuilding(ba, offset));
     builders->push_back(builder);
   }
 }
 
-bool FontFactory::isCollection(ByteArray* ba) {
+bool FontFactory::IsCollection(PushbackInputStream* pbis) {
+  ByteVector tag(4);
+  pbis->Read(&tag);
+  pbis->Unread(&tag);
+  return Tag::ttcf == GenerateTag(tag[0], tag[1], tag[2], tag[3]);
+}
+
+bool FontFactory::IsCollection(ByteArray* ba) {
   return Tag::ttcf ==
-         generate_tag(ba->get(0), ba->get(1), ba->get(2), ba->get(3));
+         GenerateTag(ba->Get(0), ba->Get(1), ba->Get(2), ba->Get(3));
 }
 
-CALLER_ATTACH WritableFontData* FontFactory::getNewData(int32_t capacity) {
-  // UNIMPLMENTED: if (capacity > 0) { this.getNewFixedData(capacity); }
-  // seems a no-op
-  return getNewGrowableData(capacity);
-}
-
-CALLER_ATTACH WritableFontData* FontFactory::getNewFixedData(int32_t capacity) {
-  ByteArrayPtr buffer;
-  buffer.attach(getNewArray(capacity));
-  WritableFontDataPtr new_fixed_data = new WritableFontData(buffer);
-  return new_fixed_data.detach();
-}
-
-CALLER_ATTACH WritableFontData* FontFactory::getNewGrowableData(
-    int32_t capacity) {
-  ByteArrayPtr buffer;
-  buffer.attach(getNewGrowableArray(capacity));
-  WritableFontDataPtr new_growable_data = new WritableFontData(buffer);
-  return new_growable_data.detach();
-}
-
-CALLER_ATTACH WritableFontData* FontFactory::getNewGrowableData(
-    ReadableFontData* src_data) {
-  WritableFontDataPtr data;
-  data.attach(getNewGrowableData(src_data->length()));
-  src_data->copyTo(data);
-  return data.detach();
-}
-
-CALLER_ATTACH ByteArray* FontFactory::getNewArray(int32_t length) {
-  ByteArrayPtr new_fixed_array = new MemoryByteArray(length);
-  return new_fixed_array.detach();
-}
-
-CALLER_ATTACH ByteArray* FontFactory::getNewGrowableArray(int32_t length) {
-  UNREFERENCED_PARAMETER(length);
-  ByteArrayPtr new_growable_array = new GrowableMemoryByteArray();
-  return new_growable_array.detach();
-}
-
-void FontFactory::serializeFont(Font* font, OutputStream* os) {
-  font->serialize(os, &table_ordering_);
-}
-
-void FontFactory::setSerializationTableOrdering(
-    const IntegerList& table_ordering) {
-  table_ordering_ = table_ordering;
-}
-
-CALLER_ATTACH Font::Builder* FontFactory::newFontBuilder() {
-  return Font::Builder::getOTFBuilder(this);
+FontFactory::FontFactory()
+    : fingerprint_(false) {
 }
 
 }  // namespace sfntly
diff --git a/sfntly/font_factory.h b/sfntly/font_factory.h
index 907ea66..7be0841 100644
--- a/sfntly/font_factory.h
+++ b/sfntly/font_factory.h
@@ -26,20 +26,92 @@
 namespace sfntly {
 
 class FontFactory : public RefCounted<FontFactory> {
+ public:
+  virtual ~FontFactory();
+
+  // Factory method for the construction of a font factory.
+  static CALLER_ATTACH FontFactory* GetInstance();
+
+  // Toggle whether fonts that are loaded are fingerprinted with a SHA-1 hash.
+  // If a font is fingerprinted then a SHA-1 hash is generated at load time and
+  // stored in the font. This is useful for uniquely identifying fonts. By
+  // default this is turned on.
+  // @param fingerprint whether fingerprinting should be turned on or off
+  // TODO(arthurhsu): IMPLEMENT: C++ port currently don't do any SHA-1
+  void FingerprintFont(bool fingerprint);
+  bool FingerprintFont();
+
+  // Load the font(s) from the input stream. The current settings on the factory
+  // are used during the loading process. One or more fonts are returned if the
+  // stream contains valid font data. Some font container formats may have more
+  // than one font and in this case multiple font objects will be returned. If
+  // the data in the stream cannot be parsed or is invalid an array of size zero
+  // will be returned.
+  void LoadFonts(InputStream* is, FontArray* output);
+
+  // ByteArray font loading
+  // Load the font(s) from the byte array. The current settings on the factory
+  // are used during the loading process. One or more fonts are returned if the
+  // stream contains valid font data. Some font container formats may have more
+  // than one font and in this case multiple font objects will be returned. If
+  // the data in the stream cannot be parsed or is invalid an array of size zero
+  // will be returned.
+  void LoadFonts(ByteArray* ba, FontArray* output);
+
+  // Load the font(s) from the input stream into font builders. The current
+  // settings on the factory are used during the loading process. One or more
+  // font builders are returned if the stream contains valid font data. Some
+  // font container formats may have more than one font and in this case
+  // multiple font builder objects will be returned. If the data in the stream
+  // cannot be parsed or is invalid an array of size zero will be returned.
+  void LoadFontsForBuilding(InputStream* is, FontBuilderArray* output);
+
+  // Load the font(s) from the byte array into font builders. The current
+  // settings on the factory are used during the loading process. One or more
+  // font builders are returned if the stream contains valid font data. Some
+  // font container formats may have more than one font and in this case
+  // multiple font builder objects will be returned. If the data in the stream
+  // cannot be parsed or is invalid an array of size zero will be returned.
+  void LoadFontsForBuilding(ByteArray* ba, FontBuilderArray* output);
+
+  CALLER_ATTACH WritableFontData* GetNewData(int32_t capacity);
+  CALLER_ATTACH WritableFontData* GetNewFixedData(int32_t capacity);
+  CALLER_ATTACH WritableFontData* GetNewGrowableData(int32_t capacity);
+  CALLER_ATTACH WritableFontData*
+      GetNewGrowableData(ReadableFontData* src_data);
+  CALLER_ATTACH ByteArray* GetNewArray(int32_t length);
+  CALLER_ATTACH ByteArray* GetNewGrowableArray(int32_t length);
+
+  // Font serialization
+  // Serialize the font to the output stream.
+  // NOTE: in this port we attempted not to implement I/O stream because dealing
+  //       with cross-platform I/O stream itself is big enough as a project.
+  //       Byte buffer it is.
+  void SerializeFont(Font* font, OutputStream* os);
+
+  // Set the table ordering to be used in serializing a font. The table ordering
+  // is an ordered list of table ids and tables will be serialized in the order
+  // given. Any tables whose id is not listed in the ordering will be placed in
+  // an unspecified order following those listed.
+  void SetSerializationTableOrdering(const IntegerList& table_ordering);
+
+  // Get an empty font builder for creating a new font from scratch.
+  CALLER_ATTACH Font::Builder* NewFontBuilder();
+
  private:
   // Offsets to specific elements in the underlying data. These offsets are
   // relative to the start of the table or the start of sub-blocks within the
   // table.
   struct Offset {
     enum {
-      // Offsets within the main directory
+      // Offsets within the main directory.
       kTTCTag = 0,
       kVersion = 4,
       kNumFonts = 8,
       kOffsetTable = 12,
 
-      // TTC Version 2.0 extensions
-      // offsets from end of OffsetTable
+      // TTC Version 2.0 extensions.
+      // Offsets from end of OffsetTable.
       kulDsigTag = 0,
       kulDsigLength = 4,
       kulDsigOffset = 8
@@ -48,97 +120,22 @@
 
   FontFactory();
 
- public:  // class is final, no virtual functions unless from parent
-  virtual ~FontFactory();
+  CALLER_ATTACH Font* LoadSingleOTF(InputStream* is);
+  CALLER_ATTACH Font* LoadSingleOTF(ByteArray* ba);
 
-  // Factory method for the construction of a font factory.
-  static CALLER_ATTACH FontFactory* getInstance();
+  void LoadCollection(InputStream* is, FontArray* output);
+  void LoadCollection(ByteArray* ba, FontArray* output);
 
-  // Toggle whether fonts that are loaded are fingerprinted with a SHA-1 hash.
-  // If a font is fingerprinted then a SHA-1 hash is generated at load time and
-  // stored in the font. This is useful for uniquely identifying fonts. By
-  // default this is turned on.
-  // @param fingerprint whether fingerprinting should be turned on or off
-  // TODO(arthurhsu): IMPLEMENT: C++ port currently don't do any SHA-1
-  void fingerprintFont(bool fingerprint);
-  bool fingerprintFont();
-
-  // Load the font(s) from the input stream. The current settings on the factory
-  // are used during the loading process. One or more fonts are returned if the
-  // stream contains valid font data. Some font container formats may have more
-  // than one font and in this case multiple font objects will be returned. If
-  // the data in the stream cannot be parsed or is invalid an array of size zero
-  // will be returned.
-  void loadFonts(InputStream* is, FontArray* output);
-
-  // Load the font(s) from the input stream into font builders. The current
-  // settings on the factory are used during the loading process. One or more
-  // font builders are returned if the stream contains valid font data. Some
-  // font container formats may have more than one font and in this case
-  // multiple font builder objects will be returned. If the data in the stream
-  // cannot be parsed or is invalid an array of size zero will be returned.
-  void loadFontsForBuilding(InputStream* is, FontBuilderArray* output);
-
- private:
-  Font* loadSingleOTF(InputStream* is);
-  void loadCollection(InputStream* is, FontArray* output);
-  Font::Builder* loadSingleOTFForBuilding(InputStream* is);
-  void loadCollectionForBuilding(InputStream* is, FontBuilderArray* builders);
-  static bool isCollection(PushbackInputStream* pbis);
-
- public:
-  // ByteArray font loading
-  // Load the font(s) from the byte array. The current settings on the factory
-  // are used during the loading process. One or more fonts are returned if the
-  // stream contains valid font data. Some font container formats may have more
-  // than one font and in this case multiple font objects will be returned. If
-  // the data in the stream cannot be parsed or is invalid an array of size zero
-  // will be returned.
-  void loadFonts(ByteArray* ba, FontArray* output);
-
-  // Load the font(s) from the byte array into font builders. The current
-  // settings on the factory are used during the loading process. One or more
-  // font builders are returned if the stream contains valid font data. Some
-  // font container formats may have more than one font and in this case
-  // multiple font builder objects will be returned. If the data in the stream
-  // cannot be parsed or is invalid an array of size zero will be returned.
-  void loadFontsForBuilding(ByteArray* ba, FontBuilderArray* output);
-
- private:
-  CALLER_ATTACH Font* loadSingleOTF(ByteArray* ba);
-  void loadCollection(ByteArray* ba, FontArray* output);
+  CALLER_ATTACH Font::Builder* LoadSingleOTFForBuilding(InputStream* is);
   CALLER_ATTACH Font::Builder*
-      loadSingleOTFForBuilding(ByteArray* ba, int32_t offset_to_offset_table);
-  void loadCollectionForBuilding(ByteArray* ba, FontBuilderArray* builders);
-  static bool isCollection(ByteArray* ba);
+      LoadSingleOTFForBuilding(ByteArray* ba, int32_t offset_to_offset_table);
 
- public:
-  CALLER_ATTACH WritableFontData* getNewData(int32_t capacity);
-  CALLER_ATTACH WritableFontData* getNewFixedData(int32_t capacity);
-  CALLER_ATTACH WritableFontData* getNewGrowableData(int32_t capacity);
-  CALLER_ATTACH WritableFontData*
-      getNewGrowableData(ReadableFontData* src_data);
-  CALLER_ATTACH ByteArray* getNewArray(int32_t length);
-  CALLER_ATTACH ByteArray* getNewGrowableArray(int32_t length);
+  void LoadCollectionForBuilding(InputStream* is, FontBuilderArray* builders);
+  void LoadCollectionForBuilding(ByteArray* ba, FontBuilderArray* builders);
 
- public:
-  // Font serialization
-  // Serialize the font to the output stream.
-  // NOTE: in this port we attempted not to implement I/O stream because dealing
-  //       with cross-platform I/O stream itself is big enough as a project.
-  //       Byte buffer it is.
-  void serializeFont(Font* font, OutputStream* os);
+  static bool IsCollection(PushbackInputStream* pbis);
+  static bool IsCollection(ByteArray* ba);
 
-  // Set the table ordering to be used in serializing a font. The table ordering
-  // is an ordered list of table ids and tables will be serialized in the order
-  // given. Any tables whose id is not listed in the ordering will be placed in
-  // an unspecified order following those listed.
-  void setSerializationTableOrdering(const IntegerList& table_ordering);
-
-  // Get an empty font builder for creating a new font from scratch.
-  CALLER_ATTACH Font::Builder* newFontBuilder();
-
- private:
   bool fingerprint_;
   IntegerList table_ordering_;
 };
diff --git a/sfntly/font_header_table.cc b/sfntly/font_header_table.cc
index 7710c5a..f896001 100644
--- a/sfntly/font_header_table.cc
+++ b/sfntly/font_header_table.cc
@@ -20,83 +20,83 @@
 /******************************************************************************
  * FontHeaderTable class
  ******************************************************************************/
+FontHeaderTable::~FontHeaderTable() {}
+
+int32_t FontHeaderTable::TableVersion() {
+  return data_->ReadFixed(Offset::kTableVersion);
+}
+
+int32_t FontHeaderTable::FontRevision() {
+  return data_->ReadFixed(Offset::kFontRevision);
+}
+
+int64_t FontHeaderTable::ChecksumAdjustment() {
+  return data_->ReadULong(Offset::kCheckSumAdjustment);
+}
+
+int64_t FontHeaderTable::MagicNumber() {
+  return data_->ReadULong(Offset::kMagicNumber);
+}
+
+int32_t FontHeaderTable::FlagsAsInt() {
+  return data_->ReadUShort(Offset::kFlags);
+}
+
+int32_t FontHeaderTable::UnitsPerEm() {
+  return data_->ReadUShort(Offset::kUnitsPerEm);
+}
+
+int64_t FontHeaderTable::Created() {
+  return data_->ReadDateTimeAsLong(Offset::kCreated);
+}
+
+int64_t FontHeaderTable::Modified() {
+  return data_->ReadDateTimeAsLong(Offset::kModified);
+}
+
+int32_t FontHeaderTable::XMin() {
+  return data_->ReadUShort(Offset::kXMin);
+}
+
+int32_t FontHeaderTable::YMin() {
+  return data_->ReadUShort(Offset::kYMin);
+}
+
+int32_t FontHeaderTable::XMax() {
+  return data_->ReadUShort(Offset::kXMax);
+}
+
+int32_t FontHeaderTable::YMax() {
+  return data_->ReadUShort(Offset::kYMax);
+}
+
+int32_t FontHeaderTable::MacStyleAsInt() {
+  return data_->ReadUShort(Offset::kMacStyle);
+}
+
+int32_t FontHeaderTable::LowestRecPPEM() {
+  return data_->ReadUShort(Offset::kLowestRecPPEM);
+}
+
+int32_t FontHeaderTable::FontDirectionHint() {
+  return data_->ReadShort(Offset::kFontDirectionHint);
+}
+
+int32_t FontHeaderTable::IndexToLocFormat() {
+  return data_->ReadShort(Offset::kIndexToLocFormat);
+}
+
+int32_t FontHeaderTable::GlyphDataFormat() {
+  return data_->ReadShort(Offset::kGlyphDataFormat);
+}
+
 FontHeaderTable::FontHeaderTable(Header* header, ReadableFontData* data)
     : Table(header, data) {
   IntegerList checksum_ranges;
   checksum_ranges.push_back(0);
   checksum_ranges.push_back(Offset::kCheckSumAdjustment);
   checksum_ranges.push_back(Offset::kMagicNumber);
-  data_->setCheckSumRanges(checksum_ranges);
-}
-
-FontHeaderTable::~FontHeaderTable() {}
-
-int32_t FontHeaderTable::tableVersion() {
-  return data_->readFixed(Offset::kTableVersion);
-}
-
-int32_t FontHeaderTable::fontRevision() {
-  return data_->readFixed(Offset::kFontRevision);
-}
-
-int64_t FontHeaderTable::checksumAdjustment() {
-  return data_->readULong(Offset::kCheckSumAdjustment);
-}
-
-int64_t FontHeaderTable::magicNumber() {
-  return data_->readULong(Offset::kMagicNumber);
-}
-
-int32_t FontHeaderTable::flagsAsInt() {
-  return data_->readUShort(Offset::kFlags);
-}
-
-int32_t FontHeaderTable::unitsPerEm() {
-  return data_->readUShort(Offset::kUnitsPerEm);
-}
-
-int64_t FontHeaderTable::created() {
-  return data_->readDateTimeAsLong(Offset::kCreated);
-}
-
-int64_t FontHeaderTable::modified() {
-  return data_->readDateTimeAsLong(Offset::kModified);
-}
-
-int32_t FontHeaderTable::xMin() {
-  return data_->readUShort(Offset::kXMin);
-}
-
-int32_t FontHeaderTable::yMin() {
-  return data_->readUShort(Offset::kYMin);
-}
-
-int32_t FontHeaderTable::xMax() {
-  return data_->readUShort(Offset::kXMax);
-}
-
-int32_t FontHeaderTable::yMax() {
-  return data_->readUShort(Offset::kYMax);
-}
-
-int32_t FontHeaderTable::macStyleAsInt() {
-  return data_->readUShort(Offset::kMacStyle);
-}
-
-int32_t FontHeaderTable::lowestRecPPEM() {
-  return data_->readUShort(Offset::kLowestRecPPEM);
-}
-
-int32_t FontHeaderTable::fontDirectionHint() {
-  return data_->readShort(Offset::kFontDirectionHint);
-}
-
-int32_t FontHeaderTable::indexToLocFormat() {
-  return data_->readShort(Offset::kIndexToLocFormat);
-}
-
-int32_t FontHeaderTable::glyphDataFormat() {
-  return data_->readShort(Offset::kGlyphDataFormat);
+  data_->SetCheckSumRanges(checksum_ranges);
 }
 
 /******************************************************************************
@@ -114,146 +114,146 @@
 
 FontHeaderTable::Builder::~Builder() {}
 
-CALLER_ATTACH FontDataTable* FontHeaderTable::Builder::subBuildTable(
+CALLER_ATTACH FontDataTable* FontHeaderTable::Builder::SubBuildTable(
     ReadableFontData* data) {
   FontDataTablePtr table = new FontHeaderTable(header(), data);
-  return table.detach();
+  return table.Detach();
 }
 
-int32_t FontHeaderTable::Builder::tableVersion() {
-  return down_cast<FontHeaderTable*>(table())->tableVersion();
+int32_t FontHeaderTable::Builder::TableVersion() {
+  return down_cast<FontHeaderTable*>(GetTable())->TableVersion();
 }
 
-void FontHeaderTable::Builder::setTableVersion(int32_t version) {
-  internalWriteData()->writeFixed(Offset::kTableVersion, version);
+void FontHeaderTable::Builder::SetTableVersion(int32_t version) {
+  InternalWriteData()->WriteFixed(Offset::kTableVersion, version);
 }
 
-int32_t FontHeaderTable::Builder::fontRevision() {
-  return down_cast<FontHeaderTable*>(table())->fontRevision();
+int32_t FontHeaderTable::Builder::FontRevision() {
+  return down_cast<FontHeaderTable*>(GetTable())->FontRevision();
 }
 
-void FontHeaderTable::Builder::setFontRevision(int32_t revision) {
-  internalWriteData()->writeFixed(Offset::kFontRevision, revision);
+void FontHeaderTable::Builder::SetFontRevision(int32_t revision) {
+  InternalWriteData()->WriteFixed(Offset::kFontRevision, revision);
 }
 
-int64_t FontHeaderTable::Builder::checksumAdjustment() {
-  return down_cast<FontHeaderTable*>(table())->checksumAdjustment();
+int64_t FontHeaderTable::Builder::ChecksumAdjustment() {
+  return down_cast<FontHeaderTable*>(GetTable())->ChecksumAdjustment();
 }
 
-void FontHeaderTable::Builder::setChecksumAdjustment(int64_t adjustment) {
-  internalWriteData()->writeULong(Offset::kCheckSumAdjustment, adjustment);
+void FontHeaderTable::Builder::SetChecksumAdjustment(int64_t adjustment) {
+  InternalWriteData()->WriteULong(Offset::kCheckSumAdjustment, adjustment);
 }
 
-int64_t FontHeaderTable::Builder::magicNumber() {
-  return down_cast<FontHeaderTable*>(table())->magicNumber();
+int64_t FontHeaderTable::Builder::MagicNumber() {
+  return down_cast<FontHeaderTable*>(GetTable())->MagicNumber();
 }
 
-void FontHeaderTable::Builder::setMagicNumber(int64_t magic_number) {
-  internalWriteData()->writeULong(Offset::kMagicNumber, magic_number);
+void FontHeaderTable::Builder::SetMagicNumber(int64_t magic_number) {
+  InternalWriteData()->WriteULong(Offset::kMagicNumber, magic_number);
 }
 
-int32_t FontHeaderTable::Builder::flagsAsInt() {
-  return down_cast<FontHeaderTable*>(table())->flagsAsInt();
+int32_t FontHeaderTable::Builder::FlagsAsInt() {
+  return down_cast<FontHeaderTable*>(GetTable())->FlagsAsInt();
 }
 
-void FontHeaderTable::Builder::setFlagsAsInt(int32_t flags) {
-  internalWriteData()->writeUShort(Offset::kFlags, flags);
+void FontHeaderTable::Builder::SetFlagsAsInt(int32_t flags) {
+  InternalWriteData()->WriteUShort(Offset::kFlags, flags);
 }
 
-int32_t FontHeaderTable::Builder::unitsPerEm() {
-  return down_cast<FontHeaderTable*>(table())->unitsPerEm();
+int32_t FontHeaderTable::Builder::UnitsPerEm() {
+  return down_cast<FontHeaderTable*>(GetTable())->UnitsPerEm();
 }
 
-void FontHeaderTable::Builder::setUnitsPerEm(int32_t units) {
-  internalWriteData()->writeUShort(Offset::kUnitsPerEm, units);
+void FontHeaderTable::Builder::SetUnitsPerEm(int32_t units) {
+  InternalWriteData()->WriteUShort(Offset::kUnitsPerEm, units);
 }
 
-int64_t FontHeaderTable::Builder::created() {
-  return down_cast<FontHeaderTable*>(table())->modified();
+int64_t FontHeaderTable::Builder::Created() {
+  return down_cast<FontHeaderTable*>(GetTable())->Created();
 }
 
-void FontHeaderTable::Builder::setCreated(int64_t date) {
-  internalWriteData()->writeDateTime(Offset::kCreated, date);
+void FontHeaderTable::Builder::SetCreated(int64_t date) {
+  InternalWriteData()->WriteDateTime(Offset::kCreated, date);
 }
 
-int64_t FontHeaderTable::Builder::modified() {
-  return down_cast<FontHeaderTable*>(table())->modified();
+int64_t FontHeaderTable::Builder::Modified() {
+  return down_cast<FontHeaderTable*>(GetTable())->Modified();
 }
 
-void FontHeaderTable::Builder::setModified(int64_t date) {
-  internalWriteData()->writeDateTime(Offset::kModified, date);
+void FontHeaderTable::Builder::SetModified(int64_t date) {
+  InternalWriteData()->WriteDateTime(Offset::kModified, date);
 }
 
-int32_t FontHeaderTable::Builder::xMin() {
-  return down_cast<FontHeaderTable*>(table())->xMin();
+int32_t FontHeaderTable::Builder::XMin() {
+  return down_cast<FontHeaderTable*>(GetTable())->XMin();
 }
 
-void FontHeaderTable::Builder::setXMin(int32_t xmin) {
-  internalWriteData()->writeShort(Offset::kXMin, xmin);
+void FontHeaderTable::Builder::SetXMin(int32_t xmin) {
+  InternalWriteData()->WriteShort(Offset::kXMin, xmin);
 }
 
-int32_t FontHeaderTable::Builder::yMin() {
-  return down_cast<FontHeaderTable*>(table())->yMin();
+int32_t FontHeaderTable::Builder::YMin() {
+  return down_cast<FontHeaderTable*>(GetTable())->YMin();
 }
 
-void FontHeaderTable::Builder::setYMin(int32_t ymin) {
-  internalWriteData()->writeShort(Offset::kYMin, ymin);
+void FontHeaderTable::Builder::SetYMin(int32_t ymin) {
+  InternalWriteData()->WriteShort(Offset::kYMin, ymin);
 }
 
-int32_t FontHeaderTable::Builder::xMax() {
-  return down_cast<FontHeaderTable*>(table())->xMax();
+int32_t FontHeaderTable::Builder::XMax() {
+  return down_cast<FontHeaderTable*>(GetTable())->XMax();
 }
 
-void FontHeaderTable::Builder::setXMax(int32_t xmax) {
-  internalWriteData()->writeShort(Offset::kXMax, xmax);
+void FontHeaderTable::Builder::SetXMax(int32_t xmax) {
+  InternalWriteData()->WriteShort(Offset::kXMax, xmax);
 }
 
-int32_t FontHeaderTable::Builder::yMax() {
-  return down_cast<FontHeaderTable*>(table())->yMax();
+int32_t FontHeaderTable::Builder::YMax() {
+  return down_cast<FontHeaderTable*>(GetTable())->YMax();
 }
 
-void FontHeaderTable::Builder::setYMax(int32_t ymax) {
-  internalWriteData()->writeShort(Offset::kYMax, ymax);
+void FontHeaderTable::Builder::SetYMax(int32_t ymax) {
+  InternalWriteData()->WriteShort(Offset::kYMax, ymax);
 }
 
-int32_t FontHeaderTable::Builder::macStyleAsInt() {
-  return down_cast<FontHeaderTable*>(table())->macStyleAsInt();
+int32_t FontHeaderTable::Builder::MacStyleAsInt() {
+  return down_cast<FontHeaderTable*>(GetTable())->MacStyleAsInt();
 }
 
-void FontHeaderTable::Builder::setMacStyleAsInt(int32_t style) {
-  internalWriteData()->writeUShort(Offset::kMacStyle, style);
+void FontHeaderTable::Builder::SetMacStyleAsInt(int32_t style) {
+  InternalWriteData()->WriteUShort(Offset::kMacStyle, style);
 }
 
-int32_t FontHeaderTable::Builder::lowestRecPPEM() {
-  return down_cast<FontHeaderTable*>(table())->lowestRecPPEM();
+int32_t FontHeaderTable::Builder::LowestRecPPEM() {
+  return down_cast<FontHeaderTable*>(GetTable())->LowestRecPPEM();
 }
 
-void FontHeaderTable::Builder::setLowestRecPPEM(int32_t size) {
-  internalWriteData()->writeUShort(Offset::kLowestRecPPEM, size);
+void FontHeaderTable::Builder::SetLowestRecPPEM(int32_t size) {
+  InternalWriteData()->WriteUShort(Offset::kLowestRecPPEM, size);
 }
 
-int32_t FontHeaderTable::Builder::fontDirectionHint() {
-  return down_cast<FontHeaderTable*>(table())->fontDirectionHint();
+int32_t FontHeaderTable::Builder::FontDirectionHint() {
+  return down_cast<FontHeaderTable*>(GetTable())->FontDirectionHint();
 }
 
-void FontHeaderTable::Builder::setFontDirectionHint(int32_t hint) {
-  internalWriteData()->writeShort(Offset::kFontDirectionHint, hint);
+void FontHeaderTable::Builder::SetFontDirectionHint(int32_t hint) {
+  InternalWriteData()->WriteShort(Offset::kFontDirectionHint, hint);
 }
 
-int32_t FontHeaderTable::Builder::indexToLocFormat() {
-  return down_cast<FontHeaderTable*>(table())->indexToLocFormat();
+int32_t FontHeaderTable::Builder::IndexToLocFormat() {
+  return down_cast<FontHeaderTable*>(GetTable())->IndexToLocFormat();
 }
 
-void FontHeaderTable::Builder::setIndexToLocFormat(int32_t format) {
-  internalWriteData()->writeShort(Offset::kIndexToLocFormat, format);
+void FontHeaderTable::Builder::SetIndexToLocFormat(int32_t format) {
+  InternalWriteData()->WriteShort(Offset::kIndexToLocFormat, format);
 }
 
-int32_t FontHeaderTable::Builder::glyphDataFormat() {
-  return down_cast<FontHeaderTable*>(table())->glyphDataFormat();
+int32_t FontHeaderTable::Builder::GlyphDataFormat() {
+  return down_cast<FontHeaderTable*>(GetTable())->GlyphDataFormat();
 }
 
-void FontHeaderTable::Builder::setGlyphDataFormat(int32_t format) {
-  internalWriteData()->writeShort(Offset::kGlyphDataFormat, format);
+void FontHeaderTable::Builder::SetGlyphDataFormat(int32_t format) {
+  InternalWriteData()->WriteShort(Offset::kGlyphDataFormat, format);
 }
 
 }  // namespace sfntly
diff --git a/sfntly/font_header_table.h b/sfntly/font_header_table.h
index c8aa9fe..dd6f593 100644
--- a/sfntly/font_header_table.h
+++ b/sfntly/font_header_table.h
@@ -39,6 +39,101 @@
 };
 
 class FontHeaderTable : public Table, public RefCounted<FontHeaderTable> {
+ public:
+  class Builder : public Table::TableBasedTableBuilder,
+                  public RefCounted<Builder> {
+   public:
+    // Constructor scope altered to public because C++ does not allow base
+    // class to instantiate derived class with protected constructors.
+    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+            WritableFontData* data);
+    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+            ReadableFontData* data);
+    virtual ~Builder();
+    virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
+
+    virtual int32_t TableVersion();
+    virtual void SetTableVersion(int32_t version);
+    virtual int32_t FontRevision();
+    virtual void SetFontRevision(int32_t revision);
+    virtual int64_t ChecksumAdjustment();
+    virtual void SetChecksumAdjustment(int64_t adjustment);
+    virtual int64_t MagicNumber();
+    virtual void SetMagicNumber(int64_t magic_number);
+    virtual int32_t FlagsAsInt();
+    virtual void SetFlagsAsInt(int32_t flags);
+    // TODO(arthurhsu): IMPLEMENT EnumSet<Flags> Flags()
+    // TODO(arthurhsu): IMPLEMENT setFlags(EnumSet<Flags> flags)
+    virtual int32_t UnitsPerEm();
+    virtual void SetUnitsPerEm(int32_t units);
+    virtual int64_t Created();
+    virtual void SetCreated(int64_t date);
+    virtual int64_t Modified();
+    virtual void SetModified(int64_t date);
+    virtual int32_t XMin();
+    virtual void SetXMin(int32_t xmin);
+    virtual int32_t YMin();
+    virtual void SetYMin(int32_t ymin);
+    virtual int32_t XMax();
+    virtual void SetXMax(int32_t xmax);
+    virtual int32_t YMax();
+    virtual void SetYMax(int32_t ymax);
+    virtual int32_t MacStyleAsInt();
+    virtual void SetMacStyleAsInt(int32_t style);
+    // TODO(arthurhsu): IMPLEMENT EnumSet<MacStyle> macStyle()
+    // TODO(arthurhsu): IMPLEMENT setMacStyle(EnumSet<MacStyle> style)
+    virtual int32_t LowestRecPPEM();
+    virtual void SetLowestRecPPEM(int32_t size);
+    virtual int32_t FontDirectionHint();
+    virtual void SetFontDirectionHint(int32_t hint);
+    virtual int32_t IndexToLocFormat();
+    virtual void SetIndexToLocFormat(int32_t format);
+    virtual int32_t GlyphDataFormat();
+    virtual void SetGlyphDataFormat(int32_t format);
+  };
+
+  virtual ~FontHeaderTable();
+  int32_t TableVersion();
+  int32_t FontRevision();
+
+  // Get the checksum adjustment. To compute: set it to 0, sum the entire font
+  // as ULONG, then store 0xB1B0AFBA - sum.
+  int64_t ChecksumAdjustment();
+
+  // Get the magic number. Set to 0x5F0F3CF5.
+  int64_t MagicNumber();
+
+  // TODO(arthurhsu): IMPLEMENT: EnumSet<Flags>
+  int32_t FlagsAsInt();
+  // TODO(arthurhsu): IMPLEMENT: Flags() returning EnumSet<Flags>
+
+  int32_t UnitsPerEm();
+
+  // Get the created date. Number of seconds since 12:00 midnight, January 1,
+  // 1904. 64-bit integer.
+  int64_t Created();
+  // Get the modified date. Number of seconds since 12:00 midnight, January 1,
+  // 1904. 64-bit integer.
+  int64_t Modified();
+
+  // Get the x min. For all glyph bounding boxes.
+  int32_t XMin();
+  // Get the y min. For all glyph bounding boxes.
+  int32_t YMin();
+  // Get the x max. For all glyph bounding boxes.
+  int32_t XMax();
+  // Get the y max. For all glyph bounding boxes.
+  int32_t YMax();
+
+  // TODO(arthurhsu): IMPLEMENT: EnumSet<MacStyle>
+  int32_t MacStyleAsInt();
+  // TODO(arthurhsu): IMPLEMENT: macStyle() returning EnumSet<MacStyle>
+
+  int32_t LowestRecPPEM();
+  int32_t FontDirectionHint();  // Note: no AsInt() form, already int
+  int32_t IndexToLocFormat();  // Note: no AsInt() form, already int
+  int32_t GlyphDataFormat();
+
  private:
   struct Offset {
     enum {
@@ -62,104 +157,7 @@
     };
   };
 
- private:
   FontHeaderTable(Header* header, ReadableFontData* data);
-
- public:  // class is final, no virtual functions unless from parent
-  virtual ~FontHeaderTable();
-  int32_t tableVersion();
-  int32_t fontRevision();
-
-  // Get the checksum adjustment. To compute: set it to 0, sum the entire font
-  // as ULONG, then store 0xB1B0AFBA - sum.
-  int64_t checksumAdjustment();
-
-  // Get the magic number. Set to 0x5F0F3CF5.
-  int64_t magicNumber();
-
-  // TODO(arthurhsu): IMPLEMENT: EnumSet<Flags>
-  int32_t flagsAsInt();
-  // TODO(arthurhsu): IMPLEMENT: flags() returning EnumSet<Flags>
-
-  int32_t unitsPerEm();
-
-  // Get the created date. Number of seconds since 12:00 midnight, January 1,
-  // 1904. 64-bit integer.
-  int64_t created();
-  // Get the modified date. Number of seconds since 12:00 midnight, January 1,
-  // 1904. 64-bit integer.
-  int64_t modified();
-
-  // Get the x min. For all glyph bounding boxes.
-  int32_t xMin();
-  // Get the y min. For all glyph bounding boxes.
-  int32_t yMin();
-  // Get the x max. For all glyph bounding boxes.
-  int32_t xMax();
-  // Get the y max. For all glyph bounding boxes.
-  int32_t yMax();
-
-  // TODO(arthurhsu): IMPLEMENT: EnumSet<MacStyle>
-  int32_t macStyleAsInt();
-  // TODO(arthurhsu): IMPLEMENT: macStyle() returning EnumSet<MacStyle>
-
-  int32_t lowestRecPPEM();
-  int32_t fontDirectionHint();  // Note: no AsInt() form, already int
-  int32_t indexToLocFormat();  // Note: no AsInt() form, already int
-  int32_t glyphDataFormat();
-
- public:
-  class Builder : public Table::TableBasedTableBuilder,
-                  public RefCounted<Builder> {
-   public:
-    // Constructor scope altered to public because C++ does not allow base
-    // class to instantiate derived class with protected constructors.
-    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
-            WritableFontData* data);
-    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
-            ReadableFontData* data);
-    virtual ~Builder();
-    virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
-
-    virtual int32_t tableVersion();
-    virtual void setTableVersion(int32_t version);
-    virtual int32_t fontRevision();
-    virtual void setFontRevision(int32_t revision);
-    virtual int64_t checksumAdjustment();
-    virtual void setChecksumAdjustment(int64_t adjustment);
-    virtual int64_t magicNumber();
-    virtual void setMagicNumber(int64_t magic_number);
-    virtual int32_t flagsAsInt();
-    virtual void setFlagsAsInt(int32_t flags);
-    // TODO(arthurhsu): IMPLEMENT EnumSet<Flags> flags()
-    // TODO(arthurhsu): IMPLEMENT setFlags(EnumSet<Flags> flags)
-    virtual int32_t unitsPerEm();
-    virtual void setUnitsPerEm(int32_t units);
-    virtual int64_t created();
-    virtual void setCreated(int64_t date);
-    virtual int64_t modified();
-    virtual void setModified(int64_t date);
-    virtual int32_t xMin();
-    virtual void setXMin(int32_t xmin);
-    virtual int32_t yMin();
-    virtual void setYMin(int32_t ymin);
-    virtual int32_t xMax();
-    virtual void setXMax(int32_t xmax);
-    virtual int32_t yMax();
-    virtual void setYMax(int32_t ymax);
-    virtual int32_t macStyleAsInt();
-    virtual void setMacStyleAsInt(int32_t style);
-    // TODO(arthurhsu): IMPLEMENT EnumSet<MacStyle> macStyle()
-    // TODO(arthurhsu): IMPLEMENT setMacStyle(EnumSet<MacStyle> style)
-    virtual int32_t lowestRecPPEM();
-    virtual void setLowestRecPPEM(int32_t size);
-    virtual int32_t fontDirectionHint();
-    virtual void setFontDirectionHint(int32_t hint);
-    virtual int32_t indexToLocFormat();
-    virtual void setIndexToLocFormat(int32_t format);
-    virtual int32_t glyphDataFormat();
-    virtual void setGlyphDataFormat(int32_t format);
-  };
 };
 typedef Ptr<FontHeaderTable> FontHeaderTablePtr;
 typedef Ptr<FontHeaderTable::Builder> FontHeaderTableBuilderPtr;
diff --git a/sfntly/glyph_table.cc b/sfntly/glyph_table.cc
index 3ff6d97..99e7c06 100644
--- a/sfntly/glyph_table.cc
+++ b/sfntly/glyph_table.cc
@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 
+#include "sfntly/glyph_table.h"
+
 #include <stdlib.h>
 
-#include "sfntly/glyph_table.h"
 #include "sfntly/port/exception_type.h"
 
 namespace sfntly {
@@ -47,33 +48,38 @@
 /******************************************************************************
  * GlyphTable class
  ******************************************************************************/
+GlyphTable::~GlyphTable() {
+}
+
+GlyphTable::Glyph* GlyphTable::GetGlyph(int32_t offset, int32_t length) {
+  return GlyphTable::Glyph::GetGlyph(data_, offset, length);
+}
+
 GlyphTable::GlyphTable(Header* header, ReadableFontData* data)
-    : Table(header, data) {}
-
-GlyphTable::~GlyphTable() {}
-
-GlyphTable::Glyph* GlyphTable::glyph(int32_t offset, int32_t length) {
-  return GlyphTable::Glyph::getGlyph(data_, offset, length);
+    : Table(header, data) {
 }
 
 /******************************************************************************
  * GlyphTable::Builder class
  ******************************************************************************/
 GlyphTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
-                            Header* header, WritableFontData* data) :
-    Table::ArrayElementTableBuilder(font_builder, header, data) {}
+                             Header* header,
+                             WritableFontData* data)
+    : Table::ArrayElementTableBuilder(font_builder, header, data) {
+}
 
-GlyphTable::Builder::~Builder() {}
+GlyphTable::Builder::~Builder() {
+}
 
-void GlyphTable::Builder::setLoca(const IntegerList& loca) {
+void GlyphTable::Builder::SetLoca(const IntegerList& loca) {
   loca_ = loca;
-  setModelChanged(false);
+  set_model_changed(false);
   glyph_builders_.clear();
 }
 
-void GlyphTable::Builder::generateLocaList(IntegerList* locas) {
+void GlyphTable::Builder::GenerateLocaList(IntegerList* locas) {
   assert(locas);
-  GlyphBuilderList* glyph_builders = getGlyphBuilders();
+  GlyphBuilderList* glyph_builders = GetGlyphBuilders();
   locas->resize(glyph_builders->size());
   locas->push_back(0);
   if (glyph_builders->size() == 0) {
@@ -83,14 +89,71 @@
     for (GlyphBuilderList::iterator b = glyph_builders->begin(),
                                     b_end = glyph_builders->end();
                                     b != b_end; ++b) {
-      int32_t size = (*b)->subDataSizeToSerialize();
+      int32_t size = (*b)->SubDataSizeToSerialize();
       locas->push_back(total + size);
       total += size;
     }
   }
 }
 
-void GlyphTable::Builder::initialize(ReadableFontData* data,
+GlyphTable::GlyphBuilderList* GlyphTable::Builder::GlyphBuilders() {
+  return GetGlyphBuilders();
+}
+
+void GlyphTable::Builder::SetGlyphBuilders(GlyphBuilderList* glyph_builders) {
+  glyph_builders_ = *glyph_builders;
+  set_model_changed();
+}
+
+CALLER_ATTACH GlyphTable::Glyph::Builder*
+    GlyphTable::Builder::GlyphBuilder(ReadableFontData* data) {
+  return Glyph::Builder::GetBuilder(this, data);
+}
+
+CALLER_ATTACH FontDataTable*
+    GlyphTable::Builder::SubBuildTable(ReadableFontData* data) {
+  FontDataTablePtr table = new GlyphTable(header(), data);
+  return table.Detach();
+}
+
+void GlyphTable::Builder::SubDataSet() {
+  glyph_builders_.clear();
+  set_model_changed(false);
+}
+
+int32_t GlyphTable::Builder::SubDataSizeToSerialize() {
+  if (glyph_builders_.empty())
+    return 0;
+
+  bool variable = false;
+  int32_t size = 0;
+
+  // Calculate size of each table.
+  for (GlyphBuilderList::iterator b = glyph_builders_.begin(),
+                                  end = glyph_builders_.end(); b != end; ++b) {
+      int32_t glyph_size = (*b)->SubDataSizeToSerialize();
+      size += abs(glyph_size);
+      variable |= glyph_size <= 0;
+  }
+  return variable ? -size : size;
+}
+
+bool GlyphTable::Builder::SubReadyToSerialize() {
+  return !glyph_builders_.empty();
+}
+
+int32_t GlyphTable::Builder::SubSerialize(WritableFontData* new_data) {
+  int32_t size = 0;
+  for (GlyphBuilderList::iterator b = glyph_builders_.begin(),
+                                  end = glyph_builders_.end(); b != end; ++b) {
+    FontDataPtr data;
+    data.Attach(new_data->Slice(size));
+    size += (*b)->SubSerialize(down_cast<WritableFontData*>(data.p_));
+  }
+  return size;
+}
+
+void GlyphTable::Builder::Initialize(ReadableFontData* data,
                                      const IntegerList& loca) {
   if (data != NULL) {
     if (loca_.empty()) {
@@ -106,222 +169,211 @@
     for (size_t i = 1; i < loca.size(); ++i) {
       loca_value = loca[i];
       GlyphBuilderPtr builder;
-      builder.attach(Glyph::Builder::getBuilder(this, data,
-          last_loca_value /*offset*/, loca_value - last_loca_value /*length*/));
+      builder.Attach(
+        Glyph::Builder::GetBuilder(this,
+                                   data,
+                                   last_loca_value /*offset*/,
+                                   loca_value - last_loca_value /*length*/));
       glyph_builders_.push_back(builder);
       last_loca_value = loca_value;
     }
   }
 }
 
-GlyphTable::GlyphBuilderList* GlyphTable::Builder::getGlyphBuilders() {
+GlyphTable::GlyphBuilderList* GlyphTable::Builder::GetGlyphBuilders() {
   if (glyph_builders_.empty()) {
-    initialize(internalReadData(), loca_);
-    setModelChanged();
+    Initialize(InternalReadData(), loca_);
+    set_model_changed();
   }
   return &glyph_builders_;
 }
 
-void GlyphTable::Builder::revert() {
+void GlyphTable::Builder::Revert() {
   glyph_builders_.clear();
-  setModelChanged(false);
-}
-
-GlyphTable::GlyphBuilderList* GlyphTable::Builder::glyphBuilders() {
-  return getGlyphBuilders();
-}
-
-void GlyphTable::Builder::setGlyphBuilders(GlyphBuilderList* glyph_builders) {
-  glyph_builders_ = *glyph_builders;
-  setModelChanged();
-}
-
-CALLER_ATTACH GlyphTable::Glyph::Builder* GlyphTable::Builder::glyphBuilder(
-    ReadableFontData* data) {
-  return Glyph::Builder::getBuilder(this, data);
-}
-
-CALLER_ATTACH FontDataTable* GlyphTable::Builder::subBuildTable(
-    ReadableFontData* data) {
-  FontDataTablePtr table = new GlyphTable(header(), data);
-  return table.detach();
-}
-
-void GlyphTable::Builder::subDataSet() {
-  glyph_builders_.clear();
-  setModelChanged(false);
-}
-
-int32_t GlyphTable::Builder::subDataSizeToSerialize() {
-  if (glyph_builders_.empty())
-    return 0;
-
-  bool variable = false;
-  int32_t size = 0;
-
-  // Calculate size of each table.
-  for (GlyphBuilderList::iterator b = glyph_builders_.begin(),
-                                  end = glyph_builders_.end(); b != end; ++b) {
-      int32_t glyph_size = (*b)->subDataSizeToSerialize();
-      size += abs(glyph_size);
-      variable |= glyph_size <= 0;
-  }
-  return variable ? -size : size;
-}
-
-bool GlyphTable::Builder::subReadyToSerialize() {
-  return !glyph_builders_.empty();
-}
-
-int32_t GlyphTable::Builder::subSerialize(WritableFontData* new_data) {
-  int32_t size = 0;
-  for (GlyphBuilderList::iterator b = glyph_builders_.begin(),
-                                  end = glyph_builders_.end(); b != end; ++b) {
-    FontDataPtr data;
-    data.attach(new_data->slice(size));
-    size += (*b)->subSerialize(down_cast<WritableFontData*>(data.p_));
-  }
-  return size;
+  set_model_changed(false);
 }
 
 /******************************************************************************
  * GlyphTable::Glyph class
  ******************************************************************************/
+GlyphTable::Glyph::~Glyph() {}
+
+CALLER_ATTACH GlyphTable::Glyph*
+    GlyphTable::Glyph::GetGlyph(ReadableFontData* data,
+                                int32_t offset,
+                                int32_t length) {
+  int32_t type = GlyphType(data, offset, length);
+  GlyphPtr glyph;
+
+  ReadableFontDataPtr sliced_data;
+  sliced_data.Attach(down_cast<ReadableFontData*>(data->Slice(offset, length)));
+  if (type == GlyphType::kSimple) {
+    glyph = new SimpleGlyph(sliced_data);
+  }
+  glyph = new CompositeGlyph(sliced_data);
+  return glyph.Detach();
+}
+
+int32_t GlyphTable::Glyph::GlyphType() {
+  return glyph_type_;
+}
+
+int32_t GlyphTable::Glyph::NumberOfContours() {
+  return number_of_contours_;
+}
+
+int32_t GlyphTable::Glyph::XMin() {
+  return data_->ReadShort(Offset::kXMin);
+}
+
+int32_t GlyphTable::Glyph::XMax() {
+  return data_->ReadShort(Offset::kXMax);
+}
+
+int32_t GlyphTable::Glyph::YMin() {
+  return data_->ReadShort(Offset::kYMin);
+}
+
+int32_t GlyphTable::Glyph::YMax() {
+  return data_->ReadShort(Offset::kYMax);
+}
+
+int32_t GlyphTable::Glyph::Padding() {
+  return padding_;
+}
+
 GlyphTable::Glyph::Glyph(ReadableFontData* data, int32_t glyph_type)
-    : SubTable(data), glyph_type_(glyph_type) {
-  if (data_->length() == 0) {
+    : SubTable(data),
+      glyph_type_(glyph_type) {
+  if (data_->Length() == 0) {
     number_of_contours_ = 0;
   } else {
     // -1 if composite
-    number_of_contours_ = data_->readShort(Offset::kNumberOfContours);
+    number_of_contours_ = data_->ReadShort(Offset::kNumberOfContours);
   }
 }
 
-GlyphTable::Glyph::~Glyph() {}
-
-int32_t GlyphTable::Glyph::glyphType(ReadableFontData* data, int32_t offset,
+int32_t GlyphTable::Glyph::GlyphType(ReadableFontData* data,
+                                     int32_t offset,
                                      int32_t length) {
   if (length == 0) {
     return GlyphType::kSimple;
   }
-  int32_t number_of_contours = data->readShort(offset);
+  int32_t number_of_contours = data->ReadShort(offset);
   if (number_of_contours >= 0) {
     return GlyphType::kSimple;
   }
   return GlyphType::kComposite;
 }
 
-CALLER_ATTACH GlyphTable::Glyph* GlyphTable::Glyph::getGlyph(
-    ReadableFontData* data, int32_t offset, int32_t length) {
-  int32_t type = glyphType(data, offset, length);
-  GlyphPtr glyph;
-
-  ReadableFontDataPtr sliced_data;
-  sliced_data.attach(down_cast<ReadableFontData*>(data->slice(offset, length)));
-  if (type == GlyphType::kSimple) {
-    glyph = new SimpleGlyph(sliced_data);
-  }
-  glyph = new CompositeGlyph(sliced_data);
-  return glyph.detach();
-}
-
-int32_t GlyphTable::Glyph::glyphType() {
-  return glyph_type_;
-}
-
-int32_t GlyphTable::Glyph::numberOfContours() {
-  return number_of_contours_;
-}
-
-int32_t GlyphTable::Glyph::xMin() {
-  return data_->readShort(Offset::kXMin);
-}
-
-int32_t GlyphTable::Glyph::xMax() {
-  return data_->readShort(Offset::kXMax);
-}
-
-int32_t GlyphTable::Glyph::yMin() {
-  return data_->readShort(Offset::kYMin);
-}
-
-int32_t GlyphTable::Glyph::yMax() {
-  return data_->readShort(Offset::kYMax);
-}
-
-int32_t GlyphTable::Glyph::padding() {
-  return padding_;
-}
-
 /******************************************************************************
  * GlyphTable::Glyph::Builder class
  ******************************************************************************/
-GlyphTable::Glyph::Builder::Builder(FontDataTableBuilderContainer* font_builder,
-                                    WritableFontData* data) :
-    SubTable::Builder(font_builder, data) {
+GlyphTable::Glyph::Builder::~Builder() {
 }
 
 GlyphTable::Glyph::Builder::Builder(FontDataTableBuilderContainer* font_builder,
-                                    ReadableFontData* data) :
-    SubTable::Builder(font_builder, data) {
+                                    WritableFontData* data)
+    : SubTable::Builder(font_builder, data) {
 }
 
-GlyphTable::Glyph::Builder::~Builder() {}
-
-CALLER_ATTACH GlyphTable::Glyph::Builder*
-    GlyphTable::Glyph::Builder::getBuilder(
-        FontDataTableBuilderContainer* table_builder, ReadableFontData* data) {
-  return getBuilder(table_builder, data, 0, data->length());
+GlyphTable::Glyph::Builder::Builder(FontDataTableBuilderContainer* font_builder,
+                                    ReadableFontData* data)
+    : SubTable::Builder(font_builder, data) {
 }
 
 CALLER_ATTACH GlyphTable::Glyph::Builder*
-    GlyphTable::Glyph::Builder::getBuilder(
-        FontDataTableBuilderContainer* table_builder, ReadableFontData* data,
-        int32_t offset, int32_t length) {
-  int32_t type = Glyph::glyphType(data, offset, length);
+    GlyphTable::Glyph::Builder::GetBuilder(
+        FontDataTableBuilderContainer* table_builder,
+        ReadableFontData* data) {
+  return GetBuilder(table_builder, data, 0, data->Length());
+}
+
+CALLER_ATTACH GlyphTable::Glyph::Builder*
+    GlyphTable::Glyph::Builder::GetBuilder(
+        FontDataTableBuilderContainer* table_builder,
+        ReadableFontData* data,
+        int32_t offset,
+        int32_t length) {
+  int32_t type = Glyph::GlyphType(data, offset, length);
   GlyphBuilderPtr builder;
   ReadableFontDataPtr sliced_data;
-  sliced_data.attach(down_cast<ReadableFontData*>(data->slice(offset, length)));
+  sliced_data.Attach(down_cast<ReadableFontData*>(data->Slice(offset, length)));
   if (type == GlyphType::kSimple) {
     builder = new SimpleGlyph::SimpleGlyphBuilder(table_builder, sliced_data);
   } else {
     builder = new CompositeGlyph::CompositeGlyphBuilder(table_builder,
                                                         sliced_data);
   }
-  return builder.detach();
+  return builder.Detach();
 }
 
-void GlyphTable::Glyph::Builder::subDataSet() {
+void GlyphTable::Glyph::Builder::SubDataSet() {
   // NOP
 }
 
-int32_t GlyphTable::Glyph::Builder::subDataSizeToSerialize() {
-  return internalReadData()->length();
+int32_t GlyphTable::Glyph::Builder::SubDataSizeToSerialize() {
+  return InternalReadData()->Length();
 }
 
-bool GlyphTable::Glyph::Builder::subReadyToSerialize() {
+bool GlyphTable::Glyph::Builder::SubReadyToSerialize() {
   return true;
 }
 
-int32_t GlyphTable::Glyph::Builder::subSerialize(WritableFontData* new_data) {
-  return internalReadData()->copyTo(new_data);
+int32_t GlyphTable::Glyph::Builder::SubSerialize(WritableFontData* new_data) {
+  return InternalReadData()->CopyTo(new_data);
 }
 
 /******************************************************************************
- * GlyphTable::SimpleGlyph and its builder
+ * GlyphTable::SimpleGlyph
  ******************************************************************************/
 GlyphTable::SimpleGlyph::SimpleGlyph(ReadableFontData* data)
     : GlyphTable::Glyph(data, GlyphType::kSimple) {
 }
 
-GlyphTable::SimpleGlyph::~SimpleGlyph() {}
+GlyphTable::SimpleGlyph::~SimpleGlyph() {
+}
 
-void GlyphTable::SimpleGlyph::initialize() {
+int32_t GlyphTable::SimpleGlyph::InstructionSize() {
+  Initialize();
+  return instruction_size_;
+}
+
+CALLER_ATTACH ReadableFontData* GlyphTable::SimpleGlyph::Instructions() {
+  Initialize();
+  return down_cast<ReadableFontData*>(
+             data_->Slice(instructions_offset_, InstructionSize()));
+}
+
+int32_t GlyphTable::SimpleGlyph::NumberOfPoints(int32_t contour) {
+  Initialize();
+  if (contour >= NumberOfContours()) {
+    return 0;
+  }
+  return contour_index_[contour + 1] - contour_index_[contour];
+}
+
+int32_t GlyphTable::SimpleGlyph::XCoordinate(int32_t contour, int32_t point) {
+  Initialize();
+  return x_coordinates_[contour_index_[contour] + point];
+}
+
+int32_t GlyphTable::SimpleGlyph::YCoordinate(int32_t contour, int32_t point) {
+  Initialize();
+  return y_coordinates_[contour_index_[contour] + point];
+}
+
+bool GlyphTable::SimpleGlyph::OnCurve(int32_t contour, int32_t point) {
+  Initialize();
+  return on_curve_[contour_index_[contour] + point];
+}
+
+void GlyphTable::SimpleGlyph::Initialize() {
   if (initialized_) {
     return;
   }
 
-  if (readFontData()->length() == 0) {
+  if (ReadFontData()->Length() == 0) {
     instruction_size_ = 0;
     number_of_points_ = 0;
     instructions_offset_ = 0;
@@ -331,38 +383,38 @@
     return;
   }
 
-  instruction_size_ = data_->readUShort(Offset::kSimpleEndPtsOfCountours +
-      numberOfContours() * DataSize::kUSHORT);
+  instruction_size_ = data_->ReadUShort(Offset::kSimpleEndPtsOfCountours +
+      NumberOfContours() * DataSize::kUSHORT);
   instructions_offset_ = Offset::kSimpleEndPtsOfCountours +
-      (numberOfContours() + 1) * DataSize::kUSHORT;
+      (NumberOfContours() + 1) * DataSize::kUSHORT;
   flags_offset_ = instructions_offset_ + instruction_size_ * DataSize::kBYTE;
-  number_of_points_ = contourEndPoint(numberOfContours() - 1) + 1;
+  number_of_points_ = ContourEndPoint(NumberOfContours() - 1) + 1;
   x_coordinates_.resize(number_of_points_);
   y_coordinates_.resize(number_of_points_);
   on_curve_.resize(number_of_points_);
-  parseData(false);
+  ParseData(false);
   x_coordinates_offset_ = flags_offset_ + flag_byte_count_ * DataSize::kBYTE;
   y_coordinates_offset_ = x_coordinates_offset_ + x_byte_count_ *
       DataSize::kBYTE;
-  contour_index_.resize(numberOfContours() + 1);
+  contour_index_.resize(NumberOfContours() + 1);
   contour_index_[0] = 0;
   for (uint32_t contour = 0; contour < contour_index_.size() - 1; ++contour) {
-    contour_index_[contour + 1] = contourEndPoint(contour) + 1;
+    contour_index_[contour + 1] = ContourEndPoint(contour) + 1;
   }
-  parseData(true);
+  ParseData(true);
   int32_t non_padded_data_length =
     5 * DataSize::kSHORT +
-    (numberOfContours() * DataSize::kUSHORT) +
+    (NumberOfContours() * DataSize::kUSHORT) +
     DataSize::kUSHORT +
     (instruction_size_ * DataSize::kBYTE) +
     (flag_byte_count_ * DataSize::kBYTE) +
     (x_byte_count_ * DataSize::kBYTE) +
     (y_byte_count_ * DataSize::kBYTE);
-  padding_ = length() - non_padded_data_length;
+  padding_ = Length() - non_padded_data_length;
   initialized_ = true;
 }
 
-void GlyphTable::SimpleGlyph::parseData(bool fill_arrays) {
+void GlyphTable::SimpleGlyph::ParseData(bool fill_arrays) {
   int32_t flag = 0;
   int32_t flag_repeat = 0;
   int32_t flag_index = 0;
@@ -373,9 +425,9 @@
        ++point_index) {
     // get the flag for the current point
     if (flag_repeat == 0) {
-      flag = flagAsInt(flag_index++);
+      flag = FlagAsInt(flag_index++);
       if ((flag & kFLAG_REPEAT) == kFLAG_REPEAT) {
-        flag_repeat = flagAsInt(flag_index++);
+        flag_repeat = FlagAsInt(flag_index++);
       }
     } else {
       flag_repeat--;
@@ -390,7 +442,7 @@
       // single byte x coord value
       if (fill_arrays) {
         x_coordinates_[point_index] =
-            data_->readUByte(x_coordinates_offset_ + x_byte_index);
+            data_->ReadUByte(x_coordinates_offset_ + x_byte_index);
         x_coordinates_[point_index] *=
             ((flag & kFLAG_XREPEATSIGN) == kFLAG_XREPEATSIGN) ? 1 : -1;
       }
@@ -400,7 +452,7 @@
       if (!((flag & kFLAG_XREPEATSIGN) == kFLAG_XREPEATSIGN)) {
         if (fill_arrays) {
           x_coordinates_[point_index] =
-            data_->readShort(x_coordinates_offset_ + x_byte_index);
+            data_->ReadShort(x_coordinates_offset_ + x_byte_index);
         }
         x_byte_index += 2;
       }
@@ -413,7 +465,7 @@
     if ((flag & kFLAG_YSHORT) == kFLAG_YSHORT) {
       if (fill_arrays) {
         y_coordinates_[point_index] =
-          data_->readUByte(y_coordinates_offset_ + y_byte_index);
+          data_->ReadUByte(y_coordinates_offset_ + y_byte_index);
         y_coordinates_[point_index] *=
           ((flag & kFLAG_YREPEATSIGN) == kFLAG_YREPEATSIGN) ? 1 : -1;
       }
@@ -422,7 +474,7 @@
       if (!((flag & kFLAG_YREPEATSIGN) == kFLAG_YREPEATSIGN)) {
         if (fill_arrays) {
           y_coordinates_[point_index] =
-            data_->readShort(y_coordinates_offset_ + y_byte_index);
+            data_->ReadShort(y_coordinates_offset_ + y_byte_index);
         }
         y_byte_index += 2;
       }
@@ -436,86 +488,130 @@
   y_byte_count_ = y_byte_index;
 }
 
-int32_t GlyphTable::SimpleGlyph::flagAsInt(int32_t index) {
-  return data_->readUByte(flags_offset_ + index * DataSize::kBYTE);
+int32_t GlyphTable::SimpleGlyph::FlagAsInt(int32_t index) {
+  return data_->ReadUByte(flags_offset_ + index * DataSize::kBYTE);
 }
 
-int32_t GlyphTable::SimpleGlyph::contourEndPoint(int32_t contour) {
-  return data_->readUShort(contour * DataSize::kUSHORT +
+int32_t GlyphTable::SimpleGlyph::ContourEndPoint(int32_t contour) {
+  return data_->ReadUShort(contour * DataSize::kUSHORT +
                            Offset::kSimpleEndPtsOfCountours);
 }
 
-int32_t GlyphTable::SimpleGlyph::instructionSize() {
-  initialize();
-  return instruction_size_;
-}
-
-CALLER_ATTACH ReadableFontData* GlyphTable::SimpleGlyph::instructions() {
-  initialize();
-  return down_cast<ReadableFontData*>(
-             data_->slice(instructions_offset_, instructionSize()));
-}
-
-int32_t GlyphTable::SimpleGlyph::numberOfPoints(int32_t contour) {
-  initialize();
-  if (contour >= numberOfContours()) {
-    return 0;
-  }
-  return contour_index_[contour + 1] - contour_index_[contour];
-}
-
-int32_t GlyphTable::SimpleGlyph::xCoordinate(int32_t contour, int32_t point) {
-  initialize();
-  return x_coordinates_[contour_index_[contour] + point];
-}
-
-int32_t GlyphTable::SimpleGlyph::yCoordinate(int32_t contour, int32_t point) {
-  initialize();
-  return y_coordinates_[contour_index_[contour] + point];
-}
-
-bool GlyphTable::SimpleGlyph::onCurve(int32_t contour, int32_t point) {
-  initialize();
-  return on_curve_[contour_index_[contour] + point];
+/******************************************************************************
+ * GlyphTable::SimpleGlyph::Builder
+ ******************************************************************************/
+GlyphTable::SimpleGlyph::SimpleGlyphBuilder::~SimpleGlyphBuilder() {
 }
 
 GlyphTable::SimpleGlyph::SimpleGlyphBuilder::SimpleGlyphBuilder(
-    FontDataTableBuilderContainer* table_builder, WritableFontData* data) :
-    Glyph::Builder(table_builder, data) {
+    FontDataTableBuilderContainer* table_builder,
+    WritableFontData* data)
+    : Glyph::Builder(table_builder, data) {
 }
 
 GlyphTable::SimpleGlyph::SimpleGlyphBuilder::SimpleGlyphBuilder(
-    FontDataTableBuilderContainer* table_builder, ReadableFontData* data) :
-    Glyph::Builder(table_builder, data) {
+    FontDataTableBuilderContainer* table_builder,
+    ReadableFontData* data)
+    : Glyph::Builder(table_builder, data) {
 }
 
-GlyphTable::SimpleGlyph::SimpleGlyphBuilder::~SimpleGlyphBuilder() {}
-
 CALLER_ATTACH FontDataTable*
-    GlyphTable::SimpleGlyph::SimpleGlyphBuilder::subBuildTable(
+    GlyphTable::SimpleGlyph::SimpleGlyphBuilder::SubBuildTable(
         ReadableFontData* data) {
   FontDataTablePtr table = new SimpleGlyph(data);
-  return table.detach();
+  return table.Detach();
 }
 
 /******************************************************************************
- * GlyphTable::CompositeGlyph and its builder
+ * GlyphTable::CompositeGlyph
  ******************************************************************************/
 GlyphTable::CompositeGlyph::CompositeGlyph(ReadableFontData* data)
     : GlyphTable::Glyph(data, GlyphType::kComposite),
-      instruction_size_(0), instructions_offset_(0) {
-  parseData();
+      instruction_size_(0),
+      instructions_offset_(0) {
+  ParseData();
 }
 
-GlyphTable::CompositeGlyph::~CompositeGlyph() {}
+GlyphTable::CompositeGlyph::~CompositeGlyph() {
+}
 
-void GlyphTable::CompositeGlyph::parseData() {
+int32_t GlyphTable::CompositeGlyph::Flags(int32_t contour) {
+  return data_->ReadUShort(contour_index_[contour]);
+}
+
+int32_t GlyphTable::CompositeGlyph::NumGlyphs() {
+  return contour_index_.size();
+}
+
+int32_t GlyphTable::CompositeGlyph::GlyphIndex(int32_t contour) {
+  return data_->ReadUShort(DataSize::kUSHORT + contour_index_[contour]);
+}
+
+int32_t GlyphTable::CompositeGlyph::Argument1(int32_t contour) {
+  int32_t index = 2 * DataSize::kUSHORT + contour_index_[contour];
+  int32_t contour_flags = Flags(contour);
+  if ((contour_flags & kFLAG_ARG_1_AND_2_ARE_WORDS) ==
+                       kFLAG_ARG_1_AND_2_ARE_WORDS) {
+    return data_->ReadUShort(index);
+  }
+  return data_->ReadByte(index);
+}
+
+int32_t GlyphTable::CompositeGlyph::Argument2(int32_t contour) {
+  int32_t index = 2 * DataSize::kUSHORT + contour_index_[contour];
+  int32_t contour_flags = Flags(contour);
+  if ((contour_flags & kFLAG_ARG_1_AND_2_ARE_WORDS) ==
+                       kFLAG_ARG_1_AND_2_ARE_WORDS) {
+    return data_->ReadUShort(index + DataSize::kUSHORT);
+  }
+  return data_->ReadByte(index + DataSize::kUSHORT);
+}
+
+int32_t GlyphTable::CompositeGlyph::TransformationSize(int32_t contour) {
+  int32_t contour_flags = Flags(contour);
+  if ((contour_flags & kFLAG_WE_HAVE_A_SCALE) == kFLAG_WE_HAVE_A_SCALE) {
+      return DataSize::kF2DOT14;
+    } else if ((contour_flags & kFLAG_WE_HAVE_AN_X_AND_Y_SCALE) ==
+                                kFLAG_WE_HAVE_AN_X_AND_Y_SCALE) {
+      return 2 * DataSize::kF2DOT14;
+    } else if ((contour_flags & kFLAG_WE_HAVE_A_TWO_BY_TWO) ==
+                                kFLAG_WE_HAVE_A_TWO_BY_TWO) {
+      return 4 * DataSize::kF2DOT14;
+    }
+    return 0;
+}
+
+void GlyphTable::CompositeGlyph::Transformation(int32_t contour,
+                                                ByteVector* transformation) {
+  int32_t contour_flags = Flags(contour);
+  int32_t index = contour_index_[contour] + 2 * DataSize::kUSHORT;
+  if ((contour_flags & kFLAG_ARG_1_AND_2_ARE_WORDS) ==
+                       kFLAG_ARG_1_AND_2_ARE_WORDS) {
+    index += 2 * DataSize::kSHORT;
+  } else {
+    index += 2 * DataSize::kBYTE;
+  }
+  int32_t tsize = TransformationSize(contour);
+  transformation->resize(tsize);
+  data_->ReadBytes(index, transformation, 0, tsize);
+}
+
+int32_t GlyphTable::CompositeGlyph::InstructionSize() {
+  return instruction_size_;
+}
+
+CALLER_ATTACH ReadableFontData* GlyphTable::CompositeGlyph::Instructions() {
+  return down_cast<ReadableFontData*>(
+             data_->Slice(instructions_offset_, InstructionSize()));
+}
+
+void GlyphTable::CompositeGlyph::ParseData() {
   int32_t index = 5 * DataSize::kUSHORT;
   int32_t flags = kFLAG_MORE_COMPONENTS;
 
   while ((flags & kFLAG_MORE_COMPONENTS) == kFLAG_MORE_COMPONENTS) {
     contour_index_.push_back(index);
-    flags = data_->readUShort(index);
+    flags = data_->ReadUShort(index);
     index += 2 * DataSize::kUSHORT;  // flags and glyphIndex
     if ((flags & kFLAG_ARG_1_AND_2_ARE_WORDS) == kFLAG_ARG_1_AND_2_ARE_WORDS) {
       index += 2 * DataSize::kSHORT;
@@ -533,102 +629,38 @@
     }
     int32_t non_padded_data_length = index;
     if ((flags & kFLAG_WE_HAVE_INSTRUCTIONS) == kFLAG_WE_HAVE_INSTRUCTIONS) {
-      instruction_size_ = data_->readUShort(index);
+      instruction_size_ = data_->ReadUShort(index);
       index += DataSize::kUSHORT;
       instructions_offset_ = index;
       non_padded_data_length = index + (instruction_size_ * DataSize::kBYTE);
     }
-    padding_ = length() - non_padded_data_length;
+    padding_ = Length() - non_padded_data_length;
   }
 }
 
-int32_t GlyphTable::CompositeGlyph::flags(int32_t contour) {
-  return data_->readUShort(contour_index_[contour]);
-}
-
-int32_t GlyphTable::CompositeGlyph::numGlyphs() {
-  return contour_index_.size();
-}
-
-int32_t GlyphTable::CompositeGlyph::glyphIndex(int32_t contour) {
-  return data_->readUShort(DataSize::kUSHORT + contour_index_[contour]);
-}
-
-int32_t GlyphTable::CompositeGlyph::argument1(int32_t contour) {
-  int32_t index = 2 * DataSize::kUSHORT + contour_index_[contour];
-  int32_t contour_flags = flags(contour);
-  if ((contour_flags & kFLAG_ARG_1_AND_2_ARE_WORDS) ==
-                       kFLAG_ARG_1_AND_2_ARE_WORDS) {
-    return data_->readUShort(index);
-  }
-  return data_->readByte(index);
-}
-
-int32_t GlyphTable::CompositeGlyph::argument2(int32_t contour) {
-  int32_t index = 2 * DataSize::kUSHORT + contour_index_[contour];
-  int32_t contour_flags = flags(contour);
-  if ((contour_flags & kFLAG_ARG_1_AND_2_ARE_WORDS) ==
-                       kFLAG_ARG_1_AND_2_ARE_WORDS) {
-    return data_->readUShort(index + DataSize::kUSHORT);
-  }
-  return data_->readByte(index + DataSize::kUSHORT);
-}
-
-int32_t GlyphTable::CompositeGlyph::transformationSize(int32_t contour) {
-  int32_t contour_flags = flags(contour);
-  if ((contour_flags & kFLAG_WE_HAVE_A_SCALE) == kFLAG_WE_HAVE_A_SCALE) {
-      return DataSize::kF2DOT14;
-    } else if ((contour_flags & kFLAG_WE_HAVE_AN_X_AND_Y_SCALE) ==
-                                kFLAG_WE_HAVE_AN_X_AND_Y_SCALE) {
-      return 2 * DataSize::kF2DOT14;
-    } else if ((contour_flags & kFLAG_WE_HAVE_A_TWO_BY_TWO) ==
-                                kFLAG_WE_HAVE_A_TWO_BY_TWO) {
-      return 4 * DataSize::kF2DOT14;
-    }
-    return 0;
-}
-
-void GlyphTable::CompositeGlyph::transformation(int32_t contour,
-                                                ByteVector* transformation) {
-  int32_t contour_flags = flags(contour);
-  int32_t index = contour_index_[contour] + 2 * DataSize::kUSHORT;
-  if ((contour_flags & kFLAG_ARG_1_AND_2_ARE_WORDS) ==
-                       kFLAG_ARG_1_AND_2_ARE_WORDS) {
-    index += 2 * DataSize::kSHORT;
-  } else {
-    index += 2 * DataSize::kBYTE;
-  }
-  int32_t tsize = transformationSize(contour);
-  transformation->resize(tsize);
-  data_->readBytes(index, transformation, 0, tsize);
-}
-
-int32_t GlyphTable::CompositeGlyph::instructionSize() {
-  return instruction_size_;
-}
-
-CALLER_ATTACH ReadableFontData* GlyphTable::CompositeGlyph::instructions() {
-  return down_cast<ReadableFontData*>(
-             data_->slice(instructions_offset_, instructionSize()));
+/******************************************************************************
+ * GlyphTable::CompositeGlyph::Builder
+ ******************************************************************************/
+GlyphTable::CompositeGlyph::CompositeGlyphBuilder::~CompositeGlyphBuilder() {
 }
 
 GlyphTable::CompositeGlyph::CompositeGlyphBuilder::CompositeGlyphBuilder(
-    FontDataTableBuilderContainer* table_builder, WritableFontData* data) :
-    Glyph::Builder(table_builder, data) {
+    FontDataTableBuilderContainer* table_builder,
+    WritableFontData* data)
+    : Glyph::Builder(table_builder, data) {
 }
 
 GlyphTable::CompositeGlyph::CompositeGlyphBuilder::CompositeGlyphBuilder(
-    FontDataTableBuilderContainer* table_builder, ReadableFontData* data) :
-    Glyph::Builder(table_builder, data) {
+    FontDataTableBuilderContainer* table_builder,
+    ReadableFontData* data)
+    : Glyph::Builder(table_builder, data) {
 }
 
-GlyphTable::CompositeGlyph::CompositeGlyphBuilder::~CompositeGlyphBuilder() {}
-
 CALLER_ATTACH FontDataTable*
-    GlyphTable::CompositeGlyph::CompositeGlyphBuilder::subBuildTable(
+    GlyphTable::CompositeGlyph::CompositeGlyphBuilder::SubBuildTable(
         ReadableFontData* data) {
   FontDataTablePtr table = new CompositeGlyph(data);
-  return table.detach();
+  return table.Detach();
 }
 
 }  // namespace sfntly
diff --git a/sfntly/glyph_table.h b/sfntly/glyph_table.h
index 8a7a8aa..c066d47 100644
--- a/sfntly/glyph_table.h
+++ b/sfntly/glyph_table.h
@@ -36,66 +36,9 @@
 //       before GlyphTable::Builder to avoid compilation errors.
 class GlyphTable : public Table, public RefCounted<GlyphTable> {
  public:
-  struct Offset {
-    enum {
-      // header
-      kNumberOfContours = 0,
-      kXMin = 2,
-      kYMin = 4,
-      kXMax = 6,
-      kYMax = 8,
-
-      // Simple Glyph Description
-      kSimpleEndPtsOfCountours = 10,
-      // offset from the end of the contours array
-      kSimpleInstructionLength = 0,
-      kSimpleInstructions = 2,
-      // flags
-      // xCoordinates
-      // yCoordinates
-
-      // Composite Glyph Description
-      kCompositeFlags = 0,
-      kCompositeGyphIndexWithoutFlag = 0,
-      kCompositeGlyphIndexWithFlag = 2,
-    };
-  };
-
- private:
-  GlyphTable(Header* header, ReadableFontData* data);
-
- public:
-  virtual ~GlyphTable();
-
-  class Glyph;
-  Glyph* glyph(int32_t offset, int32_t length);
-
   class Builder;
   class Glyph : public SubTable {
-   protected:
-    // Note: constructor refactored in C++ to avoid heavy lifting.
-    //       caller need to do data->slice(offset, length) beforehand.
-    Glyph(ReadableFontData* data, int32_t glyph_type);
-
-   private:
-    static int32_t glyphType(ReadableFontData* data, int32_t offset,
-                             int32_t length);
-
    public:
-    virtual ~Glyph();
-    static CALLER_ATTACH Glyph* getGlyph(ReadableFontData* data, int32_t offset,
-                                         int32_t length);
-    virtual int32_t glyphType();
-    virtual int32_t numberOfContours();
-    virtual int32_t xMin();
-    virtual int32_t xMax();
-    virtual int32_t yMin();
-    virtual int32_t yMax();
-    virtual int32_t padding();  // override FontDataTable::padding()
-
-    virtual int32_t instructionSize() = 0;
-    virtual ReadableFontData* instructions() = 0;
-
     // Note: Contour is an empty class for the version ported
     class Contour {
      protected:
@@ -104,42 +47,67 @@
     };
 
     class Builder : public SubTable::Builder {
+     public:
+      virtual ~Builder();
+
      protected:
       // Incoming table_builder is GlyphTable::Builder*.
       // Note: constructor refactored in C++ to avoid heavy lifting.
-      //       caller need to do data->slice(offset, length) beforehand.
+      //       caller need to do data->Slice(offset, length) beforehand.
       Builder(FontDataTableBuilderContainer* table_builder,
               WritableFontData* data);
       Builder(FontDataTableBuilderContainer* table_builder,
               ReadableFontData* data);
 
-     public:
-      virtual ~Builder();
+      static CALLER_ATTACH Builder*
+          GetBuilder(FontDataTableBuilderContainer* table_builder,
+                     ReadableFontData* data);
+      static CALLER_ATTACH Builder*
+          GetBuilder(FontDataTableBuilderContainer* table_builder,
+                     ReadableFontData* data,
+                     int32_t offset,
+                     int32_t length);
+      virtual void SubDataSet();
+      virtual int32_t SubDataSizeToSerialize();
+      virtual bool SubReadyToSerialize();
+      virtual int32_t SubSerialize(WritableFontData* new_data);
 
-     protected:
-      static CALLER_ATTACH Builder* getBuilder(
-          FontDataTableBuilderContainer* table_builder, ReadableFontData* data);
-      static CALLER_ATTACH Builder* getBuilder(
-          FontDataTableBuilderContainer* table_builder, ReadableFontData* data,
-          int32_t offset, int32_t length);
-      virtual void subDataSet();
-      virtual int32_t subDataSizeToSerialize();
-      virtual bool subReadyToSerialize();
-      virtual int32_t subSerialize(WritableFontData* new_data);
-
-     protected:
+     private:
       int32_t format_;
       friend class GlyphTable::Builder;
     };
 
-   private:
-    int32_t glyph_type_;
-    int32_t number_of_contours_;
+    virtual ~Glyph();
+    static CALLER_ATTACH Glyph* GetGlyph(ReadableFontData* data,
+                                         int32_t offset,
+                                         int32_t length);
+    virtual int32_t GlyphType();
+    virtual int32_t NumberOfContours();
+    virtual int32_t XMin();
+    virtual int32_t XMax();
+    virtual int32_t YMin();
+    virtual int32_t YMax();
+    virtual int32_t Padding();  // override FontDataTable::Padding()
+
+    virtual int32_t InstructionSize() = 0;
+    virtual ReadableFontData* Instructions() = 0;
 
    protected:
-    int32_t padding_;
-  };
+    // Note: constructor refactored in C++ to avoid heavy lifting.
+    //       caller need to do data->Slice(offset, length) beforehand.
+    Glyph(ReadableFontData* data, int32_t glyph_type);
 
+    // TODO(arthurhsu): violating C++ style guide, need refactoring.
+    int32_t padding_;
+
+   private:
+    static int32_t GlyphType(ReadableFontData* data,
+                             int32_t offset,
+                             int32_t length);
+
+    int32_t glyph_type_;
+    int32_t number_of_contours_;
+  };  // class GlyphTable::Glyph
   typedef Ptr<GlyphTable::Glyph::Builder> GlyphBuilderPtr;
   typedef std::vector<GlyphBuilderPtr> GlyphBuilderList;
 
@@ -147,19 +115,14 @@
                   public RefCounted<GlyphTable::Builder> {
    public:
     // Note: Constructor scope altered to public for base class to instantiate.
-    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+    Builder(FontDataTableBuilderContainer* font_builder,
+            Header* header,
             WritableFontData* data);
     virtual ~Builder();
 
-    virtual void setLoca(const IntegerList& loca);
-    virtual void generateLocaList(IntegerList* locas);
+    virtual void SetLoca(const IntegerList& loca);
+    virtual void GenerateLocaList(IntegerList* locas);
 
-   private:
-    void initialize(ReadableFontData* data, const IntegerList& loca);
-    GlyphBuilderList* getGlyphBuilders();
-    void revert();
-
-   public:
     // Gets the List of glyph builders for the glyph table builder. These may be
     // manipulated in any way by the caller and the changes will be reflected in
     // the final glyph table produced.
@@ -168,22 +131,26 @@
     // List. If there is current data (i.e. data read from an existing font) and
     // the <code>loca</code> list has not been set or is null, empty, or
     // invalid, then an empty glyph builder List will be returned.
-    GlyphBuilderList* glyphBuilders();
+    GlyphBuilderList* GlyphBuilders();
 
     // Replace the internal glyph builders with the one provided.
-    void setGlyphBuilders(GlyphBuilderList* glyph_builders);
+    void SetGlyphBuilders(GlyphBuilderList* glyph_builders);
 
     // Glyph builder factories
-    CALLER_ATTACH Glyph::Builder* glyphBuilder(ReadableFontData* data);
+    CALLER_ATTACH Glyph::Builder* GlyphBuilder(ReadableFontData* data);
 
    protected:  // internal API for building
-    virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
-    virtual void subDataSet();
-    virtual int32_t subDataSizeToSerialize();
-    virtual bool subReadyToSerialize();
-    virtual int32_t subSerialize(WritableFontData* new_data);
+    virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
+    virtual void SubDataSet();
+    virtual int32_t SubDataSizeToSerialize();
+    virtual bool SubReadyToSerialize();
+    virtual int32_t SubSerialize(WritableFontData* new_data);
 
    private:
+    void Initialize(ReadableFontData* data, const IntegerList& loca);
+    GlyphBuilderList* GetGlyphBuilders();
+    void Revert();
+
     GlyphBuilderList glyph_builders_;
     IntegerList loca_;
   };
@@ -197,34 +164,12 @@
     static const int32_t kFLAG_XREPEATSIGN;
     static const int32_t kFLAG_YREPEATSIGN;
 
-   public:
-    // Note: constructor refactored in C++ to avoid heavy lifting.
-    //       caller need to do data->slice(offset, length) beforehand.
-    explicit SimpleGlyph(ReadableFontData* data);
-    virtual ~SimpleGlyph();
-
-   public:
     class SimpleContour : public Glyph::Contour {
      protected:
       SimpleContour() {}
       virtual ~SimpleContour() {}
     };
 
-   private:
-    void initialize();
-    void parseData(bool fill_arrays);
-    int32_t flagAsInt(int32_t index);
-    int32_t contourEndPoint(int32_t contour);
-
-   public:  // class is final, , no virtual functions unless from parent
-    virtual int32_t instructionSize();
-    virtual CALLER_ATTACH ReadableFontData* instructions();
-    int32_t numberOfPoints(int32_t contour);
-    int32_t xCoordinate(int32_t contour, int32_t point);
-    int32_t yCoordinate(int32_t contour, int32_t point);
-    bool onCurve(int32_t contour, int32_t point);
-
-   public:
     class SimpleGlyphBuilder : public Glyph::Builder,
                                public RefCounted<SimpleGlyphBuilder> {
      public:
@@ -232,17 +177,36 @@
 
      protected:
       // Note: constructor refactored in C++ to avoid heavy lifting.
-      //       caller need to do data->slice(offset, length) beforehand.
+      //       caller need to do data->Slice(offset, length) beforehand.
       SimpleGlyphBuilder(FontDataTableBuilderContainer* table_builder,
                          WritableFontData* data);
       SimpleGlyphBuilder(FontDataTableBuilderContainer* table_builder,
                          ReadableFontData* data);
       virtual CALLER_ATTACH FontDataTable*
-          subBuildTable(ReadableFontData* data);
+          SubBuildTable(ReadableFontData* data);
+
+     private:
       friend class Glyph::Builder;
     };
 
+    // Note: constructor refactored in C++ to avoid heavy lifting.
+    //       caller need to do data->Slice(offset, length) beforehand.
+    explicit SimpleGlyph(ReadableFontData* data);
+    virtual ~SimpleGlyph();
+
+    virtual int32_t InstructionSize();
+    virtual CALLER_ATTACH ReadableFontData* Instructions();
+    int32_t NumberOfPoints(int32_t contour);
+    int32_t XCoordinate(int32_t contour, int32_t point);
+    int32_t YCoordinate(int32_t contour, int32_t point);
+    bool OnCurve(int32_t contour, int32_t point);
+
    private:
+    void Initialize();
+    void ParseData(bool fill_arrays);
+    int32_t FlagAsInt(int32_t index);
+    int32_t ContourEndPoint(int32_t contour);
+
     bool initialized_;
     int32_t instruction_size_;
     int32_t number_of_points_;
@@ -279,27 +243,6 @@
     static const int32_t kFLAG_SCALED_COMPONENT_OFFSET;
     static const int32_t kFLAG_UNSCALED_COMPONENT_OFFSET;
 
-   public:
-    // Note: constructor refactored in C++ to avoid heavy lifting.
-    //       caller need to do data->slice(offset, length) beforehand.
-    explicit CompositeGlyph(ReadableFontData* data);
-    virtual ~CompositeGlyph();
-
-   private:
-    void parseData();
-
-   public:  // class is final, no virtual functions unless from parent
-    int32_t flags(int32_t contour);
-    int32_t numGlyphs();
-    int32_t glyphIndex(int32_t contour);
-    int32_t argument1(int32_t contour);
-    int32_t argument2(int32_t contour);
-    int32_t transformationSize(int32_t contour);
-    void transformation(int32_t contour, ByteVector* transformation);
-    virtual int32_t instructionSize();
-    virtual CALLER_ATTACH ReadableFontData* instructions();
-
-   public:
     class CompositeGlyphBuilder : public Glyph::Builder,
                                   public RefCounted<CompositeGlyphBuilder> {
      public:
@@ -307,22 +250,74 @@
 
      protected:
       // Note: constructor refactored in C++ to avoid heavy lifting.
-      //       caller need to do data->slice(offset, length) beforehand.
+      //       caller need to do data->Slice(offset, length) beforehand.
       CompositeGlyphBuilder(FontDataTableBuilderContainer* table_builder,
                             WritableFontData* data);
       CompositeGlyphBuilder(FontDataTableBuilderContainer* table_builder,
                             ReadableFontData* data);
 
       virtual CALLER_ATTACH FontDataTable*
-          subBuildTable(ReadableFontData* data);
+          SubBuildTable(ReadableFontData* data);
+
+     private:
       friend class Glyph::Builder;
     };
 
+    // Note: constructor refactored in C++ to avoid heavy lifting.
+    //       caller need to do data->Slice(offset, length) beforehand.
+    explicit CompositeGlyph(ReadableFontData* data);
+    virtual ~CompositeGlyph();
+
+    int32_t Flags(int32_t contour);
+    int32_t NumGlyphs();
+    int32_t GlyphIndex(int32_t contour);
+    int32_t Argument1(int32_t contour);
+    int32_t Argument2(int32_t contour);
+    int32_t TransformationSize(int32_t contour);
+    void Transformation(int32_t contour, ByteVector* transformation);
+    virtual int32_t InstructionSize();
+    virtual CALLER_ATTACH ReadableFontData* Instructions();
+
    private:
+    void ParseData();
+
     IntegerList contour_index_;
     int32_t instruction_size_;
     int32_t instructions_offset_;
   };
+
+  virtual ~GlyphTable();
+
+  // C++ port: rename glyph() to GetGlyph().
+  Glyph* GetGlyph(int32_t offset, int32_t length);
+
+ private:
+  struct Offset {
+    enum {
+      // header
+      kNumberOfContours = 0,
+      kXMin = 2,
+      kYMin = 4,
+      kXMax = 6,
+      kYMax = 8,
+
+      // Simple Glyph Description
+      kSimpleEndPtsOfCountours = 10,
+      // offset from the end of the contours array
+      kSimpleInstructionLength = 0,
+      kSimpleInstructions = 2,
+      // flags
+      // xCoordinates
+      // yCoordinates
+
+      // Composite Glyph Description
+      kCompositeFlags = 0,
+      kCompositeGyphIndexWithoutFlag = 0,
+      kCompositeGlyphIndexWithFlag = 2,
+    };
+  };
+
+  GlyphTable(Header* header, ReadableFontData* data);
 };
 typedef Ptr<GlyphTable> GlyphTablePtr;
 typedef Ptr<GlyphTable::Builder> GlyphTableBuilderPtr;
diff --git a/sfntly/horizontal_header_table.cc b/sfntly/horizontal_header_table.cc
index f30e8db..a987d70 100644
--- a/sfntly/horizontal_header_table.cc
+++ b/sfntly/horizontal_header_table.cc
@@ -24,189 +24,192 @@
 /******************************************************************************
  * HorizontalHeaderTable class
  ******************************************************************************/
-HorizontalHeaderTable:: HorizontalHeaderTable(Header* header,
-                                              ReadableFontData* data) :
-    Table(header, data) {}
-
 HorizontalHeaderTable:: ~HorizontalHeaderTable() {}
 
-int32_t HorizontalHeaderTable::version() {
-  return data_->readFixed(Offset::kVersion);
+int32_t HorizontalHeaderTable::Version() {
+  return data_->ReadFixed(Offset::kVersion);
 }
 
-int32_t HorizontalHeaderTable::ascender() {
-  return data_->readShort(Offset::kAscender);
+int32_t HorizontalHeaderTable::Ascender() {
+  return data_->ReadShort(Offset::kAscender);
 }
 
-int32_t HorizontalHeaderTable::descender() {
-  return data_->readShort(Offset::kDescender);
+int32_t HorizontalHeaderTable::Descender() {
+  return data_->ReadShort(Offset::kDescender);
 }
 
-int32_t HorizontalHeaderTable::lineGap() {
-  return data_->readShort(Offset::kLineGap);
+int32_t HorizontalHeaderTable::LineGap() {
+  return data_->ReadShort(Offset::kLineGap);
 }
 
-int32_t HorizontalHeaderTable::advanceWidthMax() {
-  return data_->readUShort(Offset::kAdvanceWidthMax);
+int32_t HorizontalHeaderTable::AdvanceWidthMax() {
+  return data_->ReadUShort(Offset::kAdvanceWidthMax);
 }
 
-int32_t HorizontalHeaderTable::minLeftSideBearing() {
-  return data_->readShort(Offset::kMinLeftSideBearing);
+int32_t HorizontalHeaderTable::MinLeftSideBearing() {
+  return data_->ReadShort(Offset::kMinLeftSideBearing);
 }
 
-int32_t HorizontalHeaderTable::minRightSideBearing() {
-  return data_->readShort(Offset::kMinRightSideBearing);
+int32_t HorizontalHeaderTable::MinRightSideBearing() {
+  return data_->ReadShort(Offset::kMinRightSideBearing);
 }
 
-int32_t HorizontalHeaderTable::xMaxExtent() {
-  return data_->readShort(Offset::kXMaxExtent);
+int32_t HorizontalHeaderTable::XMaxExtent() {
+  return data_->ReadShort(Offset::kXMaxExtent);
 }
 
-int32_t HorizontalHeaderTable::caretSlopeRise() {
-  return data_->readShort(Offset::kCaretSlopeRise);
+int32_t HorizontalHeaderTable::CaretSlopeRise() {
+  return data_->ReadShort(Offset::kCaretSlopeRise);
 }
 
-int32_t HorizontalHeaderTable::caretSlopeRun() {
-  return data_->readShort(Offset::kCaretSlopeRun);
+int32_t HorizontalHeaderTable::CaretSlopeRun() {
+  return data_->ReadShort(Offset::kCaretSlopeRun);
 }
 
-int32_t HorizontalHeaderTable::caretOffset() {
-  return data_->readShort(Offset::kCaretOffset);
+int32_t HorizontalHeaderTable::CaretOffset() {
+  return data_->ReadShort(Offset::kCaretOffset);
 }
 
-int32_t HorizontalHeaderTable::metricDataFormat() {
-  return data_->readShort(Offset::kMetricDataFormat);
+int32_t HorizontalHeaderTable::MetricDataFormat() {
+  return data_->ReadShort(Offset::kMetricDataFormat);
 }
 
-int32_t HorizontalHeaderTable::numberOfHMetrics() {
-  return data_->readUShort(Offset::kNumberOfHMetrics);
+int32_t HorizontalHeaderTable::NumberOfHMetrics() {
+  return data_->ReadUShort(Offset::kNumberOfHMetrics);
+}
+
+HorizontalHeaderTable:: HorizontalHeaderTable(Header* header,
+                                              ReadableFontData* data)
+    : Table(header, data) {
 }
 
 /******************************************************************************
  * HorizontalHeaderTable::Builder class
  ******************************************************************************/
 HorizontalHeaderTable::Builder::Builder(
-    FontDataTableBuilderContainer* font_builder, Header* header,
-    WritableFontData* data) :
-    Table::TableBasedTableBuilder(font_builder, header, data) {
+    FontDataTableBuilderContainer* font_builder,
+    Header* header,
+    WritableFontData* data)
+    : Table::TableBasedTableBuilder(font_builder, header, data) {
 }
 
 HorizontalHeaderTable::Builder::Builder(
-    FontDataTableBuilderContainer* font_builder, Header* header,
-    ReadableFontData* data) :
-    Table::TableBasedTableBuilder(font_builder, header, data) {
+    FontDataTableBuilderContainer* font_builder,
+    Header* header,
+    ReadableFontData* data)
+    : Table::TableBasedTableBuilder(font_builder, header, data) {
 }
 
 HorizontalHeaderTable::Builder::~Builder() {}
 
-CALLER_ATTACH FontDataTable* HorizontalHeaderTable::Builder::subBuildTable(
-    ReadableFontData* data) {
+CALLER_ATTACH FontDataTable*
+    HorizontalHeaderTable::Builder::SubBuildTable(ReadableFontData* data) {
   FontDataTablePtr table = new HorizontalHeaderTable(header(), data);
-  return table.detach();
+  return table.Detach();
 }
 
-int32_t HorizontalHeaderTable::Builder::version() {
-  return internalReadData()->readFixed(Offset::kVersion);
+int32_t HorizontalHeaderTable::Builder::Version() {
+  return InternalReadData()->ReadFixed(Offset::kVersion);
 }
 
-void HorizontalHeaderTable::Builder::setVersion(int32_t version) {
-  internalWriteData()->writeFixed(Offset::kVersion, version);
+void HorizontalHeaderTable::Builder::SetVersion(int32_t version) {
+  InternalWriteData()->WriteFixed(Offset::kVersion, version);
 }
 
-int32_t HorizontalHeaderTable::Builder::ascender() {
-  return internalReadData()->readUShort(Offset::kAscender);
+int32_t HorizontalHeaderTable::Builder::Ascender() {
+  return InternalReadData()->ReadUShort(Offset::kAscender);
 }
 
-void HorizontalHeaderTable::Builder::setAscender(int32_t ascender) {
-  internalWriteData()->writeUShort(Offset::kVersion, ascender);
+void HorizontalHeaderTable::Builder::SetAscender(int32_t ascender) {
+  InternalWriteData()->WriteUShort(Offset::kVersion, ascender);
 }
 
-int32_t HorizontalHeaderTable::Builder::descender() {
-  return internalReadData()->readUShort(Offset::kDescender);
+int32_t HorizontalHeaderTable::Builder::Descender() {
+  return InternalReadData()->ReadUShort(Offset::kDescender);
 }
 
-void HorizontalHeaderTable::Builder::setDescender(int32_t descender) {
-  internalWriteData()->writeUShort(Offset::kDescender, descender);
+void HorizontalHeaderTable::Builder::SetDescender(int32_t descender) {
+  InternalWriteData()->WriteUShort(Offset::kDescender, descender);
 }
 
-int32_t HorizontalHeaderTable::Builder::lineGap() {
-  return internalReadData()->readUShort(Offset::kLineGap);
+int32_t HorizontalHeaderTable::Builder::LineGap() {
+  return InternalReadData()->ReadUShort(Offset::kLineGap);
 }
 
-void HorizontalHeaderTable::Builder::setLineGap(int32_t line_gap) {
-  internalWriteData()->writeUShort(Offset::kLineGap, line_gap);
+void HorizontalHeaderTable::Builder::SetLineGap(int32_t line_gap) {
+  InternalWriteData()->WriteUShort(Offset::kLineGap, line_gap);
 }
 
-int32_t HorizontalHeaderTable::Builder::advanceWidthMax() {
-  return internalReadData()->readUShort(Offset::kAdvanceWidthMax);
+int32_t HorizontalHeaderTable::Builder::AdvanceWidthMax() {
+  return InternalReadData()->ReadUShort(Offset::kAdvanceWidthMax);
 }
 
-void HorizontalHeaderTable::Builder::setAdvanceWidthMax(int32_t value) {
-  internalWriteData()->writeUShort(Offset::kAdvanceWidthMax, value);
+void HorizontalHeaderTable::Builder::SetAdvanceWidthMax(int32_t value) {
+  InternalWriteData()->WriteUShort(Offset::kAdvanceWidthMax, value);
 }
 
-int32_t HorizontalHeaderTable::Builder::minLeftSideBearing() {
-  return internalReadData()->readUShort(Offset::kMinLeftSideBearing);
+int32_t HorizontalHeaderTable::Builder::MinLeftSideBearing() {
+  return InternalReadData()->ReadUShort(Offset::kMinLeftSideBearing);
 }
 
-void HorizontalHeaderTable::Builder::setMinLeftSideBearing(int32_t value) {
-  internalWriteData()->writeUShort(Offset::kMinLeftSideBearing, value);
+void HorizontalHeaderTable::Builder::SetMinLeftSideBearing(int32_t value) {
+  InternalWriteData()->WriteUShort(Offset::kMinLeftSideBearing, value);
 }
 
-int32_t HorizontalHeaderTable::Builder::minRightSideBearing() {
-  return internalReadData()->readUShort(Offset::kMinRightSideBearing);
+int32_t HorizontalHeaderTable::Builder::MinRightSideBearing() {
+  return InternalReadData()->ReadUShort(Offset::kMinRightSideBearing);
 }
 
-void HorizontalHeaderTable::Builder::setMinRightSideBearing(int32_t value) {
-  internalWriteData()->writeUShort(Offset::kMinRightSideBearing, value);
+void HorizontalHeaderTable::Builder::SetMinRightSideBearing(int32_t value) {
+  InternalWriteData()->WriteUShort(Offset::kMinRightSideBearing, value);
 }
 
-int32_t HorizontalHeaderTable::Builder::xMaxExtent() {
-  return internalReadData()->readUShort(Offset::kXMaxExtent);
+int32_t HorizontalHeaderTable::Builder::XMaxExtent() {
+  return InternalReadData()->ReadUShort(Offset::kXMaxExtent);
 }
 
-void HorizontalHeaderTable::Builder::setXMaxExtent(int32_t value) {
-  internalWriteData()->writeUShort(Offset::kXMaxExtent, value);
+void HorizontalHeaderTable::Builder::SetXMaxExtent(int32_t value) {
+  InternalWriteData()->WriteUShort(Offset::kXMaxExtent, value);
 }
 
-int32_t HorizontalHeaderTable::Builder::caretSlopeRise() {
-  return internalReadData()->readUShort(Offset::kCaretSlopeRise);
+int32_t HorizontalHeaderTable::Builder::CaretSlopeRise() {
+  return InternalReadData()->ReadUShort(Offset::kCaretSlopeRise);
 }
 
-void HorizontalHeaderTable::Builder::setCaretSlopeRise(int32_t value) {
-  internalWriteData()->writeUShort(Offset::kCaretSlopeRise, value);
+void HorizontalHeaderTable::Builder::SetCaretSlopeRise(int32_t value) {
+  InternalWriteData()->WriteUShort(Offset::kCaretSlopeRise, value);
 }
 
-int32_t HorizontalHeaderTable::Builder::caretSlopeRun() {
-  return internalReadData()->readUShort(Offset::kCaretSlopeRun);
+int32_t HorizontalHeaderTable::Builder::CaretSlopeRun() {
+  return InternalReadData()->ReadUShort(Offset::kCaretSlopeRun);
 }
 
-void HorizontalHeaderTable::Builder::setCaretSlopeRun(int32_t value) {
-  internalWriteData()->writeUShort(Offset::kCaretSlopeRun, value);
+void HorizontalHeaderTable::Builder::SetCaretSlopeRun(int32_t value) {
+  InternalWriteData()->WriteUShort(Offset::kCaretSlopeRun, value);
 }
 
-int32_t HorizontalHeaderTable::Builder::caretOffset() {
-  return internalReadData()->readUShort(Offset::kCaretOffset);
+int32_t HorizontalHeaderTable::Builder::CaretOffset() {
+  return InternalReadData()->ReadUShort(Offset::kCaretOffset);
 }
 
-void HorizontalHeaderTable::Builder::setCaretOffset(int32_t value) {
-  internalWriteData()->writeUShort(Offset::kCaretOffset, value);
+void HorizontalHeaderTable::Builder::SetCaretOffset(int32_t value) {
+  InternalWriteData()->WriteUShort(Offset::kCaretOffset, value);
 }
 
-int32_t HorizontalHeaderTable::Builder::metricDataFormat() {
-  return internalReadData()->readUShort(Offset::kMetricDataFormat);
+int32_t HorizontalHeaderTable::Builder::MetricDataFormat() {
+  return InternalReadData()->ReadUShort(Offset::kMetricDataFormat);
 }
 
-void HorizontalHeaderTable::Builder::setMetricDataFormat(int32_t value) {
-  internalWriteData()->writeUShort(Offset::kMetricDataFormat, value);
+void HorizontalHeaderTable::Builder::SetMetricDataFormat(int32_t value) {
+  InternalWriteData()->WriteUShort(Offset::kMetricDataFormat, value);
 }
 
-int32_t HorizontalHeaderTable::Builder::numberOfHMetrics() {
-  return internalReadData()->readUShort(Offset::kNumberOfHMetrics);
+int32_t HorizontalHeaderTable::Builder::NumberOfHMetrics() {
+  return InternalReadData()->ReadUShort(Offset::kNumberOfHMetrics);
 }
 
-void HorizontalHeaderTable::Builder::setNumberOfHMetrics(int32_t value) {
-  internalWriteData()->writeUShort(Offset::kNumberOfHMetrics, value);
+void HorizontalHeaderTable::Builder::SetNumberOfHMetrics(int32_t value) {
+  InternalWriteData()->WriteUShort(Offset::kNumberOfHMetrics, value);
 }
 
 }  // namespace sfntly
diff --git a/sfntly/horizontal_header_table.h b/sfntly/horizontal_header_table.h
index 704391c..e8a3534 100644
--- a/sfntly/horizontal_header_table.h
+++ b/sfntly/horizontal_header_table.h
@@ -23,6 +23,64 @@
 
 class HorizontalHeaderTable : public Table,
                               public RefCounted<HorizontalHeaderTable> {
+ public:
+  class Builder : public Table::TableBasedTableBuilder,
+                  public RefCounted<Builder> {
+   public:
+    // Constructor scope altered to public because C++ does not allow base
+    // class to instantiate derived class with protected constructors.
+    Builder(FontDataTableBuilderContainer* font_builder,
+            Header* header,
+            WritableFontData* data);
+    Builder(FontDataTableBuilderContainer* font_builder,
+            Header* header,
+            ReadableFontData* data);
+    virtual ~Builder();
+    virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
+
+    int32_t Version();
+    void SetVersion(int32_t version);
+    int32_t Ascender();
+    void SetAscender(int32_t ascender);
+    int32_t Descender();
+    void SetDescender(int32_t descender);
+    int32_t LineGap();
+    void SetLineGap(int32_t line_gap);
+    int32_t AdvanceWidthMax();
+    void SetAdvanceWidthMax(int32_t value);
+    int32_t MinLeftSideBearing();
+    void SetMinLeftSideBearing(int32_t value);
+    int32_t MinRightSideBearing();
+    void SetMinRightSideBearing(int32_t value);
+    int32_t XMaxExtent();
+    void SetXMaxExtent(int32_t value);
+    int32_t CaretSlopeRise();
+    void SetCaretSlopeRise(int32_t value);
+    int32_t CaretSlopeRun();
+    void SetCaretSlopeRun(int32_t value);
+    int32_t CaretOffset();
+    void SetCaretOffset(int32_t value);
+    int32_t MetricDataFormat();
+    void SetMetricDataFormat(int32_t value);
+    int32_t NumberOfHMetrics();
+    void SetNumberOfHMetrics(int32_t value);
+  };
+
+  virtual ~HorizontalHeaderTable();
+  int32_t Version();
+  int32_t Ascender();
+  int32_t Descender();
+  int32_t LineGap();
+  int32_t AdvanceWidthMax();
+  int32_t MinLeftSideBearing();
+  int32_t MinRightSideBearing();
+  int32_t XMaxExtent();
+  int32_t CaretSlopeRise();
+  int32_t CaretSlopeRun();
+  int32_t CaretOffset();
+  int32_t MetricDataFormat();
+  int32_t NumberOfHMetrics();
+
  private:
   struct Offset {
     enum {
@@ -42,65 +100,7 @@
     };
   };
 
- private:
   HorizontalHeaderTable(Header* header, ReadableFontData* data);
-
- public:
-  virtual ~HorizontalHeaderTable();
-  int32_t version();
-  int32_t ascender();
-  int32_t descender();
-  int32_t lineGap();
-  int32_t advanceWidthMax();
-  int32_t minLeftSideBearing();
-  int32_t minRightSideBearing();
-  int32_t xMaxExtent();
-  int32_t caretSlopeRise();
-  int32_t caretSlopeRun();
-  int32_t caretOffset();
-  int32_t metricDataFormat();
-  int32_t numberOfHMetrics();
-
- public:
-  class Builder : public Table::TableBasedTableBuilder,
-                  public RefCounted<Builder> {
-   public:
-    // Constructor scope altered to public because C++ does not allow base
-    // class to instantiate derived class with protected constructors.
-    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
-            WritableFontData* data);
-    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
-            ReadableFontData* data);
-    virtual ~Builder();
-    virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
-
-    int32_t version();
-    void setVersion(int32_t version);
-    int32_t ascender();
-    void setAscender(int32_t ascender);
-    int32_t descender();
-    void setDescender(int32_t descender);
-    int32_t lineGap();
-    void setLineGap(int32_t line_gap);
-    int32_t advanceWidthMax();
-    void setAdvanceWidthMax(int32_t value);
-    int32_t minLeftSideBearing();
-    void setMinLeftSideBearing(int32_t value);
-    int32_t minRightSideBearing();
-    void setMinRightSideBearing(int32_t value);
-    int32_t xMaxExtent();
-    void setXMaxExtent(int32_t value);
-    int32_t caretSlopeRise();
-    void setCaretSlopeRise(int32_t value);
-    int32_t caretSlopeRun();
-    void setCaretSlopeRun(int32_t value);
-    int32_t caretOffset();
-    void setCaretOffset(int32_t value);
-    int32_t metricDataFormat();
-    void setMetricDataFormat(int32_t value);
-    int32_t numberOfHMetrics();
-    void setNumberOfHMetrics(int32_t value);
-  };
 };
 typedef Ptr<HorizontalHeaderTable> HorizontalHeaderTablePtr;
 typedef Ptr<HorizontalHeaderTable::Builder> HorizontalHeaderTableBuilderPtr;
diff --git a/sfntly/horizontal_metrics_table.cc b/sfntly/horizontal_metrics_table.cc
index c151e18..921d8bc 100644
--- a/sfntly/horizontal_metrics_table.cc
+++ b/sfntly/horizontal_metrics_table.cc
@@ -21,29 +21,17 @@
 /******************************************************************************
  * HorizontalMetricsTable class
  ******************************************************************************/
-HorizontalMetricsTable::HorizontalMetricsTable(Header* header,
-                                               ReadableFontData* data) :
-    Table(header, data) {
-}
-
-HorizontalMetricsTable::HorizontalMetricsTable(Header* header,
-                                               ReadableFontData* data,
-                                               int32_t num_hmetrics,
-                                               int32_t num_glyphs) :
-    Table(header, data), num_hmetrics_(num_hmetrics), num_glyphs_(num_glyphs) {
-}
-
 HorizontalMetricsTable::~HorizontalMetricsTable() {}
 
-int32_t HorizontalMetricsTable::numberOfHMetrics() {
+int32_t HorizontalMetricsTable::NumberOfHMetrics() {
   return num_hmetrics_;
 }
 
-int32_t HorizontalMetricsTable::numberOfLSBs() {
+int32_t HorizontalMetricsTable::NumberOfLSBs() {
   return num_glyphs_ - num_hmetrics_;
 }
 
-int32_t HorizontalMetricsTable::hMetricAdvanceWidth(int32_t entry) {
+int32_t HorizontalMetricsTable::HMetricAdvanceWidth(int32_t entry) {
   if (entry > num_hmetrics_) {
 #if defined (SFNTLY_NO_EXCEPTION)
     return 0;
@@ -53,10 +41,10 @@
   }
   int32_t offset = Offset::kHMetricsStart + (entry * Offset::kHMetricsSize) +
                    Offset::kHMetricsAdvanceWidth;
-  return data_->readUShort(offset);
+  return data_->ReadUShort(offset);
 }
 
-int32_t HorizontalMetricsTable::hMetricLSB(int32_t entry) {
+int32_t HorizontalMetricsTable::HMetricLSB(int32_t entry) {
   if (entry > num_hmetrics_) {
 #if defined (SFNTLY_NO_EXCEPTION)
     return 0;
@@ -66,10 +54,10 @@
   }
   int32_t offset = Offset::kHMetricsStart + (entry * Offset::kHMetricsSize) +
                    Offset::kHMetricsLeftSideBearing;
-  return data_->readShort(offset);
+  return data_->ReadShort(offset);
 }
 
-int32_t HorizontalMetricsTable::lsbTableEntry(int32_t entry) {
+int32_t HorizontalMetricsTable::LsbTableEntry(int32_t entry) {
   if (entry > num_hmetrics_) {
 #if defined (SFNTLY_NO_EXCEPTION)
     return 0;
@@ -79,62 +67,78 @@
   }
   int32_t offset = Offset::kHMetricsStart + (entry * Offset::kHMetricsSize) +
                    Offset::kLeftSideBearingSize;
-  return data_->readShort(offset);
+  return data_->ReadShort(offset);
 }
 
-int32_t HorizontalMetricsTable::advanceWidth(int32_t glyph_id) {
+int32_t HorizontalMetricsTable::AdvanceWidth(int32_t glyph_id) {
   if (glyph_id < num_hmetrics_) {
-    return hMetricAdvanceWidth(glyph_id);
+    return HMetricAdvanceWidth(glyph_id);
   }
-  return hMetricAdvanceWidth(glyph_id - num_hmetrics_);
+  return HMetricAdvanceWidth(glyph_id - num_hmetrics_);
+}
+
+HorizontalMetricsTable::HorizontalMetricsTable(Header* header,
+                                               ReadableFontData* data)
+    : Table(header, data) {
+}
+
+HorizontalMetricsTable::HorizontalMetricsTable(Header* header,
+                                               ReadableFontData* data,
+                                               int32_t num_hmetrics,
+                                               int32_t num_glyphs)
+    : Table(header, data),
+      num_hmetrics_(num_hmetrics),
+      num_glyphs_(num_glyphs) {
 }
 
 /******************************************************************************
  * HorizontalMetricsTable::Builder class
  ******************************************************************************/
-void HorizontalMetricsTable::Builder::init() {
-  num_hmetrics_ = -1;
-  num_glyphs_ = -1;
+HorizontalMetricsTable::Builder::Builder(
+    FontDataTableBuilderContainer* font_builder,
+    Header* header,
+    WritableFontData* data)
+    : Table::TableBasedTableBuilder(font_builder, header, data) {
+  Init();
 }
 
 HorizontalMetricsTable::Builder::Builder(
-    FontDataTableBuilderContainer* font_builder, Header* header,
-    WritableFontData* data) :
-    Table::TableBasedTableBuilder(font_builder, header, data) {
-  init();
-}
-
-HorizontalMetricsTable::Builder::Builder(
-    FontDataTableBuilderContainer* font_builder, Header* header,
-    ReadableFontData* data) :
-    Table::TableBasedTableBuilder(font_builder, header, data) {
-  init();
+    FontDataTableBuilderContainer* font_builder,
+    Header* header,
+    ReadableFontData* data)
+    : Table::TableBasedTableBuilder(font_builder, header, data) {
+  Init();
 }
 
 HorizontalMetricsTable::Builder::~Builder() {}
 
-CALLER_ATTACH FontDataTable* HorizontalMetricsTable::Builder::subBuildTable(
-    ReadableFontData* data) {
+CALLER_ATTACH FontDataTable*
+    HorizontalMetricsTable::Builder::SubBuildTable(ReadableFontData* data) {
   FontDataTablePtr table =
       new HorizontalMetricsTable(header(), data, num_hmetrics_, num_glyphs_);
-  return table.detach();
+  return table.Detach();
 }
 
-void HorizontalMetricsTable::Builder::setNumberOfHMetrics(
-                                          int32_t num_hmetrics) {
+void HorizontalMetricsTable::Builder::SetNumberOfHMetrics(
+    int32_t num_hmetrics) {
   assert(num_hmetrics >= 0);
   num_hmetrics_ = num_hmetrics;
-  HorizontalMetricsTable* table = down_cast<HorizontalMetricsTable*>(
-                                      this->table());
+  HorizontalMetricsTable* table =
+      down_cast<HorizontalMetricsTable*>(this->GetTable());
   table->num_hmetrics_ = num_hmetrics;
 }
 
-void HorizontalMetricsTable::Builder::setNumGlyphs(int32_t num_glyphs) {
+void HorizontalMetricsTable::Builder::SetNumGlyphs(int32_t num_glyphs) {
   assert(num_glyphs >= 0);
   num_glyphs_ = num_glyphs;
-  HorizontalMetricsTable* table = down_cast<HorizontalMetricsTable*>(
-                                      this->table());
+  HorizontalMetricsTable* table =
+      down_cast<HorizontalMetricsTable*>(this->GetTable());
   table->num_glyphs_ = num_glyphs;
 }
 
+void HorizontalMetricsTable::Builder::Init() {
+  num_hmetrics_ = -1;
+  num_glyphs_ = -1;
+}
+
 }  // namespace sfntly
diff --git a/sfntly/horizontal_metrics_table.h b/sfntly/horizontal_metrics_table.h
index c393fee..aead6fa 100644
--- a/sfntly/horizontal_metrics_table.h
+++ b/sfntly/horizontal_metrics_table.h
@@ -23,6 +23,39 @@
 
 class HorizontalMetricsTable : public Table,
                                public RefCounted<HorizontalMetricsTable> {
+ public:
+  class Builder : public Table::TableBasedTableBuilder,
+                  public RefCounted<Builder> {
+   public:
+    // Constructor scope altered to public because C++ does not allow base
+    // class to instantiate derived class with protected constructors.
+    Builder(FontDataTableBuilderContainer* font_builder,
+            Header* header,
+            WritableFontData* data);
+    Builder(FontDataTableBuilderContainer* font_builder,
+            Header* header,
+            ReadableFontData* data);
+    virtual ~Builder();
+
+    virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
+    void SetNumberOfHMetrics(int32_t num_hmetrics);
+    void SetNumGlyphs(int32_t num_glyphs);
+
+   private:
+    void Init();
+
+    int32_t num_hmetrics_;
+    int32_t num_glyphs_;
+  };
+
+  virtual ~HorizontalMetricsTable();
+  int32_t NumberOfHMetrics();
+  int32_t NumberOfLSBs();
+  int32_t HMetricAdvanceWidth(int32_t entry);
+  int32_t HMetricLSB(int32_t entry);
+  int32_t LsbTableEntry(int32_t entry);
+  int32_t AdvanceWidth(int32_t glyph_id);
+
  private:
   struct Offset {
     enum {
@@ -38,43 +71,12 @@
     };
   };
 
- private:
   HorizontalMetricsTable(Header* header, ReadableFontData* data);
-  HorizontalMetricsTable(Header* header, ReadableFontData* data,
-                         int32_t num_hmetrics, int32_t num_glyphs);
+  HorizontalMetricsTable(Header* header,
+                         ReadableFontData* data,
+                         int32_t num_hmetrics,
+                         int32_t num_glyphs);
 
- public:  // class is final, no virtual functions unless inherited from parent.
-  virtual ~HorizontalMetricsTable();
-  int32_t numberOfHMetrics();
-  int32_t numberOfLSBs();
-  int32_t hMetricAdvanceWidth(int32_t entry);
-  int32_t hMetricLSB(int32_t entry);
-  int32_t lsbTableEntry(int32_t entry);
-  int32_t advanceWidth(int32_t glyph_id);
-
- public:
-  class Builder : public Table::TableBasedTableBuilder,
-                  public RefCounted<Builder> {
-   public:
-    // Constructor scope altered to public because C++ does not allow base
-    // class to instantiate derived class with protected constructors.
-    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
-            WritableFontData* data);
-    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
-            ReadableFontData* data);
-    virtual ~Builder();
-    void init();
-
-    virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
-    void setNumberOfHMetrics(int32_t num_hmetrics);
-    void setNumGlyphs(int32_t num_glyphs);
-
-   private:
-    int32_t num_hmetrics_;
-    int32_t num_glyphs_;
-  };
-
- private:
   int32_t num_hmetrics_;
   int32_t num_glyphs_;
 };
diff --git a/sfntly/loca_table.cc b/sfntly/loca_table.cc
index 1cd1d92..e82f709 100644
--- a/sfntly/loca_table.cc
+++ b/sfntly/loca_table.cc
@@ -21,20 +21,13 @@
 /******************************************************************************
  * LocaTable class
  ******************************************************************************/
-LocaTable::LocaTable(Header* header, ReadableFontData* data)
-    : Table(header, data) {}
-
-LocaTable::LocaTable(Header* header, ReadableFontData* data, int32_t version,
-                     int32_t num_glyphs)
-    : Table(header, data), version_(version), num_glyphs_(num_glyphs) {}
-
 LocaTable::~LocaTable() {}
 
-int32_t LocaTable::numGlyphs() {
+int32_t LocaTable::NumGlyphs() {
   return num_glyphs_;
 }
 
-int32_t LocaTable::glyphOffset(int32_t glyph_id) {
+int32_t LocaTable::GlyphOffset(int32_t glyph_id) {
   if (glyph_id < 0 || glyph_id >= num_glyphs_) {
 #if defined (SFNTLY_NO_EXCEPTION)
     return 0;
@@ -42,10 +35,10 @@
     throw IndexOutOfBoundException("Glyph ID is out of bounds.");
 #endif
   }
-  return loca(glyph_id);
+  return Loca(glyph_id);
 }
 
-int32_t LocaTable::glyphLength(int32_t glyph_id) {
+int32_t LocaTable::GlyphLength(int32_t glyph_id) {
   if (glyph_id < 0 || glyph_id >= num_glyphs_) {
 #if defined (SFNTLY_NO_EXCEPTION)
     return 0;
@@ -53,14 +46,14 @@
     throw IndexOutOfBoundException("Glyph ID is out of bounds.");
 #endif
   }
-  return loca(glyph_id + 1) - loca(glyph_id);
+  return Loca(glyph_id + 1) - Loca(glyph_id);
 }
 
-int32_t LocaTable::numLocas() {
+int32_t LocaTable::NumLocas() {
   return num_glyphs_ + 1;
 }
 
-int32_t LocaTable::loca(int32_t index) {
+int32_t LocaTable::Loca(int32_t index) {
   if (index > num_glyphs_) {
 #if defined (SFNTLY_NO_EXCEPTION)
     return 0;
@@ -69,92 +62,73 @@
 #endif
   }
   if (version_ == IndexToLocFormat::kShortOffset) {
-    return 2 * data_->readShort(index * DataSize::kUSHORT);
+    return 2 * data_->ReadShort(index * DataSize::kUSHORT);
   }
-  return data_->readULongAsInt(index * DataSize::kULONG);
+  return data_->ReadULongAsInt(index * DataSize::kULONG);
+}
+
+LocaTable::LocaTable(Header* header, ReadableFontData* data)
+    : Table(header, data) {
+}
+
+LocaTable::LocaTable(Header* header,
+                     ReadableFontData* data,
+                     int32_t version,
+                     int32_t num_glyphs)
+    : Table(header, data), version_(version), num_glyphs_(num_glyphs) {
 }
 
 /******************************************************************************
- * LocaTable::Builder class
+ * LocaTable::Iterator class
  ******************************************************************************/
-LocaTable::LocaIterator::LocaIterator(LocaTable* table) : index_(-1) {
+LocaTable::LocaIterator::LocaIterator(LocaTable* table)
+    : index_(-1) {
   table_ = table;
 }
 
-bool LocaTable::LocaIterator::hasNext() {
+bool LocaTable::LocaIterator::HasNext() {
   return index_ <= table_->num_glyphs_;
 }
 
-int32_t LocaTable::LocaIterator::next() {
-  return table_->loca(index_++);
+int32_t LocaTable::LocaIterator::Next() {
+  return table_->Loca(index_++);
 }
 
 /******************************************************************************
  * LocaTable::Builder class
  ******************************************************************************/
-void LocaTable::Builder::init() {
-  num_glyphs_ = -1;
-  format_version_ = IndexToLocFormat::kLongOffset;
-}
-
 LocaTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
                             Header* header, WritableFontData* data) :
     Table::ArrayElementTableBuilder(font_builder, header, data) {
-  init();
+  Init();
 }
 
 LocaTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
                             Header* header, ReadableFontData* data) :
     Table::ArrayElementTableBuilder(font_builder, header, data) {
-  init();
+  Init();
 }
 
 LocaTable::Builder::~Builder() {}
 
-void LocaTable::Builder::initialize(ReadableFontData* data) {
-  if (data) {
-    if (numGlyphs() < 0) {
-#if defined (SFNTLY_NO_EXCEPTION)
-      return;
-#else
-      throw IllegalStateException("numglyphs not set on LocaTable Builder.");
-#endif
-    }
-    LocaTablePtr table =
-        new LocaTable(header(), data, format_version_, num_glyphs_);
-    LocaTable::LocaIterator loca_iter(table);
-    while (loca_iter.hasNext()) {
-      loca_.push_back(loca_iter.next());
-    }
-  }
-}
-
-IntegerList* LocaTable::Builder::getLocaList() {
-  if (loca_.empty()) {
-    initialize(internalReadData());
-    setModelChanged();
-  }
-  return &loca_;
-}
-
-void LocaTable::Builder::setFormatVersion(int32_t format_version) {
+void LocaTable::Builder::SetFormatVersion(int32_t format_version) {
   format_version_ = format_version;
 }
 
-IntegerList* LocaTable::Builder::locaList() {
-  return getLocaList();
+IntegerList* LocaTable::Builder::LocaList() {
+  return GetLocaList();
 }
 
-void LocaTable::Builder::setLocaList(IntegerList* list) {
+void LocaTable::Builder::SetLocaList(IntegerList* list) {
   loca_.clear();
   if (list) {
     loca_ = *list;
     num_glyphs_ = loca_.size();
-    setModelChanged();
+    set_model_changed();
   }
 }
 
-int32_t LocaTable::Builder::glyphOffset(int32_t glyph_id) {
+int32_t LocaTable::Builder::GlyphOffset(int32_t glyph_id) {
   if (glyph_id < 0 || glyph_id > (num_glyphs_ + 1)) {
 #if defined (SFNTLY_NO_EXCEPTION)
     return 0;
@@ -162,10 +136,10 @@
     throw IndexOutOfBoundException("Glyph ID is out of bounds.");
 #endif
   }
-  return loca(glyph_id);
+  return Loca(glyph_id);
 }
 
-int32_t LocaTable::Builder::glyphLength(int32_t glyph_id) {
+int32_t LocaTable::Builder::GlyphLength(int32_t glyph_id) {
   if (glyph_id < 0 || glyph_id > (num_glyphs_ + 1)) {
 #if defined (SFNTLY_NO_EXCEPTION)
     return 0;
@@ -173,49 +147,49 @@
     throw IndexOutOfBoundException("Glyph ID is out of bounds.");
 #endif
   }
-  return loca(glyph_id + 1) - loca(glyph_id);
+  return Loca(glyph_id + 1) - Loca(glyph_id);
 }
 
-void LocaTable::Builder::setNumGlyphs(int32_t num_glyphs) {
+void LocaTable::Builder::SetNumGlyphs(int32_t num_glyphs) {
   num_glyphs_ = num_glyphs;
 }
 
-int32_t LocaTable::Builder::numGlyphs() {
+int32_t LocaTable::Builder::NumGlyphs() {
   if (!loca_.empty()) {
     return loca_.size() - 1;
   }
   return num_glyphs_;
 }
 
-void LocaTable::Builder::revert() {
+void LocaTable::Builder::Revert() {
   loca_.clear();
-  setModelChanged(false);
+  set_model_changed(false);
 }
 
-void LocaTable::Builder::clear() {
-  getLocaList()->clear();
+void LocaTable::Builder::Clear() {
+  GetLocaList()->clear();
 }
 
-int32_t LocaTable::Builder::numLocas() {
-  return getLocaList()->size();
+int32_t LocaTable::Builder::NumLocas() {
+  return GetLocaList()->size();
 }
 
-int32_t LocaTable::Builder::loca(int32_t index) {
-  return getLocaList()->at(index);
+int32_t LocaTable::Builder::Loca(int32_t index) {
+  return GetLocaList()->at(index);
 }
 
-CALLER_ATTACH FontDataTable* LocaTable::Builder::subBuildTable(
+CALLER_ATTACH FontDataTable* LocaTable::Builder::SubBuildTable(
     ReadableFontData* data) {
   FontDataTablePtr table =
       new LocaTable(header(), data, format_version_, num_glyphs_);
-  return table.detach();
+  return table.Detach();
 }
 
-void LocaTable::Builder::subDataSet() {
-  initialize(internalReadData());
+void LocaTable::Builder::SubDataSet() {
+  Initialize(InternalReadData());
 }
 
-int32_t LocaTable::Builder::subDataSizeToSerialize() {
+int32_t LocaTable::Builder::SubDataSizeToSerialize() {
   if (loca_.empty()) {
     return 0;
   }
@@ -225,21 +199,52 @@
   return loca_.size() * DataSize::kUSHORT;
 }
 
-bool LocaTable::Builder::subReadyToSerialize() {
+bool LocaTable::Builder::SubReadyToSerialize() {
   return !loca_.empty();
 }
 
-int32_t LocaTable::Builder::subSerialize(WritableFontData* new_data) {
+int32_t LocaTable::Builder::SubSerialize(WritableFontData* new_data) {
   int32_t size = 0;
   for (IntegerList::iterator l = loca_.begin(), end = loca_.end();
                              l != end; ++l) {
     if (format_version_ == IndexToLocFormat::kLongOffset) {
-      size += new_data->writeULong(size, *l);
+      size += new_data->WriteULong(size, *l);
     } else {
-      size += new_data->writeUShort(size, *l / 2);
+      size += new_data->WriteUShort(size, *l / 2);
     }
   }
   return 0;
 }
 
+void LocaTable::Builder::Init() {
+  num_glyphs_ = -1;
+  format_version_ = IndexToLocFormat::kLongOffset;
+}
+
+void LocaTable::Builder::Initialize(ReadableFontData* data) {
+  if (data) {
+    if (NumGlyphs() < 0) {
+#if defined (SFNTLY_NO_EXCEPTION)
+      return;
+#else
+      throw IllegalStateException("numglyphs not set on LocaTable Builder.");
+#endif
+    }
+    LocaTablePtr table =
+        new LocaTable(header(), data, format_version_, num_glyphs_);
+    LocaTable::LocaIterator loca_iter(table);
+    while (loca_iter.HasNext()) {
+      loca_.push_back(loca_iter.Next());
+    }
+  }
+}
+
+IntegerList* LocaTable::Builder::GetLocaList() {
+  if (loca_.empty()) {
+    Initialize(InternalReadData());
+    set_model_changed();
+  }
+  return &loca_;
+}
+
 }  // namespace sfntly
diff --git a/sfntly/loca_table.h b/sfntly/loca_table.h
index 741cb56..dcf9715 100644
--- a/sfntly/loca_table.h
+++ b/sfntly/loca_table.h
@@ -23,50 +23,19 @@
 namespace sfntly {
 
 class LocaTable : public Table, public RefCounted<LocaTable> {
- private:
-  LocaTable(Header* header, ReadableFontData* data);
-  LocaTable(Header* header, ReadableFontData* data, int32_t version,
-            int32_t num_glyphs);
-
- public:  // class is final, no virtual unless inherited from parents.
-  virtual ~LocaTable();
-  int32_t numGlyphs();
-
-  // Return the offset for the given glyph id. Valid glyph ids are from 0 to the
-  // one less than the number of glyphs. The zero entry is the special entry for
-  // the notdef glyph. The final entry beyond the last glyph id is used to
-  // calculate the size of the last glyph.
-  // @param glyphId the glyph id to get the offset for; must be less than or
-  //        equal to one more than the number of glyph ids
-  // @return the offset in the glyph table to the specified glyph id
-  int32_t glyphOffset(int32_t glyph_id);
-
-  // Get the length of the data in the glyph table for the specified glyph id.
-  int32_t glyphLength(int32_t glyph_id);
-
-  // Get the number of locations or locas. This will be one more than the number
-  // of glyphs for this table since the last loca position is used to indicate
-  // the size of the final glyph.
-  int32_t numLocas();
-
-  // Get the value from the loca table for the index specified. Valid index
-  // values run from 0 to the number of glyphs in the font.
-  int32_t loca(int32_t index);
-
  public:
   // Note: different implementation than Java, caller to instantiate this class
   //       object directly from stack instead of calling LocaTable::iterator().
   class LocaIterator {
    public:
     explicit LocaIterator(LocaTable* table);
-    bool hasNext();
-    int32_t next();
+    bool HasNext();
+    int32_t Next();
 
    private:
     int32_t index_;
     LocaTable* table_;  // use dumb pointer since it's a composition object
   };
-  friend class LocaIterator;
 
   class Builder : public Table::ArrayElementTableBuilder,
                   public RefCounted<Builder> {
@@ -78,21 +47,15 @@
             ReadableFontData* data);
     virtual ~Builder();
 
-   private:
-    void init();  // short hand for common code in ctors, C++ port only
-    void initialize(ReadableFontData* data);  // ported from Java
-    IntegerList* getLocaList();
-
-   public:  // static class, no virtual function unless inherited from parent.
-    void setFormatVersion(int32_t format_version);
+    void SetFormatVersion(int32_t format_version);
 
     // Gets the List of locas for loca table builder. These may be manipulated
     // in any way by the caller and the changes will be reflected in the final
     // loca table produced.
     // If there is no current data for the loca table builder or the loca list
     // have not been previously set then this will return an empty List.
-    IntegerList* locaList();
-    void setLocaList(IntegerList* list);
+    IntegerList* LocaList();
+    void SetLocaList(IntegerList* list);
 
     // Return the offset for the given glyph id. Valid glyph ids are from 0 to
     // one less than the number of glyphs. The zero entry is the special entry
@@ -101,43 +64,79 @@
     // @param glyphId the glyph id to get the offset for; must be less than or
     //        equal to one more than the number of glyph ids
     // @return the offset in the glyph table to the specified glyph id
-    int32_t glyphOffset(int32_t glyph_id);
+    int32_t GlyphOffset(int32_t glyph_id);
 
     // Get the length of the data in the glyph table for the specified glyph id.
-    int32_t glyphLength(int32_t glyph_id);
+    int32_t GlyphLength(int32_t glyph_id);
 
     // Set the number of glyphs.
     // This method sets the number of glyphs that the builder will attempt to
     // parse location data for from the raw binary data. This method only needs
     // to be called (and <b>must</b> be) when the raw data for this builder has
     // been changed.
-    void setNumGlyphs(int32_t num_glyphs);
-    int numGlyphs();
+    void SetNumGlyphs(int32_t num_glyphs);
+    int NumGlyphs();
 
-    void revert();
-    void clear();
+    void Revert();
+    void Clear();
 
     // Get the number of locations or locas. This will be one more than the
     // number of glyphs for this table since the last loca position is used to
     // indicate the size of the final glyph.
-    int32_t numLocas();
-    int32_t loca(int32_t index);
+    int32_t NumLocas();
+    int32_t Loca(int32_t index);
 
-    virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
-    virtual void subDataSet();
-    virtual int32_t subDataSizeToSerialize();
-    virtual bool subReadyToSerialize();
-    virtual int32_t subSerialize(WritableFontData* new_data);
+    virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
+    virtual void SubDataSet();
+    virtual int32_t SubDataSizeToSerialize();
+    virtual bool SubReadyToSerialize();
+    virtual int32_t SubSerialize(WritableFontData* new_data);
 
    private:
+    void Init();  // short hand for common code in ctors, C++ port only
+    void Initialize(ReadableFontData* data);  // ported from Java
+    IntegerList* GetLocaList();
+
     int32_t format_version_;  // Note: IndexToLocFormat
     int32_t num_glyphs_;
     IntegerList loca_;
   };
 
+  virtual ~LocaTable();
+  int32_t NumGlyphs();
+
+  // Return the offset for the given glyph id. Valid glyph ids are from 0 to the
+  // one less than the number of glyphs. The zero entry is the special entry for
+  // the notdef glyph. The final entry beyond the last glyph id is used to
+  // calculate the size of the last glyph.
+  // @param glyphId the glyph id to get the offset for; must be less than or
+  //        equal to one more than the number of glyph ids
+  // @return the offset in the glyph table to the specified glyph id
+  int32_t GlyphOffset(int32_t glyph_id);
+
+  // Get the length of the data in the glyph table for the specified glyph id.
+  int32_t GlyphLength(int32_t glyph_id);
+
+  // Get the number of locations or locas. This will be one more than the number
+  // of glyphs for this table since the last loca position is used to indicate
+  // the size of the final glyph.
+  int32_t NumLocas();
+
+  // Get the value from the loca table for the index specified. Valid index
+  // values run from 0 to the number of glyphs in the font.
+  int32_t Loca(int32_t index);
+
  private:
+  LocaTable(Header* header, ReadableFontData* data);
+  LocaTable(Header* header,
+            ReadableFontData* data,
+            int32_t version,
+            int32_t num_glyphs);
+
   int32_t version_;  // Note: IndexToLocFormat
   int32_t num_glyphs_;
+
+  friend class LocaIterator;
 };
 typedef Ptr<LocaTable> LocaTablePtr;
 typedef Ptr<LocaTable::Builder> LocaTableBuilderPtr;
diff --git a/sfntly/math/fixed1616.h b/sfntly/math/fixed1616.h
index aa3a62b..843da51 100644
--- a/sfntly/math/fixed1616.h
+++ b/sfntly/math/fixed1616.h
@@ -23,15 +23,15 @@
 
 class Fixed1616 {
  public:
-  static inline int32_t integral(int32_t fixed) {
+  static inline int32_t Integral(int32_t fixed) {
     return (fixed >> 16);
   }
 
-  static inline int32_t fractional(int32_t fixed) {
+  static inline int32_t Fractional(int32_t fixed) {
     return (fixed & 0xffff);
   }
 
-  static inline int32_t fixed(int32_t integral, int32_t fractional) {
+  static inline int32_t Fixed(int32_t integral, int32_t fractional) {
     return ((integral & 0xffff) << 16) | (fractional & 0xffff);
   }
 };
diff --git a/sfntly/math/font_math.h b/sfntly/math/font_math.h
index 78b9e51..f15a786 100644
--- a/sfntly/math/font_math.h
+++ b/sfntly/math/font_math.h
@@ -23,7 +23,7 @@
 
 class FontMath {
  public:
-  static int32_t log2(int32_t a) {
+  static int32_t Log2(int32_t a) {
     int r = 0;  // r will be lg(a)
     while (a != 0) {
       a >>= 1;
diff --git a/sfntly/maximum_profile_table.cc b/sfntly/maximum_profile_table.cc
index 61a176e..0ab2aaf 100644
--- a/sfntly/maximum_profile_table.cc
+++ b/sfntly/maximum_profile_table.cc
@@ -20,202 +20,204 @@
 /******************************************************************************
  * MaximumProfileTable class
  ******************************************************************************/
-MaximumProfileTable::MaximumProfileTable(Header* header,
-                                         ReadableFontData* data) :
-    Table(header, data) {
-}
-
 MaximumProfileTable::~MaximumProfileTable() {}
 
-int32_t MaximumProfileTable::version() {
-  return data_->readFixed(Offset::kVersion);
+int32_t MaximumProfileTable::Version() {
+  return data_->ReadFixed(Offset::kVersion);
 }
 
-int32_t MaximumProfileTable::numGlyphs() {
-  return data_->readUShort(Offset::kNumGlyphs);
+int32_t MaximumProfileTable::NumGlyphs() {
+  return data_->ReadUShort(Offset::kNumGlyphs);
 }
 
-int32_t MaximumProfileTable::maxPoints() {
-  return data_->readUShort(Offset::kMaxPoints);
+int32_t MaximumProfileTable::MaxPoints() {
+  return data_->ReadUShort(Offset::kMaxPoints);
 }
 
-int32_t MaximumProfileTable::maxContours() {
-  return data_->readUShort(Offset::kMaxContours);
+int32_t MaximumProfileTable::MaxContours() {
+  return data_->ReadUShort(Offset::kMaxContours);
 }
 
-int32_t MaximumProfileTable::maxCompositePoints() {
-  return data_->readUShort(Offset::kMaxCompositePoints);
+int32_t MaximumProfileTable::MaxCompositePoints() {
+  return data_->ReadUShort(Offset::kMaxCompositePoints);
 }
 
-int32_t MaximumProfileTable::maxZones() {
-  return data_->readUShort(Offset::kMaxZones);
+int32_t MaximumProfileTable::MaxZones() {
+  return data_->ReadUShort(Offset::kMaxZones);
 }
 
-int32_t MaximumProfileTable::maxTwilightPoints() {
-  return data_->readUShort(Offset::kMaxTwilightPoints);
+int32_t MaximumProfileTable::MaxTwilightPoints() {
+  return data_->ReadUShort(Offset::kMaxTwilightPoints);
 }
 
-int32_t MaximumProfileTable::maxStorage() {
-  return data_->readUShort(Offset::kMaxStorage);
+int32_t MaximumProfileTable::MaxStorage() {
+  return data_->ReadUShort(Offset::kMaxStorage);
 }
 
-int32_t MaximumProfileTable::maxFunctionDefs() {
-  return data_->readUShort(Offset::kMaxFunctionDefs);
+int32_t MaximumProfileTable::MaxFunctionDefs() {
+  return data_->ReadUShort(Offset::kMaxFunctionDefs);
 }
 
-int32_t MaximumProfileTable::maxStackElements() {
-  return data_->readUShort(Offset::kMaxStackElements);
+int32_t MaximumProfileTable::MaxStackElements() {
+  return data_->ReadUShort(Offset::kMaxStackElements);
 }
 
-int32_t MaximumProfileTable::maxSizeOfInstructions() {
-  return data_->readUShort(Offset::kMaxSizeOfInstructions);
+int32_t MaximumProfileTable::MaxSizeOfInstructions() {
+  return data_->ReadUShort(Offset::kMaxSizeOfInstructions);
 }
 
-int32_t MaximumProfileTable::maxComponentElements() {
-  return data_->readUShort(Offset::kMaxComponentElements);
+int32_t MaximumProfileTable::MaxComponentElements() {
+  return data_->ReadUShort(Offset::kMaxComponentElements);
 }
 
-int32_t MaximumProfileTable::maxComponentDepth() {
-  return data_->readUShort(Offset::kMaxComponentDepth);
+int32_t MaximumProfileTable::MaxComponentDepth() {
+  return data_->ReadUShort(Offset::kMaxComponentDepth);
+}
+
+MaximumProfileTable::MaximumProfileTable(Header* header,
+                                         ReadableFontData* data)
+    : Table(header, data) {
 }
 
 /******************************************************************************
  * MaximumProfileTable::Builder class
  ******************************************************************************/
 MaximumProfileTable::Builder::Builder(
-    FontDataTableBuilderContainer* font_builder, Header* header,
-    WritableFontData* data) :
-    Table::TableBasedTableBuilder(font_builder, header, data) {
+    FontDataTableBuilderContainer* font_builder,
+    Header* header,
+    WritableFontData* data)
+    : Table::TableBasedTableBuilder(font_builder, header, data) {
 }
 
 MaximumProfileTable::Builder::Builder(
-    FontDataTableBuilderContainer* font_builder, Header* header,
-    ReadableFontData* data) :
-    Table::TableBasedTableBuilder(font_builder, header, data) {
+    FontDataTableBuilderContainer* font_builder,
+    Header* header,
+    ReadableFontData* data)
+    : Table::TableBasedTableBuilder(font_builder, header, data) {
 }
 
 MaximumProfileTable::Builder::~Builder() {}
 
-CALLER_ATTACH FontDataTable* MaximumProfileTable::Builder::subBuildTable(
-    ReadableFontData* data) {
+CALLER_ATTACH FontDataTable*
+    MaximumProfileTable::Builder::SubBuildTable(ReadableFontData* data) {
   FontDataTablePtr table = new MaximumProfileTable(header(), data);
-  return table.detach();
+  return table.Detach();
 }
 
-int32_t MaximumProfileTable::Builder::version() {
-  return internalReadData()->readUShort(Offset::kVersion);
+int32_t MaximumProfileTable::Builder::Version() {
+  return InternalReadData()->ReadUShort(Offset::kVersion);
 }
 
-void MaximumProfileTable::Builder::setVersion(int32_t version) {
-  internalWriteData()->writeUShort(Offset::kVersion, version);
+void MaximumProfileTable::Builder::SetVersion(int32_t version) {
+  InternalWriteData()->WriteUShort(Offset::kVersion, version);
 }
 
-int32_t MaximumProfileTable::Builder::numGlyphs() {
-  return internalReadData()->readUShort(Offset::kNumGlyphs);
+int32_t MaximumProfileTable::Builder::NumGlyphs() {
+  return InternalReadData()->ReadUShort(Offset::kNumGlyphs);
 }
 
-void MaximumProfileTable::Builder::setNumGlyphs(int32_t num_glyphs) {
-  internalWriteData()->writeUShort(Offset::kNumGlyphs, num_glyphs);
+void MaximumProfileTable::Builder::SetNumGlyphs(int32_t num_glyphs) {
+  InternalWriteData()->WriteUShort(Offset::kNumGlyphs, num_glyphs);
 }
 
-int32_t MaximumProfileTable::Builder::maxPoints() {
-  return internalReadData()->readUShort(Offset::kMaxPoints);
+int32_t MaximumProfileTable::Builder::MaxPoints() {
+  return InternalReadData()->ReadUShort(Offset::kMaxPoints);
 }
 
-void MaximumProfileTable::Builder::setMaxPoints(int32_t max_points) {
-  internalWriteData()->writeUShort(Offset::kMaxPoints, max_points);
+void MaximumProfileTable::Builder::SetMaxPoints(int32_t max_points) {
+  InternalWriteData()->WriteUShort(Offset::kMaxPoints, max_points);
 }
 
-int32_t MaximumProfileTable::Builder::maxContours() {
-  return internalReadData()->readUShort(Offset::kMaxContours);
+int32_t MaximumProfileTable::Builder::MaxContours() {
+  return InternalReadData()->ReadUShort(Offset::kMaxContours);
 }
 
-void MaximumProfileTable::Builder::setMaxContours(int32_t max_contours) {
-  internalWriteData()->writeUShort(Offset::kMaxContours, max_contours);
+void MaximumProfileTable::Builder::SetMaxContours(int32_t max_contours) {
+  InternalWriteData()->WriteUShort(Offset::kMaxContours, max_contours);
 }
 
-int32_t MaximumProfileTable::Builder::maxCompositePoints() {
-  return internalReadData()->readUShort(Offset::kMaxCompositePoints);
+int32_t MaximumProfileTable::Builder::MaxCompositePoints() {
+  return InternalReadData()->ReadUShort(Offset::kMaxCompositePoints);
 }
 
-void MaximumProfileTable::Builder::setMaxCompositePoints(
+void MaximumProfileTable::Builder::SetMaxCompositePoints(
     int32_t max_composite_points) {
-  internalWriteData()->writeUShort(Offset::kMaxCompositePoints,
+  InternalWriteData()->WriteUShort(Offset::kMaxCompositePoints,
                                    max_composite_points);
 }
 
-int32_t MaximumProfileTable::Builder::maxZones() {
-  return internalReadData()->readUShort(Offset::kMaxZones);
+int32_t MaximumProfileTable::Builder::MaxZones() {
+  return InternalReadData()->ReadUShort(Offset::kMaxZones);
 }
 
-void MaximumProfileTable::Builder::setMaxZones(int32_t max_zones) {
-  internalWriteData()->writeUShort(Offset::kMaxZones, max_zones);
+void MaximumProfileTable::Builder::SetMaxZones(int32_t max_zones) {
+  InternalWriteData()->WriteUShort(Offset::kMaxZones, max_zones);
 }
 
-int32_t MaximumProfileTable::Builder::maxTwilightPoints() {
-  return internalReadData()->readUShort(Offset::kMaxTwilightPoints);
+int32_t MaximumProfileTable::Builder::MaxTwilightPoints() {
+  return InternalReadData()->ReadUShort(Offset::kMaxTwilightPoints);
 }
 
-void MaximumProfileTable::Builder::setMaxTwilightPoints(
+void MaximumProfileTable::Builder::SetMaxTwilightPoints(
     int32_t max_twilight_points) {
-  internalWriteData()->writeUShort(Offset::kMaxTwilightPoints,
+  InternalWriteData()->WriteUShort(Offset::kMaxTwilightPoints,
                                    max_twilight_points);
 }
 
-int32_t MaximumProfileTable::Builder::maxStorage() {
-  return internalReadData()->readUShort(Offset::kMaxStorage);
+int32_t MaximumProfileTable::Builder::MaxStorage() {
+  return InternalReadData()->ReadUShort(Offset::kMaxStorage);
 }
 
-void MaximumProfileTable::Builder::setMaxStorage(int32_t max_storage) {
-  internalWriteData()->writeUShort(Offset::kMaxStorage, max_storage);
+void MaximumProfileTable::Builder::SetMaxStorage(int32_t max_storage) {
+  InternalWriteData()->WriteUShort(Offset::kMaxStorage, max_storage);
 }
 
-int32_t MaximumProfileTable::Builder::maxFunctionDefs() {
-  return internalReadData()->readUShort(Offset::kMaxFunctionDefs);
+int32_t MaximumProfileTable::Builder::MaxFunctionDefs() {
+  return InternalReadData()->ReadUShort(Offset::kMaxFunctionDefs);
 }
 
-void MaximumProfileTable::Builder::setMaxFunctionDefs(
+void MaximumProfileTable::Builder::SetMaxFunctionDefs(
     int32_t max_function_defs) {
-  internalWriteData()->writeUShort(Offset::kMaxFunctionDefs, max_function_defs);
+  InternalWriteData()->WriteUShort(Offset::kMaxFunctionDefs, max_function_defs);
 }
 
-int32_t MaximumProfileTable::Builder::maxStackElements() {
-  return internalReadData()->readUShort(Offset::kMaxStackElements);
+int32_t MaximumProfileTable::Builder::MaxStackElements() {
+  return InternalReadData()->ReadUShort(Offset::kMaxStackElements);
 }
 
-void MaximumProfileTable::Builder::setMaxStackElements(
+void MaximumProfileTable::Builder::SetMaxStackElements(
     int32_t max_stack_elements) {
-  internalWriteData()->writeUShort(Offset::kMaxStackElements,
+  InternalWriteData()->WriteUShort(Offset::kMaxStackElements,
                                    max_stack_elements);
 }
 
-int32_t MaximumProfileTable::Builder::maxSizeOfInstructions() {
-  return internalReadData()->readUShort(Offset::kMaxSizeOfInstructions);
+int32_t MaximumProfileTable::Builder::MaxSizeOfInstructions() {
+  return InternalReadData()->ReadUShort(Offset::kMaxSizeOfInstructions);
 }
 
-void MaximumProfileTable::Builder::setMaxSizeOfInstructions(
+void MaximumProfileTable::Builder::SetMaxSizeOfInstructions(
     int32_t max_size_of_instructions) {
-  internalWriteData()->writeUShort(Offset::kMaxSizeOfInstructions,
+  InternalWriteData()->WriteUShort(Offset::kMaxSizeOfInstructions,
                                    max_size_of_instructions);
 }
 
-int32_t MaximumProfileTable::Builder::maxComponentElements() {
-  return internalReadData()->readUShort(Offset::kMaxComponentElements);
+int32_t MaximumProfileTable::Builder::MaxComponentElements() {
+  return InternalReadData()->ReadUShort(Offset::kMaxComponentElements);
 }
 
-void MaximumProfileTable::Builder::setMaxComponentElements(
+void MaximumProfileTable::Builder::SetMaxComponentElements(
     int32_t max_component_elements) {
-  internalWriteData()->writeUShort(Offset::kMaxComponentElements,
+  InternalWriteData()->WriteUShort(Offset::kMaxComponentElements,
                                    max_component_elements);
 }
 
-int32_t MaximumProfileTable::Builder::maxComponentDepth() {
-  return internalReadData()->readUShort(Offset::kMaxComponentDepth);
+int32_t MaximumProfileTable::Builder::MaxComponentDepth() {
+  return InternalReadData()->ReadUShort(Offset::kMaxComponentDepth);
 }
 
-void MaximumProfileTable::Builder::setMaxComponentDepth(
+void MaximumProfileTable::Builder::SetMaxComponentDepth(
     int32_t max_component_depth) {
-  internalWriteData()->writeUShort(Offset::kMaxComponentDepth,
+  InternalWriteData()->WriteUShort(Offset::kMaxComponentDepth,
                                    max_component_depth);
 }
 
diff --git a/sfntly/maximum_profile_table.h b/sfntly/maximum_profile_table.h
index 044eccf..9e0d0a6 100644
--- a/sfntly/maximum_profile_table.h
+++ b/sfntly/maximum_profile_table.h
@@ -24,6 +24,63 @@
 
 class MaximumProfileTable : public Table,
                             public RefCounted<MaximumProfileTable> {
+ public:
+  class Builder : public Table::TableBasedTableBuilder,
+                  public RefCounted<Builder> {
+   public:
+    // Constructor scope altered to public because C++ does not allow base
+    // class to instantiate derived class with protected constructors.
+    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+            WritableFontData* data);
+    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+            ReadableFontData* data);
+    virtual ~Builder();
+
+    virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
+
+    int32_t Version();
+    void SetVersion(int32_t version);
+    int32_t NumGlyphs();
+    void SetNumGlyphs(int32_t num_glyphs);
+    int32_t MaxPoints();
+    void SetMaxPoints(int32_t max_points);
+    int32_t MaxContours();
+    void SetMaxContours(int32_t max_contours);
+    int32_t MaxCompositePoints();
+    void SetMaxCompositePoints(int32_t max_composite_points);
+    int32_t MaxZones();
+    void SetMaxZones(int32_t max_zones);
+    int32_t MaxTwilightPoints();
+    void SetMaxTwilightPoints(int32_t max_twilight_points);
+    int32_t MaxStorage();
+    void SetMaxStorage(int32_t max_storage);
+    int32_t MaxFunctionDefs();
+    void SetMaxFunctionDefs(int32_t max_function_defs);
+    int32_t MaxStackElements();
+    void SetMaxStackElements(int32_t max_stack_elements);
+    int32_t MaxSizeOfInstructions();
+    void SetMaxSizeOfInstructions(int32_t max_size_of_instructions);
+    int32_t MaxComponentElements();
+    void SetMaxComponentElements(int32_t max_component_elements);
+    int32_t MaxComponentDepth();
+    void SetMaxComponentDepth(int32_t max_component_depth);
+  };
+
+  virtual ~MaximumProfileTable();
+  int32_t Version();
+  int32_t NumGlyphs();
+  int32_t MaxPoints();
+  int32_t MaxContours();
+  int32_t MaxCompositePoints();
+  int32_t MaxZones();
+  int32_t MaxTwilightPoints();
+  int32_t MaxStorage();
+  int32_t MaxFunctionDefs();
+  int32_t MaxStackElements();
+  int32_t MaxSizeOfInstructions();
+  int32_t MaxComponentElements();
+  int32_t MaxComponentDepth();
+
  private:
   struct Offset {
     enum {
@@ -48,67 +105,7 @@
     };
   };
 
- private:
   MaximumProfileTable(Header* header, ReadableFontData* data);
-
- public:  // Class is final, no virtual functions unless derived from parent.
-  virtual ~MaximumProfileTable();
-  int32_t version();
-  int32_t numGlyphs();
-  int32_t maxPoints();
-  int32_t maxContours();
-  int32_t maxCompositePoints();
-  int32_t maxZones();
-  int32_t maxTwilightPoints();
-  int32_t maxStorage();
-  int32_t maxFunctionDefs();
-  int32_t maxStackElements();
-  int32_t maxSizeOfInstructions();
-  int32_t maxComponentElements();
-  int32_t maxComponentDepth();
-
- public:
-  class Builder : public Table::TableBasedTableBuilder,
-                  public RefCounted<Builder> {
-   public:
-    // Constructor scope altered to public because C++ does not allow base
-    // class to instantiate derived class with protected constructors.
-    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
-            WritableFontData* data);
-    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
-            ReadableFontData* data);
-    virtual ~Builder();
-
-    virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
-
-   public:  // Class is static, no virtual functions unless derived from parent.
-    int32_t version();
-    void setVersion(int32_t version);
-    int32_t numGlyphs();
-    void setNumGlyphs(int32_t num_glyphs);
-    int32_t maxPoints();
-    void setMaxPoints(int32_t max_points);
-    int32_t maxContours();
-    void setMaxContours(int32_t max_contours);
-    int32_t maxCompositePoints();
-    void setMaxCompositePoints(int32_t max_composite_points);
-    int32_t maxZones();
-    void setMaxZones(int32_t max_zones);
-    int32_t maxTwilightPoints();
-    void setMaxTwilightPoints(int32_t max_twilight_points);
-    int32_t maxStorage();
-    void setMaxStorage(int32_t max_storage);
-    int32_t maxFunctionDefs();
-    void setMaxFunctionDefs(int32_t max_function_defs);
-    int32_t maxStackElements();
-    void setMaxStackElements(int32_t max_stack_elements);
-    int32_t maxSizeOfInstructions();
-    void setMaxSizeOfInstructions(int32_t max_size_of_instructions);
-    int32_t maxComponentElements();
-    void setMaxComponentElements(int32_t max_component_elements);
-    int32_t maxComponentDepth();
-    void setMaxComponentDepth(int32_t max_component_depth);
-  };
 };
 typedef Ptr<MaximumProfileTable> MaximumProfileTablePtr;
 typedef Ptr<MaximumProfileTable::Builder> MaximumProfileTableBuilderPtr;
diff --git a/sfntly/name_table.cc b/sfntly/name_table.cc
index 0858603..19c299c 100644
--- a/sfntly/name_table.cc
+++ b/sfntly/name_table.cc
@@ -14,142 +14,558 @@
  * limitations under the License.
  */
 
-#include "port/type.h"
+#include "sfntly/name_table.h"
 
 #include <stdio.h>
 #include <string.h>
 
 #include <unicode/unistr.h>
 
-#include "sfntly/name_table.h"
 #include "sfntly/font.h"
 #include "sfntly/port/exception_type.h"
 
 namespace sfntly {
 /******************************************************************************
+ * NameTable::NameEntryId class
+ ******************************************************************************/
+NameTable::NameEntryId::NameEntryId()
+    : platform_id_(0),
+      encoding_id_(0),
+      language_id_(0),
+      name_id_(0) {
+}
+
+NameTable::NameEntryId::NameEntryId(int32_t platform_id,
+                                    int32_t encoding_id,
+                                    int32_t language_id,
+                                    int32_t name_id)
+    : platform_id_(platform_id),
+      encoding_id_(encoding_id),
+      language_id_(language_id),
+      name_id_(name_id) {
+}
+
+NameTable::NameEntryId::NameEntryId(const NameTable::NameEntryId& rhs) {
+  *this = rhs;
+}
+
+const NameTable::NameEntryId&
+    NameTable::NameEntryId::operator=(const NameTable::NameEntryId& rhs) const {
+  platform_id_ = rhs.platform_id_;
+  encoding_id_ = rhs.encoding_id_;
+  language_id_ = rhs.language_id_;
+  name_id_ = rhs.name_id_;
+  return *this;
+}
+
+bool NameTable::NameEntryId::operator==(const NameEntryId& rhs) const {
+  return platform_id_ == rhs.platform_id_ &&
+         encoding_id_ == rhs.encoding_id_ &&
+         language_id_ == rhs.language_id_ &&
+         name_id_ == rhs.name_id_;
+}
+
+bool NameTable::NameEntryId::operator<(const NameEntryId& rhs) const {
+  if (platform_id_ != rhs.platform_id_) return platform_id_ < rhs.platform_id_;
+  if (encoding_id_ != rhs.encoding_id_) return encoding_id_ < rhs.encoding_id_;
+  if (language_id_ != rhs.language_id_) return language_id_ < rhs.language_id_;
+  return name_id_ < rhs.name_id_;
+}
+
+/******************************************************************************
+ * NameTable::NameEntry class
+ ******************************************************************************/
+NameTable::NameEntry::NameEntry() {
+  Init(0, 0, 0, 0, NULL);
+}
+
+NameTable::NameEntry::NameEntry(const NameEntryId& name_entry_id,
+                                const ByteVector& name_bytes) {
+  Init(name_entry_id.platform_id(),
+       name_entry_id.encoding_id(),
+       name_entry_id.language_id(),
+       name_entry_id.name_id(),
+       &name_bytes);
+}
+
+NameTable::NameEntry::NameEntry(int32_t platform_id,
+                                int32_t encoding_id,
+                                int32_t language_id,
+                                int32_t name_id,
+                                const ByteVector& name_bytes) {
+  Init(platform_id, encoding_id, language_id, name_id, &name_bytes);
+}
+
+NameTable::NameEntry::~NameEntry() {}
+
+ByteVector* NameTable::NameEntry::NameAsBytes() {
+  return &name_bytes_;
+}
+
+int32_t NameTable::NameEntry::NameBytesLength() {
+  return name_bytes_.size();
+}
+
+UChar* NameTable::NameEntry::Name() {
+  return NameTable::ConvertFromNameBytes(&name_bytes_,
+                                         platform_id(),
+                                         encoding_id());
+}
+
+bool NameTable::NameEntry::operator==(const NameEntry& rhs) const {
+  return (name_entry_id_ == rhs.name_entry_id_ &&
+          name_bytes_ == rhs.name_bytes_);
+}
+
+void NameTable::NameEntry::Init(int32_t platform_id,
+                                int32_t encoding_id,
+                                int32_t language_id,
+                                int32_t name_id,
+                                const ByteVector* name_bytes) {
+  name_entry_id_ = NameEntryId(platform_id, encoding_id, language_id, name_id);
+  if (name_bytes) {
+    name_bytes_ = *name_bytes;
+  } else {
+    name_bytes_.clear();
+  }
+}
+
+/******************************************************************************
+ * NameTable::NameEntryBuilder class
+ ******************************************************************************/
+NameTable::NameEntryBuilder::NameEntryBuilder() {
+  Init(0, 0, 0, 0, NULL);
+}
+
+NameTable::NameEntryBuilder::NameEntryBuilder(
+    const NameEntryId& name_entry_id, const ByteVector& name_bytes) {
+  Init(name_entry_id.platform_id(),
+       name_entry_id.encoding_id(),
+       name_entry_id.language_id(),
+       name_entry_id.name_id(),
+       &name_bytes);
+}
+
+NameTable::NameEntryBuilder::NameEntryBuilder(
+    const NameEntryId& name_entry_id) {
+  Init(name_entry_id.platform_id(),
+       name_entry_id.encoding_id(),
+       name_entry_id.language_id(),
+       name_entry_id.name_id(),
+       NULL);
+}
+
+NameTable::NameEntryBuilder::NameEntryBuilder(NameEntry* b) {
+  Init(b->platform_id(),
+       b->encoding_id(),
+       b->language_id(),
+       b->name_id(),
+       b->NameAsBytes());
+}
+
+NameTable::NameEntryBuilder::~NameEntryBuilder() {}
+
+void NameTable::NameEntryBuilder::SetName(const UChar* name) {
+  if (name == NULL) {
+    name_entry_->name_bytes_.clear();
+    return;
+  }
+  NameTable::ConvertToNameBytes(name,
+                                name_entry_->platform_id(),
+                                name_entry_->encoding_id(),
+                                &name_entry_->name_bytes_);
+}
+
+void NameTable::NameEntryBuilder::SetName(const ByteVector& name_bytes) {
+  name_entry_->name_bytes_.clear();
+  std::copy(name_bytes.begin(),
+            name_bytes.end(),
+            name_entry_->name_bytes_.begin());
+}
+
+void NameTable::NameEntryBuilder::SetName(const ByteVector& name_bytes,
+                                          int32_t offset,
+                                          int32_t length) {
+  name_entry_->name_bytes_.clear();
+  std::copy(name_bytes.begin() + offset,
+            name_bytes.begin() + offset + length,
+            name_entry_->name_bytes_.begin());
+}
+
+void NameTable::NameEntryBuilder::Init(int32_t platform_id,
+                                       int32_t encoding_id,
+                                       int32_t language_id,
+                                       int32_t name_id,
+                                       const ByteVector* name_bytes) {
+  name_entry_ = new NameEntry();
+  name_entry_->Init(platform_id, encoding_id, language_id, name_id, name_bytes);
+}
+
+/******************************************************************************
+ * NameTable::NameEntryFilterInPlace class (C++ port only)
+ ******************************************************************************/
+NameTable::NameEntryFilterInPlace::NameEntryFilterInPlace(int32_t platform_id,
+                                                          int32_t encoding_id,
+                                                          int32_t language_id,
+                                                          int32_t name_id)
+    : platform_id_(platform_id),
+      encoding_id_(encoding_id),
+      language_id_(language_id),
+      name_id_(name_id) {
+}
+
+bool NameTable::NameEntryFilterInPlace::Accept(int32_t platform_id,
+                                               int32_t encoding_id,
+                                               int32_t language_id,
+                                               int32_t name_id) {
+  return (platform_id_ == platform_id &&
+          encoding_id_ == encoding_id &&
+          language_id_ == language_id &&
+          name_id_ == name_id);
+}
+
+/******************************************************************************
+ * NameTable::NameEntryIterator class
+ ******************************************************************************/
+NameTable::NameEntryIterator::NameEntryIterator(NameTable* table) {
+  Init(table, NULL);
+}
+
+NameTable::NameEntryIterator::NameEntryIterator(NameTable* table,
+                                                NameEntryFilter* filter) {
+  Init(table, filter);
+}
+
+bool NameTable::NameEntryIterator::HasNext() {
+  if (!filter_) {
+    if (name_index_ < table_->NameCount()) {
+      return true;
+    }
+    return false;
+  }
+  for (; name_index_ < table_->NameCount(); ++name_index_) {
+    if (filter_->Accept(table_->PlatformId(name_index_),
+                        table_->EncodingId(name_index_),
+                        table_->LanguageId(name_index_),
+                        table_->NameId(name_index_))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+CALLER_ATTACH NameTable::NameEntry* NameTable::NameEntryIterator::Next() {
+  if (!HasNext())
+    return NULL;
+  return table_->GetNameEntry(name_index_++);
+}
+
+void NameTable::NameEntryIterator::Remove() {
+#if !defined (SFNTLY_NO_EXCEPTION)
+  throw UnsupportedOperationException(
+            "Cannot remove a CMap table from an existing font.");
+#endif
+}
+
+void NameTable::NameEntryIterator::Init(NameTable* table,
+                                        NameEntryFilter* filter) {
+  table_ = table;
+  filter_ = filter;
+  name_index_ = 0;
+}
+
+/******************************************************************************
+ * NameTable::Builder class
+ ******************************************************************************/
+NameTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
+                            Header* header,
+                            WritableFontData* data)
+    : Table::ArrayElementTableBuilder(font_builder, header, data) {
+}
+
+NameTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
+                            Header* header,
+                            ReadableFontData* data)
+    : Table::ArrayElementTableBuilder(font_builder, header, data) {
+}
+
+void NameTable::Builder::RevertNames() {
+  name_entry_map_.clear();
+  set_model_changed(false);
+}
+
+int32_t NameTable::Builder::BuilderCount() {
+  GetNameBuilders();  // Ensure name_entry_map_ is built.
+  return (int32_t)name_entry_map_.size();
+}
+
+bool NameTable::Builder::Has(int32_t platform_id,
+                             int32_t encoding_id,
+                             int32_t language_id,
+                             int32_t name_id) {
+  NameEntryId probe(platform_id, encoding_id, language_id, name_id);
+  GetNameBuilders();  // Ensure name_entry_map_ is built.
+  return (name_entry_map_.find(probe) != name_entry_map_.end());
+}
+
+CALLER_ATTACH NameTable::NameEntryBuilder*
+    NameTable::Builder::NameBuilder(int32_t platform_id,
+                                    int32_t encoding_id,
+                                    int32_t language_id,
+                                    int32_t name_id) {
+  NameEntryId probe(platform_id, encoding_id, language_id, name_id);
+  NameEntryBuilderMap builders;
+  GetNameBuilders();  // Ensure name_entry_map_ is built.
+  if (name_entry_map_.find(probe) != name_entry_map_.end()) {
+    return name_entry_map_[probe];
+  }
+  NameEntryBuilderPtr builder = new NameEntryBuilder(probe);
+  name_entry_map_[probe] = builder;
+  return builder.Detach();
+}
+
+bool NameTable::Builder::Remove(int32_t platform_id,
+                                int32_t encoding_id,
+                                int32_t language_id,
+                                int32_t name_id) {
+  NameEntryId probe(platform_id, encoding_id, language_id, name_id);
+  GetNameBuilders();  // Ensure name_entry_map_ is built.
+  NameEntryBuilderMap::iterator position = name_entry_map_.find(probe);
+  if (position != name_entry_map_.end()) {
+    name_entry_map_.erase(position);
+    return true;
+  }
+  return false;
+}
+
+CALLER_ATTACH FontDataTable*
+    NameTable::Builder::SubBuildTable(ReadableFontData* data) {
+  FontDataTablePtr table = new NameTable(header(), data);
+  return table.Detach();
+}
+
+void NameTable::Builder::SubDataSet() {
+  name_entry_map_.clear();
+  set_model_changed(false);
+}
+
+int32_t NameTable::Builder::SubDataSizeToSerialize() {
+  if (name_entry_map_.empty()) {
+    return 0;
+  }
+
+  int32_t size = NameTable::Offset::kNameRecordStart +
+                 name_entry_map_.size() * NameTable::Offset::kNameRecordSize;
+  for (NameEntryBuilderMap::iterator b = name_entry_map_.begin(),
+                                     end = name_entry_map_.end();
+                                     b != end; ++b) {
+    NameEntryBuilderPtr p = b->second;
+    NameEntry* entry = p->name_entry();
+    size += entry->NameBytesLength();
+  }
+  return size;
+}
+
+bool NameTable::Builder::SubReadyToSerialize() {
+  return !name_entry_map_.empty();
+}
+
+int32_t NameTable::Builder::SubSerialize(WritableFontData* new_data) {
+  int32_t string_table_start_offset =
+      NameTable::Offset::kNameRecordStart +
+      name_entry_map_.size() * NameTable::Offset::kNameRecordSize;
+
+  // Header
+  new_data->WriteUShort(NameTable::Offset::kFormat, 0);
+  new_data->WriteUShort(NameTable::Offset::kCount, name_entry_map_.size());
+  new_data->WriteUShort(NameTable::Offset::kStringOffset,
+                        string_table_start_offset);
+  int32_t name_record_offset = NameTable::Offset::kNameRecordStart;
+  int32_t string_offset = 0;
+  // Note: we offered operator< in NameEntryId, which will be used by std::less,
+  //       and therefore our map will act like TreeMap in Java to provide
+  //       sorted key set.
+  for (NameEntryBuilderMap::iterator b = name_entry_map_.begin(),
+                                     end = name_entry_map_.end();
+                                     b != end; ++b) {
+    new_data->WriteUShort(
+        name_record_offset + NameTable::Offset::kNameRecordPlatformId,
+        b->first.platform_id());
+    new_data->WriteUShort(
+        name_record_offset + NameTable::Offset::kNameRecordEncodingId,
+        b->first.encoding_id());
+    new_data->WriteUShort(
+        name_record_offset + NameTable::Offset::kNameRecordLanguageId,
+        b->first.language_id());
+    new_data->WriteUShort(
+        name_record_offset + NameTable::Offset::kNameRecordNameId,
+        b->first.name_id());
+    NameEntry* builder_entry = b->second->name_entry();
+    new_data->WriteUShort(
+        name_record_offset + NameTable::Offset::kNameRecordStringLength,
+        builder_entry->NameBytesLength());
+    new_data->WriteUShort(
+        name_record_offset + NameTable::Offset::kNameRecordStringOffset,
+        string_offset);
+    name_record_offset += NameTable::Offset::kNameRecordSize;
+    string_offset += new_data->WriteBytes(
+        string_offset + string_table_start_offset,
+        builder_entry->NameAsBytes());
+  }
+
+  return string_offset + string_table_start_offset;
+}
+
+void NameTable::Builder::Initialize(ReadableFontData* data) {
+  if (data) {
+    NameTablePtr table = new NameTable(header(), data);
+    NameEntryIterator name_iter(table, NULL);
+    while (name_iter.HasNext()) {
+      NameEntryPtr name_entry = name_iter.Next();
+      NameEntryBuilderPtr name_entry_builder = new NameEntryBuilder(name_entry);
+      NameEntry* builder_entry = name_entry_builder->name_entry();
+      NameEntryId probe = builder_entry->name_entry_id();
+      name_entry_map_[probe] = name_entry_builder;
+    }
+  }
+}
+
+NameTable::NameEntryBuilderMap* NameTable::Builder::GetNameBuilders() {
+  if (name_entry_map_.empty()) {
+    Initialize(InternalReadData());
+  }
+  set_model_changed();
+  return &name_entry_map_;
+}
+
+/******************************************************************************
  * NameTable class
  ******************************************************************************/
-NameTable::NameTable(Header* header, ReadableFontData* data)
-    : Table(header, data) {}
-
 NameTable::~NameTable() {}
 
-int32_t NameTable::format() {
-  return data_->readUShort(Offset::kFormat);
+int32_t NameTable::Format() {
+  return data_->ReadUShort(Offset::kFormat);
 }
 
-int32_t NameTable::nameCount() {
-  return data_->readUShort(Offset::kCount);
+int32_t NameTable::NameCount() {
+  return data_->ReadUShort(Offset::kCount);
 }
 
-int32_t NameTable::stringOffset() {
-  return data_->readUShort(Offset::kStringOffset);
+int32_t NameTable::PlatformId(int32_t index) {
+  return data_->ReadUShort(Offset::kNameRecordPlatformId +
+                           OffsetForNameRecord(index));
 }
 
-int32_t NameTable::offsetForNameRecord(int32_t index) {
-  return Offset::kNameRecordStart + index * Offset::kNameRecordSize;
+int32_t NameTable::EncodingId(int32_t index) {
+  return data_->ReadUShort(Offset::kNameRecordEncodingId +
+                           OffsetForNameRecord(index));
 }
 
-int32_t NameTable::platformId(int32_t index) {
-  return data_->readUShort(Offset::kNameRecordPlatformId +
-                           offsetForNameRecord(index));
+int32_t NameTable::LanguageId(int32_t index) {
+  return data_->ReadUShort(Offset::kNameRecordLanguageId +
+                           OffsetForNameRecord(index));
 }
 
-int32_t NameTable::encodingId(int32_t index) {
-  return data_->readUShort(Offset::kNameRecordEncodingId +
-                           offsetForNameRecord(index));
+int32_t NameTable::NameId(int32_t index) {
+  return data_->ReadUShort(Offset::kNameRecordNameId +
+                           OffsetForNameRecord(index));
 }
 
-int32_t NameTable::languageId(int32_t index) {
-  return data_->readUShort(Offset::kNameRecordLanguageId +
-                           offsetForNameRecord(index));
-}
-
-int32_t NameTable::nameId(int32_t index) {
-  return data_->readUShort(Offset::kNameRecordNameId +
-                           offsetForNameRecord(index));
-}
-
-int32_t NameTable::nameLength(int32_t index) {
-  return data_->readUShort(Offset::kNameRecordStringLength +
-                           offsetForNameRecord(index));
-}
-
-int32_t NameTable::nameOffset(int32_t index) {
-  return data_->readUShort(Offset::kNameRecordStringOffset +
-                           offsetForNameRecord(index)) + stringOffset();
-}
-
-void NameTable::nameAsBytes(int32_t index, ByteVector* b) {
+void NameTable::NameAsBytes(int32_t index, ByteVector* b) {
   assert(b);
-  int32_t length = nameLength(index);
+  int32_t length = NameLength(index);
   b->clear();
   b->resize(length);
-  data_->readBytes(nameOffset(index), b, 0, length);
+  data_->ReadBytes(NameOffset(index), b, 0, length);
 }
 
-void NameTable::nameAsBytes(int32_t platform_id, int32_t encoding_id,
-                            int32_t language_id, int32_t name_id,
+void NameTable::NameAsBytes(int32_t platform_id,
+                            int32_t encoding_id,
+                            int32_t language_id,
+                            int32_t name_id,
                             ByteVector* b) {
   assert(b);
   NameEntryPtr entry;
-  entry.attach(nameEntry(platform_id, encoding_id, language_id, name_id));
+  entry.Attach(GetNameEntry(platform_id, encoding_id, language_id, name_id));
   if (entry) {
-    ByteVector* name = entry->nameAsBytes();
+    ByteVector* name = entry->NameAsBytes();
     std::copy(name->begin(), name->end(), b->begin());
   }
 }
 
-UChar* NameTable::name(int index) {
+UChar* NameTable::Name(int index) {
   ByteVector b;
-  nameAsBytes(index, &b);
-  return convertFromNameBytes(&b, platformId(index), encodingId(index));
+  NameAsBytes(index, &b);
+  return ConvertFromNameBytes(&b, PlatformId(index), EncodingId(index));
 }
 
-UChar* NameTable::name(int32_t platform_id, int32_t encoding_id,
-                       int32_t language_id, int32_t name_id) {
+UChar* NameTable::Name(int32_t platform_id,
+                       int32_t encoding_id,
+                       int32_t language_id,
+                       int32_t name_id) {
   NameEntryPtr entry;
-  entry.attach(nameEntry(platform_id, encoding_id, language_id, name_id));
+  entry.Attach(GetNameEntry(platform_id, encoding_id, language_id, name_id));
   if (entry) {
-    return entry->name();
+    return entry->Name();
   }
   return NULL;
 }
 
-CALLER_ATTACH NameTable::NameEntry* NameTable::nameEntry(int32_t index) {
+CALLER_ATTACH NameTable::NameEntry* NameTable::GetNameEntry(int32_t index) {
   ByteVector b;
-  nameAsBytes(index, &b);
-  NameEntryPtr instance = new NameEntry(platformId(index), encodingId(index),
-                                        languageId(index), nameId(index), b);
-  return instance.detach();
+  NameAsBytes(index, &b);
+  NameEntryPtr instance = new NameEntry(PlatformId(index),
+                                        EncodingId(index),
+                                        LanguageId(index),
+                                        NameId(index), b);
+  return instance.Detach();
 }
 
-CALLER_ATTACH NameTable::NameEntry* NameTable::nameEntry(int32_t platform_id,
-                                                         int32_t encoding_id,
-                                                         int32_t language_id,
-                                                         int32_t name_id) {
-  NameTable::NameEntryFilterInPlace filter(platform_id, encoding_id,
-                                           language_id, name_id);
-  NameTable::NameEntryIterator* name_entry_iter = iterator(&filter);
+CALLER_ATTACH NameTable::NameEntry* NameTable::GetNameEntry(int32_t platform_id,
+                                                            int32_t encoding_id,
+                                                            int32_t language_id,
+                                                            int32_t name_id) {
+  NameTable::NameEntryFilterInPlace
+      filter(platform_id, encoding_id, language_id, name_id);
+  NameTable::NameEntryIterator* name_entry_iter = Iterator(&filter);
   NameEntryPtr result;
-  if (name_entry_iter->hasNext()) {
-    result = name_entry_iter->next();
-    delete name_entry_iter;
-    return result;
+  if (name_entry_iter->HasNext()) {
+    result = name_entry_iter->Next();
   }
   delete name_entry_iter;
-  return NULL;
+  return result;
 }
 
-NameTable::NameEntryIterator* NameTable::iterator() {
+NameTable::NameEntryIterator* NameTable::Iterator() {
   return new NameTable::NameEntryIterator(this);
 }
 
-NameTable::NameEntryIterator* NameTable::iterator(NameEntryFilter* filter) {
+NameTable::NameEntryIterator* NameTable::Iterator(NameEntryFilter* filter) {
   return new NameTable::NameEntryIterator(this, filter);
 }
 
-const char* NameTable::getEncodingName(int32_t platform_id,
+NameTable::NameTable(Header* header, ReadableFontData* data)
+    : Table(header, data) {}
+
+int32_t NameTable::StringOffset() {
+  return data_->ReadUShort(Offset::kStringOffset);
+}
+
+int32_t NameTable::OffsetForNameRecord(int32_t index) {
+  return Offset::kNameRecordStart + index * Offset::kNameRecordSize;
+}
+
+int32_t NameTable::NameLength(int32_t index) {
+  return data_->ReadUShort(Offset::kNameRecordStringLength +
+                           OffsetForNameRecord(index));
+}
+
+int32_t NameTable::NameOffset(int32_t index) {
+  return data_->ReadUShort(Offset::kNameRecordStringOffset +
+                           OffsetForNameRecord(index)) + StringOffset();
+}
+
+const char* NameTable::GetEncodingName(int32_t platform_id,
                                        int32_t encoding_id) {
   switch (platform_id) {
     case PlatformId::kUnicode:
@@ -178,7 +594,7 @@
           return "MacThai";
         case MacintoshEncodingId::kChineseSimplified:
           return "EUC-CN";
-        default:  // unknown/unconfirmed cases are not ported
+        default:  // Note: unknown/unconfirmed cases are not ported.
           break;
       }
       break;
@@ -211,9 +627,9 @@
   return NULL;
 }
 
-UConverter* NameTable::getCharset(int32_t platform_id, int32_t encoding_id) {
+UConverter* NameTable::GetCharset(int32_t platform_id, int32_t encoding_id) {
   UErrorCode error_code = U_ZERO_ERROR;
-  UConverter* conv = ucnv_open(getEncodingName(platform_id, encoding_id),
+  UConverter* conv = ucnv_open(GetEncodingName(platform_id, encoding_id),
                                &error_code);
   if (U_SUCCESS(error_code)) {
     return conv;
@@ -225,12 +641,14 @@
   return NULL;
 }
 
-void NameTable::convertToNameBytes(const UChar* name, int32_t platform_id,
-                                   int32_t encoding_id, ByteVector* b) {
+void NameTable::ConvertToNameBytes(const UChar* name,
+                                   int32_t platform_id,
+                                   int32_t encoding_id,
+                                   ByteVector* b) {
   assert(b);
   assert(name);
   b->clear();
-  UConverter* cs = getCharset(platform_id, encoding_id);
+  UConverter* cs = GetCharset(platform_id, encoding_id);
   if (cs == NULL) {
     return;
   }
@@ -238,23 +656,28 @@
   // Preflight to get buffer size.
   UErrorCode error_code = U_ZERO_ERROR;
   int32_t length = ucnv_fromUChars(cs, NULL, 0, name, -1, &error_code);
-  b->resize(length + 4);  // the longest termination "\0" is 4 bytes
+  b->resize(length + 4);  // The longest termination "\0" is 4 bytes.
   memset(&((*b)[0]), 0, length + 4);
   error_code = U_ZERO_ERROR;
-  ucnv_fromUChars(cs, reinterpret_cast<char*>(&((*b)[0])), length + 4, name,
-                  -1, &error_code);
+  ucnv_fromUChars(cs,
+                  reinterpret_cast<char*>(&((*b)[0])),
+                  length + 4,
+                  name,
+                  -1,
+                  &error_code);
   if (!U_SUCCESS(error_code)) {
     b->clear();
   }
   ucnv_close(cs);
 }
 
-UChar* NameTable::convertFromNameBytes(ByteVector* name_bytes,
-    int32_t platform_id, int32_t encoding_id) {
+UChar* NameTable::ConvertFromNameBytes(ByteVector* name_bytes,
+                                       int32_t platform_id,
+                                       int32_t encoding_id) {
   if (name_bytes == NULL) {
     return NULL;
   }
-  UConverter* cs = getCharset(platform_id, encoding_id);
+  UConverter* cs = GetCharset(platform_id, encoding_id);
   UErrorCode error_code = U_ZERO_ERROR;
   if (cs == NULL) {
     char buffer[11] = {0};
@@ -280,9 +703,12 @@
   // No preflight needed here, we will be bigger.
   UChar* output_buffer = new UChar[name_bytes->size() + 1];
   memset(output_buffer, 0, sizeof(UChar) * (name_bytes->size() + 1));
-  int32_t length = ucnv_toUChars(cs, output_buffer, name_bytes->size(),
+  int32_t length = ucnv_toUChars(cs,
+                                 output_buffer,
+                                 name_bytes->size(),
                                  reinterpret_cast<char*>(&((*name_bytes)[0])),
-                                 name_bytes->size(), &error_code);
+                                 name_bytes->size(),
+                                 &error_code);
   ucnv_close(cs);
   if (length > 0) {
     return output_buffer;
@@ -292,413 +718,4 @@
   return NULL;
 }
 
-/******************************************************************************
- * NameTable::NameEntryId class
- ******************************************************************************/
-NameTable::NameEntryId::NameEntryId()
-    : platform_id_(0), encoding_id_(0), language_id_(0), name_id_(0) {
-}
-
-NameTable::NameEntryId::NameEntryId(int32_t platform_id, int32_t encoding_id,
-                                    int32_t language_id, int32_t name_id)
-    : platform_id_(platform_id), encoding_id_(encoding_id),
-      language_id_(language_id), name_id_(name_id) {
-}
-
-NameTable::NameEntryId::NameEntryId(const NameTable::NameEntryId& rhs) {
-  *this = rhs;
-}
-
-NameTable::NameEntryId::~NameEntryId() {}
-
-int32_t NameTable::NameEntryId::getPlatformId() const {
-  return platform_id_;
-}
-
-int32_t NameTable::NameEntryId::getEncodingId() const {
-  return encoding_id_;
-}
-
-int32_t NameTable::NameEntryId::getLanguageId() const {
-  return language_id_;
-}
-
-int32_t NameTable::NameEntryId::getNameId() const {
-  return name_id_;
-}
-
-const NameTable::NameEntryId& NameTable::NameEntryId::operator=(
-    const NameTable::NameEntryId& rhs) const {
-  platform_id_ = rhs.platform_id_;
-  encoding_id_ = rhs.encoding_id_;
-  language_id_ = rhs.language_id_;
-  name_id_ = rhs.name_id_;
-  return *this;
-}
-
-bool NameTable::NameEntryId::operator==(const NameEntryId& rhs) const {
-  return platform_id_ == rhs.platform_id_ && encoding_id_ == rhs.encoding_id_ &&
-         language_id_ == rhs.language_id_ && name_id_ == rhs.name_id_;
-}
-
-bool NameTable::NameEntryId::operator<(const NameEntryId& rhs) const {
-  if (platform_id_ != rhs.platform_id_) return platform_id_ < rhs.platform_id_;
-  if (encoding_id_ != rhs.encoding_id_) return encoding_id_ < rhs.encoding_id_;
-  if (language_id_ != rhs.language_id_) return language_id_ < rhs.language_id_;
-  return name_id_ < rhs.name_id_;
-}
-
-/******************************************************************************
- * NameTable::NameEntry class
- ******************************************************************************/
-void NameTable::NameEntry::init(int32_t platform_id, int32_t encoding_id,
-                                int32_t language_id, int32_t name_id,
-                                const ByteVector* name_bytes) {
-  name_entry_id_ = NameEntryId(platform_id, encoding_id, language_id, name_id);
-  if (name_bytes) {
-    name_bytes_ = *name_bytes;
-  } else {
-    name_bytes_.clear();
-  }
-}
-
-NameTable::NameEntry::NameEntry() {
-  init(0, 0, 0, 0, NULL);
-}
-
-NameTable::NameEntry::NameEntry(const NameEntryId& name_entry_id,
-                                const ByteVector& name_bytes) {
-  init(name_entry_id.getPlatformId(), name_entry_id.getEncodingId(),
-       name_entry_id.getLanguageId(), name_entry_id.getNameId(), &name_bytes);
-}
-
-NameTable::NameEntry::NameEntry(int32_t platform_id, int32_t encoding_id,
-                                int32_t language_id, int32_t name_id,
-                                const ByteVector& name_bytes) {
-  init(platform_id, encoding_id, language_id, name_id, &name_bytes);
-}
-
-NameTable::NameEntry::~NameEntry() {}
-
-NameTable::NameEntryId& NameTable::NameEntry::getNameEntryId() {
-  return name_entry_id_;
-}
-
-int32_t NameTable::NameEntry::platformId() {
-  return name_entry_id_.getPlatformId();
-}
-
-int32_t NameTable::NameEntry::encodingId() {
-  return name_entry_id_.getEncodingId();
-}
-
-int32_t NameTable::NameEntry::languageId() {
-  return name_entry_id_.getLanguageId();
-}
-
-int32_t NameTable::NameEntry::nameId() {
-  return name_entry_id_.getNameId();
-}
-
-int32_t NameTable::NameEntry::nameBytesLength() {
-  return name_bytes_.size();
-}
-
-ByteVector* NameTable::NameEntry::nameAsBytes() {
-  return &name_bytes_;
-}
-
-UChar* NameTable::NameEntry::name() {
-  return NameTable::convertFromNameBytes(&name_bytes_, platformId(),
-                                         encodingId());
-}
-
-bool NameTable::NameEntry::operator==(const NameEntry& rhs) const {
-  return (name_entry_id_ == rhs.name_entry_id_ &&
-          name_bytes_ == rhs.name_bytes_);
-}
-
-/******************************************************************************
- * NameTable::NameEntryBuilder class
- ******************************************************************************/
-NameTable::NameEntryBuilder::NameEntryBuilder() {
-  init(0, 0, 0, 0, NULL);
-}
-
-NameTable::NameEntryBuilder::NameEntryBuilder(
-    const NameEntryId& name_entry_id, const ByteVector& name_bytes) {
-  init(name_entry_id.getPlatformId(), name_entry_id.getEncodingId(),
-       name_entry_id.getLanguageId(), name_entry_id.getNameId(), &name_bytes);
-}
-
-NameTable::NameEntryBuilder::NameEntryBuilder(
-    const NameEntryId& name_entry_id) {
-  init(name_entry_id.getPlatformId(), name_entry_id.getEncodingId(),
-       name_entry_id.getLanguageId(), name_entry_id.getNameId(), NULL);
-}
-
-NameTable::NameEntryBuilder::NameEntryBuilder(NameEntry* b) {
-  init(b->platformId(), b->encodingId(), b->languageId(), b->nameId(),
-       b->nameAsBytes());
-}
-
-NameTable::NameEntryBuilder::~NameEntryBuilder() {}
-
-void NameTable::NameEntryBuilder::setName(const UChar* name) {
-  if (name == NULL) {
-    name_entry_->name_bytes_.clear();
-    return;
-  }
-  NameTable::convertToNameBytes(name, name_entry_->platformId(),
-                                name_entry_->encodingId(),
-                                &name_entry_->name_bytes_);
-}
-
-void NameTable::NameEntryBuilder::setName(const ByteVector& name_bytes) {
-  name_entry_->name_bytes_.clear();
-  std::copy(name_bytes.begin(), name_bytes.end(),
-            name_entry_->name_bytes_.begin());
-}
-
-void NameTable::NameEntryBuilder::setName(const ByteVector& name_bytes,
-    int32_t offset, int32_t length) {
-  name_entry_->name_bytes_.clear();
-  std::copy(name_bytes.begin() + offset, name_bytes.begin() + offset + length,
-            name_entry_->name_bytes_.begin());
-}
-
-CALLER_ATTACH NameTable::NameEntry* NameTable::NameEntryBuilder::entry() {
-  return name_entry_;
-}
-
-void NameTable::NameEntryBuilder::init(int32_t platform_id, int32_t encoding_id,
-    int32_t language_id, int32_t name_id, const ByteVector* name_bytes) {
-  name_entry_ = new NameEntry();
-  name_entry_->init(platform_id, encoding_id, language_id, name_id, name_bytes);
-}
-
-/******************************************************************************
- * NameTable::NameEntryFilterInPlace class (C++ port only)
- ******************************************************************************/
-NameTable::NameEntryFilterInPlace::NameEntryFilterInPlace(int32_t platform_id,
-    int32_t encoding_id, int32_t language_id, int32_t name_id)
-    : platform_id_(platform_id), encoding_id_(encoding_id),
-      language_id_(language_id), name_id_(name_id) {
-}
-
-bool NameTable::NameEntryFilterInPlace::accept(int32_t platform_id,
-    int32_t encoding_id, int32_t language_id, int32_t name_id) {
-  return (platform_id_ == platform_id && encoding_id_ == encoding_id &&
-          language_id_ == language_id && name_id_ == name_id);
-}
-
-/******************************************************************************
- * NameTable::NameEntryIterator class
- ******************************************************************************/
-void NameTable::NameEntryIterator::init(NameTable* table,
-                                        NameEntryFilter* filter) {
-  table_ = table;
-  filter_ = filter;
-  name_index_ = 0;
-}
-
-NameTable::NameEntryIterator::NameEntryIterator(NameTable* table) {
-  init(table, NULL);
-}
-
-NameTable::NameEntryIterator::NameEntryIterator(NameTable* table,
-                                                NameEntryFilter* filter) {
-  init(table, filter);
-}
-
-NameTable::NameEntryIterator::~NameEntryIterator() {
-}
-
-bool NameTable::NameEntryIterator::hasNext() {
-  if (!filter_) {
-    if (name_index_ < table_->nameCount()) {
-      return true;
-    }
-    return false;
-  }
-  for (; name_index_ < table_->nameCount(); ++name_index_) {
-    if (filter_->accept(table_->platformId(name_index_),
-                        table_->encodingId(name_index_),
-                        table_->languageId(name_index_),
-                        table_->nameId(name_index_))) {
-      return true;
-    }
-  }
-  return false;
-}
-
-CALLER_ATTACH NameTable::NameEntry* NameTable::NameEntryIterator::next() {
-  if (!hasNext())
-    return NULL;
-  return table_->nameEntry(name_index_++);
-}
-
-void NameTable::NameEntryIterator::remove() {
-#if !defined (SFNTLY_NO_EXCEPTION)
-  throw UnsupportedOperationException(
-            "Cannot remove a CMap table from an existing font.");
-#endif
-}
-
-/******************************************************************************
- * NameTable::Builder class
- ******************************************************************************/
-NameTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
-                            Header* header, WritableFontData* data) :
-    Table::ArrayElementTableBuilder(font_builder, header, data) {
-}
-
-NameTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
-                            Header* header, ReadableFontData* data) :
-    Table::ArrayElementTableBuilder(font_builder, header, data) {
-}
-
-void NameTable::Builder::initialize(ReadableFontData* data) {
-  if (data) {
-    NameTablePtr table = new NameTable(header(), data);
-    NameEntryIterator name_iter(table, NULL);
-    while (name_iter.hasNext()) {
-      NameEntryPtr name_entry = name_iter.next();
-      NameEntryBuilderPtr name_entry_builder = new NameEntryBuilder(name_entry);
-      NameEntry* builder_entry = name_entry_builder->entry();
-      NameEntryId probe = builder_entry->getNameEntryId();
-      name_entry_map_[probe] = name_entry_builder;
-    }
-  }
-}
-
-NameTable::NameEntryBuilderMap* NameTable::Builder::getNameBuilders() {
-  if (name_entry_map_.empty()) {
-    initialize(internalReadData());
-  }
-  setModelChanged();
-  return &name_entry_map_;
-}
-
-void NameTable::Builder::revertNames() {
-  name_entry_map_.clear();
-  setModelChanged(false);
-}
-
-int32_t NameTable::Builder::builderCount() {
-  getNameBuilders();  // ensure name_entry_map_ is built
-  return (int32_t)name_entry_map_.size();
-}
-
-bool NameTable::Builder::has(int32_t platform_id, int32_t encoding_id,
-                             int32_t language_id, int32_t name_id) {
-  NameEntryId probe(platform_id, encoding_id, language_id, name_id);
-  getNameBuilders();  // ensure name_entry_map_ is built
-  return (name_entry_map_.find(probe) != name_entry_map_.end());
-}
-
-CALLER_ATTACH NameTable::NameEntryBuilder* NameTable::Builder::nameBuilder(
-    int32_t platform_id, int32_t encoding_id, int32_t language_id,
-    int32_t name_id) {
-  NameEntryId probe(platform_id, encoding_id, language_id, name_id);
-  NameEntryBuilderMap builders;
-  getNameBuilders();  // ensure name_entry_map_ is built
-  if (name_entry_map_.find(probe) != name_entry_map_.end()) {
-    return name_entry_map_[probe];
-  }
-  NameEntryBuilderPtr builder = new NameEntryBuilder(probe);
-  name_entry_map_[probe] = builder;
-  return builder.detach();
-}
-
-bool NameTable::Builder::remove(int32_t platform_id, int32_t encoding_id,
-                                int32_t language_id, int32_t name_id) {
-  NameEntryId probe(platform_id, encoding_id, language_id, name_id);
-  getNameBuilders();  // ensure name_entry_map_ is built
-  NameEntryBuilderMap::iterator position = name_entry_map_.find(probe);
-  if (position != name_entry_map_.end()) {
-    name_entry_map_.erase(position);
-    return true;
-  }
-  return false;
-}
-
-CALLER_ATTACH FontDataTable* NameTable::Builder::subBuildTable(
-    ReadableFontData* data) {
-  FontDataTablePtr table = new NameTable(header(), data);
-  return table.detach();
-}
-
-void NameTable::Builder::subDataSet() {
-  name_entry_map_.clear();
-  setModelChanged(false);
-}
-
-int32_t NameTable::Builder::subDataSizeToSerialize() {
-  if (name_entry_map_.empty()) {
-    return 0;
-  }
-
-  int32_t size = NameTable::Offset::kNameRecordStart + name_entry_map_.size() *
-                 NameTable::Offset::kNameRecordSize;
-  for (NameEntryBuilderMap::iterator b = name_entry_map_.begin(),
-                                     end = name_entry_map_.end();
-                                     b != end; ++b) {
-    NameEntryBuilderPtr p = b->second;
-    NameEntry* entry = p->entry();
-    size += entry->nameBytesLength();
-  }
-  return size;
-}
-
-bool NameTable::Builder::subReadyToSerialize() {
-  return !name_entry_map_.empty();
-}
-
-int32_t NameTable::Builder::subSerialize(WritableFontData* new_data) {
-  int32_t string_table_start_offset =
-      NameTable::Offset::kNameRecordStart + name_entry_map_.size() *
-      NameTable::Offset::kNameRecordSize;
-
-  // header
-  new_data->writeUShort(NameTable::Offset::kFormat, 0);
-  new_data->writeUShort(NameTable::Offset::kCount, name_entry_map_.size());
-  new_data->writeUShort(NameTable::Offset::kStringOffset,
-                        string_table_start_offset);
-  int32_t name_record_offset = NameTable::Offset::kNameRecordStart;
-  int32_t string_offset = 0;
-  // Note: we offered operator< in NameEntryId, which will be used by std::less,
-  //       and therefore our map will act like TreeMap in Java to provide
-  //       sorted key set.
-  for (NameEntryBuilderMap::iterator b = name_entry_map_.begin(),
-                                     end = name_entry_map_.end();
-                                     b != end; ++b) {
-    new_data->writeUShort(
-        name_record_offset + NameTable::Offset::kNameRecordPlatformId,
-        b->first.getPlatformId());
-    new_data->writeUShort(
-        name_record_offset + NameTable::Offset::kNameRecordEncodingId,
-        b->first.getEncodingId());
-    new_data->writeUShort(
-        name_record_offset + NameTable::Offset::kNameRecordLanguageId,
-        b->first.getLanguageId());
-    new_data->writeUShort(
-        name_record_offset + NameTable::Offset::kNameRecordNameId,
-        b->first.getNameId());
-    NameEntry* builder_entry = b->second->entry();
-    new_data->writeUShort(
-        name_record_offset + NameTable::Offset::kNameRecordStringLength,
-        builder_entry->nameBytesLength());
-    new_data->writeUShort(
-        name_record_offset + NameTable::Offset::kNameRecordStringOffset,
-        string_offset);
-    name_record_offset += NameTable::Offset::kNameRecordSize;
-    string_offset += new_data->writeBytes(
-        string_offset + string_table_start_offset,
-        builder_entry->nameAsBytes());
-  }
-
-  return string_offset + string_table_start_offset;
-}
-
 }  // namespace sfntly
diff --git a/sfntly/name_table.h b/sfntly/name_table.h
index 6d5df2b..d0dd345 100644
--- a/sfntly/name_table.h
+++ b/sfntly/name_table.h
@@ -34,6 +34,10 @@
 
 namespace sfntly {
 
+// The following code implements the name table defined in TTF/OTF spec, which
+// can be found at http://www.microsoft.com/typography/otspec/name.htm.
+
+// Name IDs defined in TTF/OTF spec.
 struct NameId {
   enum {
     kUnknown = -1,
@@ -63,6 +67,7 @@
   };
 };
 
+// Unicode language IDs used in Name Records.
 struct UnicodeLanguageId {
   enum {
     kUnknown = -1,
@@ -408,6 +413,266 @@
 };
 
 class NameTable : public Table, public RefCounted<NameTable> {
+ public:
+  // Unique identifier for a given name record.
+  class NameEntryId {
+   public:
+    NameEntryId();  // C++ port only, must provide default constructor.
+    NameEntryId(int32_t platform_id, int32_t encoding_id, int32_t language_id,
+                int32_t name_id);
+    NameEntryId(const NameEntryId&);
+    // Make gcc -Wnon-virtual-dtor happy.
+    virtual ~NameEntryId() {}
+
+    int32_t platform_id() const { return platform_id_; }
+    int32_t encoding_id() const { return encoding_id_; }
+    int32_t language_id() const { return language_id_; }
+    int32_t name_id() const { return name_id_; }
+
+    const NameEntryId& operator=(const NameEntryId& rhs) const;
+    bool operator==(const NameEntryId& rhs) const;
+    bool operator<(const NameEntryId& rhs) const;
+
+   private:
+    mutable int32_t platform_id_;
+    mutable int32_t encoding_id_;
+    mutable int32_t language_id_;
+    mutable int32_t name_id_;
+  };
+
+  class NameEntryBuilder;
+
+  // Class to represent a name entry in the name table.
+  class NameEntry : public RefCounted<NameEntry> {
+   public:
+    NameEntry();
+    NameEntry(const NameEntryId& name_entry_id, const ByteVector& name_bytes);
+    NameEntry(int32_t platform_id, int32_t encoding_id, int32_t language_id,
+              int32_t name_id, const ByteVector& name_bytes);
+    virtual ~NameEntry();
+
+    NameEntryId& name_entry_id() { return name_entry_id_; }
+    int32_t platform_id() const { return name_entry_id_.platform_id(); }
+    int32_t encoding_id() const { return name_entry_id_.encoding_id(); }
+    int32_t language_id() const { return name_entry_id_.language_id(); };
+    int32_t name_id() const { return name_entry_id_.name_id(); }
+
+    // Get the bytes for name.  Returned pointer is the address of private
+    // member of this class, do not attempt to delete.
+    ByteVector* NameAsBytes();
+
+    // C++ port only: get the length of NameAsBytes.
+    int32_t NameBytesLength();
+
+    // Returns the name in Unicode as UChar array.
+    // Note: ICU UChar* convention requires caller to delete[] it.
+    UChar* Name();
+    bool operator==(const NameEntry& rhs) const;
+
+   private:
+    void Init(int32_t platform_id, int32_t encoding_id, int32_t language_id,
+              int32_t name_id, const ByteVector* name_bytes);
+
+    NameEntryId name_entry_id_;
+    int32_t length_;
+    ByteVector name_bytes_;
+
+    friend class NameEntryBuilder;
+  };
+
+  // Builder of a name entry.
+  // C++ port: original Java hierarchy inherits from NameEntry.  In C++ port, we
+  // opted not doing so to avoid ref count issues and nasty protected members.
+  class NameEntryBuilder : public RefCounted<NameEntryBuilder> {
+   public:
+    NameEntryBuilder();
+    NameEntryBuilder(const NameEntryId& name_entry_id,
+                     const ByteVector& name_bytes);
+    explicit NameEntryBuilder(const NameEntryId& name_entry_id);
+    explicit NameEntryBuilder(NameEntry* entry);
+    virtual ~NameEntryBuilder();
+
+    virtual void SetName(const UChar* name);
+    virtual void SetName(const ByteVector& name_bytes);
+    virtual void SetName(const ByteVector& name_bytes, int32_t offset,
+                         int32_t length);
+
+    // C++ port only. CALLER_ATTACH is not added because the lifetime shall be
+    // controlled by this class, therefore the caller shall not increase the ref
+    // count.
+    NameEntry* name_entry() { return name_entry_; }
+
+   private:
+    void Init(int32_t platform_id, int32_t encoding_id, int32_t language_id,
+              int32_t name_id, const ByteVector* name_bytes);
+
+    Ptr<NameEntry> name_entry_;
+  };
+  typedef std::map<NameEntryId, Ptr<NameEntryBuilder> > NameEntryBuilderMap;
+
+  // An interface for a filter to use with the name entry iterator. This allows
+  // name entries to be iterated and only those acceptable to the filter will be
+  // returned.
+  class NameEntryFilter {
+   public:
+    virtual bool Accept(int32_t platform_id, int32_t encoding_id,
+                        int32_t language_id, int32_t name_id) = 0;
+    // Make gcc -Wnon-virtual-dtor happy.
+    virtual ~NameEntryFilter() {}
+  };
+
+  // C++ port only: an in-place filter to mimic Java Iterator's filtering.
+  class NameEntryFilterInPlace : public NameEntryFilter {
+   public:
+    NameEntryFilterInPlace(int32_t platform_id, int32_t encoding_id,
+                           int32_t language_id, int32_t name_id);
+    // Make gcc -Wnon-virtual-dtor happy.
+    virtual ~NameEntryFilterInPlace() {}
+
+    virtual bool Accept(int32_t platform_id, int32_t encoding_id,
+                        int32_t language_id, int32_t name_id);
+
+   private:
+    int32_t platform_id_;
+    int32_t encoding_id_;
+    int32_t language_id_;
+    int32_t name_id_;
+  };
+
+  // Mimic Java's iterator to iterate through the entries within the name table.
+  class NameEntryIterator {
+   public:
+    // If filter is NULL, filter through all tables.
+    explicit NameEntryIterator(NameTable* table);
+    NameEntryIterator(NameTable* table, NameEntryFilter* filter);
+    // Make gcc -Wnon-virtual-dtor happy.
+    virtual ~NameEntryIterator() {}
+
+    virtual bool HasNext();
+    virtual CALLER_ATTACH NameEntry* Next();
+    virtual void Remove();
+
+   private:
+    void Init(NameTable* table, NameEntryFilter* filter);
+
+    NameTable* table_;  // Use dumb pointer since it's a composition object.
+    int32_t name_index_;
+    NameEntryFilter* filter_;
+  };
+
+  // The builder to construct name table for outputting.
+  class Builder : public Table::ArrayElementTableBuilder,
+                  public RefCounted<Builder> {
+   public:
+    // Constructor scope altered to public because C++ does not allow base
+    // class to instantiate derived class with protected constructors.
+    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+            WritableFontData* data);
+    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+            ReadableFontData* data);
+
+    // Revert the name builders for the name table to the last version that came
+    // from data.
+    void RevertNames();
+
+    // Number of name entry builders contained.
+    int32_t BuilderCount();
+
+    // Note: For C++ port, clear() is not implemented.  The clear() function
+    //       implies completely remove name entry builders, which is easy in
+    //       Java but will take a lot of efforts in C++ to release the builders
+    //       nicely and correctly.
+    // TODO(arthurhsu): IMPLEMENT
+    // Clear the name builders for the name table.
+    // void clear();
+
+    // Check the existance of a name entry builder by key.
+    bool Has(int32_t platform_id, int32_t encoding_id, int32_t language_id,
+             int32_t name_id);
+
+    // Get name entry builder by key.
+    CALLER_ATTACH NameEntryBuilder* NameBuilder(int32_t platform_id,
+        int32_t encoding_id, int32_t language_id, int32_t name_id);
+
+    // Remove name entry builder by key.
+    bool Remove(int32_t platform_id, int32_t encoding_id, int32_t language_id,
+                int32_t name_id);
+
+    // FontDataTable::Builder API implementation
+    virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
+    virtual void SubDataSet();
+    virtual int32_t SubDataSizeToSerialize();
+    virtual bool SubReadyToSerialize();
+    virtual int32_t SubSerialize(WritableFontData* new_data);
+
+   private:
+    void Initialize(ReadableFontData* data);
+    NameEntryBuilderMap* GetNameBuilders();
+
+    // Note: callers should use the getter funtion provided above to ensure that
+    // this is lazily initialized instead of accessing directly.
+    NameEntryBuilderMap name_entry_map_;
+  };
+
+  /****************************************************************************
+   * public methods of NameTable class
+   ****************************************************************************/
+  virtual ~NameTable();
+
+  // Get the format used in the name table.
+  virtual int32_t Format();
+
+  // Get the number of names in the name table.
+  virtual int32_t NameCount();
+
+  // Get the platform id for the given name record.
+  virtual int32_t PlatformId(int32_t index);
+
+  // Get the encoding id for the given name record.
+  // see MacintoshEncodingId, WindowsEncodingId, UnicodeEncodingId
+  virtual int32_t EncodingId(int32_t index);
+
+  // Get the language id for the given name record.
+  virtual int32_t LanguageId(int32_t index);
+
+  // Get the name id for given name record.
+  virtual int32_t NameId(int32_t index);
+
+  // Get the name as bytes for the specified name. If there is no entry for the
+  // requested name, then empty vector is returned.
+  virtual void NameAsBytes(int32_t index, ByteVector* b);
+  virtual void NameAsBytes(int32_t platform_id, int32_t encoding_id,
+                           int32_t language_id, int32_t name_id,
+                           ByteVector* b);
+
+  // Get the name as a UChar* for the given name record. If there is no
+  // encoding conversion available for the name record then a best attempt
+  // UChar* will be returned.
+  // Note: ICU UChar* convention requires caller to delete[] it.
+  virtual UChar* Name(int index);
+
+  // Get the name as a UChar* for the specified name. If there is no entry for
+  // the requested name then NULL is returned. If there is no encoding
+  // conversion available for the name then a best attempt UChar* will be
+  // returned.
+  // Note: ICU UChar* convention requires caller to delete[] it.
+  virtual UChar* Name(int32_t platform_id, int32_t encoding_id,
+                      int32_t language_id, int32_t name_id);
+
+  // Note: These functions are renamed in C++ port.  Their original Java name is
+  // nameEntry().
+  virtual CALLER_ATTACH NameEntry* GetNameEntry(int32_t index);
+  virtual CALLER_ATTACH NameEntry* GetNameEntry(int32_t platform_id,
+      int32_t encoding_id, int32_t language_id, int32_t name_id);
+
+  // Note: Not implemented in C++ port due to complexity and low usage.
+  // virtual void names(std::set<NameEntryPtr>*);
+
+  // Get the iterator to iterate through all name entries.
+  // Note: Caller delete the returned object.
+  virtual NameEntryIterator* Iterator();
+  virtual NameEntryIterator* Iterator(NameEntryFilter* filter);
+
  private:
   struct Offset {
     enum {
@@ -416,7 +681,7 @@
       kStringOffset = 4,
       kNameRecordStart = 6,
 
-      // format 1 - offset from the end of the name records
+      // Format 1 - offset from the end of the name records
       kLangTagCount = 0,
       kLangTagRecord = 2,
 
@@ -431,254 +696,36 @@
     };
   };
 
+  // The table shall be constructed using Builder, no direct instantiation.
   NameTable(Header* header, ReadableFontData* data);
 
- public:
-  virtual ~NameTable();
-  virtual int32_t format();
-
-  // Get the number of names in the name table.
-  virtual int32_t nameCount();
-
- private:
   // Get the offset to the string data in the name table.
-  int32_t stringOffset();
+  int32_t StringOffset();
 
   // Get the offset for the given name record.
-  int32_t offsetForNameRecord(int32_t index);
+  int32_t OffsetForNameRecord(int32_t index);
 
- public:
-  // Get the platform id for the given name record.
-  virtual int32_t platformId(int32_t index);
-
-  // Get the encoding id for the given name record.
-  // see MacintoshEncodingId, WindowsEncodingId, UnicodeEncodingId
-  virtual int32_t encodingId(int32_t index);
-
-  // Get the language id for the given name record.
-  virtual int32_t languageId(int32_t index);
-
-  // Get the name id for given name record.
-  virtual int32_t nameId(int32_t index);
-
- private:
   // Get the length of the string data for the given name record.
-  int32_t nameLength(int32_t index);
+  int32_t NameLength(int32_t index);
 
   // Get the offset of the string data for the given name record.
-  int32_t nameOffset(int32_t index);
+  int32_t NameOffset(int32_t index);
 
- public:
-  // Get the name as bytes for the specified name. If there is no entry for the
-  // requested name, then empty vector is returned.
-  virtual void nameAsBytes(int32_t index, ByteVector* b);
-  virtual void nameAsBytes(int32_t platform_id, int32_t encoding_id,
-                           int32_t language_id, int32_t name_id,
-                           ByteVector* b);
+  // Note: string literals are returned.  Caller shall not attempt to manipulate
+  // the returned pointer.
+  static const char* GetEncodingName(int32_t platform_id, int32_t encoding_id);
 
-  // Get the name as a UChar* for the given name record. If there is no
-  // encoding conversion available for the name record then a best attempt
-  // UChar* will be returned.
-  // Note: ICU UChar* convention requires caller to delete[] it.
-  virtual UChar* name(int index);
+  // Note: ICU UConverter* convention requires caller to ucnv_close() it.
+  static UConverter* GetCharset(int32_t platform_id, int32_t encoding_id);
 
-  // Get the name as a UChar* for the specified name. If there is no entry for
-  // the requested name then NULL is returned. If there is no encoding
-  // conversion available for the name then a best attempt UChar* will be
-  // returned.
-  // Note: ICU UChar* convention requires caller to delete[] it.
-  virtual UChar* name(int32_t platform_id, int32_t encoding_id,
-                      int32_t language_id, int32_t name_id);
-
-  class NameEntry;
-  virtual CALLER_ATTACH NameEntry* nameEntry(int32_t index);
-  virtual CALLER_ATTACH NameEntry* nameEntry(int32_t platform_id,
-      int32_t encoding_id, int32_t language_id, int32_t name_id);
-
-  // Note: Not implemented in C++ port due to complexity and low usage.
-  // virtual void names(std::set<NameEntryPtr>*);
-
-  class NameEntryId {
-   protected:
-    mutable int32_t platform_id_;
-    mutable int32_t encoding_id_;
-    mutable int32_t language_id_;
-    mutable int32_t name_id_;
-
-   public:
-    NameEntryId();  // C++ port only, must provide default constructor.
-    NameEntryId(int32_t platform_id, int32_t encoding_id, int32_t language_id,
-                int32_t name_id);
-    NameEntryId(const NameEntryId&);
-    virtual ~NameEntryId();
-    virtual int32_t getPlatformId() const;
-    virtual int32_t getEncodingId() const;
-    virtual int32_t getLanguageId() const;
-    virtual int32_t getNameId() const;
-    virtual const NameEntryId& operator=(const NameEntryId& rhs) const;
-    virtual bool operator==(const NameEntryId& rhs) const;
-    virtual bool operator<(const NameEntryId& rhs) const;
-  };
-
-  // Class to represent a name entry in the name table.
-  class NameEntryBuilder;
-  class NameEntry : public RefCounted<NameEntry> {
-   public:
-    NameEntry();
-    NameEntry(const NameEntryId& name_entry_id, const ByteVector& name_bytes);
-    NameEntry(int32_t platform_id, int32_t encoding_id, int32_t language_id,
-              int32_t name_id, const ByteVector& name_bytes);
-    virtual ~NameEntry();
-    virtual NameEntryId& getNameEntryId();
-    virtual int32_t platformId();
-    virtual int32_t encodingId();
-    virtual int32_t languageId();
-    virtual int32_t nameId();
-    virtual int32_t nameBytesLength();  // C++ port only
-    virtual ByteVector* nameAsBytes();
-    virtual UChar* name();
-    virtual bool operator==(const NameEntry& rhs) const;
-
-   private:
-    void init(int32_t platform_id, int32_t encoding_id, int32_t language_id,
-              int32_t name_id, const ByteVector* name_bytes);
-
-    NameEntryId name_entry_id_;
-    int32_t length_;
-    ByteVector name_bytes_;
-
-    friend class NameEntryBuilder;
-  };
-
-  // C++ port: we don't use original Java hierarchy to avoid ref count issues
-  // and nasty protected members.
-  class NameEntryBuilder : public RefCounted<NameEntryBuilder> {
-   public:
-    NameEntryBuilder();
-    NameEntryBuilder(const NameEntryId& name_entry_id,
-                     const ByteVector& name_bytes);
-    explicit NameEntryBuilder(const NameEntryId& name_entry_id);
-    explicit NameEntryBuilder(NameEntry* entry);
-    virtual ~NameEntryBuilder();
-
-    virtual void setName(const UChar* name);
-    virtual void setName(const ByteVector& name_bytes);
-    virtual void setName(const ByteVector& name_bytes, int32_t offset,
-                         int32_t length);
-
-    // C++ port only member functions. CALLER_ATTACH is not added because the
-    // lifetime shall be controlled by build, therefore the caller shall not
-    // increase the ref count.
-    NameEntry* entry();
-
-  private:
-    void init(int32_t platform_id, int32_t encoding_id, int32_t language_id,
-              int32_t name_id, const ByteVector* name_bytes);
-
-    Ptr<NameEntry> name_entry_;
-  };
-
-  class NameEntryFilter {
-   public:
-    virtual bool accept(int32_t platform_id, int32_t encoding_id,
-                        int32_t language_id, int32_t name_id) = 0;
-    // Make gcc -Wnon-virtual-dtor happy.
-    virtual ~NameEntryFilter() {}
-  };
-
-  // C++ port only
-  class NameEntryFilterInPlace : public NameEntryFilter {
-   public:
-    NameEntryFilterInPlace(int32_t platform_id, int32_t encoding_id,
-                           int32_t language_id, int32_t name_id);
-    // Make gcc -Wnon-virtual-dtor happy.
-    virtual ~NameEntryFilterInPlace() {}
-    virtual bool accept(int32_t platform_id, int32_t encoding_id,
-                        int32_t language_id, int32_t name_id);
-
-   private:
-    int32_t platform_id_;
-    int32_t encoding_id_;
-    int32_t language_id_;
-    int32_t name_id_;
-  };
-
-  class NameEntryIterator {
-   public:
-    // If filter is NULL, filter through all tables.
-    explicit NameEntryIterator(NameTable* table);
-    NameEntryIterator(NameTable* table, NameEntryFilter* filter);
-    // Make gcc -Wnon-virtual-dtor happy.
-    virtual ~NameEntryIterator();
-    virtual bool hasNext();
-    virtual CALLER_ATTACH NameEntry* next();
-    virtual void remove();
-
-   private:
-    void init(NameTable* table, NameEntryFilter* filter);
-
-    NameTable* table_;  // use dumb pointer since it's a composition object
-    int32_t name_index_;
-    NameEntryFilter* filter_;
-  };
-
-  // caller delete the object
-  virtual NameEntryIterator* iterator();
-  virtual NameEntryIterator* iterator(NameEntryFilter* filter);
-
- private:
-  static const char* getEncodingName(int32_t platform_id, int32_t encoding_id);
-  static UConverter* getCharset(int32_t platform_id, int32_t encoding_id);
-  static void convertToNameBytes(const UChar* name, int32_t platform_id,
+  // Note: Output will be stored in ByteVector* b.  Original data in b will be
+  // erased and replaced with converted name bytes.
+  static void ConvertToNameBytes(const UChar* name, int32_t platform_id,
                                  int32_t encoding_id, ByteVector* b);
-  static UChar* convertFromNameBytes(ByteVector* name_bytes,
+
+  // Note: ICU UChar* convention requires caller to delete[] it.
+  static UChar* ConvertFromNameBytes(ByteVector* name_bytes,
                                      int32_t platform_id, int32_t encoding_id);
-
- public:
-  typedef std::map<NameEntryId, Ptr<NameEntryBuilder> > NameEntryBuilderMap;
-
-  class Builder : public Table::ArrayElementTableBuilder,
-                  public RefCounted<Builder> {
-   public:
-    // Constructor scope altered to public because C++ does not allow base
-    // class to instantiate derived class with protected constructors.
-    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
-            WritableFontData* data);
-    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
-            ReadableFontData* data);
-
-   private:
-    void initialize(ReadableFontData* data);
-    NameEntryBuilderMap* getNameBuilders();
-
-   public:  // static class in Java, functions are not virtual unless inherited
-    void revertNames();
-    int32_t builderCount();
-
-    // Note: For C++ port, this is not implemented so far.  The clear() function
-    //       implies completely remove name entry builders, which is easy in
-    //       Java but will take a lot of efforts in C++ to release the builders
-    //       nicely and correctly.
-    // TODO(arthurhsu): IMPLEMENT
-    // Clear the name builders for the name table.
-    // void clear();
-
-    bool has(int32_t platform_id, int32_t encoding_id, int32_t language_id,
-             int32_t name_id);
-    CALLER_ATTACH NameEntryBuilder* nameBuilder(int32_t platform_id,
-        int32_t encoding_id, int32_t language_id, int32_t name_id);
-    bool remove(int32_t platform_id, int32_t encoding_id, int32_t language_id,
-                int32_t name_id);
-
-    virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
-    virtual void subDataSet();
-    virtual int32_t subDataSizeToSerialize();
-    virtual bool subReadyToSerialize();
-    virtual int32_t subSerialize(WritableFontData* new_data);
-
-   private:
-    NameEntryBuilderMap name_entry_map_;
-  };
 };  // class NameTable
 typedef Ptr<NameTable> NameTablePtr;
 typedef Ptr<NameTable::NameEntry> NameEntryPtr;
diff --git a/sfntly/os2_table.cc b/sfntly/os2_table.cc
index 4e7189d..6d6d338 100644
--- a/sfntly/os2_table.cc
+++ b/sfntly/os2_table.cc
@@ -98,163 +98,164 @@
 /******************************************************************************
  * class OS2Table
  ******************************************************************************/
-OS2Table::OS2Table(Header* header, ReadableFontData* data)
-    : Table(header, data) {
-}
-
 OS2Table::~OS2Table() {}
 
-int32_t OS2Table::version() {
-  return data_->readUShort(Offset::kVersion);
+int32_t OS2Table::Version() {
+  return data_->ReadUShort(Offset::kVersion);
 }
 
-int32_t OS2Table::xAvgCharWidth() {
-  return data_->readShort(Offset::kXAvgCharWidth);
+int32_t OS2Table::XAvgCharWidth() {
+  return data_->ReadShort(Offset::kXAvgCharWidth);
 }
 
-int32_t OS2Table::usWeightClass() {
-  return data_->readUShort(Offset::kUsWeightClass);
+int32_t OS2Table::UsWeightClass() {
+  return data_->ReadUShort(Offset::kUsWeightClass);
 }
 
-int32_t OS2Table::usWidthClass() {
-  return data_->readUShort(Offset::kUsWidthClass);
+int32_t OS2Table::UsWidthClass() {
+  return data_->ReadUShort(Offset::kUsWidthClass);
 }
 
-int32_t OS2Table::fsType() {
-  return data_->readUShort(Offset::kFsType);
+int32_t OS2Table::FsType() {
+  return data_->ReadUShort(Offset::kFsType);
 }
 
-int32_t OS2Table::ySubscriptXSize() {
-  return data_->readShort(Offset::kYSubscriptXSize);
+int32_t OS2Table::YSubscriptXSize() {
+  return data_->ReadShort(Offset::kYSubscriptXSize);
 }
 
-int32_t OS2Table::ySubscriptYSize() {
-  return data_->readShort(Offset::kYSubscriptYSize);
+int32_t OS2Table::YSubscriptYSize() {
+  return data_->ReadShort(Offset::kYSubscriptYSize);
 }
 
-int32_t OS2Table::ySubscriptXOffset() {
-  return data_->readShort(Offset::kYSubscriptXOffset);
+int32_t OS2Table::YSubscriptXOffset() {
+  return data_->ReadShort(Offset::kYSubscriptXOffset);
 }
 
-int32_t OS2Table::ySubscriptYOffset() {
-  return data_->readShort(Offset::kYSubscriptYOffset);
+int32_t OS2Table::YSubscriptYOffset() {
+  return data_->ReadShort(Offset::kYSubscriptYOffset);
 }
 
-int32_t OS2Table::ySuperscriptXSize() {
-  return data_->readShort(Offset::kYSuperscriptXSize);
+int32_t OS2Table::YSuperscriptXSize() {
+  return data_->ReadShort(Offset::kYSuperscriptXSize);
 }
 
-int32_t OS2Table::ySuperscriptYSize() {
-  return data_->readShort(Offset::kYSuperscriptYSize);
+int32_t OS2Table::YSuperscriptYSize() {
+  return data_->ReadShort(Offset::kYSuperscriptYSize);
 }
 
-int32_t OS2Table::ySuperscriptXOffset() {
-  return data_->readShort(Offset::kYSuperscriptXOffset);
+int32_t OS2Table::YSuperscriptXOffset() {
+  return data_->ReadShort(Offset::kYSuperscriptXOffset);
 }
 
-int32_t OS2Table::ySuperscriptYOffset() {
-  return data_->readShort(Offset::kYSuperscriptYOffset);
+int32_t OS2Table::YSuperscriptYOffset() {
+  return data_->ReadShort(Offset::kYSuperscriptYOffset);
 }
 
-int32_t OS2Table::yStrikeoutSize() {
-  return data_->readShort(Offset::kYStrikeoutSize);
+int32_t OS2Table::YStrikeoutSize() {
+  return data_->ReadShort(Offset::kYStrikeoutSize);
 }
 
-int32_t OS2Table::yStrikeoutPosition() {
-  return data_->readShort(Offset::kYStrikeoutPosition);
+int32_t OS2Table::YStrikeoutPosition() {
+  return data_->ReadShort(Offset::kYStrikeoutPosition);
 }
 
-int32_t OS2Table::sFamilyClass() {
-  return data_->readShort(Offset::kSFamilyClass);
+int32_t OS2Table::SFamilyClass() {
+  return data_->ReadShort(Offset::kSFamilyClass);
 }
 
-void OS2Table::panose(ByteVector* value) {
+void OS2Table::Panose(ByteVector* value) {
   value->clear();
   value->resize(10);
-  data_->readBytes(Offset::kPanose, value, 0, 10);
+  data_->ReadBytes(Offset::kPanose, value, 0, 10);
 }
 
-int64_t OS2Table::ulUnicodeRange1() {
-  return data_->readULong(Offset::kUlUnicodeRange1);
+int64_t OS2Table::UlUnicodeRange1() {
+  return data_->ReadULong(Offset::kUlUnicodeRange1);
 }
 
-int64_t OS2Table::ulUnicodeRange2() {
-  return data_->readULong(Offset::kUlUnicodeRange2);
+int64_t OS2Table::UlUnicodeRange2() {
+  return data_->ReadULong(Offset::kUlUnicodeRange2);
 }
 
-int64_t OS2Table::ulUnicodeRange3() {
-  return data_->readULong(Offset::kUlUnicodeRange3);
+int64_t OS2Table::UlUnicodeRange3() {
+  return data_->ReadULong(Offset::kUlUnicodeRange3);
 }
 
-int64_t OS2Table::ulUnicodeRange4() {
-  return data_->readULong(Offset::kUlUnicodeRange4);
+int64_t OS2Table::UlUnicodeRange4() {
+  return data_->ReadULong(Offset::kUlUnicodeRange4);
 }
 
-void OS2Table::achVendId(ByteVector* b) {
+void OS2Table::AchVendId(ByteVector* b) {
   b->clear();
   b->resize(4);
-  data_->readBytes(Offset::kAchVendId, b, 0, 4);
+  data_->ReadBytes(Offset::kAchVendId, b, 0, 4);
 }
 
-int32_t OS2Table::fsSelection() {
-  return data_->readUShort(Offset::kFsSelection);
+int32_t OS2Table::FsSelection() {
+  return data_->ReadUShort(Offset::kFsSelection);
 }
 
-int32_t OS2Table::usFirstCharIndex() {
-  return data_->readUShort(Offset::kUsFirstCharIndex);
+int32_t OS2Table::UsFirstCharIndex() {
+  return data_->ReadUShort(Offset::kUsFirstCharIndex);
 }
 
-int32_t OS2Table::usLastCharIndex() {
-  return data_->readUShort(Offset::kUsLastCharIndex);
+int32_t OS2Table::UsLastCharIndex() {
+  return data_->ReadUShort(Offset::kUsLastCharIndex);
 }
 
-int32_t OS2Table::sTypoAscender() {
-  return data_->readShort(Offset::kSTypoAscender);
+int32_t OS2Table::STypoAscender() {
+  return data_->ReadShort(Offset::kSTypoAscender);
 }
 
-int32_t OS2Table::sTypoDecender() {
-  return data_->readShort(Offset::kSTypoDescender);
+int32_t OS2Table::STypoDecender() {
+  return data_->ReadShort(Offset::kSTypoDescender);
 }
 
-int32_t OS2Table::sTypoLineGap() {
-  return data_->readShort(Offset::kSTypoLineGap);
+int32_t OS2Table::STypoLineGap() {
+  return data_->ReadShort(Offset::kSTypoLineGap);
 }
 
-int32_t OS2Table::usWinAscent() {
-  return data_->readUShort(Offset::kUsWinAscent);
+int32_t OS2Table::UsWinAscent() {
+  return data_->ReadUShort(Offset::kUsWinAscent);
 }
 
-int32_t OS2Table::usWinDescent() {
-  return data_->readUShort(Offset::kUsWinDescent);
+int32_t OS2Table::UsWinDescent() {
+  return data_->ReadUShort(Offset::kUsWinDescent);
 }
 
-int64_t OS2Table::ulCodePageRange1() {
-  return data_->readULong(Offset::kUlCodePageRange1);
+int64_t OS2Table::UlCodePageRange1() {
+  return data_->ReadULong(Offset::kUlCodePageRange1);
 }
 
-int64_t OS2Table::ulCodePageRange2() {
-  return data_->readULong(Offset::kUlCodePageRange2);
+int64_t OS2Table::UlCodePageRange2() {
+  return data_->ReadULong(Offset::kUlCodePageRange2);
 }
 
-int64_t OS2Table::ulCodePageRange() {
-  return ((0xffffffff & ulCodePageRange2()) << 32) |
-         (0xffffffff & ulCodePageRange1());
+int64_t OS2Table::UlCodePageRange() {
+  // TODO(arthurhsu): Possible bug point, check with stuartg.
+  return ((0xffffffff & UlCodePageRange2()) << 32) |
+         (0xffffffff & UlCodePageRange1());
 }
 
-int32_t OS2Table::sxHeight() {
-  return data_->readShort(Offset::kSxHeight);
+int32_t OS2Table::SxHeight() {
+  return data_->ReadShort(Offset::kSxHeight);
 }
 
-int32_t OS2Table::usDefaultChar() {
-  return data_->readUShort(Offset::kUsDefaultChar);
+int32_t OS2Table::UsDefaultChar() {
+  return data_->ReadUShort(Offset::kUsDefaultChar);
 }
 
-int32_t OS2Table::usBreakChar() {
-  return data_->readUShort(Offset::kUsBreakChar);
+int32_t OS2Table::UsBreakChar() {
+  return data_->ReadUShort(Offset::kUsBreakChar);
 }
 
-int32_t OS2Table::usMaxContext() {
-  return data_->readUShort(Offset::kUsMaxContext);
+int32_t OS2Table::UsMaxContext() {
+  return data_->ReadUShort(Offset::kUsMaxContext);
+}
+
+OS2Table::OS2Table(Header* header, ReadableFontData* data)
+    : Table(header, data) {
 }
 
 /******************************************************************************
@@ -267,10 +268,10 @@
 
 OS2Table::Builder::~Builder() {}
 
-CALLER_ATTACH FontDataTable* OS2Table::Builder::subBuildTable(
+CALLER_ATTACH FontDataTable* OS2Table::Builder::SubBuildTable(
     ReadableFontData* data) {
   FontDataTablePtr table = new OS2Table(header(), data);
-  return table.detach();
+  return table.Detach();
 }
 
 }  // namespace sfntly
diff --git a/sfntly/os2_table.h b/sfntly/os2_table.h
index 9bf33c2..058435a 100644
--- a/sfntly/os2_table.h
+++ b/sfntly/os2_table.h
@@ -300,6 +300,61 @@
 };
 
 class OS2Table : public Table, public RefCounted<OS2Table> {
+ public:
+  class Builder : public Table::TableBasedTableBuilder,
+                  public RefCounted<Builder> {
+   public:
+    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+            WritableFontData* data);
+    virtual ~Builder();
+    virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
+  };
+
+  ~OS2Table();
+
+  int32_t Version();
+  int32_t XAvgCharWidth();
+  int32_t UsWeightClass();
+  int32_t UsWidthClass();
+  // UNIMPLEMENTED: public EnumSet<EmbeddingFlags> fsType()
+  int32_t FsType();
+  int32_t YSubscriptXSize();
+  int32_t YSubscriptYSize();
+  int32_t YSubscriptXOffset();
+  int32_t YSubscriptYOffset();
+  int32_t YSuperscriptXSize();
+  int32_t YSuperscriptYSize();
+  int32_t YSuperscriptXOffset();
+  int32_t YSuperscriptYOffset();
+  int32_t YStrikeoutSize();
+  int32_t YStrikeoutPosition();
+  int32_t SFamilyClass();
+  void Panose(ByteVector* value);
+  int64_t UlUnicodeRange1();
+  int64_t UlUnicodeRange2();
+  int64_t UlUnicodeRange3();
+  int64_t UlUnicodeRange4();
+  // UNIMPLEMENTED: public EnumSet<UnicodeRange> UlUnicodeRange()
+  void AchVendId(ByteVector* b);
+  // UNIMPLEMENTED: public EnumSet<FsSelection> fsSelection()
+  int32_t FsSelection();
+  int32_t UsFirstCharIndex();
+  int32_t UsLastCharIndex();
+  int32_t STypoAscender();
+  int32_t STypoDecender();
+  int32_t STypoLineGap();
+  int32_t UsWinAscent();
+  int32_t UsWinDescent();
+  int64_t UlCodePageRange1();
+  int64_t UlCodePageRange2();
+  // UNIMPLEMENTED: public EnumSet<CodePageRange> ulCodePageRange()
+  int64_t UlCodePageRange();
+  int32_t SxHeight();
+  int32_t SCapHeight();
+  int32_t UsDefaultChar();
+  int32_t UsBreakChar();
+  int32_t UsMaxContext();
+
  private:
   struct Offset {
     enum {
@@ -344,62 +399,6 @@
   };
 
   OS2Table(Header* header, ReadableFontData* data);
-
- public:
-  ~OS2Table();
-
-  int32_t version();
-  int32_t xAvgCharWidth();
-  int32_t usWeightClass();
-  int32_t usWidthClass();
-  // UNIMPLEMENTED: public EnumSet<EmbeddingFlags> fsType()
-  int32_t fsType();
-  int32_t ySubscriptXSize();
-  int32_t ySubscriptYSize();
-  int32_t ySubscriptXOffset();
-  int32_t ySubscriptYOffset();
-  int32_t ySuperscriptXSize();
-  int32_t ySuperscriptYSize();
-  int32_t ySuperscriptXOffset();
-  int32_t ySuperscriptYOffset();
-  int32_t yStrikeoutSize();
-  int32_t yStrikeoutPosition();
-  int32_t sFamilyClass();
-  void panose(ByteVector* value);
-  int64_t ulUnicodeRange1();
-  int64_t ulUnicodeRange2();
-  int64_t ulUnicodeRange3();
-  int64_t ulUnicodeRange4();
-  // UNIMPLEMENTED: public EnumSet<UnicodeRange> ulUnicodeRange()
-  void achVendId(ByteVector* b);
-  // UNIMPLEMENTED: public EnumSet<FsSelection> fsSelection()
-  int32_t fsSelection();
-  int32_t usFirstCharIndex();
-  int32_t usLastCharIndex();
-  int32_t sTypoAscender();
-  int32_t sTypoDecender();
-  int32_t sTypoLineGap();
-  int32_t usWinAscent();
-  int32_t usWinDescent();
-  int64_t ulCodePageRange1();
-  int64_t ulCodePageRange2();
-  // UNIMPLEMENTED: public EnumSet<CodePageRange> ulCodePageRange()
-  int64_t ulCodePageRange();
-  int32_t sxHeight();
-  int32_t sCapHeight();
-  int32_t usDefaultChar();
-  int32_t usBreakChar();
-  int32_t usMaxContext();
-
- public:
-  class Builder : public Table::TableBasedTableBuilder,
-                  public RefCounted<Builder> {
-   public:
-    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
-            WritableFontData* data);
-    virtual ~Builder();
-    virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
-  };
 };
 
 }  // namespace sfntly
diff --git a/sfntly/port/atomic.h b/sfntly/port/atomic.h
index 4c2d65b..abfc429 100644
--- a/sfntly/port/atomic.h
+++ b/sfntly/port/atomic.h
@@ -21,7 +21,7 @@
 
 #include <windows.h>
 
-static inline size_t atomicIncrement(size_t* address) {
+static inline size_t AtomicIncrement(size_t* address) {
 #if defined (_WIN64)
   return InterlockedIncrement64(reinterpret_cast<LONGLONG*>(address));
 #else
@@ -29,7 +29,7 @@
 #endif
 }
 
-static inline size_t atomicDecrement(size_t* address) {
+static inline size_t AtomicDecrement(size_t* address) {
 #if defined (_WIN64)
   return InterlockedDecrement64(reinterpret_cast<LONGLONG*>(address));
 #else
@@ -41,11 +41,11 @@
 
 #include <libkern/OSAtomic.h>
 
-static inline size_t atomicIncrement(size_t* address) {
+static inline size_t AtomicIncrement(size_t* address) {
   return OSAtomicIncrement32Barrier(reinterpret_cast<int32_t*>(address));
 }
 
-static inline size_t atomicDecrement(size_t* address) {
+static inline size_t AtomicDecrement(size_t* address) {
   return OSAtomicDecrement32Barrier(reinterpret_cast<int32_t*>(address));
 }
 
@@ -58,11 +58,11 @@
 
 #include <stddef.h>
 
-static inline size_t atomicIncrement(size_t* address) {
+static inline size_t AtomicIncrement(size_t* address) {
   return __sync_add_and_fetch(address, 1);
 }
 
-static inline size_t atomicDecrement(size_t* address) {
+static inline size_t AtomicDecrement(size_t* address) {
   return __sync_sub_and_fetch(address, 1);
 }
 
diff --git a/sfntly/port/endian.h b/sfntly/port/endian.h
index c6898ee..1364e42 100644
--- a/sfntly/port/endian.h
+++ b/sfntly/port/endian.h
@@ -22,18 +22,18 @@
 
 namespace sfntly {
 
-static inline uint16_t endian_swap16(uint16_t value) {
+static inline uint16_t EndianSwap16(uint16_t value) {
   return (uint16_t)((value >> 8) | (value << 8));
 }
 
-static inline int32_t endian_swap32(int32_t value) {
+static inline int32_t EndianSwap32(int32_t value) {
   return (((value & 0x000000ff) << 24) |
           ((value & 0x0000ff00) <<  8) |
           ((value & 0x00ff0000) >>  8) |
           ((value & 0xff000000) >> 24));
 }
 
-static inline uint64_t endian_swap64(uint64_t value) {
+static inline uint64_t EndianSwap64(uint64_t value) {
   return (((value & 0x00000000000000ffLL) << 56) |
           ((value & 0x000000000000ff00LL) << 40) |
           ((value & 0x0000000000ff0000LL) << 24) |
@@ -45,31 +45,31 @@
 }
 
 #ifdef SFNTLY_LITTLE_ENDIAN
-  #define toBE16(n) endian_swap16(n)
-  #define toBE32(n) endian_swap32(n)
-  #define toBE64(n) endian_swap64(n)
-  #define toLE16(n) (n)
-  #define toLE32(n) (n)
-  #define toLE64(n) (n)
-  #define fromBE16(n) endian_swap16(n)
-  #define fromBE32(n) endian_swap32(n)
-  #define fromBE64(n) endian_swap64(n)
-  #define fromLE16(n) (n)
-  #define fromLE32(n) (n)
-  #define fromLE64(n) (n)
+  #define ToBE16(n) EndianSwap16(n)
+  #define ToBE32(n) EndianSwap32(n)
+  #define ToBE64(n) EndianSwap64(n)
+  #define ToLE16(n) (n)
+  #define ToLE32(n) (n)
+  #define ToLE64(n) (n)
+  #define FromBE16(n) EndianSwap16(n)
+  #define FromBE32(n) EndianSwap32(n)
+  #define FromBE64(n) EndianSwap64(n)
+  #define FromLE16(n) (n)
+  #define FromLE32(n) (n)
+  #define FromLE64(n) (n)
 #else  // SFNTLY_BIG_ENDIAN
-  #define toBE16(n) (n)
-  #define toBE32(n) (n)
-  #define toBE64(n) (n)
-  #define toLE16(n) endian_swap16(n)
-  #define toLE32(n) endian_swap32(n)
-  #define toLE64(n) endian_swap64(n)
-  #define fromBE16(n) (n)
-  #define fromBE32(n) (n)
-  #define fromBE64(n) (n)
-  #define fromLE16(n) endian_swap16(n)
-  #define fromLE32(n) endian_swap32(n)
-  #define fromLE64(n) endian_swap64(n)
+  #define ToBE16(n) (n)
+  #define ToBE32(n) (n)
+  #define ToBE64(n) (n)
+  #define ToLE16(n) EndianSwap16(n)
+  #define ToLE32(n) EndianSwap32(n)
+  #define ToLE64(n) EndianSwap64(n)
+  #define FromBE16(n) (n)
+  #define FromBE32(n) (n)
+  #define FromBE64(n) (n)
+  #define FromLE16(n) EndianSwap16(n)
+  #define FromLE32(n) EndianSwap32(n)
+  #define FromLE64(n) EndianSwap64(n)
 #endif
 
 }  // namespace sfntly
diff --git a/sfntly/port/file_input_stream.cc b/sfntly/port/file_input_stream.cc
index 04a0fd6..661b6fd 100644
--- a/sfntly/port/file_input_stream.cc
+++ b/sfntly/port/file_input_stream.cc
@@ -23,38 +23,21 @@
 
 namespace sfntly {
 
-FileInputStream::FileInputStream() : file_(NULL), position_(0), length_(0) {
+FileInputStream::FileInputStream()
+    : file_(NULL),
+      position_(0),
+      length_(0) {
 }
 
 FileInputStream::~FileInputStream() {
-  close();
+  Close();
 }
 
-int32_t FileInputStream::available() {
+int32_t FileInputStream::Available() {
   return length_ - position_;
 }
 
-bool FileInputStream::open(const char* file_path) {
-  assert(file_path);
-  if (file_) {
-    close();
-  }
-#if defined (WIN32)
-  fopen_s(&file_, file_path, "rb");
-#else
-  file_ = fopen(file_path, "rb");
-#endif
-  if (file_ == NULL) {
-    return false;
-  }
-
-  fseek(file_, 0, SEEK_END);
-  length_ = ftell(file_);
-  fseek(file_, 0, SEEK_SET);
-  return true;
-}
-
-void FileInputStream::close() {
+void FileInputStream::Close() {
   if (file_) {
     fclose(file_);
     length_ = 0;
@@ -63,16 +46,16 @@
   }
 }
 
-void FileInputStream::mark(int32_t readlimit) {
+void FileInputStream::Mark(int32_t readlimit) {
   // NOP
   UNREFERENCED_PARAMETER(readlimit);
 }
 
-bool FileInputStream::markSupported() {
+bool FileInputStream::MarkSupported() {
   return false;
 }
 
-int32_t FileInputStream::read() {
+int32_t FileInputStream::Read() {
   if (!file_) {
 #if defined (SFNTLY_NO_EXCEPTION)
     return 0;
@@ -93,11 +76,11 @@
   return value;
 }
 
-int32_t FileInputStream::read(ByteVector* b) {
-  return read(b, 0, b->capacity());
+int32_t FileInputStream::Read(ByteVector* b) {
+  return Read(b, 0, b->capacity());
 }
 
-int32_t FileInputStream::read(ByteVector* b, int32_t offset, int32_t length) {
+int32_t FileInputStream::Read(ByteVector* b, int32_t offset, int32_t length) {
   assert(b);
   if (!file_) {
 #if defined (SFNTLY_NO_EXCEPTION)
@@ -122,11 +105,11 @@
   return actual_read;
 }
 
-void FileInputStream::reset() {
+void FileInputStream::Reset() {
   // NOP
 }
 
-int64_t FileInputStream::skip(int64_t n) {
+int64_t FileInputStream::Skip(int64_t n) {
   if (!file_) {
 #if defined (SFNTLY_NO_EXCEPTION)
     return 0;
@@ -147,11 +130,11 @@
   return skip_count;
 }
 
-void FileInputStream::unread(ByteVector* b) {
-  unread(b, 0, b->capacity());
+void FileInputStream::Unread(ByteVector* b) {
+  Unread(b, 0, b->capacity());
 }
 
-void FileInputStream::unread(ByteVector* b, int32_t offset, int32_t length) {
+void FileInputStream::Unread(ByteVector* b, int32_t offset, int32_t length) {
   assert(b);
   assert(b->size() >= size_t(offset + length));
   if (!file_) {
@@ -164,9 +147,29 @@
   size_t unread_count = std::min<size_t>(position_, length);
   fseek(file_, position_ - unread_count, SEEK_SET);
   position_ -= unread_count;
-  read(b, offset, length);
+  Read(b, offset, length);
   fseek(file_, position_ - unread_count, SEEK_SET);
   position_ -= unread_count;
 }
 
+bool FileInputStream::Open(const char* file_path) {
+  assert(file_path);
+  if (file_) {
+    Close();
+  }
+#if defined (WIN32)
+  fopen_s(&file_, file_path, "rb");
+#else
+  file_ = fopen(file_path, "rb");
+#endif
+  if (file_ == NULL) {
+    return false;
+  }
+
+  fseek(file_, 0, SEEK_END);
+  length_ = ftell(file_);
+  fseek(file_, 0, SEEK_SET);
+  return true;
+}
+
 }  // namespace sfntly
diff --git a/sfntly/port/file_input_stream.h b/sfntly/port/file_input_stream.h
index 0ec85b6..a63726f 100644
--- a/sfntly/port/file_input_stream.h
+++ b/sfntly/port/file_input_stream.h
@@ -29,22 +29,22 @@
   virtual ~FileInputStream();
 
   // InputStream methods
-  virtual int32_t available();
-  virtual void close();
-  virtual void mark(int32_t readlimit);
-  virtual bool markSupported();
-  virtual int32_t read();
-  virtual int32_t read(ByteVector* b);
-  virtual int32_t read(ByteVector* b, int32_t offset, int32_t length);
-  virtual void reset();
-  virtual int64_t skip(int64_t n);
+  virtual int32_t Available();
+  virtual void Close();
+  virtual void Mark(int32_t readlimit);
+  virtual bool MarkSupported();
+  virtual int32_t Read();
+  virtual int32_t Read(ByteVector* b);
+  virtual int32_t Read(ByteVector* b, int32_t offset, int32_t length);
+  virtual void Reset();
+  virtual int64_t Skip(int64_t n);
 
   // PushbackInputStream methods
-  virtual void unread(ByteVector* b);
-  virtual void unread(ByteVector* b, int32_t offset, int32_t length);
+  virtual void Unread(ByteVector* b);
+  virtual void Unread(ByteVector* b, int32_t offset, int32_t length);
 
   // Own methods
-  virtual bool open(const char* file_path);
+  virtual bool Open(const char* file_path);
 
  private:
   FILE* file_;
diff --git a/sfntly/port/input_stream.h b/sfntly/port/input_stream.h
index ebbccf0..a56afb9 100644
--- a/sfntly/port/input_stream.h
+++ b/sfntly/port/input_stream.h
@@ -24,23 +24,24 @@
 // C++ equivalent to Java's OutputStream class
 class InputStream {
  public:
-  virtual int32_t available() = 0;
-  virtual void close() = 0;
-  virtual void mark(int32_t readlimit) = 0;
-  virtual bool markSupported() = 0;
-  virtual int32_t read() = 0;
-  virtual int32_t read(ByteVector* b) = 0;
-  virtual int32_t read(ByteVector* b, int32_t offset, int32_t length) = 0;
-  virtual void reset() = 0;
-  virtual int64_t skip(int64_t n) = 0;
   // Make gcc -Wnon-virtual-dtor happy.
   virtual ~InputStream() {}
+
+  virtual int32_t Available() = 0;
+  virtual void Close() = 0;
+  virtual void Mark(int32_t readlimit) = 0;
+  virtual bool MarkSupported() = 0;
+  virtual int32_t Read() = 0;
+  virtual int32_t Read(ByteVector* b) = 0;
+  virtual int32_t Read(ByteVector* b, int32_t offset, int32_t length) = 0;
+  virtual void Reset() = 0;
+  virtual int64_t Skip(int64_t n) = 0;
 };
 
 class PushbackInputStream : public InputStream {
  public:
-  virtual void unread(ByteVector* b) = 0;
-  virtual void unread(ByteVector* b, int32_t offset, int32_t length) = 0;
+  virtual void Unread(ByteVector* b) = 0;
+  virtual void Unread(ByteVector* b, int32_t offset, int32_t length) = 0;
 };
 
 }  // namespace sfntly
diff --git a/sfntly/port/memory_output_stream.cc b/sfntly/port/memory_output_stream.cc
index 1f3ecd4..5ddeec2 100644
--- a/sfntly/port/memory_output_stream.cc
+++ b/sfntly/port/memory_output_stream.cc
@@ -24,25 +24,27 @@
 MemoryOutputStream::~MemoryOutputStream() {
 }
 
-void MemoryOutputStream::write(ByteVector* buffer) {
+void MemoryOutputStream::Write(ByteVector* buffer) {
   store_.insert(store_.end(), buffer->begin(), buffer->end());
 }
 
-void MemoryOutputStream::write(ByteVector* buffer, int32_t offset,
+void MemoryOutputStream::Write(ByteVector* buffer,
+                               int32_t offset,
                                int32_t length) {
-  store_.insert(store_.end(), buffer->begin() + offset,
+  store_.insert(store_.end(),
+                buffer->begin() + offset,
                 buffer->begin() + offset + length);
 }
 
-void MemoryOutputStream::write(byte_t b) {
+void MemoryOutputStream::Write(byte_t b) {
   store_.push_back(b);
 }
 
-byte_t* MemoryOutputStream::get() {
+byte_t* MemoryOutputStream::Get() {
   return &(store_[0]);
 }
 
-size_t MemoryOutputStream::size() {
+size_t MemoryOutputStream::Size() {
   return store_.size();
 }
 
diff --git a/sfntly/port/memory_output_stream.h b/sfntly/port/memory_output_stream.h
index 4a7cb74..a0befea 100644
--- a/sfntly/port/memory_output_stream.h
+++ b/sfntly/port/memory_output_stream.h
@@ -32,14 +32,14 @@
   MemoryOutputStream();
   virtual ~MemoryOutputStream();
 
-  virtual void close() {}  // no-op
-  virtual void flush() {}  // no-op
-  virtual void write(ByteVector* buffer);
-  virtual void write(ByteVector* buffer, int32_t offset, int32_t length);
-  virtual void write(byte_t b);
+  virtual void Close() {}  // no-op
+  virtual void Flush() {}  // no-op
+  virtual void Write(ByteVector* buffer);
+  virtual void Write(ByteVector* buffer, int32_t offset, int32_t length);
+  virtual void Write(byte_t b);
 
-  byte_t* get();
-  size_t size();
+  byte_t* Get();
+  size_t Size();
 
  private:
   std::vector<byte_t> store_;
diff --git a/sfntly/port/output_stream.h b/sfntly/port/output_stream.h
index 0b232e2..c5d71cf 100644
--- a/sfntly/port/output_stream.h
+++ b/sfntly/port/output_stream.h
@@ -24,13 +24,14 @@
 // C++ equivalent to Java's OutputStream class
 class OutputStream {
  public:
-  virtual void close() = 0;
-  virtual void flush() = 0;
-  virtual void write(ByteVector* buffer) = 0;
-  virtual void write(ByteVector* buffer, int32_t offset, int32_t length) = 0;
-  virtual void write(byte_t b) = 0;
   // Make gcc -Wnon-virtual-dtor happy.
   virtual ~OutputStream() {}
+
+  virtual void Close() = 0;
+  virtual void Flush() = 0;
+  virtual void Write(ByteVector* buffer) = 0;
+  virtual void Write(ByteVector* buffer, int32_t offset, int32_t length) = 0;
+  virtual void Write(byte_t b) = 0;
 };
 
 }  // namespace sfntly
diff --git a/sfntly/port/refcount.h b/sfntly/port/refcount.h
index ed1fa96..6ac09bb 100644
--- a/sfntly/port/refcount.h
+++ b/sfntly/port/refcount.h
@@ -27,16 +27,16 @@
 //  public:
 //   static Foo* CreateInstance() {
 //     Ptr<Foo> obj = new Foo();  // ref count = 1
-//     return obj.detach();
+//     return obj.Detach();
 //   }
 // };
 // typedef Ptr<Foo> FooPtr;  // common short-hand notation
 // FooPtr obj;
-// obj.attach(Foo::CreatedInstance());  // ref count = 1
+// obj.Attach(Foo::CreatedInstance());  // ref count = 1
 // {
 //   FooPtr obj2 = obj;  // ref count = 2
 // }  // ref count = 1, obj2 out of scope
-// obj.release();  // ref count = 0, object destroyed
+// obj.Release();  // ref count = 0, object destroyed
 
 // Notes on usage:
 // 1. Virtual inherit from RefCount interface in base class if smart pointers
@@ -57,10 +57,10 @@
 //    VC++ will generate SEH which is not handled well in VC++ debugger.  One
 //    can use WinDBG to run it and get the faulting stack.
 // 6. Idioms for heap object as return value
-//    Foo* createFoo() { FooPtr obj = new Foo(); return obj.detach(); }
+//    Foo* createFoo() { FooPtr obj = new Foo(); return obj.Detach(); }
 //    Foo* passthru() { FooPtr obj = createFoo(), return obj; }
 //    FooPtr end_scope_pointer;
-//    end_scope_pointer.attach(passThrough);
+//    end_scope_pointer.Attach(passThrough);
 //    If you are not passing that object back, you are the end of scope.
 
 #ifndef TYPOGRAPHY_FONT_SFNTLY_SRC_SFNTLY_PORT_REFCOUNT_H_
@@ -101,10 +101,11 @@
 
 class RefCount {
  public:
-  virtual size_t addRef() const = 0;
-  virtual size_t release() const = 0;
   // Make gcc -Wnon-virtual-dtor happy.
   virtual ~RefCount() {}
+
+  virtual size_t AddRef() const = 0;
+  virtual size_t Release() const = 0;
 };
 
 template <typename T>
@@ -114,8 +115,8 @@
   ~NoAddRefRelease();
 
  private:
-  virtual size_t addRef() const = 0;
-  virtual size_t release() const = 0;
+  virtual size_t AddRef() const = 0;
+  virtual size_t Release() const = 0;
 };
 
 template <typename TDerived>
@@ -123,15 +124,15 @@
  public:
   RefCounted() : ref_count_(0) {
 #if defined (ENABLE_OBJECT_COUNTER)
-    object_id_ = atomicIncrement(&next_id_);
-    atomicIncrement(&object_counter_);
+    object_id_ = AtomicIncrement(&next_id_);
+    AtomicIncrement(&object_counter_);
     DEBUG_OUTPUT("C ");
 #endif
   }
   RefCounted(const RefCounted<TDerived>&) : ref_count_(0) {}
   virtual ~RefCounted() {
 #if defined (ENABLE_OBJECT_COUNTER)
-    atomicDecrement(&object_counter_);
+    AtomicDecrement(&object_counter_);
     DEBUG_OUTPUT("D ");
 #endif
   }
@@ -141,14 +142,14 @@
     return *this;
   }
 
-  virtual size_t addRef() const {
-    size_t new_count = atomicIncrement(&ref_count_);
+  virtual size_t AddRef() const {
+    size_t new_count = AtomicIncrement(&ref_count_);
     DEBUG_OUTPUT("A ");
     return new_count;
   }
 
-  virtual size_t release() const {
-    size_t new_ref_count = atomicDecrement(&ref_count_);
+  virtual size_t Release() const {
+    size_t new_ref_count = AtomicDecrement(&ref_count_);
     DEBUG_OUTPUT("R ");
     if (new_ref_count == 0) {
       // A C-style is used to cast away const-ness and to derived.
@@ -189,7 +190,7 @@
   }
 
   ~Ptr() {
-    release();
+    Release();
   }
 
   T* operator=(T* pT) {
@@ -201,9 +202,9 @@
       if (p == NULL) {
         return NULL;
       }
-      p->addRef();  // always addRef() before release()
+      p->AddRef();  // always AddRef() before Release()
     }
-    release();
+    Release();
     p_ = pT;
     return p_;
   }
@@ -243,26 +244,26 @@
     return (p_ == pT);
   }
 
-  size_t release() const {
+  size_t Release() const {
     size_t ref_count = 0;
     if (p_) {
       RefCount* p = static_cast<RefCount*>(p_);
       if (p) {
-        ref_count = p->release();
+        ref_count = p->Release();
       }
       p_ = NULL;
     }
     return ref_count;
   }
 
-  void attach(T* pT) {
+  void Attach(T* pT) {
     if (p_ != pT) {
-      release();
+      Release();
       p_ = pT;
     }
   }
 
-  T* detach() {
+  T* Detach() {
     T* pT = p_;
     p_ = NULL;
     return pT;
diff --git a/sfntly/subtable.cc b/sfntly/subtable.cc
index 9ca94f3..782fd80 100644
--- a/sfntly/subtable.cc
+++ b/sfntly/subtable.cc
@@ -20,24 +20,25 @@
 /******************************************************************************
  * SubTable class
  ******************************************************************************/
-SubTable::SubTable(ReadableFontData* data) : FontDataTable(data) {
-}
-
 SubTable::~SubTable() {}
 
+SubTable::SubTable(ReadableFontData* data)
+    : FontDataTable(data) {
+}
+
 /******************************************************************************
  * SubTable::Builder class
  ******************************************************************************/
-SubTable::Builder::Builder(FontDataTableBuilderContainer* container,
-                           WritableFontData* data) :
-    FontDataTable::Builder(container, data) {
-}
-
-SubTable::Builder::Builder(FontDataTableBuilderContainer* container,
-                           ReadableFontData* data) :
-    FontDataTable::Builder(container, data) {
-}
-
 SubTable::Builder::~Builder() {}
 
+SubTable::Builder::Builder(FontDataTableBuilderContainer* container,
+                           WritableFontData* data)
+    : FontDataTable::Builder(container, data) {
+}
+
+SubTable::Builder::Builder(FontDataTableBuilderContainer* container,
+                           ReadableFontData* data)
+    : FontDataTable::Builder(container, data) {
+}
+
 }  // namespace sfntly
diff --git a/sfntly/subtable.h b/sfntly/subtable.h
index 23e1e42..30ecf66 100644
--- a/sfntly/subtable.h
+++ b/sfntly/subtable.h
@@ -26,23 +26,22 @@
 // of these are the CMap subtables within CMap table (cmap) or a glyph within
 // the glyph table (glyf).
 class SubTable : public FontDataTable {
- protected:
-  // Note: constructor refactored in C++ to avoid heavy lifting.
-  //       caller need to do data->slice(offset, length) beforehand.
-  explicit SubTable(ReadableFontData* data);
-
- public:
-  virtual ~SubTable();
-
  public:
   class Builder : public FontDataTable::Builder {
+   public:
+    virtual ~Builder();
+
    protected:
     Builder(FontDataTableBuilderContainer* container, WritableFontData* data);
     Builder(FontDataTableBuilderContainer* container, ReadableFontData* data);
-
-   public:
-    virtual ~Builder();
   };
+
+  virtual ~SubTable();
+
+ protected:
+  // Note: constructor refactored in C++ to avoid heavy lifting.
+  //       caller need to do data->Slice(offset, length) beforehand.
+  explicit SubTable(ReadableFontData* data);
 };
 
 }  // namespace sfntly
diff --git a/sfntly/table.cc b/sfntly/table.cc
index 8a1ec02..a11177e 100644
--- a/sfntly/table.cc
+++ b/sfntly/table.cc
@@ -15,6 +15,7 @@
  */
 
 #include "sfntly/table.h"
+
 #include "sfntly/font.h"
 #include "sfntly/tag.h"
 #include "sfntly/cmap_table.h"
@@ -32,61 +33,56 @@
 /******************************************************************************
  * Table class
  ******************************************************************************/
-Table::Table(Header* header, ReadableFontData* data) : FontDataTable(data) {
-  header_ = header;
-}
-
 Table::~Table() {}
 
-int64_t Table::calculatedChecksum() {
-  return data_->checksum();
+int64_t Table::CalculatedChecksum() {
+  return data_->Checksum();
 }
 
-Table::Header* Table::header() {
-  return header_;
+WritableFontData* Table::GetNewData(int32_t size) {
+  return font_->GetNewData(size);
 }
 
-int32_t Table::headerTag() {
-  return header_->tag();
-}
-
-int32_t Table::headerOffset() {
-  return header_->offset();
-}
-
-int32_t Table::headerLength() {
-  return header_->length();
-}
-
-int64_t Table::headerChecksum() {
-  return header_->checksum();
-}
-
-WritableFontData* Table::getNewData(int32_t size) {
-  return font_->getNewData(size);
-}
-
-void Table::setFont(Font* font) {
+void Table::SetFont(Font* font) {
   font_ = font;
 }
 
+Table::Table(Header* header, ReadableFontData* data)
+    : FontDataTable(data) {
+  header_ = header;
+}
+
 /******************************************************************************
  * Table::Header class
  ******************************************************************************/
 Table::Header::Header(int32_t tag)
-    : tag_(tag), offset_(0), length_(0), offset_valid_(false), checksum_(0),
+    : tag_(tag),
+      offset_(0),
+      length_(0),
+      offset_valid_(false),
+      checksum_(0),
       checksum_valid_(false) {
 }
 
 Table::Header::Header(int32_t tag, int32_t length)
-    : tag_(tag), offset_(0), length_(length), offset_valid_(false),
-      checksum_(0), checksum_valid_(false) {
+    : tag_(tag),
+      offset_(0),
+      length_(length),
+      offset_valid_(false),
+      checksum_(0),
+      checksum_valid_(false) {
 }
 
-Table::Header::Header(int32_t tag, int64_t checksum, int32_t offset,
+Table::Header::Header(int32_t tag,
+                      int64_t checksum,
+                      int32_t offset,
                       int32_t length)
-    : tag_(tag), offset_(offset), length_(length), offset_valid_(true),
-      checksum_(checksum), checksum_valid_(true) {
+    : tag_(tag),
+      offset_(offset),
+      length_(length),
+      offset_valid_(true),
+      checksum_(checksum),
+      checksum_valid_(true) {
 }
 
 Table::Header::~Header() {}
@@ -96,58 +92,30 @@
   return lhs->offset_ > rhs->offset_;
 }
 
-int32_t Table::Header::tag() { return tag_; }
-int32_t Table::Header::offset() { return offset_; }
-int32_t Table::Header::length() { return length_; }
-bool Table::Header::offsetValid() { return offset_valid_; }
-int64_t Table::Header::checksum() { return checksum_; }
-bool Table::Header::checksumValid() { return checksum_valid_; }
-
 /******************************************************************************
  * Table::Builder class
  ******************************************************************************/
-Table::Builder::Builder(FontDataTableBuilderContainer* font_builder,
-                        Header* header, WritableFontData* data) :
-    FontDataTable::Builder(font_builder, data) {
-  header_ = header;
-}
-
-Table::Builder::Builder(FontDataTableBuilderContainer* font_builder,
-                        Header* header, ReadableFontData* data) :
-    FontDataTable::Builder(font_builder, data) {
-  header_ = header;
-}
-
-Table::Builder::Builder(FontDataTableBuilderContainer* font_builder,
-                        Header* header) :
-    FontDataTable::Builder(font_builder) {
-  header_ = header;
-}
-
 Table::Builder::~Builder() {
-  header_.release();
+  header_.Release();
 }
 
-Table::Header* Table::Builder::header() {
-  return header_;
-}
-
-void Table::Builder::notifyPostTableBuild(FontDataTable* table) {
-  if (modelChanged() || dataChanged()) {
+void Table::Builder::NotifyPostTableBuild(FontDataTable* table) {
+  if (modelChanged() || data_changed()) {
     Table* derived_table = down_cast<Table*>(table);
     header_ = new Header(header()->tag(),
-                         derived_table->readFontData()->length());
+                         derived_table->ReadFontData()->Length());
   }
 }
 
-WritableFontData* Table::Builder::getNewData(int32_t size) {
+WritableFontData* Table::Builder::GetNewData(int32_t size) {
   UNREFERENCED_PARAMETER(size);
-  return internalWriteData();
+  return InternalWriteData();
 }
 
-CALLER_ATTACH Table::Builder* Table::Builder::getBuilder(
-    FontDataTableBuilderContainer* font_builder, Header* header,
-    WritableFontData* table_data) {
+CALLER_ATTACH Table::Builder*
+    Table::Builder::GetBuilder(FontDataTableBuilderContainer* font_builder,
+                               Header* header,
+                               WritableFontData* table_data) {
   int32_t tag = header->tag();
   TableBuilderPtr builder;
   Table::Builder* builder_raw = NULL;
@@ -199,77 +167,113 @@
   }
 
   builder = builder_raw;
-  return builder.detach();
+  return builder.Detach();
+}
+
+Table::Builder::Builder(FontDataTableBuilderContainer* font_builder,
+                        Header* header,
+                        WritableFontData* data)
+    : FontDataTable::Builder(font_builder, data) {
+  header_ = header;
+}
+
+Table::Builder::Builder(FontDataTableBuilderContainer* font_builder,
+                        Header* header,
+                        ReadableFontData* data)
+    : FontDataTable::Builder(font_builder, data) {
+  header_ = header;
+}
+
+Table::Builder::Builder(FontDataTableBuilderContainer* font_builder,
+                        Header* header)
+    : FontDataTable::Builder(font_builder) {
+  header_ = header;
 }
 
 /******************************************************************************
  * Table::TableBasedTableBuilder class
  ******************************************************************************/
-Table::TableBasedTableBuilder::TableBasedTableBuilder(
-    FontDataTableBuilderContainer* font_builder, Header* header,
-    WritableFontData* data) : Builder(font_builder, header, data) {}
-
-Table::TableBasedTableBuilder::TableBasedTableBuilder(
-    FontDataTableBuilderContainer* font_builder, Header* header,
-    ReadableFontData* data) : Builder(font_builder, header, data) {}
-
-Table::TableBasedTableBuilder::TableBasedTableBuilder(
-    FontDataTableBuilderContainer* font_builder, Header* header) :
-    Builder(font_builder, header) {}
-
 Table::TableBasedTableBuilder::~TableBasedTableBuilder() {}
 
-Table* Table::TableBasedTableBuilder::table() {
-  if (table_ == NULL) {
-    table_.attach(down_cast<Table*>(subBuildTable(internalReadData())));
-  }
-  return table_;
-}
-
-void Table::TableBasedTableBuilder::subDataSet() {
-  table_ = NULL;
-}
-
-int32_t Table::TableBasedTableBuilder::subDataSizeToSerialize() {
+int32_t Table::TableBasedTableBuilder::SubSerialize(WritableFontData* data) {
+  UNREFERENCED_PARAMETER(data);
   return 0;
 }
 
-bool Table::TableBasedTableBuilder::subReadyToSerialize() {
+bool Table::TableBasedTableBuilder::SubReadyToSerialize() {
   return false;
 }
 
-int32_t Table::TableBasedTableBuilder::subSerialize(WritableFontData* data) {
-  UNREFERENCED_PARAMETER(data);
+int32_t Table::TableBasedTableBuilder::SubDataSizeToSerialize() {
   return 0;
 }
 
+void Table::TableBasedTableBuilder::SubDataSet() {
+  table_ = NULL;
+}
+
+Table::TableBasedTableBuilder::TableBasedTableBuilder(
+    FontDataTableBuilderContainer* font_builder,
+    Header* header,
+    WritableFontData* data)
+    : Builder(font_builder, header, data) {
+}
+
+Table::TableBasedTableBuilder::TableBasedTableBuilder(
+    FontDataTableBuilderContainer* font_builder,
+    Header* header,
+    ReadableFontData* data)
+    : Builder(font_builder, header, data) {
+}
+
+Table::TableBasedTableBuilder::TableBasedTableBuilder(
+    FontDataTableBuilderContainer* font_builder,
+    Header* header)
+    : Builder(font_builder, header) {
+}
+
+Table* Table::TableBasedTableBuilder::GetTable() {
+  if (table_ == NULL) {
+    table_.Attach(down_cast<Table*>(SubBuildTable(InternalReadData())));
+  }
+  return table_;
+}
+
 /******************************************************************************
  * Table::GenericTableBuilder class
  ******************************************************************************/
 Table::GenericTableBuilder::GenericTableBuilder(
-    FontDataTableBuilderContainer* font_builder, Header* header,
-    WritableFontData* data) :
-    TableBasedTableBuilder(font_builder, header, data) {}
+    FontDataTableBuilderContainer* font_builder,
+    Header* header,
+    WritableFontData* data)
+    : TableBasedTableBuilder(font_builder, header, data) {
+}
 
-CALLER_ATTACH FontDataTable* Table::GenericTableBuilder::subBuildTable(
-    ReadableFontData* data) {
+CALLER_ATTACH FontDataTable*
+    Table::GenericTableBuilder::SubBuildTable(ReadableFontData* data) {
   // Note: In C++ port, we use GenericTable, the ref-counted version of Table
   UNREFERENCED_PARAMETER(data);
-  FontDataTablePtr table = new GenericTable(this->header(), internalReadData());
-  return table.detach();
+  FontDataTablePtr table = new GenericTable(this->header(), InternalReadData());
+  return table.Detach();
 }
 
 /******************************************************************************
  * Table::ArrayElementTableBuilder class
  ******************************************************************************/
-Table::ArrayElementTableBuilder::ArrayElementTableBuilder(
-    FontDataTableBuilderContainer* font_builder, Header* header,
-    WritableFontData* data) : Builder(font_builder, header, data) {}
-
-Table::ArrayElementTableBuilder::ArrayElementTableBuilder(
-    FontDataTableBuilderContainer* font_builder, Header* header,
-    ReadableFontData* data) : Builder(font_builder, header, data) {}
-
 Table::ArrayElementTableBuilder::~ArrayElementTableBuilder() {}
 
+Table::ArrayElementTableBuilder::ArrayElementTableBuilder(
+    FontDataTableBuilderContainer* font_builder,
+    Header* header,
+    WritableFontData* data)
+    : Builder(font_builder, header, data) {
+}
+
+Table::ArrayElementTableBuilder::ArrayElementTableBuilder(
+    FontDataTableBuilderContainer* font_builder,
+    Header* header,
+    ReadableFontData* data)
+    : Builder(font_builder, header, data) {
+}
+
 }  // namespace sfntly
diff --git a/sfntly/table.h b/sfntly/table.h
index 9f05ef5..217abcd 100644
--- a/sfntly/table.h
+++ b/sfntly/table.h
@@ -36,13 +36,12 @@
     Header(int32_t tag, int64_t checksum, int32_t offset, int32_t length);
     virtual ~Header();
 
-   public:  // class is final, no virtual functions unless from parent
-    int32_t tag();
-    int32_t offset();
-    int32_t length();
-    bool offsetValid();
-    int64_t checksum();
-    bool checksumValid();
+    int32_t tag() { return tag_; }
+    int32_t offset() { return offset_; }
+    int32_t length() { return length_; }
+    bool offset_valid() { return offset_valid_; }
+    int64_t checksum() { return checksum_; }
+    bool checksum_valid() { return checksum_valid_; }
 
    private:
     int32_t tag_;
@@ -60,89 +59,95 @@
   //       chosen.
   class Builder : public FontDataTable::Builder,
                   public FontDataTableBuilderContainer {
+   public:
+    virtual ~Builder();
+    virtual Header* header() { return header_; }
+    virtual void NotifyPostTableBuild(FontDataTable* table);
+    virtual WritableFontData* GetNewData(int32_t size);
+
+    static CALLER_ATTACH Builder*
+        GetBuilder(FontDataTableBuilderContainer* font_builder,
+                   Header* header,
+                   WritableFontData* table_data);
+
    protected:
     // Note: original version is Font.Builder font_builder. This results in
     //       mutual inclusion happiness that Java solved for C++.  Therefore,
     //       we need to avoid that happiness when we port it to C++.
-    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+    Builder(FontDataTableBuilderContainer* font_builder,
+            Header* header,
             WritableFontData* data);
-    Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+    Builder(FontDataTableBuilderContainer* font_builder,
+            Header* header,
             ReadableFontData* data);
-    Builder(FontDataTableBuilderContainer* font_builder, Header* header);
-
-   public:
-    virtual ~Builder();
-    virtual Header* header();
-    virtual void notifyPostTableBuild(FontDataTable* table);
-    virtual WritableFontData* getNewData(int32_t size);
-
-   public:
-    static CALLER_ATTACH Builder* getBuilder(
-        FontDataTableBuilderContainer* font_builder, Header* header,
-        WritableFontData* table_data);
+    Builder(FontDataTableBuilderContainer* font_builder,
+            Header* header);
 
    private:
     Ptr<Header> header_;
   };
 
   class TableBasedTableBuilder : public Builder {
-   protected:
-    TableBasedTableBuilder(FontDataTableBuilderContainer* font_builder,
-      Header* header, WritableFontData* data);
-    TableBasedTableBuilder(FontDataTableBuilderContainer* font_builder,
-      Header* header, ReadableFontData* data);
-    TableBasedTableBuilder(FontDataTableBuilderContainer* font_builder,
-      Header* header);
    public:
     virtual ~TableBasedTableBuilder();
 
-   protected:
-    virtual Table* table();
-
-   public:
-    virtual int32_t subSerialize(WritableFontData* new_data);
-    virtual bool subReadyToSerialize();
-    virtual int32_t subDataSizeToSerialize();
-    virtual void subDataSet();
+    virtual int32_t SubSerialize(WritableFontData* new_data);
+    virtual bool SubReadyToSerialize();
+    virtual int32_t SubDataSizeToSerialize();
+    virtual void SubDataSet();
 
    protected:
+    TableBasedTableBuilder(FontDataTableBuilderContainer* font_builder,
+                           Header* header,
+                           WritableFontData* data);
+    TableBasedTableBuilder(FontDataTableBuilderContainer* font_builder,
+                           Header* header,
+                           ReadableFontData* data);
+    TableBasedTableBuilder(FontDataTableBuilderContainer* font_builder,
+                           Header* header);
+
+    // C++ port: renamed table() to GetTable()
+    virtual Table* GetTable();
+
+    // TODO(arthurhsu): style guide violation: protected member, need refactor
     Ptr<Table> table_;
   };
 
   class GenericTableBuilder : public TableBasedTableBuilder,
-    public RefCounted<GenericTableBuilder> {
+                              public RefCounted<GenericTableBuilder> {
    public:
     GenericTableBuilder(FontDataTableBuilderContainer* font_builder,
-      Header* header, WritableFontData* data);
-    virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
+                        Header* header,
+                        WritableFontData* data);
+    virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
   };
 
   class ArrayElementTableBuilder : public Builder {
-   protected:
-    ArrayElementTableBuilder(FontDataTableBuilderContainer* font_builder,
-                             Header* header, WritableFontData* data);
-    ArrayElementTableBuilder(FontDataTableBuilderContainer* font_builder,
-                             Header* header, ReadableFontData* data);
    public:
     virtual ~ArrayElementTableBuilder();
+
+   protected:
+    ArrayElementTableBuilder(FontDataTableBuilderContainer* font_builder,
+                             Header* header,
+                             WritableFontData* data);
+    ArrayElementTableBuilder(FontDataTableBuilderContainer* font_builder,
+                             Header* header,
+                             ReadableFontData* data);
   };
 
+  virtual ~Table();
+  virtual int64_t CalculatedChecksum();
+  virtual Header* header()          { return header_; }
+  virtual int32_t header_tag()      { return header_->tag(); }
+  virtual int32_t header_offset()   { return header_->offset(); }
+  virtual int32_t header_length()   { return header_->length(); }
+  virtual int64_t header_checksum() { return header_->checksum(); }
+  virtual WritableFontData* GetNewData(int32_t size);
+  virtual void SetFont(Font* font);
+
  protected:
   Table(Header* header, ReadableFontData* data);
 
- public:
-  virtual ~Table();
-  virtual int64_t calculatedChecksum();
-  virtual Header* header();
-  virtual int32_t headerTag();
-  virtual int32_t headerOffset();
-  virtual int32_t headerLength();
-  virtual int64_t headerChecksum();
-
- public:  // FontDataTableBuilderContainer, deprecated
-  virtual WritableFontData* getNewData(int32_t size);
-  virtual void setFont(Font* font);
-
  private:
   Ptr<Header> header_;
   Ptr<Font> font_;
diff --git a/sfntly/tag.cc b/sfntly/tag.cc
index 257e65f..e3c11cd 100644
--- a/sfntly/tag.cc
+++ b/sfntly/tag.cc
@@ -19,42 +19,42 @@
 
 namespace sfntly {
 
-const int32_t Tag::ttcf = generate_tag('t', 't', 'c', 'f');
-const int32_t Tag::cmap = generate_tag('c', 'm', 'a', 'p');
-const int32_t Tag::head = generate_tag('h', 'e', 'a', 'd');
-const int32_t Tag::hhea = generate_tag('h', 'h', 'e', 'a');
-const int32_t Tag::hmtx = generate_tag('h', 'm', 't', 'x');
-const int32_t Tag::maxp = generate_tag('m', 'a', 'x', 'p');
-const int32_t Tag::name = generate_tag('n', 'a', 'm', 'e');
-const int32_t Tag::OS_2 = generate_tag('O', 'S', '/', '2');
-const int32_t Tag::post = generate_tag('p', 'o', 's', 't');
-const int32_t Tag::cvt  = generate_tag('c', 'v', 't', ' ');
-const int32_t Tag::fpgm = generate_tag('f', 'p', 'g', 'm');
-const int32_t Tag::glyf = generate_tag('g', 'l', 'y', 'f');
-const int32_t Tag::loca = generate_tag('l', 'o', 'c', 'a');
-const int32_t Tag::prep = generate_tag('p', 'r', 'e', 'p');
-const int32_t Tag::CFF  = generate_tag('C', 'F', 'F', ' ');
-const int32_t Tag::VORG = generate_tag('V', 'O', 'R', 'G');
-const int32_t Tag::EBDT = generate_tag('E', 'B', 'D', 'T');
-const int32_t Tag::EBLC = generate_tag('E', 'B', 'L', 'C');
-const int32_t Tag::EBSC = generate_tag('E', 'B', 'S', 'C');
-const int32_t Tag::BASE = generate_tag('B', 'A', 'S', 'E');
-const int32_t Tag::GDEF = generate_tag('G', 'D', 'E', 'F');
-const int32_t Tag::GPOS = generate_tag('G', 'P', 'O', 'S');
-const int32_t Tag::GSUB = generate_tag('G', 'S', 'U', 'B');
-const int32_t Tag::JSTF = generate_tag('J', 'S', 'T', 'F');
-const int32_t Tag::DSIG = generate_tag('D', 'S', 'I', 'G');
-const int32_t Tag::gasp = generate_tag('g', 'a', 's', 'p');
-const int32_t Tag::hdmx = generate_tag('h', 'd', 'm', 'x');
-const int32_t Tag::kern = generate_tag('k', 'e', 'r', 'n');
-const int32_t Tag::LTSH = generate_tag('L', 'T', 'S', 'H');
-const int32_t Tag::PCLT = generate_tag('P', 'C', 'L', 'T');
-const int32_t Tag::VDMX = generate_tag('V', 'D', 'M', 'X');
-const int32_t Tag::vhea = generate_tag('v', 'h', 'e', 'a');
-const int32_t Tag::vmtx = generate_tag('v', 'm', 't', 'x');
-const int32_t Tag::bhed = generate_tag('b', 'h', 'e', 'd');
-const int32_t Tag::bdat = generate_tag('b', 'd', 'a', 't');
-const int32_t Tag::bloc = generate_tag('b', 'l', 'o', 'c');
+const int32_t Tag::ttcf = GenerateTag('t', 't', 'c', 'f');
+const int32_t Tag::cmap = GenerateTag('c', 'm', 'a', 'p');
+const int32_t Tag::head = GenerateTag('h', 'e', 'a', 'd');
+const int32_t Tag::hhea = GenerateTag('h', 'h', 'e', 'a');
+const int32_t Tag::hmtx = GenerateTag('h', 'm', 't', 'x');
+const int32_t Tag::maxp = GenerateTag('m', 'a', 'x', 'p');
+const int32_t Tag::name = GenerateTag('n', 'a', 'm', 'e');
+const int32_t Tag::OS_2 = GenerateTag('O', 'S', '/', '2');
+const int32_t Tag::post = GenerateTag('p', 'o', 's', 't');
+const int32_t Tag::cvt  = GenerateTag('c', 'v', 't', ' ');
+const int32_t Tag::fpgm = GenerateTag('f', 'p', 'g', 'm');
+const int32_t Tag::glyf = GenerateTag('g', 'l', 'y', 'f');
+const int32_t Tag::loca = GenerateTag('l', 'o', 'c', 'a');
+const int32_t Tag::prep = GenerateTag('p', 'r', 'e', 'p');
+const int32_t Tag::CFF  = GenerateTag('C', 'F', 'F', ' ');
+const int32_t Tag::VORG = GenerateTag('V', 'O', 'R', 'G');
+const int32_t Tag::EBDT = GenerateTag('E', 'B', 'D', 'T');
+const int32_t Tag::EBLC = GenerateTag('E', 'B', 'L', 'C');
+const int32_t Tag::EBSC = GenerateTag('E', 'B', 'S', 'C');
+const int32_t Tag::BASE = GenerateTag('B', 'A', 'S', 'E');
+const int32_t Tag::GDEF = GenerateTag('G', 'D', 'E', 'F');
+const int32_t Tag::GPOS = GenerateTag('G', 'P', 'O', 'S');
+const int32_t Tag::GSUB = GenerateTag('G', 'S', 'U', 'B');
+const int32_t Tag::JSTF = GenerateTag('J', 'S', 'T', 'F');
+const int32_t Tag::DSIG = GenerateTag('D', 'S', 'I', 'G');
+const int32_t Tag::gasp = GenerateTag('g', 'a', 's', 'p');
+const int32_t Tag::hdmx = GenerateTag('h', 'd', 'm', 'x');
+const int32_t Tag::kern = GenerateTag('k', 'e', 'r', 'n');
+const int32_t Tag::LTSH = GenerateTag('L', 'T', 'S', 'H');
+const int32_t Tag::PCLT = GenerateTag('P', 'C', 'L', 'T');
+const int32_t Tag::VDMX = GenerateTag('V', 'D', 'M', 'X');
+const int32_t Tag::vhea = GenerateTag('v', 'h', 'e', 'a');
+const int32_t Tag::vmtx = GenerateTag('v', 'm', 't', 'x');
+const int32_t Tag::bhed = GenerateTag('b', 'h', 'e', 'd');
+const int32_t Tag::bdat = GenerateTag('b', 'd', 'a', 't');
+const int32_t Tag::bloc = GenerateTag('b', 'l', 'o', 'c');
 
 const int32_t CFF_TABLE_ORDERING[] = {
     Tag::head,
diff --git a/sfntly/tag.h b/sfntly/tag.h
index fe6da46..9e73007 100644
--- a/sfntly/tag.h
+++ b/sfntly/tag.h
@@ -82,7 +82,7 @@
   static const int32_t bloc;
 };
 
-inline int32_t generate_tag(char a, char b, char c, char d) {
+inline int32_t GenerateTag(char a, char b, char c, char d) {
   return (((int32_t)(a) << 24) |
           ((int32_t)(b) << 16) |
           ((int32_t)(c) <<  8) |
diff --git a/sfntly/tools/subsetter.cc b/sfntly/tools/subsetter.cc
index 44ba22e..c234a1e 100644
--- a/sfntly/tools/subsetter.cc
+++ b/sfntly/tools/subsetter.cc
@@ -14,10 +14,11 @@
  * limitations under the License.
  */
 
+#include "sfntly/tools/subsetter/subsetter.h"
+
 #include <algorithm>
 #include <iterator>
 
-#include "sfntly/tools/subsetter/subsetter.h"
 #include "sfntly/tools/subsetter/glyph_table_subsetter.h"
 
 namespace sfntly {
@@ -31,32 +32,32 @@
 }
 
 Subsetter::~Subsetter() {
-  font_factory_.release();
-  font_.release();
+  font_factory_.Release();
+  font_.Release();
   table_subsetters_.clear();
 }
 
-void Subsetter::setGlyphs(IntegerList* glyphs) {
+void Subsetter::SetGlyphs(IntegerList* glyphs) {
   new_to_old_glyphs_ = *glyphs;
 }
 
-void Subsetter::setCMaps(CMapIdList* cmap_ids, int32_t number) {
+void Subsetter::SetCMaps(CMapIdList* cmap_ids, int32_t number) {
   UNREFERENCED_PARAMETER(cmap_ids);
   UNREFERENCED_PARAMETER(number);
   // TODO(arthurhsu): IMPLEMENT
 }
 
-void Subsetter::setRemoveTables(IntegerSet* remove_tables) {
+void Subsetter::SetRemoveTables(IntegerSet* remove_tables) {
   remove_tables_ = *remove_tables;
 }
 
-CALLER_ATTACH Font::Builder* Subsetter::subset() {
+CALLER_ATTACH Font::Builder* Subsetter::Subset() {
   FontBuilderPtr font_builder;
-  font_builder.attach(font_factory_->newFontBuilder());
+  font_builder.Attach(font_factory_->NewFontBuilder());
 
   IntegerSet table_tags;
-  for (TableMap::iterator i = font_->tables()->begin(),
-                          e = font_->tables()->end(); i != e; ++i) {
+  for (TableMap::iterator i = font_->Tables()->begin(),
+                          e = font_->Tables()->end(); i != e; ++i) {
     table_tags.insert(i->first);
   }
   if (!remove_tables_.empty()) {
@@ -70,9 +71,9 @@
            table_subsetter = table_subsetters_.begin(),
            table_subsetter_end = table_subsetters_.end();
            table_subsetter != table_subsetter_end; ++table_subsetter) {
-    bool handled = (*table_subsetter)->subset(this, font_, font_builder);
+    bool handled = (*table_subsetter)->Subset(this, font_, font_builder);
     if (handled) {
-      IntegerSet* handled_tags = (*table_subsetter)->tagsHandled();
+      IntegerSet* handled_tags = (*table_subsetter)->TagsHandled();
       IntegerSet result;
       std::set_difference(table_tags.begin(), table_tags.end(),
                           handled_tags->begin(), handled_tags->end(),
@@ -82,24 +83,24 @@
   }
   for (IntegerSet::iterator tag = table_tags.begin(),
                             tag_end = table_tags.end(); tag != tag_end; ++tag) {
-    Table* table = font_->table(*tag);
+    Table* table = font_->GetTable(*tag);
     if (table) {
-      // The newTableBuilder() call will alter internal state of font_builder
+      // The NewTableBuilder() call will alter internal state of font_builder
       // AND the reference count of returned object.  Therefore we need to
       // dereference it.
       TableBuilderPtr dereference;
-      dereference.attach(
-          font_builder->newTableBuilder(*tag, table->readFontData()));
+      dereference.Attach(
+          font_builder->NewTableBuilder(*tag, table->ReadFontData()));
     }
   }
-  return font_builder.detach();
+  return font_builder.Detach();
 }
 
-IntegerList* Subsetter::glyphPermutationTable() {
+IntegerList* Subsetter::GlyphPermutationTable() {
   return &new_to_old_glyphs_;
 }
 
-CMapIdList* Subsetter::cmapId() {
+CMapIdList* Subsetter::CMapId() {
   return &cmap_ids_;
 }
 
diff --git a/sfntly/tools/subsetter/glyph_table_subsetter.cc b/sfntly/tools/subsetter/glyph_table_subsetter.cc
index 04d0c48..7609f74 100644
--- a/sfntly/tools/subsetter/glyph_table_subsetter.cc
+++ b/sfntly/tools/subsetter/glyph_table_subsetter.cc
@@ -14,11 +14,12 @@
  * limitations under the License.
  */
 
+#include "sfntly/tools/subsetter/glyph_table_subsetter.h"
+
 #include "sfntly/tag.h"
 #include "sfntly/glyph_table.h"
 #include "sfntly/loca_table.h"
 #include "sfntly/tools/subsetter/subsetter.h"
-#include "sfntly/tools/subsetter/glyph_table_subsetter.h"
 #include "sfntly/port/exception_type.h"
 
 namespace sfntly {
@@ -31,18 +32,19 @@
 
 GlyphTableSubsetter::~GlyphTableSubsetter() {}
 
-bool GlyphTableSubsetter::subset(Subsetter* subsetter, Font* font,
+bool GlyphTableSubsetter::Subset(Subsetter* subsetter,
+                                 Font* font,
                                  Font::Builder* font_builder) {
   assert(font);
   assert(subsetter);
   assert(font_builder);
 
-  IntegerList* permutation_table = subsetter->glyphPermutationTable();
+  IntegerList* permutation_table = subsetter->GlyphPermutationTable();
   if (!permutation_table || permutation_table->empty())
     return false;
 
-  GlyphTablePtr glyph_table = down_cast<GlyphTable*>(font->table(Tag::glyf));
-  LocaTablePtr loca_table = down_cast<LocaTable*>(font->table(Tag::loca));
+  GlyphTablePtr glyph_table = down_cast<GlyphTable*>(font->GetTable(Tag::glyf));
+  LocaTablePtr loca_table = down_cast<LocaTable*>(font->GetTable(Tag::loca));
   if (glyph_table == NULL || loca_table == NULL) {
 #if defined (SFNTLY_NO_EXCEPTION)
     return false;
@@ -52,11 +54,11 @@
   }
 
   GlyphTableBuilderPtr glyph_table_builder;
-  glyph_table_builder.attach(down_cast<GlyphTable::Builder*>(
-       font_builder->newTableBuilder(Tag::glyf)));
+  glyph_table_builder.Attach(down_cast<GlyphTable::Builder*>(
+       font_builder->NewTableBuilder(Tag::glyf)));
   LocaTableBuilderPtr loca_table_builder;
-  loca_table_builder.attach(down_cast<LocaTable::Builder*>(
-       font_builder->newTableBuilder(Tag::loca)));
+  loca_table_builder.Attach(down_cast<LocaTable::Builder*>(
+       font_builder->NewTableBuilder(Tag::loca)));
   if (glyph_table_builder == NULL || loca_table_builder == NULL) {
 #if defined (SFNTLY_NO_EXCEPTION)
     return false;
@@ -65,25 +67,25 @@
 #endif
   }
   GlyphTable::GlyphBuilderList* glyph_builders =
-      glyph_table_builder->glyphBuilders();
+      glyph_table_builder->GlyphBuilders();
   for (IntegerList::iterator old_glyph_id = permutation_table->begin(),
                              old_glyph_id_end = permutation_table->end();
                              old_glyph_id != old_glyph_id_end; ++old_glyph_id) {
-    int old_offset = loca_table->glyphOffset(*old_glyph_id);
-    int old_length = loca_table->glyphLength(*old_glyph_id);
+    int old_offset = loca_table->GlyphOffset(*old_glyph_id);
+    int old_length = loca_table->GlyphLength(*old_glyph_id);
     GlyphPtr glyph;
-    glyph.attach(glyph_table->glyph(old_offset, old_length));
-    ReadableFontDataPtr data = glyph->readFontData();
+    glyph.Attach(glyph_table->GetGlyph(old_offset, old_length));
+    ReadableFontDataPtr data = glyph->ReadFontData();
     WritableFontDataPtr copy_data;
-    copy_data.attach(font_builder->getNewData(data->length()));
-    data->copyTo(copy_data);
+    copy_data.Attach(font_builder->GetNewData(data->Length()));
+    data->CopyTo(copy_data);
     GlyphBuilderPtr glyph_builder;
-    glyph_builder.attach(glyph_table_builder->glyphBuilder(copy_data));
+    glyph_builder.Attach(glyph_table_builder->GlyphBuilder(copy_data));
     glyph_builders->push_back(glyph_builder);
   }
   IntegerList loca_list;
-  glyph_table_builder->generateLocaList(&loca_list);
-  loca_table_builder->setLocaList(&loca_list);
+  glyph_table_builder->GenerateLocaList(&loca_list);
+  loca_table_builder->SetLocaList(&loca_list);
   return true;
 }
 
diff --git a/sfntly/tools/subsetter/glyph_table_subsetter.h b/sfntly/tools/subsetter/glyph_table_subsetter.h
index 14e3c3d..3687e27 100644
--- a/sfntly/tools/subsetter/glyph_table_subsetter.h
+++ b/sfntly/tools/subsetter/glyph_table_subsetter.h
@@ -27,7 +27,8 @@
   GlyphTableSubsetter();
   virtual ~GlyphTableSubsetter();
 
-  virtual bool subset(Subsetter* subsetter, Font* font,
+  virtual bool Subset(Subsetter* subsetter,
+                      Font* font,
                       Font::Builder* font_builder);
 };
 
diff --git a/sfntly/tools/subsetter/subsetter.h b/sfntly/tools/subsetter/subsetter.h
index 01308b5..df417ad 100644
--- a/sfntly/tools/subsetter/subsetter.h
+++ b/sfntly/tools/subsetter/subsetter.h
@@ -31,7 +31,7 @@
   Subsetter(Font* font, FontFactory* font_factory);
   virtual ~Subsetter();
 
-  virtual void setGlyphs(IntegerList* glyphs);
+  virtual void SetGlyphs(IntegerList* glyphs);
 
   // Set the cmaps to be used in the subsetted font. The cmaps are listed in
   // order of priority and the number parameter gives a count of how many of the
@@ -49,12 +49,12 @@
   //     into the subsetted font.
   // @param cmapIds the cmap ids to use for the subsetted font
   // @param number the maximum number of cmaps to place in the subsetted font
-  virtual void setCMaps(CMapIdList* cmap_ids, int32_t number);
+  virtual void SetCMaps(CMapIdList* cmap_ids, int32_t number);
 
-  virtual void setRemoveTables(IntegerSet* remove_tables);
-  virtual CALLER_ATTACH Font::Builder* subset();
-  virtual IntegerList* glyphPermutationTable();
-  virtual CMapIdList* cmapId();
+  virtual void SetRemoveTables(IntegerSet* remove_tables);
+  virtual CALLER_ATTACH Font::Builder* Subset();
+  virtual IntegerList* GlyphPermutationTable();
+  virtual CMapIdList* CMapId();
 
  private:
   FontPtr font_;
diff --git a/sfntly/tools/subsetter/table_subsetter.h b/sfntly/tools/subsetter/table_subsetter.h
index 9565da6..437705c 100644
--- a/sfntly/tools/subsetter/table_subsetter.h
+++ b/sfntly/tools/subsetter/table_subsetter.h
@@ -26,9 +26,9 @@
 class Subsetter;
 class TableSubsetter : virtual public RefCount {
  public:
-  virtual IntegerSet* tagsHandled() = 0;
-  virtual bool tagHandled(int32_t tag) = 0;
-  virtual bool subset(Subsetter* subsetter, Font* font,
+  virtual IntegerSet* TagsHandled() = 0;
+  virtual bool TagHandled(int32_t tag) = 0;
+  virtual bool Subset(Subsetter* subsetter, Font* font,
                       Font::Builder* font_builder) = 0;
 };
 typedef Ptr<TableSubsetter> TableSubsetterPtr;
diff --git a/sfntly/tools/subsetter/table_subsetter_impl.cc b/sfntly/tools/subsetter/table_subsetter_impl.cc
index 481f10f..f239c78 100644
--- a/sfntly/tools/subsetter/table_subsetter_impl.cc
+++ b/sfntly/tools/subsetter/table_subsetter_impl.cc
@@ -27,11 +27,11 @@
 
 TableSubsetterImpl::~TableSubsetterImpl() {}
 
-bool TableSubsetterImpl::tagHandled(int32_t tag) {
+bool TableSubsetterImpl::TagHandled(int32_t tag) {
   return tags_.find(tag) != tags_.end();
 }
 
-IntegerSet* TableSubsetterImpl::tagsHandled() {
+IntegerSet* TableSubsetterImpl::TagsHandled() {
   return &tags_;
 }
 
diff --git a/sfntly/tools/subsetter/table_subsetter_impl.h b/sfntly/tools/subsetter/table_subsetter_impl.h
index 7fabba8..162464a 100644
--- a/sfntly/tools/subsetter/table_subsetter_impl.h
+++ b/sfntly/tools/subsetter/table_subsetter_impl.h
@@ -25,8 +25,8 @@
  public:
   TableSubsetterImpl(const int32_t* tags, size_t tags_length);
   virtual ~TableSubsetterImpl();
-  virtual bool tagHandled(int32_t tag);
-  virtual IntegerSet* tagsHandled();
+  virtual bool TagHandled(int32_t tag);
+  virtual IntegerSet* TagsHandled();
 
  protected:
   IntegerSet tags_;
diff --git a/test/byte_array_test.cc b/test/byte_array_test.cc
index 7c6efa9..89478f4 100644
--- a/test/byte_array_test.cc
+++ b/test/byte_array_test.cc
@@ -27,50 +27,50 @@
 const int32_t BYTE_ARRAY_SIZES[] =
     {1, 7, 127, 128, 129, 255, 256, 257, 666, 1023, 10000, 0xffff, 0x10000};
 
-void fillTestByteArray(ByteArray* ba, int32_t size) {
+void FillTestByteArray(ByteArray* ba, int32_t size) {
   for (int32_t i = 0; i < size; ++i) {
-    ba->put(i, (byte_t)(i % 256));
+    ba->Put(i, (byte_t)(i % 256));
   }
 }
 
-void readByteArrayWithBuffer(ByteArray* ba, ByteVector* buffer, ByteVector* b) {
-  b->resize(ba->length());
+void ReadByteArrayWithBuffer(ByteArray* ba, ByteVector* buffer, ByteVector* b) {
+  b->resize(ba->Length());
   int32_t index = 0;
-  while (index < ba->length()) {
-    int32_t bytes_read = ba->get(index, buffer);
+  while (index < ba->Length()) {
+    int32_t bytes_read = ba->Get(index, buffer);
     std::copy(buffer->begin(), buffer->begin() + bytes_read,
               b->begin() + index);
     index += bytes_read;
   }
 }
 
-void readByteArrayWithSlidingWindow(ByteArray* ba, int window_size,
+void ReadByteArrayWithSlidingWindow(ByteArray* ba, int window_size,
                                     ByteVector* b) {
-  b->resize(ba->length());
+  b->resize(ba->Length());
   int32_t index = 0;
   int32_t actual_window_size = window_size;
-  while (index < ba->length()) {
+  while (index < ba->Length()) {
     actual_window_size =
         std::min<int32_t>(actual_window_size, b->size() - index);
-    int32_t bytes_read = ba->get(index, b, index, actual_window_size);
+    int32_t bytes_read = ba->Get(index, b, index, actual_window_size);
     index += bytes_read;
   }
 }
 
-bool readComparison(ByteArray* ba1, ByteArray* ba2) {
+bool ReadComparison(ByteArray* ba1, ByteArray* ba2) {
   // single byte reads
-  for (int i = 0; i < ba1->length(); ++i) {
-    EXPECT_EQ(ba1->get(i), ba2->get(i));
+  for (int i = 0; i < ba1->Length(); ++i) {
+    EXPECT_EQ(ba1->Get(i), ba2->Get(i));
   }
 
   ByteVector b1, b2;
   // buffer reads
-  int increments = std::max<int32_t>(ba1->length() / 11, 1);
-  for (int buffer_size = 1; buffer_size < ba1->length();
+  int increments = std::max<int32_t>(ba1->Length() / 11, 1);
+  for (int buffer_size = 1; buffer_size < ba1->Length();
        buffer_size += increments) {
     ByteVector buffer(buffer_size);
-    readByteArrayWithBuffer(ba1, &buffer, &b1);
-    readByteArrayWithBuffer(ba2, &buffer, &b2);
+    ReadByteArrayWithBuffer(ba1, &buffer, &b1);
+    ReadByteArrayWithBuffer(ba2, &buffer, &b2);
     EXPECT_GT(b1.size(), static_cast<size_t>(0));
     EXPECT_EQ(b1.size(), b2.size());
     EXPECT_TRUE(std::equal(b1.begin(), b1.end(), b2.begin()));
@@ -79,10 +79,10 @@
   // sliding window reads
   b1.clear();
   b2.clear();
-  for (int window_size = 1; window_size < ba1->length();
+  for (int window_size = 1; window_size < ba1->Length();
        window_size += increments) {
-    readByteArrayWithSlidingWindow(ba1, window_size, &b1);
-    readByteArrayWithSlidingWindow(ba2, window_size, &b2);
+    ReadByteArrayWithSlidingWindow(ba1, window_size, &b1);
+    ReadByteArrayWithSlidingWindow(ba2, window_size, &b2);
     EXPECT_GT(b1.size(), static_cast<size_t>(0));
     EXPECT_EQ(b1.size(), b2.size());
     EXPECT_TRUE(std::equal(b1.begin(), b1.end(), b2.begin()));
@@ -91,46 +91,46 @@
   return true;
 }
 
-bool copyTest(ByteArray* ba) {
-  ByteArrayPtr fixed_copy = new MemoryByteArray(ba->length());
-  ba->copyTo(fixed_copy);
-  EXPECT_EQ(ba->length(), fixed_copy->length());
-  EXPECT_TRUE(readComparison(ba, fixed_copy));
+bool CopyTest(ByteArray* ba) {
+  ByteArrayPtr fixed_copy = new MemoryByteArray(ba->Length());
+  ba->CopyTo(fixed_copy);
+  EXPECT_EQ(ba->Length(), fixed_copy->Length());
+  EXPECT_TRUE(ReadComparison(ba, fixed_copy));
 
   ByteArrayPtr growable_copy = new GrowableMemoryByteArray();
-  ba->copyTo(growable_copy);
-  EXPECT_EQ(ba->length(), growable_copy->length());
-  EXPECT_TRUE(readComparison(ba, growable_copy));
+  ba->CopyTo(growable_copy);
+  EXPECT_EQ(ba->Length(), growable_copy->Length());
+  EXPECT_TRUE(ReadComparison(ba, growable_copy));
 
   return true;
 }
 
-bool byteArrayTester(ByteArray* ba) {
-  return copyTest(ba);
+bool ByteArrayTester(ByteArray* ba) {
+  return CopyTest(ba);
 }
 
 }  // namespace byte_array_test
 
-bool testMemoryByteArray() {
+bool TestMemoryByteArray() {
   for (size_t i = 0;
        i < sizeof(byte_array_test::BYTE_ARRAY_SIZES) / sizeof(int32_t); ++i) {
     int32_t size = byte_array_test::BYTE_ARRAY_SIZES[i];
     fprintf(stderr, "fixed mem: iteration %ld, size %d\n", i, size);
     ByteArrayPtr ba = new MemoryByteArray(size);
-    byte_array_test::fillTestByteArray(ba, size);
-    EXPECT_TRUE(byte_array_test::byteArrayTester(ba));
+    byte_array_test::FillTestByteArray(ba, size);
+    EXPECT_TRUE(byte_array_test::ByteArrayTester(ba));
   }
   return true;
 }
 
-bool testGrowableMemoryByteArray() {
+bool TestGrowableMemoryByteArray() {
   for (size_t i = 0;
        i < sizeof(byte_array_test::BYTE_ARRAY_SIZES) / sizeof(int32_t); ++i) {
     int32_t size = byte_array_test::BYTE_ARRAY_SIZES[i];
     fprintf(stderr, "growable mem: iteration %ld, size %d\n", i, size);
     ByteArrayPtr ba = new GrowableMemoryByteArray();
-    byte_array_test::fillTestByteArray(ba, size);
-    EXPECT_TRUE(byte_array_test::byteArrayTester(ba));
+    byte_array_test::FillTestByteArray(ba, size);
+    EXPECT_TRUE(byte_array_test::ByteArrayTester(ba));
   }
   return true;
 }
diff --git a/test/byte_array_test.h b/test/byte_array_test.h
index 0d67ca8..88e8ce8 100644
--- a/test/byte_array_test.h
+++ b/test/byte_array_test.h
@@ -19,8 +19,8 @@
 
 namespace sfntly {
 
-bool testMemoryByteArray();
-bool testGrowableMemoryByteArray();
+bool TestMemoryByteArray();
+bool TestGrowableMemoryByteArray();
 
 }  // namespace sfntly
 
diff --git a/test/endian_test.cc b/test/endian_test.cc
index 887fed5..50beeeb 100644
--- a/test/endian_test.cc
+++ b/test/endian_test.cc
@@ -25,7 +25,7 @@
 
 namespace sfntly {
 
-bool testEndian() {
+bool TestEndian() {
   byte_t test_data[] = {
       0x68, 0x65, 0x61, 0x64,  // 0: head
       0xca, 0xca, 0xca, 0xca,  // 4: ubyte, byte, char
@@ -38,35 +38,35 @@
 
   ByteArrayPtr ba1 = new GrowableMemoryByteArray();
   for (size_t i = 0; i < sizeof(test_data); ++i) {
-    ba1->put(i, test_data[i]);
+    ba1->Put(i, test_data[i]);
   }
   ReadableFontDataPtr rfd = new ReadableFontData(ba1);
-  EXPECT_EQ(rfd->readULongAsInt(0), Tag::head);
-  EXPECT_EQ(rfd->readUByte(4), 202);
-  EXPECT_EQ(rfd->readByte(5), -54);
-  EXPECT_EQ(rfd->readChar(6), 202);
-  EXPECT_EQ(rfd->readUShort(8), 24);
-  EXPECT_EQ(rfd->readShort(10), -32744);
-  EXPECT_EQ(rfd->readUInt24(12), 24);
-  EXPECT_EQ(rfd->readULong(16), 24);
-  EXPECT_EQ(rfd->readLong(20), -256);
-  EXPECT_EQ(rfd->readFixed(24), Fixed1616::fixed(1, 0));
+  EXPECT_EQ(rfd->ReadULongAsInt(0), Tag::head);
+  EXPECT_EQ(rfd->ReadUByte(4), 202);
+  EXPECT_EQ(rfd->ReadByte(5), -54);
+  EXPECT_EQ(rfd->ReadChar(6), 202);
+  EXPECT_EQ(rfd->ReadUShort(8), 24);
+  EXPECT_EQ(rfd->ReadShort(10), -32744);
+  EXPECT_EQ(rfd->ReadUInt24(12), 24);
+  EXPECT_EQ(rfd->ReadULong(16), 24);
+  EXPECT_EQ(rfd->ReadLong(20), -256);
+  EXPECT_EQ(rfd->ReadFixed(24), Fixed1616::Fixed(1, 0));
 
   MemoryOutputStream os;
   FontOutputStream fos(&os);
-  fos.writeULong(Tag::head);
-  fos.write(202);
-  fos.write(202);
-  fos.write(202);
-  fos.write(202);
-  fos.writeUShort(24);
-  fos.writeShort(-32744);
-  fos.writeUInt24(24);
-  fos.writeChar(0);
-  fos.writeULong(24);
-  fos.writeLong(-256);
-  fos.writeFixed(Fixed1616::fixed(1, 0));
-  EXPECT_EQ(memcmp(os.get(), test_data, sizeof(test_data)), 0);
+  fos.WriteULong(Tag::head);
+  fos.Write(202);
+  fos.Write(202);
+  fos.Write(202);
+  fos.Write(202);
+  fos.WriteUShort(24);
+  fos.WriteShort(-32744);
+  fos.WriteUInt24(24);
+  fos.WriteChar(0);
+  fos.WriteULong(24);
+  fos.WriteLong(-256);
+  fos.WriteFixed(Fixed1616::Fixed(1, 0));
+  EXPECT_EQ(memcmp(os.Get(), test_data, sizeof(test_data)), 0);
 
   return true;
 }
diff --git a/test/endian_test.h b/test/endian_test.h
index ce96251..8fc36ff 100644
--- a/test/endian_test.h
+++ b/test/endian_test.h
@@ -19,7 +19,7 @@
 
 namespace sfntly {
 
-bool testEndian();
+bool TestEndian();
 
 }  // namespace sfntly
 
diff --git a/test/file_io_test.cc b/test/file_io_test.cc
index 1c02b0a..6c48a27 100644
--- a/test/file_io_test.cc
+++ b/test/file_io_test.cc
@@ -23,7 +23,7 @@
 
 namespace sfntly {
 
-bool testFileInputStream() {
+bool TestFileInputStream() {
   FILE* file_handle = NULL;
 #if defined (WIN32)
   fopen_s(&file_handle, SAMPLE_TTF_FILE, "rb");
@@ -44,47 +44,47 @@
 
   // Full file reading test
   FileInputStream is;
-  is.open(SAMPLE_TTF_FILE);
-  EXPECT_EQ(length, (size_t)is.available());
+  is.Open(SAMPLE_TTF_FILE);
+  EXPECT_EQ(length, (size_t)is.Available());
   ByteVector b2;
-  is.read(&b2, 0, length);
-  is.close();
+  is.Read(&b2, 0, length);
+  is.Close();
   EXPECT_EQ(memcmp(&(b1[0]), &(b2[0]), length), 0);
   b2.clear();
 
   // Partial reading test
-  is.open(SAMPLE_TTF_FILE);
-  is.skip(89);
-  is.read(&b2, 0, 100);
+  is.Open(SAMPLE_TTF_FILE);
+  is.Skip(89);
+  is.Read(&b2, 0, 100);
   EXPECT_EQ(memcmp(&(b1[89]), &(b2[0]), 100), 0);
   b2.clear();
 
   // Skip test
-  is.skip(-89);
-  is.read(&b2, 0, 100);
+  is.Skip(-89);
+  is.Read(&b2, 0, 100);
   EXPECT_EQ(memcmp(&(b1[100]), &(b2[0]), 100), 0);
   b2.clear();
-  is.skip(100);
-  is.read(&b2, 0, 100);
+  is.Skip(100);
+  is.Read(&b2, 0, 100);
   EXPECT_EQ(memcmp(&(b1[300]), &(b2[0]), 100), 0);
-  is.skip(-400);
+  is.Skip(-400);
   b2.clear();
 
   // Offset test
-  is.read(&b2, 0, 100);
-  is.read(&b2, 100, 100);
+  is.Read(&b2, 0, 100);
+  is.Read(&b2, 100, 100);
   EXPECT_EQ(memcmp(&(b1[0]), &(b2[0]), 200), 0);
 
   // Unread test
   ByteVector b3;
   b3.resize(200);
-  is.unread(&b3);
+  is.Unread(&b3);
   EXPECT_EQ(memcmp(&(b3[0]), &(b2[0]), 200), 0);
 
   return true;
 }
 
-bool testFontInputStreamBasic() {
+bool TestFontInputStreamBasic() {
   FILE* file_handle = NULL;
 #if defined (WIN32)
   fopen_s(&file_handle, SAMPLE_TTF_FILE, "rb");
@@ -104,47 +104,47 @@
   fclose(file_handle);
 
   FileInputStream is;
-  is.open(SAMPLE_TTF_FILE);
+  is.Open(SAMPLE_TTF_FILE);
   FontInputStream font_is1(&is);
-  EXPECT_EQ((size_t)font_is1.available(), length);
+  EXPECT_EQ((size_t)font_is1.Available(), length);
 
   ByteVector b2;
-  font_is1.read(&b2, 0, length);
-  font_is1.close();
+  font_is1.Read(&b2, 0, length);
+  font_is1.Close();
   EXPECT_EQ(memcmp(&(b1[0]), &(b2[0]), length), 0);
   b2.clear();
 
-  is.open(SAMPLE_TTF_FILE);
-  is.skip(89);
+  is.Open(SAMPLE_TTF_FILE);
+  is.Skip(89);
   FontInputStream font_is2(&is, 200);
-  font_is2.read(&b2, 0, 100);
+  font_is2.Read(&b2, 0, 100);
   EXPECT_EQ(memcmp(&(b1[89]), &(b2[0]), 100), 0);
-  font_is2.read(&b2, 100, 100);
+  font_is2.Read(&b2, 100, 100);
   EXPECT_EQ(memcmp(&(b1[89]), &(b2[0]), 200), 0);
   b2.clear();
-  font_is2.skip(-200);
-  font_is2.read(&b2, 0, 100);
+  font_is2.Skip(-200);
+  font_is2.Read(&b2, 0, 100);
   EXPECT_EQ(memcmp(&(b1[89]), &(b2[0]), 100), 0);
 
   return true;
 }
 
-bool testFontInputStreamTableLoading() {
+bool TestFontInputStreamTableLoading() {
   FileInputStream is;
-  is.open(SAMPLE_TTF_FILE);
+  is.Open(SAMPLE_TTF_FILE);
   FontInputStream font_is(&is);
 
-  font_is.skip(TTF_OFFSET[SAMPLE_TTF_GDEF]);
+  font_is.Skip(TTF_OFFSET[SAMPLE_TTF_GDEF]);
   FontInputStream gdef_is(&font_is, TTF_LENGTH[SAMPLE_TTF_GDEF]);
   ByteVector gdef_data;
-  gdef_is.read(&gdef_data, 0, TTF_LENGTH[SAMPLE_TTF_GDEF]);
+  gdef_is.Read(&gdef_data, 0, TTF_LENGTH[SAMPLE_TTF_GDEF]);
   EXPECT_EQ(memcmp(&(gdef_data[0]), TTF_GDEF_DATA,
                    TTF_LENGTH[SAMPLE_TTF_GDEF]), 0);
 
-  font_is.skip(TTF_OFFSET[SAMPLE_TTF_HEAD] - font_is.position());
+  font_is.Skip(TTF_OFFSET[SAMPLE_TTF_HEAD] - font_is.position());
   FontInputStream head_is(&font_is, TTF_LENGTH[SAMPLE_TTF_HEAD]);
   ByteVector head_data;
-  head_is.read(&head_data, 0, TTF_LENGTH[SAMPLE_TTF_HEAD]);
+  head_is.Read(&head_data, 0, TTF_LENGTH[SAMPLE_TTF_HEAD]);
   EXPECT_EQ(memcmp(&(head_data[0]), TTF_HEAD_DATA,
                    TTF_LENGTH[SAMPLE_TTF_HEAD]), 0);
 
diff --git a/test/file_io_test.h b/test/file_io_test.h
index ab5c109..9ff1972 100644
--- a/test/file_io_test.h
+++ b/test/file_io_test.h
@@ -19,9 +19,9 @@
 
 namespace sfntly {
 
-bool testFileInputStream();
-bool testFontInputStreamBasic();
-bool testFontInputStreamTableLoading();
+bool TestFileInputStream();
+bool TestFontInputStreamBasic();
+bool TestFontInputStreamTableLoading();
 
 }  // namespace sfntly
 
diff --git a/test/font_data_test.cc b/test/font_data_test.cc
index ad30522..3686856 100644
--- a/test/font_data_test.cc
+++ b/test/font_data_test.cc
@@ -28,87 +28,91 @@
 const int32_t BYTE_ARRAY_SIZES[] =
     {1, 7, 127, 128, 129, 255, 256, 257, 666, 1023, 0x10000};
 
-void fillTestByteArray(ByteArray* ba, int32_t size) {
+void FillTestByteArray(ByteArray* ba, int32_t size) {
   for (int32_t i = 0; i < size; ++i) {
-    ba->put(i, (byte_t)(i % 256));
+    ba->Put(i, (byte_t)(i % 256));
   }
 }
 
-void readFontDataWithSingleByte(ReadableFontData* rfd, ByteVector* buffer) {
-  buffer->resize(rfd->length());
-  for (int32_t index = 0; index < rfd->length(); ++index) {
-    (*buffer)[index] = (byte_t)(rfd->readByte(index));
+void ReadFontDataWithSingleByte(ReadableFontData* rfd, ByteVector* buffer) {
+  buffer->resize(rfd->Length());
+  for (int32_t index = 0; index < rfd->Length(); ++index) {
+    (*buffer)[index] = (byte_t)(rfd->ReadByte(index));
   }
 }
 
-void readFontDataWithBuffer(ReadableFontData* rfd, int32_t buffer_size,
+void ReadFontDataWithBuffer(ReadableFontData* rfd,
+                            int32_t buffer_size,
                             ByteVector* b) {
   ByteVector buffer(buffer_size);
-  b->resize(rfd->length());
+  b->resize(rfd->Length());
 
   int32_t index = 0;
-  while (index < rfd->length()) {
-    int32_t bytes_read = rfd->readBytes(index, &buffer, 0, buffer.size());
+  while (index < rfd->Length()) {
+    int32_t bytes_read = rfd->ReadBytes(index, &buffer, 0, buffer.size());
     EXPECT_GE(bytes_read, 0);
     std::copy(buffer.begin(), buffer.begin() + bytes_read, b->begin() + index);
     index += bytes_read;
   }
 }
 
-void readFontDataWithSlidingWindow(ReadableFontData* rfd, int32_t window_size,
+void ReadFontDataWithSlidingWindow(ReadableFontData* rfd, int32_t window_size,
                                    ByteVector* b) {
-  b->resize(rfd->length());
+  b->resize(rfd->Length());
   int32_t index = 0;
-  while (index < rfd->length()) {
+  while (index < rfd->Length()) {
     int32_t actual_window_size =
         std::min<int32_t>(window_size, b->size() - index);
-    int32_t bytes_read = rfd->readBytes(index, b, index, actual_window_size);
+    int32_t bytes_read = rfd->ReadBytes(index, b, index, actual_window_size);
     EXPECT_GE(bytes_read, 0);
     index += bytes_read;
   }
 }
 
-void writeFontDataWithSingleByte(ReadableFontData* rfd, WritableFontData* wfd) {
-  for (int32_t index = 0; index < rfd->length(); ++index) {
-    byte_t b = (byte_t)(rfd->readByte(index));
-    wfd->writeByte(index, b);
+void WriteFontDataWithSingleByte(ReadableFontData* rfd, WritableFontData* wfd) {
+  for (int32_t index = 0; index < rfd->Length(); ++index) {
+    byte_t b = (byte_t)(rfd->ReadByte(index));
+    wfd->WriteByte(index, b);
   }
 }
 
-void writeFontDataWithBuffer(ReadableFontData* rfd, WritableFontData* wfd,
+void WriteFontDataWithBuffer(ReadableFontData* rfd,
+                             WritableFontData* wfd,
                              int32_t buffer_size) {
   ByteVector buffer(buffer_size);
   int32_t index = 0;
-  while (index < rfd->length()) {
-    int32_t bytesRead = rfd->readBytes(index, &buffer, 0, buffer.size());
-    wfd->writeBytes(index, &buffer, 0, buffer.size());
+  while (index < rfd->Length()) {
+    int32_t bytesRead = rfd->ReadBytes(index, &buffer, 0, buffer.size());
+    wfd->WriteBytes(index, &buffer, 0, buffer.size());
     index += bytesRead;
   }
 }
 
-void writeFontDataWithSlidingWindow(ReadableFontData* rfd,
+void WriteFontDataWithSlidingWindow(ReadableFontData* rfd,
                                     WritableFontData* wfd,
                                     int32_t window_size) {
-  ByteVector b(rfd->length());
+  ByteVector b(rfd->Length());
   int32_t index = 0;
-  while (index < rfd->length()) {
+  while (index < rfd->Length()) {
     int32_t sliding_size = std::min<int32_t>(window_size, b.size() - index);
-    int32_t bytes_read = rfd->readBytes(index, &b, index, sliding_size);
-    wfd->writeBytes(index, &b, index, sliding_size);
+    int32_t bytes_read = rfd->ReadBytes(index, &b, index, sliding_size);
+    wfd->WriteBytes(index, &b, index, sliding_size);
     index += bytes_read;
   }
 }
 
-bool readComparison(int32_t offset, int32_t length, ReadableFontData* rfd1,
+bool ReadComparison(int32_t offset,
+                    int32_t length,
+                    ReadableFontData* rfd1,
                     ReadableFontData* rfd2) {
-  EXPECT_TRUE(length == rfd2->length());
+  EXPECT_TRUE(length == rfd2->Length());
   ByteVector b1, b2;
   b1.resize(length);
   b2.resize(length);
 
   // single byte reads
-  readFontDataWithSingleByte(rfd1, &b1);
-  readFontDataWithSingleByte(rfd2, &b2);
+  ReadFontDataWithSingleByte(rfd1, &b1);
+  ReadFontDataWithSingleByte(rfd2, &b2);
   EXPECT_EQ(memcmp(&(b1[offset]), &(b2[0]), length), 0);
 
   // buffer reads
@@ -119,8 +123,8 @@
     b2.clear();
     b1.resize(length);
     b2.resize(length);
-    readFontDataWithBuffer(rfd1, buffer_size, &b1);
-    readFontDataWithBuffer(rfd2, buffer_size, &b2);
+    ReadFontDataWithBuffer(rfd1, buffer_size, &b1);
+    ReadFontDataWithBuffer(rfd2, buffer_size, &b2);
     int result = memcmp(&(b1[offset]), &(b2[0]), length);
     EXPECT_EQ(result, 0);
   }
@@ -132,80 +136,80 @@
     b2.clear();
     b1.resize(length);
     b2.resize(length);
-    readFontDataWithSlidingWindow(rfd1, window_size, &b1);
-    readFontDataWithSlidingWindow(rfd2, window_size, &b2);
+    ReadFontDataWithSlidingWindow(rfd1, window_size, &b1);
+    ReadFontDataWithSlidingWindow(rfd2, window_size, &b2);
     int result = memcmp(&(b1[offset]), &(b2[0]), length);
     EXPECT_EQ(result, 0);
   }
   return true;
 }
 
-void slicingReadTest(ReadableFontData* rfd) {
-  for (int32_t trim = 0; trim < (rfd->length() / 2) + 1;
-       trim += (rfd->length() / 21) + 1) {
+void SlicingReadTest(ReadableFontData* rfd) {
+  for (int32_t trim = 0; trim < (rfd->Length() / 2) + 1;
+       trim += (rfd->Length() / 21) + 1) {
     fprintf(stderr, "\tread - trim = %d\n", trim);
-    int32_t length = rfd->length() - 2 * trim;
+    int32_t length = rfd->Length() - 2 * trim;
     ReadableFontDataPtr slice;
-    slice.attach(down_cast<ReadableFontData*>(rfd->slice(trim, length)));
-    EXPECT_TRUE(readComparison(trim, length, rfd, slice));
+    slice.Attach(down_cast<ReadableFontData*>(rfd->Slice(trim, length)));
+    EXPECT_TRUE(ReadComparison(trim, length, rfd, slice));
   }
 }
 
-void slicingWriteTest(ReadableFontData* rfd, WritableFontData* wfd) {
-  for (int32_t trim = 0; trim < (rfd->length() / 2) + 1;
-       trim += (rfd->length() / 21) + 1) {
+void SlicingWriteTest(ReadableFontData* rfd, WritableFontData* wfd) {
+  for (int32_t trim = 0; trim < (rfd->Length() / 2) + 1;
+       trim += (rfd->Length() / 21) + 1) {
     fprintf(stderr, "\twrite - trim = %d\n", trim);
-    int32_t length = rfd->length() - 2 * trim;
+    int32_t length = rfd->Length() - 2 * trim;
     WritableFontDataPtr w_slice;
     ReadableFontDataPtr r_slice;
 
     // single byte writes
-    w_slice.attach(down_cast<WritableFontData*>(wfd->slice(trim, length)));
-    r_slice.attach(down_cast<ReadableFontData*>(rfd->slice(trim, length)));
-    writeFontDataWithSingleByte(r_slice, w_slice);
-    EXPECT_TRUE(readComparison(trim, length, rfd, w_slice));
+    w_slice.Attach(down_cast<WritableFontData*>(wfd->Slice(trim, length)));
+    r_slice.Attach(down_cast<ReadableFontData*>(rfd->Slice(trim, length)));
+    WriteFontDataWithSingleByte(r_slice, w_slice);
+    EXPECT_TRUE(ReadComparison(trim, length, rfd, w_slice));
 
     // buffer writes
     int32_t increments = std::max<int32_t>(length / 11, 1);
     for (int32_t buffer_size = 1; buffer_size < length;
          buffer_size += increments) {
-      w_slice.attach(down_cast<WritableFontData*>(wfd->slice(trim, length)));
-      r_slice.attach(down_cast<ReadableFontData*>(rfd->slice(trim, length)));
-      writeFontDataWithBuffer(r_slice, w_slice, buffer_size);
-      EXPECT_TRUE(readComparison(trim, length, rfd, w_slice));
+      w_slice.Attach(down_cast<WritableFontData*>(wfd->Slice(trim, length)));
+      r_slice.Attach(down_cast<ReadableFontData*>(rfd->Slice(trim, length)));
+      WriteFontDataWithBuffer(r_slice, w_slice, buffer_size);
+      EXPECT_TRUE(ReadComparison(trim, length, rfd, w_slice));
     }
 
     // sliding window writes
     for (int window_size = 1; window_size < length; window_size += increments) {
-      w_slice.attach(down_cast<WritableFontData*>(wfd->slice(trim, length)));
-      r_slice.attach(down_cast<ReadableFontData*>(rfd->slice(trim, length)));
-      writeFontDataWithSlidingWindow(r_slice, w_slice, window_size);
-      EXPECT_TRUE(readComparison(trim, length, rfd, w_slice));
+      w_slice.Attach(down_cast<WritableFontData*>(wfd->Slice(trim, length)));
+      r_slice.Attach(down_cast<ReadableFontData*>(rfd->Slice(trim, length)));
+      WriteFontDataWithSlidingWindow(r_slice, w_slice, window_size);
+      EXPECT_TRUE(ReadComparison(trim, length, rfd, w_slice));
     }
   }
 }
 
-bool testReadableFontData() {
+bool TestReadableFontData() {
   for (size_t i = 0; i < sizeof(BYTE_ARRAY_SIZES) / sizeof(int32_t); ++i) {
     int32_t size = BYTE_ARRAY_SIZES[i];
     ByteArrayPtr ba = new MemoryByteArray(size);
-    fillTestByteArray(ba, size);
+    FillTestByteArray(ba, size);
     ReadableFontDataPtr rfd = new ReadableFontData(ba);
-    slicingReadTest(rfd);
+    SlicingReadTest(rfd);
   }
   return true;
 }
 
-bool testWritableFontData() {
+bool TestWritableFontData() {
   for (size_t i = 0; i < sizeof(BYTE_ARRAY_SIZES) / sizeof(int32_t); ++i) {
     int32_t size = BYTE_ARRAY_SIZES[i];
     ByteArrayPtr ba = new MemoryByteArray(size);
-    fillTestByteArray(ba, size);
+    FillTestByteArray(ba, size);
     WritableFontDataPtr wfd = new WritableFontData(ba);
-    slicingReadTest(wfd);
+    SlicingReadTest(wfd);
     ByteArrayPtr temp = new MemoryByteArray(size);
     WritableFontDataPtr wfd_copy = new WritableFontData(temp);
-    slicingWriteTest(wfd, wfd_copy);
+    SlicingWriteTest(wfd, wfd_copy);
   }
   return true;
 }
diff --git a/test/font_data_test.h b/test/font_data_test.h
index 78e910d..bca1924 100644
--- a/test/font_data_test.h
+++ b/test/font_data_test.h
@@ -18,8 +18,8 @@
 #define TYPOGRAPHY_FONT_SFNTLY_SRC_TEST_FONT_DATA_TEST_H_
 
 namespace sfntly {
-  bool testReadableFontData();
-  bool testWritableFontData();
+  bool TestReadableFontData();
+  bool TestWritableFontData();
 }
 
 #endif  // TYPOGRAPHY_FONT_SFNTLY_SRC_TEST_FONT_DATA_TEST_H_
diff --git a/test/font_parsing_test.cc b/test/font_parsing_test.cc
index 3c9f732..71446ec 100644
--- a/test/font_parsing_test.cc
+++ b/test/font_parsing_test.cc
@@ -30,52 +30,52 @@
 
 namespace sfntly {
 
-bool testFontParsing() {
+bool TestFontParsing() {
   ByteVector input_buffer;
-  loadFile(SAMPLE_TTF_FILE, &input_buffer);
+  LoadFile(SAMPLE_TTF_FILE, &input_buffer);
   ByteArrayPtr ba = new MemoryByteArray(&(input_buffer[0]),
                                         input_buffer.size());
 
-  FontFactoryPtr factory = FontFactory::getInstance();
+  FontFactoryPtr factory = FontFactory::GetInstance();
   // File based
   FontBuilderArray font_builder_array;
-  builderForFontFile(SAMPLE_TTF_FILE, factory, &font_builder_array);
+  BuilderForFontFile(SAMPLE_TTF_FILE, factory, &font_builder_array);
   FontBuilderPtr font_builder = font_builder_array[0];
   // Memory based
   FontBuilderArray font_builder_array2;
-  factory->loadFontsForBuilding(ba, &font_builder_array2);
+  factory->LoadFontsForBuilding(ba, &font_builder_array2);
   FontBuilderPtr font_builder2 = font_builder_array2[0];
 
   for (size_t i = 0; i < SAMPLE_TTF_KNOWN_TAGS; ++i) {
-    EXPECT_TRUE(font_builder->hasTableBuilder(TTF_KNOWN_TAGS[i]));
-    EXPECT_TRUE(font_builder2->hasTableBuilder(TTF_KNOWN_TAGS[i]));
+    EXPECT_TRUE(font_builder->HasTableBuilder(TTF_KNOWN_TAGS[i]));
+    EXPECT_TRUE(font_builder2->HasTableBuilder(TTF_KNOWN_TAGS[i]));
   }
 
   // Generic table
   Ptr<Table::GenericTableBuilder> gdef_builder =
       down_cast<Table::GenericTableBuilder*>(
-          font_builder->getTableBuilder(Tag::GDEF));
+          font_builder->GetTableBuilder(Tag::GDEF));
   Ptr<Table::Header> gdef_header = gdef_builder->header();
   EXPECT_EQ(gdef_header->length(), TTF_LENGTH[SAMPLE_TTF_GDEF]);
   EXPECT_EQ(gdef_header->offset(), TTF_OFFSET[SAMPLE_TTF_GDEF]);
   EXPECT_EQ(gdef_header->checksum(), TTF_CHECKSUM[SAMPLE_TTF_GDEF]);
-  EXPECT_TRUE(gdef_header->checksumValid());
+  EXPECT_TRUE(gdef_header->checksum_valid());
 
-  WritableFontDataPtr wfd = gdef_builder->data();
+  WritableFontDataPtr wfd = gdef_builder->Data();
   ByteVector b;
   b.resize(TTF_LENGTH[SAMPLE_TTF_GDEF]);
-  wfd->readBytes(0, &b, 0, TTF_LENGTH[SAMPLE_TTF_GDEF]);
+  wfd->ReadBytes(0, &b, 0, TTF_LENGTH[SAMPLE_TTF_GDEF]);
   EXPECT_EQ(memcmp(&(b[0]), TTF_GDEF_DATA, TTF_LENGTH[SAMPLE_TTF_GDEF]), 0);
 
   // Header table
   FontHeaderTableBuilderPtr header_builder =
       down_cast<FontHeaderTable::Builder*>(
-          font_builder->getTableBuilder(Tag::head));
+          font_builder->GetTableBuilder(Tag::head));
   Ptr<Table::Header> header_header = header_builder->header();
   EXPECT_EQ(header_header->length(), TTF_LENGTH[SAMPLE_TTF_HEAD]);
   EXPECT_EQ(header_header->offset(), TTF_OFFSET[SAMPLE_TTF_HEAD]);
   EXPECT_EQ(header_header->checksum(), TTF_CHECKSUM[SAMPLE_TTF_HEAD]);
-  EXPECT_TRUE(header_header->checksumValid());
+  EXPECT_TRUE(header_header->checksum_valid());
 
   // Data conformance
   for (size_t i = 0; i < SAMPLE_TTF_KNOWN_TAGS; ++i) {
@@ -83,46 +83,46 @@
     b1.resize(TTF_LENGTH[i]);
     b2.resize(TTF_LENGTH[i]);
     TableBuilderPtr builder1 =
-        font_builder->getTableBuilder(TTF_KNOWN_TAGS[i]);
+        font_builder->GetTableBuilder(TTF_KNOWN_TAGS[i]);
     TableBuilderPtr builder2 =
-        font_builder2->getTableBuilder(TTF_KNOWN_TAGS[i]);
-    WritableFontDataPtr wfd1 = builder1->data();
-    WritableFontDataPtr wfd2 = builder2->data();
-    wfd1->readBytes(0, &b1, 0, TTF_LENGTH[i]);
-    wfd2->readBytes(0, &b2, 0, TTF_LENGTH[i]);
+        font_builder2->GetTableBuilder(TTF_KNOWN_TAGS[i]);
+    WritableFontDataPtr wfd1 = builder1->Data();
+    WritableFontDataPtr wfd2 = builder2->Data();
+    wfd1->ReadBytes(0, &b1, 0, TTF_LENGTH[i]);
+    wfd2->ReadBytes(0, &b2, 0, TTF_LENGTH[i]);
     EXPECT_EQ(memcmp(&(b1[0]), &(b2[0]), TTF_LENGTH[i]), 0);
   }
 
   return true;
 }
 
-bool testTTFReadWrite() {
-  FontFactoryPtr factory = FontFactory::getInstance();
+bool TestTTFReadWrite() {
+  FontFactoryPtr factory = FontFactory::GetInstance();
   FontBuilderArray font_builder_array;
-  builderForFontFile(SAMPLE_TTF_FILE, factory, &font_builder_array);
+  BuilderForFontFile(SAMPLE_TTF_FILE, factory, &font_builder_array);
   FontBuilderPtr font_builder = font_builder_array[0];
-  FontPtr font = font_builder->build();
+  FontPtr font = font_builder->Build();
   MemoryOutputStream output_stream;
-  factory->serializeFont(font, &output_stream);
-  EXPECT_GE(output_stream.size(), SAMPLE_TTF_SIZE);
+  factory->SerializeFont(font, &output_stream);
+  EXPECT_GE(output_stream.Size(), SAMPLE_TTF_SIZE);
 
   return true;
 }
 
-bool testTTFMemoryBasedReadWrite() {
+bool TestTTFMemoryBasedReadWrite() {
   ByteVector input_buffer;
-  loadFile(SAMPLE_TTF_FILE, &input_buffer);
+  LoadFile(SAMPLE_TTF_FILE, &input_buffer);
 
-  FontFactoryPtr factory = FontFactory::getInstance();
+  FontFactoryPtr factory = FontFactory::GetInstance();
   FontBuilderArray font_builder_array;
   ByteArrayPtr ba = new MemoryByteArray(&(input_buffer[0]),
                                         input_buffer.size());
-  factory->loadFontsForBuilding(ba, &font_builder_array);
+  factory->LoadFontsForBuilding(ba, &font_builder_array);
   FontBuilderPtr font_builder = font_builder_array[0];
-  FontPtr font = font_builder->build();
+  FontPtr font = font_builder->Build();
   MemoryOutputStream output_stream;
-  factory->serializeFont(font, &output_stream);
-  EXPECT_GE(output_stream.size(), input_buffer.size());
+  factory->SerializeFont(font, &output_stream);
+  EXPECT_GE(output_stream.Size(), input_buffer.size());
 
   return true;
 }
diff --git a/test/font_parsing_test.h b/test/font_parsing_test.h
index d66689f..7b69a27 100644
--- a/test/font_parsing_test.h
+++ b/test/font_parsing_test.h
@@ -19,9 +19,9 @@
 
 namespace sfntly {
 
-bool testFontParsing();
-bool testTTFReadWrite();
-bool testTTFMemoryBasedReadWrite();
+bool TestFontParsing();
+bool TestTTFReadWrite();
+bool TestTTFMemoryBasedReadWrite();
 
 }  // namespace sfntly
 
diff --git a/test/main.cc b/test/main.cc
index 0838b94..2c77eda 100644
--- a/test/main.cc
+++ b/test/main.cc
@@ -35,60 +35,60 @@
 namespace sfntly {
 
 TEST(SmartPointer, All) {
-  EXPECT_TRUE(testSmartPointer());
+  EXPECT_TRUE(TestSmartPointer());
 }
 
 TEST(Endian, All) {
-  EXPECT_TRUE(sfntly::testEndian());
+  EXPECT_TRUE(sfntly::TestEndian());
 }
 
 #if defined RUN_LENGTHY_TESTS
 TEST(ByteArray, All) {
-  EXPECT_TRUE(sfntly::testMemoryByteArray());
-  EXPECT_TRUE(sfntly::testGrowableMemoryByteArray());
+  EXPECT_TRUE(sfntly::TestMemoryByteArray());
+  EXPECT_TRUE(sfntly::TestGrowableMemoryByteArray());
 }
 #endif
 
 #if defined RUN_LENGTHY_TESTS
 TEST(FontData, All) {
-  EXPECT_TRUE(sfntly::testReadableFontData());
-  EXPECT_TRUE(sfntly::testWritableFontData());
+  EXPECT_TRUE(sfntly::TestReadableFontData());
+  EXPECT_TRUE(sfntly::TestWritableFontData());
 }
 #endif
 
 TEST(FileIO, All) {
-  EXPECT_TRUE(sfntly::testFileInputStream());
-  EXPECT_TRUE(sfntly::testFontInputStreamBasic());
-  EXPECT_TRUE(sfntly::testFontInputStreamTableLoading());
+  EXPECT_TRUE(sfntly::TestFileInputStream());
+  EXPECT_TRUE(sfntly::TestFontInputStreamBasic());
+  EXPECT_TRUE(sfntly::TestFontInputStreamTableLoading());
 }
 
 TEST(OpenTypeData, All) {
-  EXPECT_TRUE(sfntly::testOTFRead());
-  EXPECT_TRUE(sfntly::testOTFCopy());
+  EXPECT_TRUE(sfntly::TestOTFRead());
+  EXPECT_TRUE(sfntly::TestOTFCopy());
 }
 
 TEST(FontParsing, All) {
-  EXPECT_TRUE(sfntly::testFontParsing());
-  EXPECT_TRUE(sfntly::testTTFReadWrite());
-  EXPECT_TRUE(sfntly::testTTFMemoryBasedReadWrite());
+  EXPECT_TRUE(sfntly::TestFontParsing());
+  EXPECT_TRUE(sfntly::TestTTFReadWrite());
+  EXPECT_TRUE(sfntly::TestTTFMemoryBasedReadWrite());
 }
 
 TEST(OTFBasicEditing, All) {
-  EXPECT_TRUE(sfntly::testOTFBasicEditing());
+  EXPECT_TRUE(sfntly::TestOTFBasicEditing());
 }
 
 TEST(NameEditing, All) {
-  EXPECT_TRUE(sfntly::testChangeOneName());
-  EXPECT_TRUE(sfntly::testModifyNameTableAndRevert());
-  EXPECT_TRUE(sfntly::testRemoveOneName());
+  EXPECT_TRUE(sfntly::TestChangeOneName());
+  EXPECT_TRUE(sfntly::TestModifyNameTableAndRevert());
+  EXPECT_TRUE(sfntly::TestRemoveOneName());
 }
 
 TEST(TestUtils, Extension) {
-  EXPECT_TRUE(sfntly::testExtension());
+  EXPECT_TRUE(sfntly::TestExtension());
 }
 
 TEST(TestUtils, Encoding) {
-  EXPECT_TRUE(sfntly::testEncoding());
+  EXPECT_TRUE(sfntly::TestEncoding());
 }
 
 }  // namespace sfntly
diff --git a/test/name_editing_test.cc b/test/name_editing_test.cc
index 7b87b78..6822bf0 100644
--- a/test/name_editing_test.cc
+++ b/test/name_editing_test.cc
@@ -36,49 +36,49 @@
 static ByteVector input_buffer;
 static ByteArrayPtr ba;
 
-void loadTestFile(FontFactory* factory, FontBuilderArray* font_builders) {
+void LoadTestFile(FontFactory* factory, FontBuilderArray* font_builders) {
   assert(factory);
   assert(font_builders);
   if (ba == NULL) {
-    loadFile(SAMPLE_TTF_FILE, &input_buffer);
+    LoadFile(SAMPLE_TTF_FILE, &input_buffer);
     ba = new MemoryByteArray(&(input_buffer[0]), input_buffer.size());
   }
 
-  factory->loadFontsForBuilding(ba, font_builders);
+  factory->LoadFontsForBuilding(ba, font_builders);
 }
 
-bool testChangeOneName() {
-  FontFactoryPtr factory = FontFactory::getInstance();
+bool TestChangeOneName() {
+  FontFactoryPtr factory = FontFactory::GetInstance();
   FontBuilderArray font_builder_array;
-  loadTestFile(factory, &font_builder_array);
+  LoadTestFile(factory, &font_builder_array);
   FontBuilderPtr font_builder = font_builder_array[0];
 
   NameTableBuilderPtr name_builder = down_cast<NameTable::Builder*>(
-      font_builder->getTableBuilder(Tag::name));
+      font_builder->GetTableBuilder(Tag::name));
 
   // Change the font name.
   NameEntryBuilderPtr neb =
-      name_builder->nameBuilder(PlatformId::kWindows,
+      name_builder->NameBuilder(PlatformId::kWindows,
                                 WindowsEncodingId::kUnicodeUCS2,
                                 WindowsLanguageId::kEnglish_UnitedStates,
                                 NameId::kFontFamilyName);
   U_STRING_DECL(new_name, "Timothy", 7);
-  neb->setName(new_name);
+  neb->SetName(new_name);
 
   // Build the font.
-  FontPtr font = font_builder->build();
+  FontPtr font = font_builder->Build();
 
   // Serialize and reload the serialized font.
   MemoryOutputStream os;
-  factory->serializeFont(font, &os);
+  factory->SerializeFont(font, &os);
   FontArray font_array;
-  ByteArrayPtr new_ba = new MemoryByteArray(os.get(), os.size());
-  factory->loadFonts(new_ba, &font_array);
+  ByteArrayPtr new_ba = new MemoryByteArray(os.Get(), os.Size());
+  factory->LoadFonts(new_ba, &font_array);
   FontPtr new_font = font_array[0];
 
   // Check the font name.
-  NameTablePtr name_table = down_cast<NameTable*>(font->table(Tag::name));
-  UChar* name = name_table->name(PlatformId::kWindows,
+  NameTablePtr name_table = down_cast<NameTable*>(font->GetTable(Tag::name));
+  UChar* name = name_table->Name(PlatformId::kWindows,
                                  WindowsEncodingId::kUnicodeUCS2,
                                  WindowsLanguageId::kEnglish_UnitedStates,
                                  NameId::kFontFamilyName);
@@ -88,86 +88,86 @@
   return true;
 }
 
-bool testModifyNameTableAndRevert() {
-  FontFactoryPtr factory = FontFactory::getInstance();
+bool TestModifyNameTableAndRevert() {
+  FontFactoryPtr factory = FontFactory::GetInstance();
   FontBuilderArray font_builder_array;
-  loadTestFile(factory, &font_builder_array);
+  LoadTestFile(factory, &font_builder_array);
   FontBuilderPtr font_builder = font_builder_array[0];
 
   NameTableBuilderPtr name_builder = down_cast<NameTable::Builder*>(
-      font_builder->getTableBuilder(Tag::name));
+      font_builder->GetTableBuilder(Tag::name));
 
   // Change the font name.
   NameEntryBuilderPtr neb =
-      name_builder->nameBuilder(PlatformId::kWindows,
+      name_builder->NameBuilder(PlatformId::kWindows,
                                 WindowsEncodingId::kUnicodeUCS2,
                                 WindowsLanguageId::kEnglish_UnitedStates,
                                 NameId::kFontFamilyName);
-  NameTable::NameEntry* neb_entry = neb->entry();
-  UChar* original_name = neb_entry->name();
+  NameTable::NameEntry* neb_entry = neb->name_entry();
+  UChar* original_name = neb_entry->Name();
   EXPECT_TRUE(original_name != NULL);
 
   U_STRING_DECL(new_name, "Timothy", 7);
-  neb->setName(new_name);
-  name_builder->revertNames();
+  neb->SetName(new_name);
+  name_builder->RevertNames();
 
   // Build the font.
-  FontPtr font = font_builder->build();
+  FontPtr font = font_builder->Build();
 
   // Serialize and reload the serialized font.
   MemoryOutputStream os;
-  factory->serializeFont(font, &os);
+  factory->SerializeFont(font, &os);
   FontArray font_array;
-  ByteArrayPtr new_ba = new MemoryByteArray(os.get(), os.size());
-  factory->loadFonts(new_ba, &font_array);
+  ByteArrayPtr new_ba = new MemoryByteArray(os.Get(), os.Size());
+  factory->LoadFonts(new_ba, &font_array);
   FontPtr new_font = font_array[0];
 
   // Check the font name.
-  NameTablePtr name_table = down_cast<NameTable*>(font->table(Tag::name));
-  UChar* name = name_table->name(PlatformId::kWindows,
+  NameTablePtr name_table = down_cast<NameTable*>(font->GetTable(Tag::name));
+  UChar* name = name_table->Name(PlatformId::kWindows,
                                  WindowsEncodingId::kUnicodeUCS2,
                                  WindowsLanguageId::kEnglish_UnitedStates,
                                  NameId::kFontFamilyName);
 
   EXPECT_EQ(u_strcmp(name, original_name), 0);
-  delete name;
-  delete original_name;
+  delete[] name;
+  delete[] original_name;
 
   return true;
 }
 
-bool testRemoveOneName() {
-  FontFactoryPtr factory = FontFactory::getInstance();
+bool TestRemoveOneName() {
+  FontFactoryPtr factory = FontFactory::GetInstance();
   FontBuilderArray font_builder_array;
-  loadTestFile(factory, &font_builder_array);
+  LoadTestFile(factory, &font_builder_array);
   FontBuilderPtr font_builder = font_builder_array[0];
 
   NameTableBuilderPtr name_builder = down_cast<NameTable::Builder*>(
-      font_builder->getTableBuilder(Tag::name));
+      font_builder->GetTableBuilder(Tag::name));
 
-  EXPECT_TRUE(name_builder->has(PlatformId::kWindows,
+  EXPECT_TRUE(name_builder->Has(PlatformId::kWindows,
                                 WindowsEncodingId::kUnicodeUCS2,
                                 WindowsLanguageId::kEnglish_UnitedStates,
                                 NameId::kFontFamilyName));
-  EXPECT_TRUE(name_builder->remove(PlatformId::kWindows,
+  EXPECT_TRUE(name_builder->Remove(PlatformId::kWindows,
                                    WindowsEncodingId::kUnicodeUCS2,
                                    WindowsLanguageId::kEnglish_UnitedStates,
                                    NameId::kFontFamilyName));
 
   // Build the font.
-  FontPtr font = font_builder->build();
+  FontPtr font = font_builder->Build();
 
   // Serialize and reload the serialized font.
   MemoryOutputStream os;
-  factory->serializeFont(font, &os);
+  factory->SerializeFont(font, &os);
   FontArray font_array;
-  ByteArrayPtr new_ba = new MemoryByteArray(os.get(), os.size());
-  factory->loadFonts(new_ba, &font_array);
+  ByteArrayPtr new_ba = new MemoryByteArray(os.Get(), os.Size());
+  factory->LoadFonts(new_ba, &font_array);
   FontPtr new_font = font_array[0];
 
   // Check the font name.
-  NameTablePtr name_table = down_cast<NameTable*>(font->table(Tag::name));
-  UChar* name = name_table->name(PlatformId::kWindows,
+  NameTablePtr name_table = down_cast<NameTable*>(font->GetTable(Tag::name));
+  UChar* name = name_table->Name(PlatformId::kWindows,
                                  WindowsEncodingId::kUnicodeUCS2,
                                  WindowsLanguageId::kEnglish_UnitedStates,
                                  NameId::kFontFamilyName);
@@ -179,14 +179,14 @@
 // Note: Function is not implemented but the test case is built.  Uncomment
 //       when NameTable::clear() is implemented.
 /*
-bool testClearAllNamesAndSetOne() {
-  FontFactoryPtr factory = FontFactory::getInstance();
+bool TestClearAllNamesAndSetOne() {
+  FontFactoryPtr factory = FontFactory::GetInstance();
   FontBuilderArray font_builder_array;
-  loadTestFile(factory, &font_builder_array);
+  LoadTestFile(factory, &font_builder_array);
   FontBuilderPtr font_builder = font_builder_array[0];
 
   NameTableBuilderPtr name_builder = down_cast<NameTable::Builder*>(
-      font_builder->getTableBuilder(Tag::name));
+      font_builder->GetTableBuilder(Tag::name));
 
   EXPECT_GT(name_builder->builderCount(), 0);
   name_builder->clear();
@@ -194,32 +194,34 @@
 
   // Change the font name.
   NameEntryBuilderPtr neb =
-      name_builder->nameBuilder(PlatformId::kWindows,
+      name_builder->NameBuilder(PlatformId::kWindows,
                                 WindowsEncodingId::kUnicodeUCS2,
                                 WindowsLanguageId::kEnglish_UnitedStates,
                                 NameId::kFontFamilyName);
   U_STRING_DECL(new_name, "Fred", 4);
-  neb->setName(new_name);
+  neb->SetName(new_name);
 
   // Build the font.
-  FontPtr font = font_builder->build();
+  FontPtr font = font_builder->Build();
 
   // Serialize and reload the serialized font.
   MemoryOutputStream os;
-  factory->serializeFont(font, &os);
+  factory->SerializeFont(font, &os);
   FontArray font_array;
-  ByteArrayPtr new_ba = new MemoryByteArray(os.get(), os.size());
-  factory->loadFonts(new_ba, &font_array);
+  ByteArrayPtr new_ba = new MemoryByteArray(os.Get(), os.Size());
+  factory->LoadFonts(new_ba, &font_array);
   FontPtr new_font = font_array[0];
 
   // Check the font name.
   NameTablePtr name_table = down_cast<NameTable*>(font->table(Tag::name));
-  UChar* name = name_table->name(PlatformId::kWindows,
+  UChar* name = name_table->Name(PlatformId::kWindows,
                                  WindowsEncodingId::kUnicodeUCS2,
                                  WindowsLanguageId::kEnglish_UnitedStates,
                                  NameId::kFontFamilyName);
-  EXPECT_EQ(name_table->nameCount(), 1);
+  EXPECT_EQ(name_table->NameCount(), 1);
   EXPECT_EQ(u_strcmp(name, new_name), 0);
+
+  delete[] name;
   return true;
 }
 */
diff --git a/test/name_editing_test.h b/test/name_editing_test.h
index b5edf0f..dff38d8 100644
--- a/test/name_editing_test.h
+++ b/test/name_editing_test.h
@@ -19,12 +19,12 @@
 
 namespace sfntly {
 
-bool testChangeOneName();
-bool testModifyNameTableAndRevert();
-bool testRemoveOneName();
+bool TestChangeOneName();
+bool TestModifyNameTableAndRevert();
+bool TestRemoveOneName();
 // Note: Function is not implemented but the test case is built.  Uncomment
 //       when NameTable::clear() is implemented.
-// bool testClearAllNamesAndSetOne();
+// bool TestClearAllNamesAndSetOne();
 
 }  // namespace sfntly
 
diff --git a/test/open_type_data_test.cc b/test/open_type_data_test.cc
index ef1d390..da07e69 100644
--- a/test/open_type_data_test.cc
+++ b/test/open_type_data_test.cc
@@ -24,7 +24,7 @@
 const byte_t TEST_OTF_DATA[] =
     {0xff, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
 
-bool testOTFRead() {
+bool TestOTFRead() {
   ByteVector bytes;
   for (size_t i = 0; i < sizeof(TEST_OTF_DATA) / sizeof(byte_t); ++i) {
     bytes.push_back(TEST_OTF_DATA[i]);
@@ -32,18 +32,18 @@
   ByteArrayPtr array = new MemoryByteArray(&(bytes[0]), bytes.size());
   ReadableFontDataPtr data = new ReadableFontData(array);
 
-  EXPECT_EQ(-1, data->readByte(0));
-  EXPECT_EQ(0xff, data->readUByte(0));
-  EXPECT_EQ(0x01, data->readByte(1));
-  EXPECT_EQ(65281, data->readUShort(0));
-  EXPECT_EQ(-255, data->readShort(0));
-  EXPECT_EQ(16711937, data->readUInt24(0));
-  EXPECT_EQ(4278255873LL, data->readULong(0));
-  EXPECT_EQ(-16711423, data->readLong(0));
+  EXPECT_EQ(-1, data->ReadByte(0));
+  EXPECT_EQ(0xff, data->ReadUByte(0));
+  EXPECT_EQ(0x01, data->ReadByte(1));
+  EXPECT_EQ(65281, data->ReadUShort(0));
+  EXPECT_EQ(-255, data->ReadShort(0));
+  EXPECT_EQ(16711937, data->ReadUInt24(0));
+  EXPECT_EQ(4278255873LL, data->ReadULong(0));
+  EXPECT_EQ(-16711423, data->ReadLong(0));
   return true;
 }
 
-bool testOTFCopy() {
+bool TestOTFCopy() {
   ByteVector source_bytes(1024);
   for (size_t i = 0; i < source_bytes.size(); ++i) {
     source_bytes[i] = (byte_t)(i & 0xff);
@@ -56,7 +56,7 @@
       new MemoryByteArray(&(destination_bytes[0]), 1024);
   WritableFontDataPtr destination = new WritableFontData(destination_array);
 
-  int32_t length = source->copyTo(destination);
+  int32_t length = source->CopyTo(destination);
   EXPECT_EQ(1024, length);
   EXPECT_TRUE(std::equal(source_bytes.begin(), source_bytes.end(),
                          destination_bytes.begin()));
diff --git a/test/open_type_data_test.h b/test/open_type_data_test.h
index 99bd422..30d8a54 100644
--- a/test/open_type_data_test.h
+++ b/test/open_type_data_test.h
@@ -19,8 +19,8 @@
 
 namespace sfntly {
 
-bool testOTFRead();
-bool testOTFCopy();
+bool TestOTFRead();
+bool TestOTFCopy();
 
 }  // namespace sfntly
 
diff --git a/test/otf_basic_editing_test.cc b/test/otf_basic_editing_test.cc
index 6c8bde9..e9f4bcd 100644
--- a/test/otf_basic_editing_test.cc
+++ b/test/otf_basic_editing_test.cc
@@ -29,39 +29,39 @@
 
 namespace sfntly {
 
-bool testOTFBasicEditing() {
-  FontFactoryPtr factory = FontFactory::getInstance();
+bool TestOTFBasicEditing() {
+  FontFactoryPtr factory = FontFactory::GetInstance();
   FontBuilderArray font_builder_array;
-  builderForFontFile(SAMPLE_TTF_FILE, factory, &font_builder_array);
+  BuilderForFontFile(SAMPLE_TTF_FILE, factory, &font_builder_array);
   FontBuilderPtr font_builder = font_builder_array[0];
 
   // ensure the builder is not bogus
   EXPECT_TRUE(font_builder != NULL);
-  TableBuilderMap* builder_map = font_builder->tableBuilders();
+  TableBuilderMap* builder_map = font_builder->table_builders();
   EXPECT_TRUE(builder_map != NULL);
   for (TableBuilderMap::iterator i = builder_map->begin(),
                                  e = builder_map->end(); i != e; ++i) {
     EXPECT_TRUE(i->second != NULL);
     if (i->second == NULL) {
       char tag[5] = {0};
-      int32_t value = toBE32(i->first);
+      int32_t value = ToBE32(i->first);
       memcpy(tag, &value, 4);
       fprintf(stderr, "tag %s does not have valid builder\n", tag);
     }
   }
 
   IntegerSet builder_tags;
-  font_builder->tableBuilderTags(&builder_tags);
+  font_builder->TableBuilderTags(&builder_tags);
   FontHeaderTableBuilderPtr header_builder =
       down_cast<FontHeaderTable::Builder*>(
-          font_builder->getTableBuilder(Tag::head));
-  int64_t mod_date = header_builder->modified();
-  header_builder->setModified(mod_date + 1);
+          font_builder->GetTableBuilder(Tag::head));
+  int64_t mod_date = header_builder->Modified();
+  header_builder->SetModified(mod_date + 1);
   FontPtr font;
-  font.attach(font_builder->build());
+  font.Attach(font_builder->Build());
 
   // ensure every table had a builder
-  TableMap* table_map = font->tables();
+  TableMap* table_map = font->Tables();
   for (TableMap::iterator i = table_map->begin(), e = table_map->end();
                           i != e; ++i) {
     TablePtr table = (*i).second;
@@ -71,9 +71,9 @@
   }
   EXPECT_TRUE(builder_tags.empty());
 
-  FontHeaderTablePtr header = down_cast<FontHeaderTable*>(
-      font->table(Tag::head));
-  int64_t after_mod_date = header->modified();
+  FontHeaderTablePtr header =
+      down_cast<FontHeaderTable*>(font->GetTable(Tag::head));
+  int64_t after_mod_date = header->Modified();
   EXPECT_EQ(mod_date + 1, after_mod_date);
   return true;
 }
diff --git a/test/otf_basic_editing_test.h b/test/otf_basic_editing_test.h
index b3abfad..483ed90 100644
--- a/test/otf_basic_editing_test.h
+++ b/test/otf_basic_editing_test.h
@@ -19,7 +19,7 @@
 
 namespace sfntly {
 
-bool testOTFBasicEditing();
+bool TestOTFBasicEditing();
 
 }  // namespace sfntly
 
diff --git a/test/smart_pointer_test.cc b/test/smart_pointer_test.cc
index a35e289..7eac019 100644
--- a/test/smart_pointer_test.cc
+++ b/test/smart_pointer_test.cc
@@ -28,7 +28,7 @@
   int foo() { return foo_; }
 };
 
-bool testSmartPointer() {
+bool TestSmartPointer() {
   // scope out allocation
   {
     Ptr<Foo> p1;
@@ -55,7 +55,7 @@
     EXPECT_EQ(size_t(2), p3->ref_count_);
     EXPECT_EQ(size_t(2), RefCounted<Foo>::object_counter_);
 
-    p3.release();
+    p3.Release();
     EXPECT_EQ(size_t(1), p1->ref_count_);
     EXPECT_EQ(NULL, p3.p_);
     EXPECT_EQ(size_t(2), RefCounted<Foo>::object_counter_);
diff --git a/test/smart_pointer_test.h b/test/smart_pointer_test.h
index ebc0a1f..b57f614 100644
--- a/test/smart_pointer_test.h
+++ b/test/smart_pointer_test.h
@@ -17,6 +17,6 @@
 #ifndef TYPOGRAPHY_FONT_SFNTLY_SRC_TEST_SMART_POINTER_TEST_H_
 #define TYPOGRAPHY_FONT_SFNTLY_SRC_TEST_SMART_POINTER_TEST_H_
 
-bool testSmartPointer();
+bool TestSmartPointer();
 
 #endif  // TYPOGRAPHY_FONT_SFNTLY_SRC_TEST_SMART_POINTER_TEST_H_
diff --git a/test/test_font_utils.cc b/test/test_font_utils.cc
index 830f96e..2c7e1fe 100644
--- a/test/test_font_utils.cc
+++ b/test/test_font_utils.cc
@@ -23,32 +23,32 @@
 
 namespace sfntly {
 
-void builderForFontFile(const char* font_path, FontFactory* factory,
+void BuilderForFontFile(const char* font_path, FontFactory* factory,
                         FontBuilderArray* builders) {
   assert(factory);
   FileInputStream is;
-  is.open(font_path);
-  factory->loadFontsForBuilding(&is, builders);
+  is.Open(font_path);
+  factory->LoadFontsForBuilding(&is, builders);
   EXPECT_GT(builders->size(), static_cast<size_t>(0));
 }
 
-void serializeFont(const char* font_path, FontFactory* factory, Font* font) {
+void SerializeFont(const char* font_path, FontFactory* factory, Font* font) {
   assert(font_path);
   assert(factory);
   assert(font);
   MemoryOutputStream output_stream;
-  factory->serializeFont(font, &output_stream);
-  serializeToFile(&output_stream, font_path);
+  factory->SerializeFont(font, &output_stream);
+  SerializeToFile(&output_stream, font_path);
 }
 
-void loadFont(const char* font_path, FontFactory* factory, FontArray* fonts) {
+void LoadFont(const char* font_path, FontFactory* factory, FontArray* fonts) {
   FileInputStream is;
-  is.open(font_path);
-  factory->loadFonts(&is, fonts);
-  is.close();
+  is.Open(font_path);
+  factory->LoadFonts(&is, fonts);
+  is.Close();
 }
 
-void loadFile(const char* input_file_path, ByteVector* input_buffer) {
+void LoadFile(const char* input_file_path, ByteVector* input_buffer) {
   assert(input_file_path);
   assert(input_buffer);
 
@@ -68,7 +68,7 @@
   fclose(input_file);
 }
 
-void serializeToFile(MemoryOutputStream* output_stream, const char* file_path) {
+void SerializeToFile(MemoryOutputStream* output_stream, const char* file_path) {
   assert(file_path);
   assert(output_stream);
 
@@ -79,12 +79,12 @@
   output_file = fopen(file_path, "wb");
 #endif
   EXPECT_NE(output_file, reinterpret_cast<FILE*>(NULL));
-  fwrite(output_stream->get(), 1, output_stream->size(), output_file);
+  fwrite(output_stream->Get(), 1, output_stream->Size(), output_file);
   fflush(output_file);
   fclose(output_file);
 }
 
-void hexDump(const unsigned char* byte_data, size_t length) {
+void HexDump(const unsigned char* byte_data, size_t length) {
   if (byte_data == NULL || length == 0) {
     fprintf(stderr, "<NULL>\n");
     return;
diff --git a/test/test_font_utils.h b/test/test_font_utils.h
index b0c5696..6c70edc 100644
--- a/test/test_font_utils.h
+++ b/test/test_font_utils.h
@@ -23,15 +23,15 @@
 
 namespace sfntly {
 
-void builderForFontFile(const char* font_path, FontFactory* factory,
+void BuilderForFontFile(const char* font_path, FontFactory* factory,
                         FontBuilderArray* builders);
-void serializeFont(const char* font_path, FontFactory* factory, Font* font);
-void loadFont(const char* font_path, FontFactory* factory, FontArray* fonts);
+void SerializeFont(const char* font_path, FontFactory* factory, Font* font);
+void LoadFont(const char* font_path, FontFactory* factory, FontArray* fonts);
 
-void loadFile(const char* input_file_path, ByteVector* input_buffer);
-void serializeToFile(MemoryOutputStream* output_stream, const char* file_path);
+void LoadFile(const char* input_file_path, ByteVector* input_buffer);
+void SerializeToFile(MemoryOutputStream* output_stream, const char* file_path);
 
-void hexDump(const unsigned char* byte_data, size_t length);
+void HexDump(const unsigned char* byte_data, size_t length);
 
 }  // namespace sfntly
 
diff --git a/test/test_utils.cc b/test/test_utils.cc
index 4b4644e..4751b92 100644
--- a/test/test_utils.cc
+++ b/test/test_utils.cc
@@ -30,15 +30,15 @@
 TestUtils::TestUtils() {}
 
 // static
-// OutputStream createOutputStream(const char *file_path) {
+// OutputStream CreateOutputStream(const char *file_path) {
 // }
 
 // static
-// void TestUtils::createNewFile(const char* file_path) {
+// void TestUtils::CreateNewFile(const char* file_path) {
 // }
 
 // static
-int32_t TestUtils::encodeOneChar(UConverter* encoder, int16_t uchar) {
+int32_t TestUtils::EncodeOneChar(UConverter* encoder, int16_t uchar) {
   char* target = new char[ucnv_getMaxCharSize(encoder) * 2];
   char* target_end;
   UChar* source = new UChar[2];
@@ -69,7 +69,7 @@
 }
 
 // static
-UConverter* TestUtils::getEncoder(const char* charset_name) {
+UConverter* TestUtils::GetEncoder(const char* charset_name) {
   if (charset_name == NULL || strcmp(charset_name, "") == 0)
     return NULL;
   UErrorCode status = U_ZERO_ERROR;
@@ -81,7 +81,7 @@
 
 // Get a file's extension
 // static
-const char* TestUtils::extension(const char* file_path) {
+const char* TestUtils::Extension(const char* file_path) {
   if (!file_path)
     return NULL;
   return strrchr(file_path, EXTENSION_SEPARATOR);
diff --git a/test/test_utils.h b/test/test_utils.h
index 6aa4d99..4d692e1 100644
--- a/test/test_utils.h
+++ b/test/test_utils.h
@@ -40,8 +40,10 @@
   // @param length the length of the byte arrays to compare
   // @return true if the array segments are equal; false otherwise
   // TODO(dfilimon): implement
-  static bool equals(ByteArray* b1, int32_t offset1,
-                     ByteArray* b2, int32_t offset2);
+  static bool Equals(ByteArray* b1,
+                     int32_t offset1,
+                     ByteArray* b2,
+                     int32_t offset2);
 
   // @param offset1 offset to start comparing the first ByteArray from
   // @param ba1 the first ByteArray
@@ -50,8 +52,11 @@
   // @param length the number of bytes to compare
   // @return true if all bytes in the ranges given are equal; false otherwise
   // TODO(dfilimon): implement
-  static bool equals(ByteArray* b1, int32_t offset1,
-                     ByteArray* b2, int32_t offset2, int32_t length);
+  static bool Equals(ByteArray* b1,
+                     int32_t offset1,
+                     ByteArray* b2,
+                     int32_t offset2,
+                     int32_t length);
 
   // TODO(dfilimon): implement FileOutputStream in port/file_output_stream.*
   // static OutputStream createOutputStream(const char* file_path);
@@ -62,13 +67,13 @@
   // Creates a new file including deleting an already existing file with the
   // same path and name and creating any needed directories.
   // TODO(dfilimon): implement
-  static void createNewFile(const char* file_path);
+  static void CreateNewFile(const char* file_path);
 
   // Converts an integer into a 4 character string using the ASCII encoding.
   // @param i the value to convert
   // @return the String based on the number
   // TODO(dfilimon): implement
-  static void dumpLongAsString(int32_t i, std::string* result);
+  static void DumpLongAsString(int32_t i, std::string* result);
 
   // Calculate an OpenType checksum from the array.
   // @param b the array to calculate checksum on
@@ -76,20 +81,20 @@
   // @param length the number of bytes to check; must be a multiple of 4
   // @return checksum
   // TODO(dfilimon): implement
-  static int64_t checkSum(ByteArray* b, int32_t offset, int32_t length);
+  static int64_t CheckSum(ByteArray* b, int32_t offset, int32_t length);
 
   // Encode a single character in UTF-16.
   // We only support the BMP for now
   // @param encoder the encoder to use for the encoding
   // @param uchar the Unicode character to encode
   // @return the encoded character
-  static int32_t encodeOneChar(UConverter* encoder, int16_t uchar);
+  static int32_t EncodeOneChar(UConverter* encoder, int16_t uchar);
 
   // Get an encoder for the charset name.
   // If the name is null or the empty string then just return null.
   // @param charsetName the charset to get an encoder for
   // @return an encoder or null if no encoder available for charset name
-  static UConverter* getEncoder(const char* charsetName);
+  static UConverter* GetEncoder(const char* charsetName);
 
  private:
   static const char EXTENSION_SEPARATOR = '.';
@@ -99,7 +104,7 @@
   // @param file the whose name to process
   // @return string containing the extension or an empty string if
   // there is no extension
-  static const char* extension(const char* file_path);
+  static const char* Extension(const char* file_path);
 };
 }
 #endif  // TYPOGRAPHY_FONT_SFNTLY_SRC_TEST_TEST_UTILS_H_
diff --git a/test/test_utils_test.cc b/test/test_utils_test.cc
index 12c5512..41ba905 100644
--- a/test/test_utils_test.cc
+++ b/test/test_utils_test.cc
@@ -27,8 +27,8 @@
 
 // Check if proper encoding is being performed
 // Conversion is done from UTF16 to UTF8, SJIS
-bool testEncoding() {
-  UConverter* conv = TestUtils::getEncoder("utf8");
+bool TestEncoding() {
+  UConverter* conv = TestUtils::GetEncoder("utf8");
   EXPECT_TRUE(conv != NULL);
   // Ūnĭcōde̽
   UChar from[8] = {0x016A, 0x006E, 0x012D, 0x0063, 0x014D, 0x0064, 0x0065,
@@ -37,7 +37,7 @@
                       0x65, 0xcc, 0xbd};
   int32_t i, j = 0;
   for (i = 0; i < 7; ++i) {
-    int32_t encoded = TestUtils::encodeOneChar(conv, (int16_t)from[i]);
+    int32_t encoded = TestUtils::EncodeOneChar(conv, (int16_t)from[i]);
     for (; encoded; encoded <<= 8) {
       byte_t b = (encoded & 0xff000000) >> 24;
       if (!b)
@@ -54,22 +54,22 @@
 }
 
 // Check if the proper extension is obtained
-bool testExtension() {
+bool TestExtension() {
   // usual file name
   const char *result;
-  result = TestUtils::extension("../data/ext/arial.ttf");
+  result = TestUtils::Extension("../data/ext/tuffy.ttf");
   EXPECT_EQ(strcmp(result, ".ttf"), 0);
 
   // more than one 'extension'
-  result = TestUtils::extension("arial.ttf.fake");
+  result = TestUtils::Extension("tuffy.ttf.fake");
   EXPECT_EQ(strcmp(result, ".fake"), 0);
 
   // no extension
-  result = TestUtils::extension("arial");
+  result = TestUtils::Extension("tuffy");
   EXPECT_STREQ(result, NULL);
 
   // bogus extension
-  result = TestUtils::extension("arial.");
+  result = TestUtils::Extension("tuffy.");
   EXPECT_EQ(strcmp(result, "."), 0);
 
   return true;
diff --git a/test/test_utils_test.h b/test/test_utils_test.h
index 1b4649e..c830ed1 100644
--- a/test/test_utils_test.h
+++ b/test/test_utils_test.h
@@ -21,9 +21,9 @@
 
 namespace sfntly {
 
-bool testEncoding();
-bool testExtension();
-bool testReadFile();
+bool TestEncoding();
+bool TestExtension();
+bool TestReadFile();
 
 }  // namespace sfntly