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.

[wuchengli, 2015/11/19 03:33:40]

There was only subject in the change description. Explain more about the issue
in the change description.

[kcwu, 2015/11/20 10:04:06]

Done.

 // 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 "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 206 matching lines @@
   // 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<size_t> coded_bpl(num_planes);
   std::vector<size_t> visible_bpl(num_planes);
   std::vector<size_t> visible_plane_rows(num_planes);
+  std::vector<std::vector<uint8>> padding(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_sizes[i]);
   }
 
   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];
       }
+      if (padding_sizes[i]) {

[wuchengli, 2015/11/19 03:33:40]

We can use padding[i].size() and remove |padding_sizes| variable.

[kcwu, 2015/11/20 10:04:06]

Done.

+        CHECK(WriteFile(&dest_file, dest_offset, &padding[i][0],

[wuchengli, 2015/11/19 03:33:40]

s/CHECK/LOG_ASSERT/

[kcwu, 2015/11/20 10:04:06]

Done.

+                        padding_sizes[i]));
+      }
       dest_offset += padding_sizes[i];
     }
   }
   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)
@@ skipping 1209 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)));
 
   return RUN_ALL_TESTS();
 }