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

content/browser/renderer_host/media/video_capture_manager.cc

 // 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 "content/browser/renderer_host/media/video_capture_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 27 matching lines @@
 #include "content/browser/media/capture/desktop_capture_device.h"
 #if defined(USE_AURA)
 #include "content/browser/media/capture/desktop_capture_device_aura.h"
 #endif
 #endif
 
 #if defined(ENABLE_SCREEN_CAPTURE) && defined(OS_ANDROID)
 #include "content/browser/media/capture/screen_capture_device_android.h"
 #endif
 
-#if defined(OS_MACOSX)
-#include "media/base/mac/avfoundation_glue.h"
-#endif
-
 namespace {
 
 // Compares two VideoCaptureFormat by checking smallest frame_size area, then
 // by _largest_ frame_rate. Used to order a VideoCaptureFormats vector so that
 // the first entry for a given resolution has the largest frame rate, as needed
 // by the ConsolidateCaptureFormats() method.
 bool IsCaptureFormatSmaller(const media::VideoCaptureFormat& format1,
                             const media::VideoCaptureFormat& format2) {
   DCHECK(format1.frame_size.GetCheckedArea().IsValid());
   DCHECK(format2.frame_size.GetCheckedArea().IsValid());
@@ skipping 232 matching lines @@
 void VideoCaptureManager::Unregister() {
   DCHECK(listener_);
   listener_ = nullptr;
 }
 
 void VideoCaptureManager::EnumerateDevices(
     const EnumerationCallback& client_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "VideoCaptureManager::EnumerateDevices";
 
-#if defined(OS_MACOSX)
-  if (NeedToInitializeCaptureDeviceApi(MEDIA_DEVICE_VIDEO_CAPTURE)) {
-    InitializeCaptureDeviceApiOnUIThread(base::Bind(
-        &VideoCaptureManager::EnumerateDevices, this, client_callback));
-    return;
-  }
-#endif
-
   // Bind a callback to ConsolidateDevicesInfoOnDeviceThread() with an argument
   // for another callback to OnDevicesInfoEnumerated() to be run in the current
   // loop, i.e. IO loop. Pass a timer for UMA histogram collection.
   base::Callback<void(std::unique_ptr<VideoCaptureDeviceDescriptors>)>
       devices_enumerated_callback = base::Bind(
           &VideoCaptureManager::ConsolidateDevicesInfoOnDeviceThread, this,
           media::BindToCurrentLoop(base::Bind(
               &VideoCaptureManager::OnDevicesInfoEnumerated, this,
               base::Owned(new base::ElapsedTimer()), client_callback)),
           devices_info_cache_);
@@ skipping 114 matching lines @@
     device_start_queue_.pop_front();
   }
   DeviceStartQueue::iterator request = device_start_queue_.begin();
   if (request == device_start_queue_.end())
     return;
 
   const int serial_id = request->serial_id();
   DeviceEntry* const entry = GetDeviceEntryBySerialId(serial_id);
   DCHECK(entry);
 
-#if defined(OS_MACOSX)
-  if (NeedToInitializeCaptureDeviceApi(entry->stream_type)) {
-    InitializeCaptureDeviceApiOnUIThread(
-        base::Bind(&VideoCaptureManager::HandleQueuedStartRequest, this));
-    return;
-  }
-#endif
-
   DVLOG(3) << "HandleQueuedStartRequest, Post start to device thread, device = "
            << entry->id << " start id = " << entry->serial_id;
 
   base::Callback<std::unique_ptr<VideoCaptureDevice>(void)>
       start_capture_function;
 
   switch (entry->stream_type) {
     case MEDIA_DEVICE_VIDEO_CAPTURE: {
       // We look up the device id from the renderer in our local enumeration
       // since the renderer does not have all the information that might be
@@ skipping 738 matching lines @@
     VideoCaptureDevice::TakePhotoCallback callback,
     VideoCaptureDevice* device) {
   // Unretained() is safe to use here because |device| would be null if it
   // was scheduled for shutdown and destruction, and because this task is
   // guaranteed to run before the task that destroys the |device|.
   device_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoCaptureDevice::TakePhoto,
                             base::Unretained(device), base::Passed(&callback)));
 }
 
-#if defined(OS_MACOSX)
-void VideoCaptureManager::OnDeviceLayerInitialized(
-    const base::Closure& and_then) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  capture_device_api_initialized_ = true;
-  and_then.Run();
-}
-
-bool VideoCaptureManager::NeedToInitializeCaptureDeviceApi(
-    MediaStreamType stream_type) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  return !capture_device_api_initialized_ &&
-         stream_type == MEDIA_DEVICE_VIDEO_CAPTURE;
-}
-
-void VideoCaptureManager::InitializeCaptureDeviceApiOnUIThread(
-    const base::Closure& and_then) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  BrowserThread::PostTaskAndReply(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&AVFoundationGlue::InitializeAVFoundation),
-      base::Bind(&VideoCaptureManager::OnDeviceLayerInitialized, this,
-                 and_then));
-}
-#endif
-
 #if defined(OS_ANDROID)
 void VideoCaptureManager::OnApplicationStateChange(
     base::android::ApplicationState state) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Only release/resume devices when the Application state changes from
   // RUNNING->STOPPED->RUNNING.
   if (state == base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES &&
       !application_state_has_running_activities_) {
     ResumeDevices();
@@ skipping 38 matching lines @@
     if (!device_in_queue) {
       // Session ID is only valid for Screen capture. So we can fake it to
       // resume video capture devices here.
       QueueStartDevice(kFakeSessionId, entry.get(), entry->parameters);
     }
   }
 }
 #endif  // defined(OS_ANDROID)
 
 }  // namespace content