Sample code: IPC Transport object for GPU

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"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_messages.h"
+#include "content/common/gpu/jpeg_decode_params.h"
 #include "ipc/ipc_message_macros.h"
 #include "ipc/message_filter.h"
 #include "media/filters/jpeg_parser.h"
 #include "ui/gfx/geometry/size.h"
 
 #if defined(OS_CHROMEOS)
 #if defined(ARCH_CPU_X86_FAMILY)
 #include "content/common/gpu/media/vaapi_jpeg_decode_accelerator.h"
 #endif
 #if defined(USE_V4L2_CODEC)
 #include "content/common/gpu/media/v4l2_device.h"
 #include "content/common/gpu/media/v4l2_jpeg_decode_accelerator.h"
 #endif
 #endif
 
 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) {
+bool VerifyDecodeParams(const content::JpegDecodeParams& 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) {
@@ skipping 138 matching lines @@
   }
 
   void NotifyDecodeStatusOnIOThread(int32_t route_id,
                                     int32_t buffer_id,
                                     media::JpegDecodeAccelerator::Error error) {
     DCHECK(io_task_runner_->BelongsToCurrentThread());
     SendOnIOThread(new AcceleratedJpegDecoderHostMsg_DecodeAck(
         route_id, buffer_id, error));
   }
 
-  void OnDecodeOnIOThread(
-      const int32_t* route_id,
-      const AcceleratedJpegDecoderMsg_Decode_Params& params) {
+  void OnDecodeOnIOThread(const int32_t* route_id,
+                          const JpegDecodeParams& 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,
           media::JpegDecodeAccelerator::INVALID_ARGUMENT);
       if (base::SharedMemory::IsHandleValid(params.input_buffer_handle))
         base::SharedMemory::CloseHandle(params.input_buffer_handle);
@@ skipping 217 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