mac: Remove more media/base/mac glue unneeded now that we target 10.9

media/capture/video/mac/video_capture_device_avfoundation_mac.mm

 // Copyright 2013 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.
 
 #import "media/capture/video/mac/video_capture_device_avfoundation_mac.h"
 
+#import <AVFoundation/AVFoundation.h>
 #import <CoreMedia/CoreMedia.h>
 #import <CoreVideo/CoreVideo.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/mac_util.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 78 matching lines @@
     }
   }
 }
 
 // This function translates Mac Core Video pixel formats to Chromium pixel
 // formats.
 media::VideoPixelFormat FourCCToChromiumPixelFormat(FourCharCode code) {
   switch (code) {
     case kCVPixelFormatType_422YpCbCr8:
       return media::PIXEL_FORMAT_UYVY;
-    case CoreMediaGlue::kCMPixelFormat_422YpCbCr8_yuvs:
+    case kCMPixelFormat_422YpCbCr8_yuvs:
       return media::PIXEL_FORMAT_YUY2;
-    case CoreMediaGlue::kCMVideoCodecType_JPEG_OpenDML:
+    case kCMVideoCodecType_JPEG_OpenDML:
       return media::PIXEL_FORMAT_MJPEG;
     default:
       return media::PIXEL_FORMAT_UNKNOWN;
   }
 }
 
 // Extracts |base_address| and |length| out of a SampleBuffer.
