vea_unittest: Fix driver doesn't suppport hole in memory mapped file

content/common/gpu/media/video_encode_accelerator_unittest.cc

 // Copyright 2013 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 <inttypes.h>
 
 #include <algorithm>
 #include <queue>
 #include <string>
 
@@ skipping 221 matching lines @@
       test_stream->mapped_aligned_in_file.IsValid())
     return;
 
   // All encoders in multiple encoder test reuse the same test_stream, make
   // sure they requested the same coded_size
   ASSERT_TRUE(!test_stream->mapped_aligned_in_file.IsValid() ||
               coded_size == test_stream->coded_size);
   test_stream->coded_size = coded_size;
 
   size_t num_planes = media::VideoFrame::NumPlanes(kInputFormat);
-  std::vector<size_t> padding_sizes(num_planes);
+  std::vector<std::vector<uint8>> padding(num_planes);
   std::vector<size_t> coded_bpl(num_planes);
   std::vector<size_t> visible_bpl(num_planes);
   std::vector<size_t> visible_plane_rows(num_planes);
 
   // Calculate padding in bytes to be added after each plane required to keep
   // starting addresses of all planes at a 64 byte boudnary. This padding will
   // be added after each plane when copying to the temporary file.
   // At the same time we also need to take into account coded_size requested by
   // the VEA; each row of visible_bpl bytes in the original file needs to be
   // copied into a row of coded_bpl bytes in the aligned file.
   for (size_t i = 0; i < num_planes; i++) {
     const size_t size =
         media::VideoFrame::PlaneSize(kInputFormat, i, coded_size).GetArea();
     test_stream->aligned_plane_size.push_back(Align64Bytes(size));
     test_stream->aligned_buffer_size += test_stream->aligned_plane_size.back();
 
     coded_bpl[i] =
         media::VideoFrame::RowBytes(i, kInputFormat, coded_size.width());
     visible_bpl[i] = media::VideoFrame::RowBytes(
         i, kInputFormat, test_stream->visible_size.width());
     visible_plane_rows[i] = media::VideoFrame::Rows(
         i, kInputFormat, test_stream->visible_size.height());
     const size_t padding_rows =
         media::VideoFrame::Rows(i, kInputFormat, coded_size.height()) -
         visible_plane_rows[i];
-    padding_sizes[i] = padding_rows * coded_bpl[i] + Align64Bytes(size) - size;
+    padding[i].resize(padding_rows * coded_bpl[i] + Align64Bytes(size) - size);
   }
 
   base::MemoryMappedFile src_file;
   LOG_ASSERT(src_file.Initialize(base::FilePath(test_stream->in_filename)));
   LOG_ASSERT(base::CreateTemporaryFile(&test_stream->aligned_in_file));
 
   size_t visible_buffer_size = media::VideoFrame::AllocationSize(
       kInputFormat, test_stream->visible_size);
   LOG_ASSERT(src_file.length() % visible_buffer_size == 0U)
       << "Stream byte size is not a product of calculated frame byte size";
@@ skipping 13 matching lines @@
   for (size_t frame = 0; frame < test_stream->num_frames; frame++) {
     for (size_t i = 0; i < num_planes; i++) {
       // Assert that each plane of frame starts at 64 byte boundary.
       ASSERT_EQ(dest_offset & 63, 0)
           << "Planes of frame should be mapped at a 64 byte boundary";
       for (size_t j = 0; j < visible_plane_rows[i]; j++) {
         LOG_ASSERT(WriteFile(&dest_file, dest_offset, src, visible_bpl[i]));
         src += visible_bpl[i];
         dest_offset += coded_bpl[i];
       }
-      dest_offset += padding_sizes[i];
+      if (!padding[i].empty()) {
+        LOG_ASSERT(WriteFile(&dest_file, dest_offset, &padding[i][0],
+                             padding[i].size()));
+        dest_offset += padding[i].size();
+      }
     }
   }
   LOG_ASSERT(test_stream->mapped_aligned_in_file.Initialize(dest_file.Pass()));
   // Assert that memory mapped of file starts at 64 byte boundary. So each
   // plane of frames also start at 64 byte boundary.
 
   ASSERT_EQ(
       reinterpret_cast<off_t>(test_stream->mapped_aligned_in_file.data()) & 63,
       0)
       << "File should be mapped at a 64 byte boundary";
@@ skipping 1456 matching lines @@
 
   content::g_env =
       reinterpret_cast<content::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new content::VideoEncodeAcceleratorTestEnvironment(
                   test_stream_data.Pass(), log_path, run_at_fps,
                   needs_encode_latency, verify_all_output)));
 
   return RUN_ALL_TESTS();
 }