Use ParamTraits for media::BitstreamBuffer.

content/common/gpu/media/gpu_jpeg_decode_accelerator.cc

 // Copyright 2015 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 "content/common/gpu/media/gpu_jpeg_decode_accelerator.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 23 matching lines @@
 
 namespace {
 
 void DecodeFinished(scoped_ptr<base::SharedMemory> shm) {
   // Do nothing. Because VideoFrame is backed by |shm|, the purpose of this
   // function is to just keep reference of |shm| to make sure it lives util
   // decode finishes.
 }
 
 bool VerifyDecodeParams(const AcceleratedJpegDecoderMsg_Decode_Params& params) {
-  if (params.input_buffer_id < 0) {
-    LOG(ERROR) << "BitstreamBuffer id " << params.input_buffer_id
-               << " out of range";
-    return false;
-  }
-
   const int kJpegMaxDimension = UINT16_MAX;
   if (params.coded_size.IsEmpty() ||
       params.coded_size.width() > kJpegMaxDimension ||
       params.coded_size.height() > kJpegMaxDimension) {
     LOG(ERROR) << "invalid coded_size " << params.coded_size.ToString();
     return false;
   }
 
-  if (!base::SharedMemory::IsHandleValid(params.input_buffer_handle)) {
-    LOG(ERROR) << "invalid input_buffer_handle";
-    return false;
-  }
-
   if (!base::SharedMemory::IsHandleValid(params.output_video_frame_handle)) {
     LOG(ERROR) << "invalid output_video_frame_handle";
     return false;
   }
 
   if (params.output_buffer_size <
       media::VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420,
                                         params.coded_size)) {
     LOG(ERROR) << "output_buffer_size is too small: "
                << params.output_buffer_size;
@@ skipping 128 matching lines @@
 
   void OnDecodeOnIOThread(
       const int32_t* route_id,
       const AcceleratedJpegDecoderMsg_Decode_Params& params) {
     DCHECK(io_task_runner_->BelongsToCurrentThread());
     DCHECK(route_id);
     TRACE_EVENT0("jpeg", "GpuJpegDecodeAccelerator::MessageFilter::OnDecode");
 
     if (!VerifyDecodeParams(params)) {
       NotifyDecodeStatusOnIOThread(
-          *route_id, params.input_buffer_id,
+          *route_id, params.input_buffer.id(),
           media::JpegDecodeAccelerator::INVALID_ARGUMENT);
-      if (base::SharedMemory::IsHandleValid(params.input_buffer_handle))
-        base::SharedMemory::CloseHandle(params.input_buffer_handle);
       if (base::SharedMemory::IsHandleValid(params.output_video_frame_handle))
         base::SharedMemory::CloseHandle(params.output_video_frame_handle);
       return;
     }
 
     // For handles in |params|, from now on, |params.output_video_frame_handle|
-    // is taken cared by scoper. |params.input_buffer_handle| need to be closed
-    // manually for early exits.
+    // is taken cared by scoper. |params.input_buffer.handle()| need to be
+    // closed manually for early exits.
     scoped_ptr<base::SharedMemory> output_shm(
         new base::SharedMemory(params.output_video_frame_handle, false));
     if (!output_shm->Map(params.output_buffer_size)) {
       LOG(ERROR) << "Could not map output shared memory for input buffer id "
-                 << params.input_buffer_id;
+                 << params.input_buffer.id();
       NotifyDecodeStatusOnIOThread(
-          *route_id, params.input_buffer_id,
+          *route_id, params.input_buffer.id(),
           media::JpegDecodeAccelerator::PLATFORM_FAILURE);
-      base::SharedMemory::CloseHandle(params.input_buffer_handle);
+      base::SharedMemory::CloseHandle(params.input_buffer.handle());
       return;
     }
 
-    media::BitstreamBuffer input_buffer(params.input_buffer_id,
-                                        params.input_buffer_handle,
-                                        params.input_buffer_size);
-
     uint8_t* shm_memory = static_cast<uint8_t*>(output_shm->memory());
     scoped_refptr<media::VideoFrame> frame =
         media::VideoFrame::WrapExternalSharedMemory(
             media::PIXEL_FORMAT_I420,          // format
             params.coded_size,                 // coded_size
             gfx::Rect(params.coded_size),      // visible_rect
             params.coded_size,                 // natural_size
             shm_memory,                        // data
             params.output_buffer_size,         // data_size
             params.output_video_frame_handle,  // handle
             0,                                 // data_offset
             base::TimeDelta());                // timestamp
     if (!frame.get()) {
       LOG(ERROR) << "Could not create VideoFrame for input buffer id "
-                 << params.input_buffer_id;
+                 << params.input_buffer.id();
       NotifyDecodeStatusOnIOThread(
-          *route_id, params.input_buffer_id,
+          *route_id, params.input_buffer.id(),
           media::JpegDecodeAccelerator::PLATFORM_FAILURE);
-      base::SharedMemory::CloseHandle(params.input_buffer_handle);
+      base::SharedMemory::CloseHandle(params.input_buffer.handle());
       return;
     }
     frame->AddDestructionObserver(
         base::Bind(DecodeFinished, base::Passed(&output_shm)));
 
     DCHECK_GT(client_map_.count(*route_id), 0u);
     Client* client = client_map_[*route_id];
-    client->Decode(input_buffer, frame);
+    client->Decode(params.input_buffer, frame);
   }
 
  protected:
   ~MessageFilter() override {
     if (client_map_.empty())
       return;
 
     if (child_task_runner_->BelongsToCurrentThread()) {
       STLDeleteValues(&client_map_);
     } else {
@@ skipping 156 matching lines @@
   for (const auto& create_jda_function : create_jda_fps) {
     scoped_ptr<media::JpegDecodeAccelerator> accelerator =
         (*create_jda_function)(base::ThreadTaskRunnerHandle::Get());
     if (accelerator && accelerator->IsSupported())
       return true;
   }
   return false;
 }
 
 }  // namespace content