Make VEA test support videos with different coded size and visible size

base/files/memory_mapped_file_unittest.cc

 // Copyright 2014 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 "base/files/memory_mapped_file.h"
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
@@ skipping 51 matching lines @@
   ASSERT_EQ(kFileSize, map.length());
   ASSERT_TRUE(map.data() != NULL);
   EXPECT_TRUE(map.IsValid());
   ASSERT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
 }
 
 TEST_F(MemoryMappedFileTest, MapWholeFileByFD) {
   const size_t kFileSize = 68 * 1024;
   CreateTemporaryTestFile(kFileSize);
   MemoryMappedFile map;
-  map.Initialize(File(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ));
+  map.Initialize(File(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ),
+                 false);
   ASSERT_EQ(kFileSize, map.length());
   ASSERT_TRUE(map.data() != NULL);
   EXPECT_TRUE(map.IsValid());
   ASSERT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
 }
 
 TEST_F(MemoryMappedFileTest, MapSmallFile) {
   const size_t kFileSize = 127;
   CreateTemporaryTestFile(kFileSize);
   MemoryMappedFile map;
   map.Initialize(temp_file_path());
   ASSERT_EQ(kFileSize, map.length());
   ASSERT_TRUE(map.data() != NULL);
   EXPECT_TRUE(map.IsValid());
   ASSERT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
 }
 
 TEST_F(MemoryMappedFileTest, MapWholeFileUsingRegion) {
   const size_t kFileSize = 157 * 1024;
   CreateTemporaryTestFile(kFileSize);
   MemoryMappedFile map;
 
   File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
-  map.Initialize(file.Pass(), MemoryMappedFile::Region::kWholeFile);
+  map.Initialize(file.Pass(), MemoryMappedFile::Region::kWholeFile, false);
   ASSERT_EQ(kFileSize, map.length());
   ASSERT_TRUE(map.data() != NULL);
   EXPECT_TRUE(map.IsValid());
   ASSERT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
 }
 
 TEST_F(MemoryMappedFileTest, MapPartialRegionAtBeginning) {
   const size_t kFileSize = 157 * 1024;
   const size_t kPartialSize = 4 * 1024 + 32;
   CreateTemporaryTestFile(kFileSize);
   MemoryMappedFile map;
 
   File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
-  map.Initialize(file.Pass(), MemoryMappedFile::Region(0, kPartialSize));
+  map.Initialize(file.Pass(), MemoryMappedFile::Region(0, kPartialSize), false);
   ASSERT_EQ(kPartialSize, map.length());
   ASSERT_TRUE(map.data() != NULL);
   EXPECT_TRUE(map.IsValid());
   ASSERT_TRUE(CheckBufferContents(map.data(), kPartialSize, 0));
 }
 
 TEST_F(MemoryMappedFileTest, MapPartialRegionAtEnd) {
   const size_t kFileSize = 157 * 1024;
   const size_t kPartialSize = 5 * 1024 - 32;
   const size_t kOffset = kFileSize - kPartialSize;
   CreateTemporaryTestFile(kFileSize);
   MemoryMappedFile map;
 
   File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
-  map.Initialize(file.Pass(), MemoryMappedFile::Region(kOffset, kPartialSize));
+  map.Initialize(file.Pass(), MemoryMappedFile::Region(kOffset, kPartialSize),
+                 false);
   ASSERT_EQ(kPartialSize, map.length());
   ASSERT_TRUE(map.data() != NULL);
   EXPECT_TRUE(map.IsValid());
   ASSERT_TRUE(CheckBufferContents(map.data(), kPartialSize, kOffset));
 }
 
 TEST_F(MemoryMappedFileTest, MapSmallPartialRegionInTheMiddle) {
   const size_t kFileSize = 157 * 1024;
   const size_t kOffset = 1024 * 5 + 32;
   const size_t kPartialSize = 8;
 
   CreateTemporaryTestFile(kFileSize);
   MemoryMappedFile map;
 
   File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
-  map.Initialize(file.Pass(), MemoryMappedFile::Region(kOffset, kPartialSize));
+  map.Initialize(file.Pass(), MemoryMappedFile::Region(kOffset, kPartialSize),
+                 false);
   ASSERT_EQ(kPartialSize, map.length());
   ASSERT_TRUE(map.data() != NULL);
   EXPECT_TRUE(map.IsValid());
   ASSERT_TRUE(CheckBufferContents(map.data(), kPartialSize, kOffset));
 }
 
 TEST_F(MemoryMappedFileTest, MapLargePartialRegionInTheMiddle) {
   const size_t kFileSize = 157 * 1024;
   const size_t kOffset = 1024 * 5 + 32;
   const size_t kPartialSize = 16 * 1024 - 32;
 
   CreateTemporaryTestFile(kFileSize);
   MemoryMappedFile map;
 
   File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
-  map.Initialize(file.Pass(), MemoryMappedFile::Region(kOffset, kPartialSize));
+  map.Initialize(file.Pass(), MemoryMappedFile::Region(kOffset, kPartialSize),
+                 false);
   ASSERT_EQ(kPartialSize, map.length());
   ASSERT_TRUE(map.data() != NULL);
   EXPECT_TRUE(map.IsValid());
   ASSERT_TRUE(CheckBufferContents(map.data(), kPartialSize, kOffset));
 }
 
