Remove platform_video_capturing_mac and the callback thread checker in VideoCaptureDeviceAVFoundati…

media/capture/video/mac/video_capture_device_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 "media/capture/video/mac/video_capture_device_mac.h"
 
 #include <IOKit/IOCFPlugIn.h>
 #include <IOKit/usb/IOUSBLib.h>
 #include <IOKit/usb/USBSpec.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/mac/scoped_ioobject.h"
 #include "base/mac/scoped_ioplugininterface.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #import "media/base/mac/avfoundation_glue.h"
 #include "media/base/timestamp_constants.h"
-#import "media/capture/video/mac/platform_video_capturing_mac.h"
 #import "media/capture/video/mac/video_capture_device_avfoundation_mac.h"
 #include "ui/gfx/geometry/size.h"
 
 @implementation DeviceNameAndTransportType
 
 - (id)initWithName:(NSString*)deviceName transportType:(int32_t)transportType {
   if (self = [super init]) {
     deviceName_.reset([deviceName copy]);
     transportType_ = transportType;
   }
@@ skipping 277 matching lines @@
     : device_name_(device_name),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       state_(kNotInitialized),
       capture_device_(nil),
       first_timestamp_(media::kNoTimestamp()),
       weak_factory_(this) {
 }
 
 VideoCaptureDeviceMac::~VideoCaptureDeviceMac() {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  [capture_device_ release];
 }
 
 void VideoCaptureDeviceMac::AllocateAndStart(
     const VideoCaptureParams& params,
     scoped_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (state_ != kIdle) {
     return;
   }
 
@@ skipping 12 matching lines @@
   }
 
   capture_format_.frame_size = params.requested_format.frame_size;
   capture_format_.frame_rate =
       std::max(kMinFrameRate,
                std::min(params.requested_format.frame_rate, kMaxFrameRate));
   // Leave the pixel format selection to AVFoundation. The pixel format
   // will be passed to |ReceiveFrame|.
   capture_format_.pixel_format = PIXEL_FORMAT_UNKNOWN;
 
-    if (!UpdateCaptureResolution())
-      return;
+  if (!UpdateCaptureResolution())
+    return;
 
   // Try setting the power line frequency removal (anti-flicker). The built-in
   // cameras are normally suspended so the configuration must happen right
   // before starting capture and during configuration.
   const std::string& device_model = device_name_.GetModel();
   if (device_model.length() > 2 * kVidPidSize) {
     std::string vendor_id = device_model.substr(0, kVidPidSize);
     std::string model_id = device_model.substr(kVidPidSize + 1);
     int vendor_id_as_int, model_id_as_int;
     if (base::HexStringToInt(base::StringPiece(vendor_id), &vendor_id_as_int) &&
@@ skipping 19 matching lines @@
   [capture_device_ setFrameReceiver:nil];
   client_.reset();
   state_ = kIdle;
 }
 
 bool VideoCaptureDeviceMac::Init(
     VideoCaptureDevice::Name::CaptureApiType capture_api_type) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kNotInitialized);
 
-  if (capture_api_type == Name::AVFOUNDATION) {
-    capture_device_ =
-        [[VideoCaptureDeviceAVFoundation alloc] initWithFrameReceiver:this];
-  }
+  if (capture_api_type != Name::AVFOUNDATION)
+    return false;
+
+  capture_device_.reset(
+      [[VideoCaptureDeviceAVFoundation alloc] initWithFrameReceiver:this]);
 
   if (!capture_device_)
     return false;
 
   state_ = kIdle;
   return true;
 }
 
 void VideoCaptureDeviceMac::ReceiveFrame(const uint8_t* video_frame,
                                          int video_frame_length,
@@ skipping 50 matching lines @@
   if (![capture_device_ setCaptureHeight:capture_format_.frame_size.height()
                                    width:capture_format_.frame_size.width()
                                frameRate:capture_format_.frame_rate]) {
     ReceiveError(FROM_HERE, "Could not configure capture device.");
     return false;
   }
   return true;
 }
 
 }  // namespace media