-void ExtractBaseAddressAndLength(
-    char** base_address,
-    size_t* length,
-    CoreMediaGlue::CMSampleBufferRef sample_buffer) {
-  CoreMediaGlue::CMBlockBufferRef block_buffer =
-      CoreMediaGlue::CMSampleBufferGetDataBuffer(sample_buffer);
+void ExtractBaseAddressAndLength(char** base_address,
+                                 size_t* length,
+                                 CMSampleBufferRef sample_buffer) {
+  CMBlockBufferRef block_buffer = CMSampleBufferGetDataBuffer(sample_buffer);
   DCHECK(block_buffer);
 
   size_t length_at_offset;
-  const OSStatus status = CoreMediaGlue::CMBlockBufferGetDataPointer(
+  const OSStatus status = CMBlockBufferGetDataPointer(
       block_buffer, 0, &length_at_offset, length, base_address);
   DCHECK_EQ(noErr, status);
   // Expect the (M)JPEG data to be available as a contiguous reference, i.e.
   // not covered by multiple memory blocks.
   DCHECK_EQ(length_at_offset, *length);
 }
 
 }  // anonymous namespace
 
 @implementation VideoCaptureDeviceAVFoundation
 
 #pragma mark Class methods
 
 + (void)getDeviceNames:(NSMutableDictionary*)deviceNames {
   // At this stage we already know that AVFoundation is supported and the whole
   // library is loaded and initialised, by the device monitoring.
-  NSArray* devices = [AVCaptureDeviceGlue devices];
+  NSArray* devices = [AVCaptureDevice devices];
   int number_of_suspended_devices = 0;
-  for (CrAVCaptureDevice* device in devices) {
-    if ([device hasMediaType:AVFoundationGlue::AVMediaTypeVideo()] ||
-        [device hasMediaType:AVFoundationGlue::AVMediaTypeMuxed()]) {
+  for (AVCaptureDevice* device in devices) {
+    if ([device hasMediaType:AVMediaTypeVideo] ||
+        [device hasMediaType:AVMediaTypeMuxed]) {
       if ([device isSuspended]) {
         ++number_of_suspended_devices;
         continue;
       }
       DeviceNameAndTransportType* nameAndTransportType =
           [[[DeviceNameAndTransportType alloc]
                initWithName:[device localizedName]
               transportType:[device transportType]] autorelease];
       [deviceNames setObject:nameAndTransportType forKey:[device uniqueID]];
     }
   }
   MaybeWriteUma([deviceNames count], number_of_suspended_devices);
 }
 
 + (NSDictionary*)deviceNames {
   NSMutableDictionary* deviceNames =
       [[[NSMutableDictionary alloc] init] autorelease];
   // The device name retrieval is not going to happen in the main thread, and
   // this might cause instabilities (it did in QTKit), so keep an eye here.
   [self getDeviceNames:deviceNames];
   return deviceNames;
 }
 
 + (void)getDevice:(const media::VideoCaptureDeviceDescriptor&)descriptor
     supportedFormats:(media::VideoCaptureFormats*)formats {
-  NSArray* devices = [AVCaptureDeviceGlue devices];
-  CrAVCaptureDevice* device = nil;
+  NSArray* devices = [AVCaptureDevice devices];
+  AVCaptureDevice* device = nil;
   for (device in devices) {
     if ([[device uniqueID] UTF8String] == descriptor.device_id)
       break;
   }
   if (device == nil)
     return;
-  for (CrAVCaptureDeviceFormat* format in device.formats) {
+  for (AVCaptureDeviceFormat* format in device.formats) {
     // MediaSubType is a CMPixelFormatType but can be used as CVPixelFormatType
     // as well according to CMFormatDescription.h
     const media::VideoPixelFormat pixelFormat = FourCCToChromiumPixelFormat(
-        CoreMediaGlue::CMFormatDescriptionGetMediaSubType(
-            [format formatDescription]));
+        CMFormatDescriptionGetMediaSubType([format formatDescription]));
 
-    CoreMediaGlue::CMVideoDimensions dimensions =
-        CoreMediaGlue::CMVideoFormatDescriptionGetDimensions(
-            [format formatDescription]);
+    CMVideoDimensions dimensions =
+        CMVideoFormatDescriptionGetDimensions([format formatDescription]);
 
-    for (CrAVFrameRateRange* frameRate in
+    for (AVFrameRateRange* frameRate in
          [format videoSupportedFrameRateRanges]) {
       media::VideoCaptureFormat format(
           gfx::Size(dimensions.width, dimensions.height),
           frameRate.maxFrameRate, pixelFormat);
       formats->push_back(format);
       DVLOG(2) << descriptor.display_name << " "
                << media::VideoCaptureFormat::ToString(format);
     }
   }
 }
 
 #pragma mark Public methods
 
 - (id)initWithFrameReceiver:(media::VideoCaptureDeviceMac*)frameReceiver {
   if ((self = [super init])) {
     DCHECK(main_thread_checker_.CalledOnValidThread());
     DCHECK(frameReceiver);
     [self setFrameReceiver:frameReceiver];
-    captureSession_.reset(
-        [[AVFoundationGlue::AVCaptureSessionClass() alloc] init]);
+    captureSession_.reset([[AVCaptureSession alloc] init]);
   }
   return self;
 }
 
 - (void)dealloc {
   [self stopCapture];
   [super dealloc];
 }
 
 - (void)setFrameReceiver:(media::VideoCaptureDeviceMac*)frameReceiver {
@@ skipping 14 matching lines @@
       [captureSession_ removeOutput:stillImageOutput_];
     if (captureDeviceInput_) {
       [captureSession_ removeInput:captureDeviceInput_];
       // No need to release |captureDeviceInput_|, is owned by the session.
       captureDeviceInput_ = nil;
     }
     return YES;
   }
 
   // Look for input device with requested name.
-  captureDevice_ = [AVCaptureDeviceGlue deviceWithUniqueID:deviceId];
+  captureDevice_ = [AVCaptureDevice deviceWithUniqueID:deviceId];
   if (!captureDevice_) {
     [self
         sendErrorString:[NSString stringWithUTF8String:
                                       "Could not open video capture device."]];
     return NO;
   }
 
   // Create the capture input associated with the device. Easy peasy.
   NSError* error = nil;
   captureDeviceInput_ =
-      [AVCaptureDeviceInputGlue deviceInputWithDevice:captureDevice_
-                                                error:&error];
+      [AVCaptureDeviceInput deviceInputWithDevice:captureDevice_ error:&error];
   if (!captureDeviceInput_) {
     captureDevice_ = nil;
     [self sendErrorString:
               [NSString stringWithFormat:
                             @"Could not create video capture input (%@): %@",
                             [error localizedDescription],
                             [error localizedFailureReason]]];
     return NO;
   }
   [captureSession_ addInput:captureDeviceInput_];
 
   // Create a new data output for video. The data output is configured to
   // discard late frames by default.
-  captureVideoDataOutput_.reset(
-      [[AVFoundationGlue::AVCaptureVideoDataOutputClass() alloc] init]);
+  captureVideoDataOutput_.reset([[AVCaptureVideoDataOutput alloc] init]);
   if (!captureVideoDataOutput_) {
     [captureSession_ removeInput:captureDeviceInput_];
     [self sendErrorString:[NSString stringWithUTF8String:
                                         "Could not create video data output."]];
     return NO;
   }
   [captureVideoDataOutput_ setAlwaysDiscardsLateVideoFrames:true];
   [captureVideoDataOutput_
       setSampleBufferDelegate:self
                         queue:dispatch_get_global_queue(
                                   DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)];
   [captureSession_ addOutput:captureVideoDataOutput_];
 
   // Create and plug the still image capture output. This should happen in
   // advance of the actual picture to allow for the 3A to stabilize.
-  stillImageOutput_.reset(
-      [[AVFoundationGlue::AVCaptureStillImageOutputClass() alloc] init]);
+  stillImageOutput_.reset([[AVCaptureStillImageOutput alloc] init]);
   if (stillImageOutput_ && [captureSession_ canAddOutput:stillImageOutput_])
     [captureSession_ addOutput:stillImageOutput_];
 
   return YES;
 }
 
 - (BOOL)setCaptureHeight:(int)height
                    width:(int)width
                frameRate:(float)frameRate {
   DCHECK(![captureSession_ isRunning] &&
          main_thread_checker_.CalledOnValidThread());
 
   frameWidth_ = width;
   frameHeight_ = height;
   frameRate_ = frameRate;
 
   FourCharCode best_fourcc = kCVPixelFormatType_422YpCbCr8;
   const bool prefer_mjpeg =
       width > kMjpegWidthThreshold || height > kMjpegHeightThreshold;
-  for (CrAVCaptureDeviceFormat* format in captureDevice_.formats) {
+  for (AVCaptureDeviceFormat* format in captureDevice_.formats) {
     const FourCharCode fourcc =
-        CoreMediaGlue::CMFormatDescriptionGetMediaSubType(
-            [format formatDescription]);
-    if (prefer_mjpeg &&
-        fourcc == CoreMediaGlue::kCMVideoCodecType_JPEG_OpenDML) {
+        CMFormatDescriptionGetMediaSubType([format formatDescription]);
+    if (prefer_mjpeg && fourcc == kCMVideoCodecType_JPEG_OpenDML) {
       best_fourcc = fourcc;
       break;
     }
 
     // Compare according to Chromium preference.
     if (media::VideoCaptureFormat::ComparePixelFormatPreference(
             FourCCToChromiumPixelFormat(fourcc),
             FourCCToChromiumPixelFormat(best_fourcc))) {
       best_fourcc = fourcc;
     }
   }
 
-  if (best_fourcc == CoreMediaGlue::kCMVideoCodecType_JPEG_OpenDML) {
+  if (best_fourcc == kCMVideoCodecType_JPEG_OpenDML) {
     [captureSession_ removeOutput:stillImageOutput_];
     stillImageOutput_.reset();
   }
 
   // The capture output has to be configured, despite Mac documentation
   // detailing that setting the sessionPreset would be enough. The reason for
   // this mismatch is probably because most of the AVFoundation docs are written
   // for iOS and not for MacOsX. AVVideoScalingModeKey() refers to letterboxing
   // yes/no and preserve aspect ratio yes/no when scaling. Currently we set
   // cropping and preservation.
   NSDictionary* videoSettingsDictionary = @{
-    (id) kCVPixelBufferWidthKey : @(width), (id)
-    kCVPixelBufferHeightKey : @(height), (id)
-    kCVPixelBufferPixelFormatTypeKey : @(best_fourcc),
-    AVFoundationGlue::AVVideoScalingModeKey() :
-        AVFoundationGlue::AVVideoScalingModeResizeAspectFill()
+    (id)kCVPixelBufferWidthKey : @(width),
+    (id)kCVPixelBufferHeightKey : @(height),
+    (id)kCVPixelBufferPixelFormatTypeKey : @(best_fourcc),
+    AVVideoScalingModeKey : AVVideoScalingModeResizeAspectFill
   };
   [captureVideoDataOutput_ setVideoSettings:videoSettingsDictionary];
 
-  CrAVCaptureConnection* captureConnection = [captureVideoDataOutput_
-      connectionWithMediaType:AVFoundationGlue::AVMediaTypeVideo()];
+  AVCaptureConnection* captureConnection =
+      [captureVideoDataOutput_ connectionWithMediaType:AVMediaTypeVideo];
   // Check selector existence, related to bugs http://crbug.com/327532 and
   // http://crbug.com/328096.
   // CMTimeMake accepts integer argumenst but |frameRate| is float, round it.
   if ([captureConnection
           respondsToSelector:@selector(isVideoMinFrameDurationSupported)] &&
       [captureConnection isVideoMinFrameDurationSupported]) {
     [captureConnection
-        setVideoMinFrameDuration:CoreMediaGlue::CMTimeMake(
-                                     media::kFrameRatePrecision,
-                                     (int)(frameRate *
-                                           media::kFrameRatePrecision))];
+        setVideoMinFrameDuration:CMTimeMake(media::kFrameRatePrecision,
+                                            (int)(frameRate *
+                                                  media::kFrameRatePrecision))];
   }
   if ([captureConnection
           respondsToSelector:@selector(isVideoMaxFrameDurationSupported)] &&
       [captureConnection isVideoMaxFrameDurationSupported]) {
     [captureConnection
-        setVideoMaxFrameDuration:CoreMediaGlue::CMTimeMake(
-                                     media::kFrameRatePrecision,
-                                     (int)(frameRate *
-                                           media::kFrameRatePrecision))];
+        setVideoMaxFrameDuration:CMTimeMake(media::kFrameRatePrecision,
+                                            (int)(frameRate *
+                                                  media::kFrameRatePrecision))];
   }
   return YES;
 }
 
 - (BOOL)startCapture {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!captureSession_) {
     DLOG(ERROR) << "Video capture session not initialized.";
     return NO;
   }
   // Connect the notifications.
   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
   [nc addObserver:self
          selector:@selector(onVideoError:)
-             name:AVFoundationGlue::AVCaptureSessionRuntimeErrorNotification()
+             name:AVCaptureSessionRuntimeErrorNotification
            object:captureSession_];
   [captureSession_ startRunning];
   return YES;
 }
 
 - (void)stopCapture {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if ([captureSession_ isRunning])
     [captureSession_ stopRunning];  // Synchronous.
   [[NSNotificationCenter defaultCenter] removeObserver:self];
 }
 
 - (void)takePhoto {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK([captureSession_ isRunning]);
   if (!stillImageOutput_)
     return;
 
   DCHECK_EQ(1u, [[stillImageOutput_ connections] count]);
-  CrAVCaptureConnection* const connection =
+  AVCaptureConnection* const connection =
       [[stillImageOutput_ connections] firstObject];
   if (!connection) {
     base::AutoLock lock(lock_);
     frameReceiver_->OnPhotoError();
     return;
   }
 
-  const auto handler = ^(CoreMediaGlue::CMSampleBufferRef sampleBuffer,
-                         NSError* error) {
+  const auto handler = ^(CMSampleBufferRef sampleBuffer, NSError* error) {
     base::AutoLock lock(lock_);
     if (!frameReceiver_)
       return;
     if (error != nil) {
       frameReceiver_->OnPhotoError();
       return;
     }
 
     // Recommended compressed pixel format is JPEG, we don't expect surprises.
     // TODO(mcasas): Consider using [1] for merging EXIF output information:
     // [1] +(NSData*)jpegStillImageNSDataRepresentation:jpegSampleBuffer;
-    DCHECK_EQ(
-        CoreMediaGlue::kCMVideoCodecType_JPEG,
-        CoreMediaGlue::CMFormatDescriptionGetMediaSubType(
-            CoreMediaGlue::CMSampleBufferGetFormatDescription(sampleBuffer)));
+    DCHECK_EQ(kCMVideoCodecType_JPEG,
+              CMFormatDescriptionGetMediaSubType(
+                  CMSampleBufferGetFormatDescription(sampleBuffer)));
 
     char* baseAddress = 0;
     size_t length = 0;
     ExtractBaseAddressAndLength(&baseAddress, &length, sampleBuffer);
     frameReceiver_->OnPhotoTaken(reinterpret_cast<uint8_t*>(baseAddress),
                                  length, "image/jpeg");
   };
 
   [stillImageOutput_ captureStillImageAsynchronouslyFromConnection:connection
                                                  completionHandler:handler];
 }
 
 #pragma mark Private methods
 
 // |captureOutput| is called by the capture device to deliver a new frame.
 // AVFoundation calls from a number of threads, depending on, at least, if
 // Chrome is on foreground or background.
-- (void)captureOutput:(CrAVCaptureOutput*)captureOutput
-didOutputSampleBuffer:(CoreMediaGlue::CMSampleBufferRef)sampleBuffer
-       fromConnection:(CrAVCaptureConnection*)connection {
-  const CoreMediaGlue::CMFormatDescriptionRef formatDescription =
-      CoreMediaGlue::CMSampleBufferGetFormatDescription(sampleBuffer);
+- (void)captureOutput:(AVCaptureOutput*)captureOutput
+    didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
+           fromConnection:(AVCaptureConnection*)connection {
+  const CMFormatDescriptionRef formatDescription =
+      CMSampleBufferGetFormatDescription(sampleBuffer);
   const FourCharCode fourcc =
-      CoreMediaGlue::CMFormatDescriptionGetMediaSubType(formatDescription);
-  const CoreMediaGlue::CMVideoDimensions dimensions =
-      CoreMediaGlue::CMVideoFormatDescriptionGetDimensions(formatDescription);
+      CMFormatDescriptionGetMediaSubType(formatDescription);
+  const CMVideoDimensions dimensions =
+      CMVideoFormatDescriptionGetDimensions(formatDescription);
   const media::VideoCaptureFormat captureFormat(
       gfx::Size(dimensions.width, dimensions.height), frameRate_,
       FourCCToChromiumPixelFormat(fourcc));
 
   char* baseAddress = 0;
   size_t frameSize = 0;
   CVImageBufferRef videoFrame = nil;
-  if (fourcc == CoreMediaGlue::kCMVideoCodecType_JPEG_OpenDML) {
+  if (fourcc == kCMVideoCodecType_JPEG_OpenDML) {
     ExtractBaseAddressAndLength(&baseAddress, &frameSize, sampleBuffer);
   } else {
-    videoFrame = CoreMediaGlue::CMSampleBufferGetImageBuffer(sampleBuffer);
+    videoFrame = CMSampleBufferGetImageBuffer(sampleBuffer);
     // Lock the frame and calculate frame size.
     if (CVPixelBufferLockBaseAddress(videoFrame, kCVPixelBufferLock_ReadOnly) ==
         kCVReturnSuccess) {
       baseAddress = static_cast<char*>(CVPixelBufferGetBaseAddress(videoFrame));
       frameSize = CVPixelBufferGetHeight(videoFrame) *
                   CVPixelBufferGetBytesPerRow(videoFrame);
     } else {
       videoFrame = nil;
     }
   }
 
   {
     base::AutoLock lock(lock_);
-    const CoreMediaGlue::CMTime cm_timestamp =
-        CoreMediaGlue::CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
+    const CMTime cm_timestamp =
+        CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
     const base::TimeDelta timestamp =
         CMTIME_IS_VALID(cm_timestamp)
             ? base::TimeDelta::FromMicroseconds(
                   cm_timestamp.value * base::TimeTicks::kMicrosecondsPerSecond /
                   cm_timestamp.timescale)
             : media::kNoTimestamp;
 
     if (frameReceiver_ && baseAddress) {
       frameReceiver_->ReceiveFrame(reinterpret_cast<uint8_t*>(baseAddress),
                                    frameSize, captureFormat, 0, 0, timestamp);
     }
   }
 
   if (videoFrame)
     CVPixelBufferUnlockBaseAddress(videoFrame, kCVPixelBufferLock_ReadOnly);
 }
 
 - (void)onVideoError:(NSNotification*)errorNotification {
-  NSError* error = base::mac::ObjCCast<NSError>([[errorNotification userInfo]
-      objectForKey:AVFoundationGlue::AVCaptureSessionErrorKey()]);
+  NSError* error = base::mac::ObjCCast<NSError>(
+      [[errorNotification userInfo] objectForKey:AVCaptureSessionErrorKey]);
   [self sendErrorString:[NSString
                             stringWithFormat:@"%@: %@",
                                              [error localizedDescription],
                                              [error localizedFailureReason]]];
 }
 
 - (void)sendErrorString:(NSString*)error {
   DLOG(ERROR) << [error UTF8String];
   base::AutoLock lock(lock_);
   if (frameReceiver_)
     frameReceiver_->ReceiveError(FROM_HERE, [error UTF8String]);
 }
 
 @end