Add deduplication logic to .pak files

ui/base/resource/data_pack_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/base/resource/data_pack.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/strings/string_piece.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/base/resource/data_pack_literal.h"
 #include "ui/base/ui_base_paths.h"
 
 namespace ui {
 
 class DataPackTest
     : public testing::TestWithParam<DataPack::TextEncodingType> {
  public:
   DataPackTest() {}
 };
 
-extern const char kSamplePakContents[];
-extern const char kSampleCorruptPakContents[];
-extern const size_t kSamplePakSize;
-extern const size_t kSampleCorruptPakSize;
-
 TEST(DataPackTest, LoadFromPath) {
   base::ScopedTempDir dir;
   ASSERT_TRUE(dir.CreateUniqueTempDir());
   base::FilePath data_path =
       dir.GetPath().Append(FILE_PATH_LITERAL("sample.pak"));
 
   // Dump contents into the pak file.
-  ASSERT_EQ(base::WriteFile(data_path, kSamplePakContents, kSamplePakSize),
-            static_cast<int>(kSamplePakSize));
+  ASSERT_EQ(base::WriteFile(data_path, kSamplePakContentsV4, kSamplePakSizeV4),
+            static_cast<int>(kSamplePakSizeV4));
 
   // Load the file through the data pack API.
   DataPack pack(SCALE_FACTOR_100P);
   ASSERT_TRUE(pack.LoadFromPath(data_path));
 
   base::StringPiece data;
   ASSERT_TRUE(pack.HasResource(4));
   ASSERT_TRUE(pack.GetStringPiece(4, &data));
   EXPECT_EQ("this is id 4", data);
   ASSERT_TRUE(pack.HasResource(6));
@@ skipping 11 matching lines @@
   ASSERT_FALSE(pack.GetStringPiece(140, &data));
 }
 
 TEST(DataPackTest, LoadFromFile) {
   base::ScopedTempDir dir;
   ASSERT_TRUE(dir.CreateUniqueTempDir());
   base::FilePath data_path =
       dir.GetPath().Append(FILE_PATH_LITERAL("sample.pak"));
 
   // Dump contents into the pak file.
-  ASSERT_EQ(base::WriteFile(data_path, kSamplePakContents, kSamplePakSize),
-            static_cast<int>(kSamplePakSize));
+  ASSERT_EQ(base::WriteFile(data_path, kSamplePakContentsV4, kSamplePakSizeV4),
+            static_cast<int>(kSamplePakSizeV4));
 
   base::File file(data_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
   ASSERT_TRUE(file.IsValid());
 
   // Load the file through the data pack API.
   DataPack pack(SCALE_FACTOR_100P);
   ASSERT_TRUE(pack.LoadFromFile(std::move(file)));
 
   base::StringPiece data;
   ASSERT_TRUE(pack.HasResource(4));
@@ skipping 18 matching lines @@
   base::ScopedTempDir dir;
   ASSERT_TRUE(dir.CreateUniqueTempDir());
   base::FilePath data_path =
       dir.GetPath().Append(FILE_PATH_LITERAL("sample.pak"));
 
   // Construct a file which has a non page-aligned zero-filled header followed
   // by the actual pak file content.
   const char kPadding[5678] = {0};
   ASSERT_EQ(static_cast<int>(sizeof(kPadding)),
             base::WriteFile(data_path, kPadding, sizeof(kPadding)));
-  ASSERT_TRUE(base::AppendToFile(
-      data_path, kSamplePakContents, kSamplePakSize));
+  ASSERT_TRUE(
+      base::AppendToFile(data_path, kSamplePakContentsV4, kSamplePakSizeV4));
 
   base::File file(data_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
   ASSERT_TRUE(file.IsValid());
 
   // Load the file through the data pack API.
   DataPack pack(SCALE_FACTOR_100P);
-  base::MemoryMappedFile::Region region = {sizeof(kPadding), kSamplePakSize};
+  base::MemoryMappedFile::Region region = {sizeof(kPadding), kSamplePakSizeV4};
   ASSERT_TRUE(pack.LoadFromFileRegion(std::move(file), region));
 
   base::StringPiece data;
   ASSERT_TRUE(pack.HasResource(4));
   ASSERT_TRUE(pack.GetStringPiece(4, &data));
   EXPECT_EQ("this is id 4", data);
   ASSERT_TRUE(pack.HasResource(6));
   ASSERT_TRUE(pack.GetStringPiece(6, &data));
   EXPECT_EQ("this is id 6", data);
 
   // Try reading zero-length data blobs, just in case.
   ASSERT_TRUE(pack.GetStringPiece(1, &data));
   EXPECT_EQ(0U, data.length());
   ASSERT_TRUE(pack.GetStringPiece(10, &data));
   EXPECT_EQ(0U, data.length());
 
   // Try looking up an invalid key.
   ASSERT_FALSE(pack.HasResource(140));
   ASSERT_FALSE(pack.GetStringPiece(140, &data));
 }
 
-TEST(DataPackTest, LoadFromBuffer) {
+TEST(DataPackTest, LoadFromBufferV4) {
   DataPack pack(SCALE_FACTOR_100P);
 
   ASSERT_TRUE(pack.LoadFromBuffer(
-      base::StringPiece(kSamplePakContents, kSamplePakSize)));
+      base::StringPiece(kSamplePakContentsV4, kSamplePakSizeV4)));
 
   base::StringPiece data;
   ASSERT_TRUE(pack.HasResource(4));
   ASSERT_TRUE(pack.GetStringPiece(4, &data));
   EXPECT_EQ("this is id 4", data);
   ASSERT_TRUE(pack.HasResource(6));
   ASSERT_TRUE(pack.GetStringPiece(6, &data));
   EXPECT_EQ("this is id 6", data);
 
   // Try reading zero-length data blobs, just in case.
   ASSERT_TRUE(pack.GetStringPiece(1, &data));
   EXPECT_EQ(0U, data.length());
   ASSERT_TRUE(pack.GetStringPiece(10, &data));
   EXPECT_EQ(0U, data.length());
 
   // Try looking up an invalid key.
   ASSERT_FALSE(pack.HasResource(140));
   ASSERT_FALSE(pack.GetStringPiece(140, &data));
 }
 
+TEST(DataPackTest, LoadFromBufferV5) {
+  DataPack pack(SCALE_FACTOR_100P);
+
+  ASSERT_TRUE(pack.LoadFromBuffer(
+      base::StringPiece(kSamplePakContentsV5, kSamplePakSizeV5)));
+
+  base::StringPiece data;
+  ASSERT_TRUE(pack.HasResource(4));
+  ASSERT_TRUE(pack.GetStringPiece(4, &data));
+  EXPECT_EQ("this is id 4", data);
+  ASSERT_TRUE(pack.HasResource(6));
+  ASSERT_TRUE(pack.GetStringPiece(6, &data));
+  EXPECT_EQ("this is id 6", data);
+
+  // Try reading zero-length data blobs, just in case.
+  ASSERT_TRUE(pack.GetStringPiece(1, &data));
+  EXPECT_EQ(0U, data.length());
+  ASSERT_TRUE(pack.GetStringPiece(10, &data));
+  EXPECT_EQ("this is id 4", data);
+
+  // Try looking up an invalid key.
+  ASSERT_FALSE(pack.HasResource(140));
+  ASSERT_FALSE(pack.GetStringPiece(140, &data));
+}
+
 INSTANTIATE_TEST_CASE_P(WriteBINARY, DataPackTest, ::testing::Values(
     DataPack::BINARY));
 INSTANTIATE_TEST_CASE_P(WriteUTF8, DataPackTest, ::testing::Values(
     DataPack::UTF8));
 INSTANTIATE_TEST_CASE_P(WriteUTF16, DataPackTest, ::testing::Values(
     DataPack::UTF16));
 
 TEST(DataPackTest, LoadFileWithTruncatedHeader) {
   base::FilePath data_path;
   ASSERT_TRUE(PathService::Get(UI_DIR_TEST_DATA, &data_path));
@@ skipping 41 matching lines @@
 }
 
 #if defined(OS_POSIX)
 TEST(DataPackTest, ModifiedWhileUsed) {
   base::ScopedTempDir dir;
   ASSERT_TRUE(dir.CreateUniqueTempDir());
   base::FilePath data_path =
       dir.GetPath().Append(FILE_PATH_LITERAL("sample.pak"));
 
   // Dump contents into the pak file.
-  ASSERT_EQ(base::WriteFile(data_path, kSamplePakContents, kSamplePakSize),
-            static_cast<int>(kSamplePakSize));
+  ASSERT_EQ(base::WriteFile(data_path, kSamplePakContentsV4, kSamplePakSizeV4),
+            static_cast<int>(kSamplePakSizeV4));
 
   base::File file(data_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
   ASSERT_TRUE(file.IsValid());
 
   // Load the file through the data pack API.
   DataPack pack(SCALE_FACTOR_100P);
   ASSERT_TRUE(pack.LoadFromFile(std::move(file)));
 
   base::StringPiece data;
   ASSERT_TRUE(pack.HasResource(10));
   ASSERT_TRUE(pack.GetStringPiece(10, &data));
 
   ASSERT_EQ(base::WriteFile(data_path, kSampleCorruptPakContents,
                             kSampleCorruptPakSize),
             static_cast<int>(kSampleCorruptPakSize));
 
   // Reading asset #10 should now fail as it extends past the end of the file.
   ASSERT_TRUE(pack.HasResource(10));
   ASSERT_FALSE(pack.GetStringPiece(10, &data));
 }
 #endif
 
 }  // namespace ui