Replace the use of an int32* with a proper struct for decoder configuration.

webkit/plugins/ppapi/ppb_video_decoder_impl.cc

 // Copyright (c) 2011 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 "webkit/plugins/ppapi/ppb_video_decoder_impl.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 12 matching lines @@
 #include "webkit/plugins/ppapi/ppb_buffer_impl.h"
 #include "webkit/plugins/ppapi/ppb_context_3d_impl.h"
 #include "webkit/plugins/ppapi/ppb_graphics_3d_impl.h"
 #include "webkit/plugins/ppapi/resource_tracker.h"
 
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Buffer_API;
 using ppapi::thunk::PPB_Context3D_API;
 using ppapi::thunk::PPB_Graphics3D_API;
 using ppapi::thunk::PPB_VideoDecoder_API;
+typedef media::VideoDecodeAccelerator::Config Config;
 
 namespace webkit {
 namespace ppapi {
 
 PPB_VideoDecoder_Impl::PPB_VideoDecoder_Impl(PP_Instance instance)
     : Resource(instance),
       ppp_videodecoder_(NULL) {
   PluginModule* plugin_module = ResourceHelper::GetPluginModule(this);
   if (plugin_module) {
     ppp_videodecoder_ = static_cast<const PPP_VideoDecoder_Dev*>(
         plugin_module->GetPluginInterface(PPP_VIDEODECODER_DEV_INTERFACE));
   }
 }
 
 PPB_VideoDecoder_Impl::~PPB_VideoDecoder_Impl() {
 }
 
 PPB_VideoDecoder_API* PPB_VideoDecoder_Impl::AsPPB_VideoDecoder_API() {
   return this;
 }
 
+// Convert PP_VideoDecoderConfig_Dev to media::VideoDecodeAccelerator::Config.
+static media::VideoDecodeAccelerator::Config PPToMediaConfig(
+    const PP_VideoDecoderConfig_Dev& pp_config) {
+  Config media_config;
+  // TODO(fischman,vrk): this assumes the enums in the two Config objects match
+  // up, as do their fields.  Add a COMPILE_ASSERT of these facts somewhere.
+  media_config.format = static_cast<Config::Format>(pp_config.format);
+  media_config.h264_profile =
+      static_cast<Config::H264Profile>(pp_config.h264_profile);
+  return media_config;
+}
+
 // static
-PP_Resource PPB_VideoDecoder_Impl::Create(PP_Instance instance,
-                                          PP_Resource graphics_context,
-                                          const PP_VideoConfigElement* config) {
+PP_Resource PPB_VideoDecoder_Impl::Create(
+    PP_Instance instance,
+    PP_Resource graphics_context,
+    const PP_VideoDecoderConfig_Dev& config) {
   PluginDelegate::PlatformContext3D* platform_context = NULL;
   gpu::gles2::GLES2Implementation* gles2_impl = NULL;
   EnterResourceNoLock<PPB_Context3D_API> enter_context(graphics_context, false);
   if (enter_context.succeeded()) {
     PPB_Context3D_Impl* context3d_impl =
         static_cast<PPB_Context3D_Impl*>(enter_context.object());
     platform_context = context3d_impl->platform_context();
     gles2_impl = context3d_impl->gles2_impl();
   } else {
     EnterResourceNoLock<PPB_Graphics3D_API> enter_context(graphics_context,
@@ skipping 10 matching lines @@
       new PPB_VideoDecoder_Impl(instance));
   if (decoder->Init(graphics_context, platform_context, gles2_impl, config))
     return decoder->GetReference();
   return 0;
 }
 
 bool PPB_VideoDecoder_Impl::Init(
     PP_Resource graphics_context,
     PluginDelegate::PlatformContext3D* context,
     gpu::gles2::GLES2Implementation* gles2_impl,
-    const PP_VideoConfigElement* config) {
+    const PP_VideoDecoderConfig_Dev& config) {
   InitCommon(graphics_context, gles2_impl);
 
   int command_buffer_route_id = context->GetCommandBufferRouteId();
   if (command_buffer_route_id == 0)
     return false;
 
-  std::vector<int32> copied;
-  if (!CopyConfigsToVector(config, &copied))
-    return false;
-
   PluginDelegate* plugin_delegate = ResourceHelper::GetPluginDelegate(this);
   if (!plugin_delegate)
     return false;
 
   platform_video_decoder_ = plugin_delegate->CreateVideoDecoder(
       this, command_buffer_route_id);
   if (!platform_video_decoder_)
     return false;
 
   FlushCommandBuffer();
-  return platform_video_decoder_->Initialize(copied);
+  return platform_video_decoder_->Initialize(PPToMediaConfig(config));
 }
 
 int32_t PPB_VideoDecoder_Impl::Decode(
     const PP_VideoBitstreamBuffer_Dev* bitstream_buffer,
     PP_CompletionCallback callback) {
   if (!platform_video_decoder_)
     return PP_ERROR_BADRESOURCE;
 
   EnterResourceNoLock<PPB_Buffer_API> enter(bitstream_buffer->data, true);
   if (enter.failed())
@@ skipping 133 matching lines @@
 void PPB_VideoDecoder_Impl::NotifyFlushDone() {
   RunFlushCallback(PP_OK);
 }
 
 void PPB_VideoDecoder_Impl::NotifyInitializeDone() {
   NOTREACHED() << "PlatformVideoDecoder::Initialize() is synchronous!";
 }
 
 }  // namespace ppapi
 }  // namespace webkit