Remove the length field from the index entries in data pack files.

ui/base/resource/data_pack.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/base/resource/data_pack.h"
 
 #include <errno.h>
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/metrics/histogram.h"
 #include "base/string_piece.h"
 
 // For details of the file layout, see
 // http://dev.chromium.org/developers/design-documents/linuxresourcesandlocalizedstrings
 
 namespace {
 
-static const uint32 kFileFormatVersion = 2;
+static const uint32 kFileFormatVersion = 3;
 // Length of file header: version and entry count.
 static const size_t kHeaderLength = 2 * sizeof(uint32);
 
 #pragma pack(push,2)
 struct DataPackEntry {
   uint16 resource_id;
   uint32 file_offset;
-  uint32 length;
 
   static int CompareById(const void* void_key, const void* void_entry) {
     uint16 key = *reinterpret_cast<const uint16*>(void_key);
     const DataPackEntry* entry =
         reinterpret_cast<const DataPackEntry*>(void_entry);
     if (key < entry->resource_id) {
       return -1;
     } else if (key > entry->resource_id) {
       return 1;
     } else {
       return 0;
     }
   }
 };
 #pragma pack(pop)
 
-COMPILE_ASSERT(sizeof(DataPackEntry) == 10, size_of_header_must_be_ten);
+COMPILE_ASSERT(sizeof(DataPackEntry) == 6, size_of_entry_must_be_six);
 
 // We're crashing when trying to load a pak file on Windows.  Add some error
 // codes for logging.
 // http://crbug.com/58056
 enum LoadErrors {
   INIT_FAILED = 1,
   BAD_VERSION,
   INDEX_TRUNCATED,
   ENTRY_NOT_FOUND,
 
@@ skipping 38 matching lines @@
   // 1) Check we have enough entries.
   if (kHeaderLength + resource_count_ * sizeof(DataPackEntry) >
       mmap_->length()) {
     LOG(ERROR) << "Data pack file corruption: too short for number of "
                   "entries specified.";
     UMA_HISTOGRAM_ENUMERATION("DataPack.Load", INDEX_TRUNCATED,
                               LOAD_ERRORS_COUNT);
     mmap_.reset();
     return false;
   }
-  // 2) Verify the entries are within the appropriate bounds.
-  for (size_t i = 0; i < resource_count_; ++i) {
+  // 2) Verify the entries are within the appropriate bounds. There's an extra
+  // entry after the last item which gives us the length of the last item.
+  for (size_t i = 0; i < resource_count_ + 1; ++i) {
     const DataPackEntry* entry = reinterpret_cast<const DataPackEntry*>(
         mmap_->data() + kHeaderLength + (i * sizeof(DataPackEntry)));
-    if (entry->file_offset + entry->length > mmap_->length()) {
+    if (entry->file_offset > mmap_->length()) {
       LOG(ERROR) << "Entry #" << i << " in data pack points off end of file. "
                  << "Was the file corrupted?";
       UMA_HISTOGRAM_ENUMERATION("DataPack.Load", ENTRY_NOT_FOUND,
                                 LOAD_ERRORS_COUNT);
       mmap_.reset();
       return false;
     }
   }
 
   return true;
 }
 
 bool DataPack::GetStringPiece(uint16 resource_id,
                               base::StringPiece* data) const {
   // It won't be hard to make this endian-agnostic, but it's not worth
   // bothering to do right now.
 #if defined(__BYTE_ORDER)
   // Linux check
   COMPILE_ASSERT(__BYTE_ORDER == __LITTLE_ENDIAN,
                  datapack_assumes_little_endian);
 #elif defined(__BIG_ENDIAN__)
   // Mac check
   #error DataPack assumes little endian
 #endif
 
-  DataPackEntry* target = reinterpret_cast<DataPackEntry*>(
+  const DataPackEntry* target = reinterpret_cast<const DataPackEntry*>(
       bsearch(&resource_id, mmap_->data() + kHeaderLength, resource_count_,
               sizeof(DataPackEntry), DataPackEntry::CompareById));
   if (!target) {
     return false;
   }
 
-  data->set(mmap_->data() + target->file_offset, target->length);
+  const DataPackEntry* next_entry = target + 1;
+  size_t length = next_entry->file_offset - target->file_offset;
+
+  data->set(mmap_->data() + target->file_offset, length);
   return true;
 }
 
 RefCountedStaticMemory* DataPack::GetStaticMemory(uint16 resource_id) const {
   base::StringPiece piece;
   if (!GetStringPiece(resource_id, &piece))
     return NULL;
 
   return new RefCountedStaticMemory(
       reinterpret_cast<const unsigned char*>(piece.data()), piece.length());
@@ skipping 14 matching lines @@
 
   // Note: the python version of this function explicitly sorted keys, but
   // std::map is a sorted associative container, we shouldn't have to do that.
   uint32 entry_count = resources.size();
   if (fwrite(&entry_count, sizeof(entry_count), 1, file) != 1) {
     LOG(ERROR) << "Failed to write entry count";
     file_util::CloseFile(file);
     return false;
   }
 
-  // Each entry is 1 uint16 + 2 uint32s.
-  uint32 index_length = entry_count * sizeof(DataPackEntry);
+  // Each entry is a uint16 + a uint32. We have an extra entry after the last
+  // item so we can compute the size of the list item.
+  uint32 index_length = (entry_count + 1) * sizeof(DataPackEntry);
   uint32 data_offset = kHeaderLength + index_length;
   for (std::map<uint16, base::StringPiece>::const_iterator it =
            resources.begin();
        it != resources.end(); ++it) {
     uint16 resource_id = it->first;
     if (fwrite(&resource_id, sizeof(resource_id), 1, file) != 1) {
       LOG(ERROR) << "Failed to write id for " << resource_id;
       file_util::CloseFile(file);
       return false;
     }
 
     if (fwrite(&data_offset, sizeof(data_offset), 1, file) != 1) {
       LOG(ERROR) << "Failed to write offset for " << resource_id;
       file_util::CloseFile(file);
       return false;
     }
 
-    uint32 len = it->second.length();
-    if (fwrite(&len, sizeof(len), 1, file) != 1) {
-      LOG(ERROR) << "Failed to write length for " << resource_id;
-      file_util::CloseFile(file);
-      return false;
-    }
+    data_offset += it->second.length();
+  }
 
-    data_offset += len;
+  // We place an extra entry after the last item that allows us to read the
+  // size of the last item.
+  uint16 resource_id = 0;
+  if (fwrite(&resource_id, sizeof(resource_id), 1, file) != 1) {
+    LOG(ERROR) << "Failed to write extra resource id.";
+    file_util::CloseFile(file);
+    return false;
+  }
+
+  if (fwrite(&data_offset, sizeof(data_offset), 1, file) != 1) {
+    LOG(ERROR) << "Failed to write extra offset.";
+    file_util::CloseFile(file);
+    return false;
   }
 
   for (std::map<uint16, base::StringPiece>::const_iterator it =
            resources.begin();
        it != resources.end(); ++it) {
     if (fwrite(it->second.data(), it->second.length(), 1, file) != 1) {
       LOG(ERROR) << "Failed to write data for " << it->first;
       file_util::CloseFile(file);
       return false;
     }
   }
 
   file_util::CloseFile(file);
 
   return true;
 }
 
 }  // namespace ui