Use mojo typemap to simplify the code using DmabufPlane

chrome/gpu/arc_gpu_video_decode_accelerator.cc

 // Copyright 2016 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 "chrome/gpu/arc_gpu_video_decode_accelerator.h"
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_math.h"
@@ skipping 180 matching lines @@
     return;
   }
   InputBufferInfo* input_info = &input_buffer_info_[index];
   input_info->handle = std::move(ashmem_fd);
   input_info->offset = offset;
   input_info->length = length;
 }
 
 bool ArcGpuVideoDecodeAccelerator::VerifyDmabuf(
     const base::ScopedFD& dmabuf_fd,
-    const std::vector<DmabufPlane>& dmabuf_planes) const {
+    const std::vector<::arc::ArcVideoAcceleratorDmabufPlane>& dmabuf_planes)
+    const {
   size_t num_planes = media::VideoFrame::NumPlanes(output_pixel_format_);
   if (dmabuf_planes.size() != num_planes) {
     DLOG(ERROR) << "Invalid number of dmabuf planes passed: "
                 << dmabuf_planes.size() << ", expected: " << num_planes;
     return false;
   }
 
   off_t size = lseek(dmabuf_fd.get(), 0, SEEK_END);
   lseek(dmabuf_fd.get(), 0, SEEK_SET);
   if (size < 0) {
     DPLOG(ERROR) << "fail to find the size of dmabuf";
     return false;
   }
 
   size_t i = 0;
   for (const auto& plane : dmabuf_planes) {
     DVLOG(4) << "Plane " << i << ", offset: " << plane.offset
              << ", stride: " << plane.stride;
 
     size_t rows =
         media::VideoFrame::Rows(i, output_pixel_format_, coded_size_.height());
     base::CheckedNumeric<off_t> current_size(plane.offset);
-    current_size += plane.stride * rows;
+    current_size += base::CheckMul(plane.stride, rows);
 
     if (!current_size.IsValid() || current_size.ValueOrDie() > size) {
       DLOG(ERROR) << "Invalid strides/offsets";
       return false;
     }
 
     ++i;
   }
 
   return true;
 }
 
 void ArcGpuVideoDecodeAccelerator::BindDmabuf(
     PortType port,
     uint32_t index,
     base::ScopedFD dmabuf_fd,
-    const std::vector<DmabufPlane>& dmabuf_planes) {
+    const std::vector<::arc::ArcVideoAcceleratorDmabufPlane>& dmabuf_planes) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!vda_) {
     DLOG(ERROR) << "VDA not initialized";
     return;
   }
 
   if (port != PORT_OUTPUT) {
     DLOG(ERROR) << "Dmabuf is only supported for input";
     arc_client_->OnError(INVALID_ARGUMENT);
@@ skipping 269 matching lines @@
       }
       return true;
     default:
       DLOG(ERROR) << "Invalid port: " << port;
       return false;
   }
 }
 
 }  // namespace arc
 }  // namespace chromeos