+TEST_F(MemoryMappedFileTest, MapWholeFileWithWrite) {
+  const size_t kFileSize = 68 * 1024;
+  CreateTemporaryTestFile(kFileSize);
+  MemoryMappedFile* map = new MemoryMappedFile();
+  map->Initialize(File(temp_file_path(), File::FLAG_OPEN |
+                                         File::FLAG_READ |
+                                         File::FLAG_WRITE), true);
+  ASSERT_EQ(kFileSize, map->length());
+  ASSERT_TRUE(map->data() != NULL);
+  EXPECT_TRUE(map->IsValid());
+  ASSERT_TRUE(CheckBufferContents(map->data(), kFileSize, 0));
+
+  size_t size = 20, offset = 100;
+  scoped_ptr<uint8[]> test_data(CreateTestBuffer(size, offset));
+  memcpy(map->data(), test_data.get(), size);
+  delete map;
+
+  MemoryMappedFile read_map;
+  read_map.Initialize(File(temp_file_path(), File::FLAG_OPEN |
+                                             File::FLAG_READ), false);
+  ASSERT_EQ(kFileSize, read_map.length());
+  ASSERT_TRUE(read_map.data() != NULL);
+  EXPECT_TRUE(read_map.IsValid());
+  ASSERT_TRUE(CheckBufferContents(read_map.data(), size, offset));
+}
+
+TEST_F(MemoryMappedFileTest, MapLargePartialRegionInTheMiddleWithWrite) {
+  const size_t kFileSize = 157 * 1024;
+  const size_t kOffset = 1024 * 5 + 32;
+  const size_t kPartialSize = 16 * 1024 - 32;
+
+  CreateTemporaryTestFile(kFileSize);
+  MemoryMappedFile* map = new MemoryMappedFile();
+
+  File file(temp_file_path(), File::FLAG_OPEN |
+                              File::FLAG_READ |
+                              File::FLAG_WRITE);
+  map->Initialize(
+      file.Pass(), MemoryMappedFile::Region(kOffset, kPartialSize), true);
+  ASSERT_EQ(kPartialSize, map->length());
+  ASSERT_TRUE(map->data() != NULL);
+  EXPECT_TRUE(map->IsValid());
+  ASSERT_TRUE(CheckBufferContents(map->data(), kPartialSize, kOffset));
+
+  size_t size = 20, offset = 100;
+  scoped_ptr<uint8[]> test_data(CreateTestBuffer(size, offset));
+  memcpy(map->data(), test_data.get(), size);
+  delete map;
+
+  MemoryMappedFile read_map;
+  read_map.Initialize(
+      File(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ),
+      MemoryMappedFile::Region(kOffset, kPartialSize),
+      false);
+  ASSERT_EQ(kPartialSize, read_map.length());
+  ASSERT_TRUE(read_map.data() != NULL);
+  EXPECT_TRUE(read_map.IsValid());
+  ASSERT_TRUE(CheckBufferContents(read_map.data(), size, offset));
+}
+
 }  // namespace
 
 }  // namespace base