Implement media::VideoDecodeAccelerator on Mac

ui/gfx/video_decode_acceleration_support_mac.mm

 // Copyright (c) 2012 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 "ui/gfx/video_decode_acceleration_support_mac.h"
 
 #include <dlfcn.h>
 
 #include "base/bind.h"
 #include "base/file_path.h"
@@ skipping 104 matching lines @@
       loop_(base::MessageLoopProxy::current()) {
 }
 
 VideoDecodeAccelerationSupport::Status VideoDecodeAccelerationSupport::Create(
     int width,
     int height,
     int pixel_format,
     const void* avc_bytes,
     size_t avc_size) {
   if (!InitializeVdaApis())
-    return VDA_LOAD_FRAMEWORK_ERROR;
+    return LOAD_FRAMEWORK_ERROR;
 
   NSData* avc_data = [NSData dataWithBytes:avc_bytes length:avc_size];
   NSDictionary* config = [NSDictionary dictionaryWithObjectsAndKeys:
       [NSNumber numberWithInt:width],
       CFToNSCast(kVDADecoderConfiguration_Width),
       [NSNumber numberWithInt:height],
       CFToNSCast(kVDADecoderConfiguration_Height),
       [NSNumber numberWithInt:'avc1'],
       CFToNSCast(kVDADecoderConfiguration_SourceFormat),
       avc_data,
       CFToNSCast(kVDADecoderConfiguration_avcCData),
       nil];
 
   NSDictionary* format_info = [NSDictionary dictionaryWithObjectsAndKeys:
       [NSNumber numberWithInt:pixel_format],
       CFToNSCast(kCVPixelBufferPixelFormatTypeKey),
       // Must set to an empty dictionary as per documentation.
       [NSDictionary dictionary],
       CFToNSCast(kCVPixelBufferIOSurfacePropertiesKey),
       nil];
 
   OSStatus status = g_VDADecoderCreate(NSToCFCast(config),
       NSToCFCast(format_info),
       reinterpret_cast<VDADecoderOutputCallback*>(OnFrameReadyCallback), this,
       &decoder_);
   switch (status) {
     case kVDADecoderNoErr:
-      return VDA_SUCCESS;
+      return SUCCESS;
     case kVDADecoderHardwareNotSupportedErr:
-      return VDA_HARDWARE_NOT_SUPPORTED_ERROR;
+      return HARDWARE_NOT_SUPPORTED_ERROR;
     default:
-      return VDA_OTHER_ERROR;
+      return OTHER_ERROR;
   }
 }
 
 VideoDecodeAccelerationSupport::Status VideoDecodeAccelerationSupport::Decode(
     const void* bytes,
     size_t size,
     const FrameReadyCallback& cb) {
   DCHECK(decoder_);
   ++frame_id_count_;
   frame_ready_callbacks_[frame_id_count_] = cb;
 
   NSData* data = [NSData dataWithBytes:bytes length:size];
   NSDictionary* frame_info = [NSDictionary
       dictionaryWithObject:[NSNumber numberWithInt:frame_id_count_]
                     forKey:kFrameIdKey];
 
   OSStatus status = g_VDADecoderDecode(decoder_, 0, NSToCFCast(data),
       NSToCFCast(frame_info));
   if (status != kVDADecoderNoErr) {
     frame_ready_callbacks_.erase(frame_id_count_);
-    return VDA_OTHER_ERROR;
+    return OTHER_ERROR;
   }
-  return VDA_SUCCESS;
+  return SUCCESS;
 }
 
 VideoDecodeAccelerationSupport::Status VideoDecodeAccelerationSupport::Flush(
     bool emit_frames) {
   DCHECK(decoder_);
   OSStatus status = g_VDADecoderFlush(
       decoder_, emit_frames ? kVDADecoderFlush_EmitFrames : 0);
   if (!emit_frames)
     frame_ready_callbacks_.clear();
-  return status == kVDADecoderNoErr ? VDA_SUCCESS : VDA_OTHER_ERROR;
+  return status == kVDADecoderNoErr ? SUCCESS : OTHER_ERROR;
 }
 
 VideoDecodeAccelerationSupport::Status
 VideoDecodeAccelerationSupport::Destroy() {
   DCHECK(decoder_);
   OSStatus status = g_VDADecoderDestroy(decoder_);
   decoder_ = NULL;
-  return status == kVDADecoderNoErr ? VDA_SUCCESS : VDA_OTHER_ERROR;
+  return status == kVDADecoderNoErr ? SUCCESS : OTHER_ERROR;
 }
 
 VideoDecodeAccelerationSupport::~VideoDecodeAccelerationSupport() {
   DCHECK(!decoder_);
 }
 
 // static
 void VideoDecodeAccelerationSupport::OnFrameReadyCallback(
     void* callback_data,
     CFDictionaryRef frame_info,
@@ skipping 21 matching lines @@
                                                   OSStatus status,
                                                   int frame_id) {
   frame_ready_callbacks_[frame_id].Run(image_buffer, status);
   // Match the retain in OnFrameReadyCallback.
   if (image_buffer)
     CFRelease(image_buffer);
   frame_ready_callbacks_.erase(frame_id);
 }
 
 }  // namespace