Revert of Make cricket::VideoCapturer implement VideoSourceInterface

webrtc/media/base/capturemanager.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/media/base/capturemanager.h"
 
 #include <algorithm>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/media/base/videocapturer.h"
 
 namespace cricket {
 
 // CaptureManager helper class.
 class VideoCapturerState {
  public:
   static const VideoFormatPod kDefaultCaptureFormat;
 
-  explicit VideoCapturerState(VideoCapturer* capturer);
+  static VideoCapturerState* Create(VideoCapturer* video_capturer);
   ~VideoCapturerState() {}
 
   void AddCaptureResolution(const VideoFormat& desired_format);
   bool RemoveCaptureResolution(const VideoFormat& format);
   VideoFormat GetHighestFormat(VideoCapturer* video_capturer) const;
 
   int IncCaptureStartRef();
   int DecCaptureStartRef();
+  CaptureRenderAdapter* adapter() {
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
+    return adapter_.get();
+  }
   VideoCapturer* GetVideoCapturer() {
     RTC_DCHECK(thread_checker_.CalledOnValidThread());
-    return video_capturer_;
+    return adapter()->video_capturer();
   }
 
   int start_count() const {
     RTC_DCHECK(thread_checker_.CalledOnValidThread());
     return start_count_;
   }
 
  private:
   struct CaptureResolutionInfo {
     VideoFormat video_format;
     int format_ref_count;
   };
   typedef std::vector<CaptureResolutionInfo> CaptureFormats;
 
+  explicit VideoCapturerState(CaptureRenderAdapter* adapter);
+
   rtc::ThreadChecker thread_checker_;
+  rtc::scoped_ptr<CaptureRenderAdapter> adapter_;
 
-  VideoCapturer* video_capturer_;
   int start_count_;
   CaptureFormats capture_formats_;
 };
 
 const VideoFormatPod VideoCapturerState::kDefaultCaptureFormat = {
   640, 360, FPS_TO_INTERVAL(30), FOURCC_ANY
 };
 
-VideoCapturerState::VideoCapturerState(VideoCapturer* capturer)
-    : video_capturer_(capturer), start_count_(1) {}
+VideoCapturerState::VideoCapturerState(CaptureRenderAdapter* adapter)
+    : adapter_(adapter), start_count_(1) {}
+
+// static
+VideoCapturerState* VideoCapturerState::Create(VideoCapturer* video_capturer) {
+  CaptureRenderAdapter* adapter = CaptureRenderAdapter::Create(video_capturer);
+  if (!adapter) {
+    return NULL;
+  }
+  return new VideoCapturerState(adapter);
+}
 
 void VideoCapturerState::AddCaptureResolution(
     const VideoFormat& desired_format) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   for (CaptureFormats::iterator iter = capture_formats_.begin();
        iter != capture_formats_.end(); ++iter) {
     if (desired_format == iter->video_format) {
       ++(iter->format_ref_count);
       return;
     }
@@ skipping 179 matching lines @@
   return true;
 }
 
 void CaptureManager::AddVideoSink(VideoCapturer* video_capturer,
                                   rtc::VideoSinkInterface<VideoFrame>* sink) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   // TODO(nisse): Do we really need to tolerate NULL inputs?
   if (!video_capturer || !sink) {
     return;
   }
-  rtc::VideoSinkWants wants;
-  // Renderers must be able to apply rotation.
-  wants.rotation_applied = false;
-  video_capturer->AddOrUpdateSink(sink, wants);
+  CaptureRenderAdapter* adapter = GetAdapter(video_capturer);
+  if (!adapter) {
+    return;
+  }
+  adapter->AddSink(sink);
 }
 
 void CaptureManager::RemoveVideoSink(
     VideoCapturer* video_capturer,
     rtc::VideoSinkInterface<VideoFrame>* sink) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!video_capturer || !sink) {
     return;
   }
-  video_capturer->RemoveSink(sink);
+  CaptureRenderAdapter* adapter = GetAdapter(video_capturer);
+  if (!adapter) {
+    return;
+  }
+  adapter->RemoveSink(sink);
 }
 
 bool CaptureManager::IsCapturerRegistered(VideoCapturer* video_capturer) const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   return GetCaptureState(video_capturer) != NULL;
 }
 
 bool CaptureManager::RegisterVideoCapturer(VideoCapturer* video_capturer) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  VideoCapturerState* capture_state = new VideoCapturerState(video_capturer);
+  VideoCapturerState* capture_state =
+      VideoCapturerState::Create(video_capturer);
+  if (!capture_state) {
+    return false;
+  }
   capture_states_[video_capturer] = capture_state;
   SignalCapturerStateChange.repeat(video_capturer->SignalStateChange);
   return true;
 }
 
 void CaptureManager::UnregisterVideoCapturer(
     VideoCapturerState* capture_state) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   VideoCapturer* video_capturer = capture_state->GetVideoCapturer();
   capture_states_.erase(video_capturer);
@@ skipping 47 matching lines @@
 VideoCapturerState* CaptureManager::GetCaptureState(
     VideoCapturer* video_capturer) const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   CaptureStates::const_iterator iter = capture_states_.find(video_capturer);
   if (iter == capture_states_.end()) {
     return NULL;
   }
   return iter->second;
 }
 
+CaptureRenderAdapter* CaptureManager::GetAdapter(
+    VideoCapturer* video_capturer) const {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  VideoCapturerState* capture_state = GetCaptureState(video_capturer);
+  if (!capture_state) {
+    return NULL;
+  }
+  return capture_state->adapter();
+}
+
 }  // namespace cricket