diff --git a/api/DEPS b/api/DEPS
index 96fd36b..bc80704 100644
--- a/api/DEPS
+++ b/api/DEPS
@@ -120,7 +120,6 @@
   "peer_connection_interface\.h": [
     "+logging/rtc_event_log/rtc_event_log_factory_interface.h",
     "+media/base/media_config.h",
-    "+media/base/video_capturer.h",
     "+media/base/media_engine.h",
     "+p2p/base/port_allocator.h",
     "+rtc_base/bitrate_allocation_strategy.h",
diff --git a/media/BUILD.gn b/media/BUILD.gn
index 2cb0afc..c016def 100644
--- a/media/BUILD.gn
+++ b/media/BUILD.gn
@@ -108,8 +108,6 @@
     "base/video_adapter.h",
     "base/video_broadcaster.cc",
     "base/video_broadcaster.h",
-    "base/video_capturer.cc",
-    "base/video_capturer.h",
     "base/video_common.cc",
     "base/video_common.h",
     "base/video_source_base.cc",
@@ -464,8 +462,6 @@
       "base/fake_network_interface.h",
       "base/fake_rtp.cc",
       "base/fake_rtp.h",
-      "base/fake_video_capturer.cc",
-      "base/fake_video_capturer.h",
       "base/fake_video_renderer.cc",
       "base/fake_video_renderer.h",
       "base/test_utils.cc",
@@ -559,7 +555,6 @@
       "base/turn_utils_unittest.cc",
       "base/video_adapter_unittest.cc",
       "base/video_broadcaster_unittest.cc",
-      "base/video_capturer_unittest.cc",
       "base/video_common_unittest.cc",
       "engine/apm_helpers_unittest.cc",
       "engine/encoder_simulcast_proxy_unittest.cc",
diff --git a/media/base/fake_video_capturer.cc b/media/base/fake_video_capturer.cc
deleted file mode 100644
index 84bb032..0000000
--- a/media/base/fake_video_capturer.cc
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- *  Copyright (c) 2018 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 "media/base/fake_video_capturer.h"
-
-#include <string.h>
-#include <cstdint>
-
-#include "absl/memory/memory.h"
-#include "api/scoped_refptr.h"
-#include "api/video/i420_buffer.h"
-#include "api/video/video_frame_buffer.h"
-#include "rtc_base/arraysize.h"
-#include "rtc_base/checks.h"
-#include "rtc_base/time_utils.h"
-
-namespace cricket {
-
-FakeVideoCapturer::FakeVideoCapturer(bool is_screencast)
-    : running_(false),
-      is_screencast_(is_screencast),
-      rotation_(webrtc::kVideoRotation_0) {
-  // Default supported formats. Use ResetSupportedFormats to over write.
-  using cricket::VideoFormat;
-  static const VideoFormat formats[] = {
-      {1280, 720, VideoFormat::FpsToInterval(30), cricket::FOURCC_I420},
-      {640, 480, VideoFormat::FpsToInterval(30), cricket::FOURCC_I420},
-      {320, 240, VideoFormat::FpsToInterval(30), cricket::FOURCC_I420},
-      {160, 120, VideoFormat::FpsToInterval(30), cricket::FOURCC_I420},
-      {1280, 720, VideoFormat::FpsToInterval(60), cricket::FOURCC_I420},
-  };
-  ResetSupportedFormats({&formats[0], &formats[arraysize(formats)]});
-}
-
-FakeVideoCapturer::FakeVideoCapturer() : FakeVideoCapturer(false) {}
-
-FakeVideoCapturer::~FakeVideoCapturer() {
-  SignalDestroyed(this);
-}
-
-void FakeVideoCapturer::ResetSupportedFormats(
-    const std::vector<cricket::VideoFormat>& formats) {
-  SetSupportedFormats(formats);
-}
-
-bool FakeVideoCapturer::CaptureFrame() {
-  if (!GetCaptureFormat()) {
-    return false;
-  }
-  RTC_CHECK_EQ(GetCaptureFormat()->fourcc, FOURCC_I420);
-  return CaptureFrame(frame_source_->GetFrame());
-}
-
-bool FakeVideoCapturer::CaptureCustomFrame(int width, int height) {
-  // Default to 30fps.
-  // TODO(nisse): Would anything break if we always stick to
-  // the configure frame interval?
-  return CaptureFrame(frame_source_->GetFrame(width, height, rotation_,
-                                              rtc::kNumMicrosecsPerSec / 30));
-}
-
-bool FakeVideoCapturer::CaptureFrame(const webrtc::VideoFrame& frame) {
-  if (!running_) {
-    return false;
-  }
-
-  int adapted_width;
-  int adapted_height;
-  int crop_width;
-  int crop_height;
-  int crop_x;
-  int crop_y;
-
-  // TODO(nisse): It's a bit silly to have this logic in a fake
-  // class. Child classes of VideoCapturer are expected to call
-  // AdaptFrame, and the test case
-  // VideoCapturerTest.SinkWantsMaxPixelAndMaxPixelCountStepUp
-  // depends on this.
-  if (AdaptFrame(frame.width(), frame.height(), frame.timestamp_us(),
-                 frame.timestamp_us(), &adapted_width, &adapted_height,
-                 &crop_width, &crop_height, &crop_x, &crop_y, nullptr)) {
-    rtc::scoped_refptr<webrtc::I420Buffer> buffer(
-        webrtc::I420Buffer::Create(adapted_width, adapted_height));
-    buffer->InitializeData();
-
-    webrtc::VideoFrame adapted_frame =
-        webrtc::VideoFrame::Builder()
-            .set_video_frame_buffer(buffer)
-            .set_rotation(frame.rotation())
-            .set_timestamp_us(frame.timestamp_us())
-            .set_id(frame.id())
-            .build();
-    OnFrame(adapted_frame, frame.width(), frame.height());
-  }
-
-  return true;
-}
-
-cricket::CaptureState FakeVideoCapturer::Start(
-    const cricket::VideoFormat& format) {
-  SetCaptureFormat(&format);
-  running_ = true;
-  SetCaptureState(cricket::CS_RUNNING);
-  frame_source_ = absl::make_unique<FakeFrameSource>(
-      format.width, format.height,
-      format.interval / rtc::kNumNanosecsPerMicrosec, rtc::TimeMicros());
-  frame_source_->SetRotation(rotation_);
-  return cricket::CS_RUNNING;
-}
-
-void FakeVideoCapturer::Stop() {
-  running_ = false;
-  SetCaptureFormat(NULL);
-  SetCaptureState(cricket::CS_STOPPED);
-}
-
-bool FakeVideoCapturer::IsRunning() {
-  return running_;
-}
-
-bool FakeVideoCapturer::IsScreencast() const {
-  return is_screencast_;
-}
-
-bool FakeVideoCapturer::GetPreferredFourccs(std::vector<uint32_t>* fourccs) {
-  fourccs->push_back(cricket::FOURCC_I420);
-  fourccs->push_back(cricket::FOURCC_MJPG);
-  return true;
-}
-
-void FakeVideoCapturer::SetRotation(webrtc::VideoRotation rotation) {
-  rotation_ = rotation;
-  if (frame_source_)
-    frame_source_->SetRotation(rotation_);
-}
-
-webrtc::VideoRotation FakeVideoCapturer::GetRotation() {
-  return rotation_;
-}
-
-FakeVideoCapturerWithTaskQueue::FakeVideoCapturerWithTaskQueue(
-    bool is_screencast)
-    : FakeVideoCapturer(is_screencast) {}
-
-FakeVideoCapturerWithTaskQueue::FakeVideoCapturerWithTaskQueue() {}
-
-bool FakeVideoCapturerWithTaskQueue::CaptureFrame() {
-  if (task_queue_.IsCurrent())
-    return FakeVideoCapturer::CaptureFrame();
-  bool ret = false;
-  task_queue_.SendTask(
-      [this, &ret]() { ret = FakeVideoCapturer::CaptureFrame(); });
-  return ret;
-}
-
-bool FakeVideoCapturerWithTaskQueue::CaptureCustomFrame(int width, int height) {
-  if (task_queue_.IsCurrent())
-    return FakeVideoCapturer::CaptureCustomFrame(width, height);
-  bool ret = false;
-  task_queue_.SendTask([this, &ret, width, height]() {
-    ret = FakeVideoCapturer::CaptureCustomFrame(width, height);
-  });
-  return ret;
-}
-
-}  // namespace cricket
diff --git a/media/base/fake_video_capturer.h b/media/base/fake_video_capturer.h
deleted file mode 100644
index 3cb64b0..0000000
--- a/media/base/fake_video_capturer.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- *  Copyright (c) 2004 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.
- */
-
-#ifndef MEDIA_BASE_FAKE_VIDEO_CAPTURER_H_
-#define MEDIA_BASE_FAKE_VIDEO_CAPTURER_H_
-
-#include <string.h>
-
-#include <memory>
-#include <vector>
-
-#include "api/video/i420_buffer.h"
-#include "api/video/video_frame.h"
-#include "media/base/fake_frame_source.h"
-#include "media/base/video_capturer.h"
-#include "media/base/video_common.h"
-#include "rtc_base/task_queue_for_test.h"
-#include "rtc_base/time_utils.h"
-
-namespace cricket {
-
-// Fake video capturer that allows the test to manually pump in frames.
-class FakeVideoCapturer : public cricket::VideoCapturer {
- public:
-  explicit FakeVideoCapturer(bool is_screencast);
-  FakeVideoCapturer();
-
-  ~FakeVideoCapturer() override;
-
-  void ResetSupportedFormats(const std::vector<cricket::VideoFormat>& formats);
-  virtual bool CaptureFrame();
-  virtual bool CaptureCustomFrame(int width, int height);
-
-  sigslot::signal1<FakeVideoCapturer*> SignalDestroyed;
-
-  cricket::CaptureState Start(const cricket::VideoFormat& format) override;
-  void Stop() override;
-  bool IsRunning() override;
-  bool IsScreencast() const override;
-  bool GetPreferredFourccs(std::vector<uint32_t>* fourccs) override;
-
-  void SetRotation(webrtc::VideoRotation rotation);
-
-  webrtc::VideoRotation GetRotation();
-
- private:
-  bool CaptureFrame(const webrtc::VideoFrame& frame);
-
-  bool running_;
-  const bool is_screencast_;
-  // Duplicates FakeFrameSource::rotation_, but needed to support
-  // SetRotation before Start.
-  webrtc::VideoRotation rotation_;
-  std::unique_ptr<FakeFrameSource> frame_source_;
-};
-
-// Inherits from FakeVideoCapturer but adds a TaskQueue so that frames can be
-// delivered on a TaskQueue as expected by VideoSinkInterface implementations.
-class FakeVideoCapturerWithTaskQueue : public FakeVideoCapturer {
- public:
-  explicit FakeVideoCapturerWithTaskQueue(bool is_screencast);
-  FakeVideoCapturerWithTaskQueue();
-
-  bool CaptureFrame() override;
-  bool CaptureCustomFrame(int width, int height) override;
-
- protected:
-  rtc::test::TaskQueueForTest task_queue_{"FakeVideoCapturerWithTaskQueue"};
-};
-
-}  // namespace cricket
-
-#endif  // MEDIA_BASE_FAKE_VIDEO_CAPTURER_H_
diff --git a/media/base/video_capturer.cc b/media/base/video_capturer.cc
deleted file mode 100644
index b51f4d8..0000000
--- a/media/base/video_capturer.cc
+++ /dev/null
@@ -1,393 +0,0 @@
-/*
- *  Copyright (c) 2010 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.
- */
-
-// Implementation file of class VideoCapturer.
-
-#include "media/base/video_capturer.h"
-
-#include <cstdint>
-
-#include "api/scoped_refptr.h"
-#include "api/video/i420_buffer.h"
-#include "api/video/video_frame.h"
-#include "api/video/video_frame_buffer.h"
-#include "api/video/video_rotation.h"
-#include "rtc_base/checks.h"
-#include "rtc_base/logging.h"
-#include "rtc_base/time_utils.h"
-
-namespace cricket {
-
-namespace {
-
-static const int64_t kMaxDistance = ~(static_cast<int64_t>(1) << 63);
-#ifdef WEBRTC_LINUX
-static const int kYU12Penalty = 16;  // Needs to be higher than MJPG index.
-#endif
-
-}  // namespace
-
-/////////////////////////////////////////////////////////////////////
-// Implementation of class VideoCapturer
-/////////////////////////////////////////////////////////////////////
-VideoCapturer::VideoCapturer() : apply_rotation_(false) {
-  thread_checker_.DetachFromThread();
-  Construct();
-}
-
-VideoCapturer::~VideoCapturer() {}
-
-void VideoCapturer::Construct() {
-  enable_camera_list_ = false;
-  capture_state_ = CS_STOPPED;
-  scaled_width_ = 0;
-  scaled_height_ = 0;
-  enable_video_adapter_ = true;
-}
-
-const std::vector<VideoFormat>* VideoCapturer::GetSupportedFormats() const {
-  return &filtered_supported_formats_;
-}
-
-bool VideoCapturer::StartCapturing(const VideoFormat& capture_format) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  CaptureState result = Start(capture_format);
-  const bool success = (result == CS_RUNNING) || (result == CS_STARTING);
-  if (!success) {
-    return false;
-  }
-  if (result == CS_RUNNING) {
-    SetCaptureState(result);
-  }
-  return true;
-}
-
-bool VideoCapturer::apply_rotation() {
-  return apply_rotation_;
-}
-
-void VideoCapturer::SetSupportedFormats(
-    const std::vector<VideoFormat>& formats) {
-  // This method is OK to call during initialization on a separate thread.
-  RTC_DCHECK(capture_state_ == CS_STOPPED ||
-             thread_checker_.CalledOnValidThread());
-  supported_formats_ = formats;
-  UpdateFilteredSupportedFormats();
-}
-
-bool VideoCapturer::GetBestCaptureFormat(const VideoFormat& format,
-                                         VideoFormat* best_format) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  // TODO(fbarchard): Directly support max_format.
-  UpdateFilteredSupportedFormats();
-  const std::vector<VideoFormat>* supported_formats = GetSupportedFormats();
-
-  if (supported_formats->empty()) {
-    return false;
-  }
-  RTC_LOG(LS_INFO) << " Capture Requested " << format.ToString();
-  int64_t best_distance = kMaxDistance;
-  std::vector<VideoFormat>::const_iterator best = supported_formats->end();
-  std::vector<VideoFormat>::const_iterator i;
-  for (i = supported_formats->begin(); i != supported_formats->end(); ++i) {
-    int64_t distance = GetFormatDistance(format, *i);
-    // TODO(fbarchard): Reduce to LS_VERBOSE if/when camera capture is
-    // relatively bug free.
-    RTC_LOG(LS_INFO) << " Supported " << i->ToString() << " distance "
-                     << distance;
-    if (distance < best_distance) {
-      best_distance = distance;
-      best = i;
-    }
-  }
-  if (supported_formats->end() == best) {
-    RTC_LOG(LS_ERROR) << " No acceptable camera format found";
-    return false;
-  }
-
-  if (best_format) {
-    best_format->width = best->width;
-    best_format->height = best->height;
-    best_format->fourcc = best->fourcc;
-    best_format->interval = best->interval;
-    RTC_LOG(LS_INFO) << " Best " << best_format->ToString() << " Interval "
-                     << best_format->interval << " distance " << best_distance;
-  }
-  return true;
-}
-
-void VideoCapturer::ConstrainSupportedFormats(const VideoFormat& max_format) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  max_format_.reset(new VideoFormat(max_format));
-  RTC_LOG(LS_VERBOSE) << " ConstrainSupportedFormats " << max_format.ToString();
-  UpdateFilteredSupportedFormats();
-}
-
-bool VideoCapturer::GetInputSize(int* width, int* height) {
-  rtc::CritScope cs(&frame_stats_crit_);
-  if (!input_size_valid_) {
-    return false;
-  }
-  *width = input_width_;
-  *height = input_height_;
-
-  return true;
-}
-
-void VideoCapturer::RemoveSink(
-    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  broadcaster_.RemoveSink(sink);
-  OnSinkWantsChanged(broadcaster_.wants());
-}
-
-void VideoCapturer::AddOrUpdateSink(
-    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
-    const rtc::VideoSinkWants& wants) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  broadcaster_.AddOrUpdateSink(sink, wants);
-  OnSinkWantsChanged(broadcaster_.wants());
-}
-
-void VideoCapturer::OnSinkWantsChanged(const rtc::VideoSinkWants& wants) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  apply_rotation_ = wants.rotation_applied;
-
-  if (video_adapter()) {
-    video_adapter()->OnResolutionFramerateRequest(wants.target_pixel_count,
-                                                  wants.max_pixel_count,
-                                                  wants.max_framerate_fps);
-  }
-}
-
-bool VideoCapturer::AdaptFrame(int width,
-                               int height,
-                               int64_t camera_time_us,
-                               int64_t system_time_us,
-                               int* out_width,
-                               int* out_height,
-                               int* crop_width,
-                               int* crop_height,
-                               int* crop_x,
-                               int* crop_y,
-                               int64_t* translated_camera_time_us) {
-  if (translated_camera_time_us) {
-    *translated_camera_time_us =
-        timestamp_aligner_.TranslateTimestamp(camera_time_us, system_time_us);
-  }
-  if (!broadcaster_.frame_wanted()) {
-    return false;
-  }
-
-  if (enable_video_adapter_) {
-    if (!video_adapter_.AdaptFrameResolution(
-            width, height, camera_time_us * rtc::kNumNanosecsPerMicrosec,
-            crop_width, crop_height, out_width, out_height)) {
-      // VideoAdapter dropped the frame.
-      broadcaster_.OnDiscardedFrame();
-      return false;
-    }
-    *crop_x = (width - *crop_width) / 2;
-    *crop_y = (height - *crop_height) / 2;
-  } else {
-    *out_width = width;
-    *out_height = height;
-    *crop_width = width;
-    *crop_height = height;
-    *crop_x = 0;
-    *crop_y = 0;
-  }
-
-  return true;
-}
-
-void VideoCapturer::OnFrame(const webrtc::VideoFrame& frame,
-                            int orig_width,
-                            int orig_height) {
-  // For a child class which implements rotation itself, we should
-  // always have apply_rotation_ == false or frame.rotation() == 0.
-  // Except possibly during races where apply_rotation_ is changed
-  // mid-stream.
-  if (apply_rotation_ && frame.rotation() != webrtc::kVideoRotation_0) {
-    rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer(
-        frame.video_frame_buffer());
-    if (buffer->type() != webrtc::VideoFrameBuffer::Type::kI420) {
-      // Sources producing non-I420 frames must handle apply_rotation
-      // themselves. But even if they do, we may occasionally end up
-      // in this case, for frames in flight at the time
-      // applied_rotation is set to true. In that case, we just drop
-      // the frame.
-      RTC_LOG(LS_WARNING) << "Non-I420 frame requiring rotation. Discarding.";
-      return;
-    }
-    webrtc::VideoFrame rotated_frame =
-        webrtc::VideoFrame::Builder()
-            .set_video_frame_buffer(webrtc::I420Buffer::Rotate(
-                *buffer->GetI420(), frame.rotation()))
-            .set_rotation(webrtc::kVideoRotation_0)
-            .set_timestamp_us(frame.timestamp_us())
-            .set_id(frame.id())
-            .build();
-    broadcaster_.OnFrame(rotated_frame);
-  } else {
-    broadcaster_.OnFrame(frame);
-  }
-  UpdateInputSize(orig_width, orig_height);
-}
-
-void VideoCapturer::SetCaptureState(CaptureState state) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  if (state == capture_state_) {
-    // Don't trigger a state changed callback if the state hasn't changed.
-    return;
-  }
-  capture_state_ = state;
-  SignalStateChange(this, capture_state_);
-}
-
-// Get the distance between the supported and desired formats.
-// Prioritization is done according to this algorithm:
-// 1) Width closeness. If not same, we prefer wider.
-// 2) Height closeness. If not same, we prefer higher.
-// 3) Framerate closeness. If not same, we prefer faster.
-// 4) Compression. If desired format has a specific fourcc, we need exact match;
-//                otherwise, we use preference.
-int64_t VideoCapturer::GetFormatDistance(const VideoFormat& desired,
-                                         const VideoFormat& supported) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  int64_t distance = kMaxDistance;
-
-  // Check fourcc.
-  uint32_t supported_fourcc = CanonicalFourCC(supported.fourcc);
-  int64_t delta_fourcc = kMaxDistance;
-  if (FOURCC_ANY == desired.fourcc) {
-    // Any fourcc is OK for the desired. Use preference to find best fourcc.
-    std::vector<uint32_t> preferred_fourccs;
-    if (!GetPreferredFourccs(&preferred_fourccs)) {
-      return distance;
-    }
-
-    for (size_t i = 0; i < preferred_fourccs.size(); ++i) {
-      if (supported_fourcc == CanonicalFourCC(preferred_fourccs[i])) {
-        delta_fourcc = i;
-#ifdef WEBRTC_LINUX
-        // For HD avoid YU12 which is a software conversion and has 2 bugs
-        // b/7326348 b/6960899.  Reenable when fixed.
-        if (supported.height >= 720 && (supported_fourcc == FOURCC_YU12 ||
-                                        supported_fourcc == FOURCC_YV12)) {
-          delta_fourcc += kYU12Penalty;
-        }
-#endif
-        break;
-      }
-    }
-  } else if (supported_fourcc == CanonicalFourCC(desired.fourcc)) {
-    delta_fourcc = 0;  // Need exact match.
-  }
-
-  if (kMaxDistance == delta_fourcc) {
-    // Failed to match fourcc.
-    return distance;
-  }
-
-  // Check resolution and fps.
-  int desired_width = desired.width;
-  int desired_height = desired.height;
-  int64_t delta_w = supported.width - desired_width;
-  float supported_fps = VideoFormat::IntervalToFpsFloat(supported.interval);
-  float delta_fps =
-      supported_fps - VideoFormat::IntervalToFpsFloat(desired.interval);
-  // Check height of supported height compared to height we would like it to be.
-  int64_t aspect_h = desired_width
-                         ? supported.width * desired_height / desired_width
-                         : desired_height;
-  int64_t delta_h = supported.height - aspect_h;
-
-  distance = 0;
-  // Set high penalty if the supported format is lower than the desired format.
-  // 3x means we would prefer down to down to 3/4, than up to double.
-  // But we'd prefer up to double than down to 1/2.  This is conservative,
-  // strongly avoiding going down in resolution, similar to
-  // the old method, but not completely ruling it out in extreme situations.
-  // It also ignores framerate, which is often very low at high resolutions.
-  // TODO(fbarchard): Improve logic to use weighted factors.
-  static const int kDownPenalty = -3;
-  if (delta_w < 0) {
-    delta_w = delta_w * kDownPenalty;
-  }
-  if (delta_h < 0) {
-    delta_h = delta_h * kDownPenalty;
-  }
-  // Require camera fps to be at least 80% of what is requested if resolution
-  // matches.
-  // Require camera fps to be at least 96% of what is requested, or higher,
-  // if resolution differs. 96% allows for slight variations in fps. e.g. 29.97
-  if (delta_fps < 0) {
-    float min_desirable_fps =
-        delta_w
-            ? VideoFormat::IntervalToFpsFloat(desired.interval) * 28.f / 30.f
-            : VideoFormat::IntervalToFpsFloat(desired.interval) * 23.f / 30.f;
-    delta_fps = -delta_fps;
-    if (supported_fps < min_desirable_fps) {
-      distance |= static_cast<int64_t>(1) << 62;
-    } else {
-      distance |= static_cast<int64_t>(1) << 15;
-    }
-  }
-  int64_t idelta_fps = static_cast<int>(delta_fps);
-
-  // 12 bits for width and height and 8 bits for fps and fourcc.
-  distance |=
-      (delta_w << 28) | (delta_h << 16) | (idelta_fps << 8) | delta_fourcc;
-
-  return distance;
-}
-
-void VideoCapturer::UpdateFilteredSupportedFormats() {
-  filtered_supported_formats_.clear();
-  filtered_supported_formats_ = supported_formats_;
-  if (!max_format_) {
-    return;
-  }
-  std::vector<VideoFormat>::iterator iter = filtered_supported_formats_.begin();
-  while (iter != filtered_supported_formats_.end()) {
-    if (ShouldFilterFormat(*iter)) {
-      iter = filtered_supported_formats_.erase(iter);
-    } else {
-      ++iter;
-    }
-  }
-  if (filtered_supported_formats_.empty()) {
-    // The device only captures at resolutions higher than |max_format_| this
-    // indicates that |max_format_| should be ignored as it is better to capture
-    // at too high a resolution than to not capture at all.
-    filtered_supported_formats_ = supported_formats_;
-  }
-}
-
-bool VideoCapturer::ShouldFilterFormat(const VideoFormat& format) const {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  if (!enable_camera_list_) {
-    return false;
-  }
-  return format.width > max_format_->width ||
-         format.height > max_format_->height;
-}
-
-void VideoCapturer::UpdateInputSize(int width, int height) {
-  // Update stats protected from fetches from different thread.
-  rtc::CritScope cs(&frame_stats_crit_);
-
-  input_size_valid_ = true;
-  input_width_ = width;
-  input_height_ = height;
-}
-
-}  // namespace cricket
diff --git a/media/base/video_capturer.h b/media/base/video_capturer.h
deleted file mode 100644
index 05219be..0000000
--- a/media/base/video_capturer.h
+++ /dev/null
@@ -1,283 +0,0 @@
-/*
- *  Copyright (c) 2010 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.
- */
-
-// Declaration of abstract class VideoCapturer
-
-#ifndef MEDIA_BASE_VIDEO_CAPTURER_H_
-#define MEDIA_BASE_VIDEO_CAPTURER_H_
-
-#include <stdint.h>
-
-#include <algorithm>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "api/video/video_source_interface.h"
-#include "media/base/video_adapter.h"
-#include "media/base/video_broadcaster.h"
-#include "media/base/video_common.h"
-#include "rtc_base/constructor_magic.h"
-#include "rtc_base/critical_section.h"
-#include "rtc_base/system/rtc_export.h"
-#include "rtc_base/third_party/sigslot/sigslot.h"
-#include "rtc_base/thread_checker.h"
-#include "rtc_base/timestamp_aligner.h"
-
-namespace webrtc {
-class VideoFrame;
-}
-
-namespace cricket {
-
-// Current state of the capturer.
-enum CaptureState {
-  CS_STOPPED,   // The capturer has been stopped or hasn't started yet.
-  CS_STARTING,  // The capturer is in the process of starting. Note, it may
-                // still fail to start.
-  CS_RUNNING,   // The capturer has been started successfully and is now
-                // capturing.
-  CS_FAILED,    // The capturer failed to start.
-};
-
-// VideoCapturer is an abstract class that defines the interfaces for video
-// capturing. The subclasses implement the video capturer for various types of
-// capturers and various platforms.
-//
-// The captured frames may need to be adapted (for example, cropping).
-// Video adaptation is built into and enabled by default. After a frame has
-// been captured from the device, it is sent to the video adapter, then out to
-// the sinks.
-//
-// Programming model:
-//   Create an object of a subclass of VideoCapturer
-//   Initialize
-//   SignalStateChange.connect()
-//   AddOrUpdateSink()
-//   Find the capture format for Start() by either calling GetSupportedFormats()
-//   and selecting one of the supported or calling GetBestCaptureFormat().
-//   video_adapter()->OnOutputFormatRequest(desired_encoding_format)
-//   Start()
-//   GetCaptureFormat() optionally
-//   Stop()
-//
-// Assumption:
-//   The Start() and Stop() methods are called by a single thread (E.g., the
-//   media engine thread). Hence, the VideoCapture subclasses dont need to be
-//   thread safe.
-//
-class RTC_EXPORT VideoCapturer
-    : public sigslot::has_slots<>,
-      public rtc::VideoSourceInterface<webrtc::VideoFrame> {
- public:
-  VideoCapturer();
-
-  ~VideoCapturer() override;
-
-  // Gets the id of the underlying device, which is available after the capturer
-  // is initialized. Can be used to determine if two capturers reference the
-  // same device.
-  const std::string& GetId() const { return id_; }
-
-  // Get the capture formats supported by the video capturer. The supported
-  // formats are non empty after the device has been opened successfully.
-  const std::vector<VideoFormat>* GetSupportedFormats() const;
-
-  // Get the best capture format for the desired format. The best format is the
-  // same as one of the supported formats except that the frame interval may be
-  // different. If the application asks for 16x9 and the camera does not support
-  // 16x9 HD or the application asks for 16x10, we find the closest 4x3 and then
-  // crop; Otherwise, we find what the application asks for. Note that we assume
-  // that for HD, the desired format is always 16x9. The subclasses can override
-  // the default implementation.
-  // Parameters
-  //   desired: the input desired format. If desired.fourcc is not kAnyFourcc,
-  //            the best capture format has the exactly same fourcc. Otherwise,
-  //            the best capture format uses a fourcc in GetPreferredFourccs().
-  //   best_format: the output of the best capture format.
-  // Return false if there is no such a best format, that is, the desired format
-  // is not supported.
-  virtual bool GetBestCaptureFormat(const VideoFormat& desired,
-                                    VideoFormat* best_format);
-
-  // TODO(hellner): deprecate (make private) the Start API in favor of this one.
-  //                Also remove CS_STARTING as it is implied by the return
-  //                value of StartCapturing().
-  bool StartCapturing(const VideoFormat& capture_format);
-  // Start the video capturer with the specified capture format.
-  // Parameter
-  //   capture_format: The caller got this parameter by either calling
-  //                   GetSupportedFormats() and selecting one of the supported
-  //                   or calling GetBestCaptureFormat().
-  // Return
-  //   CS_STARTING:  The capturer is trying to start. Success or failure will
-  //                 be notified via the |SignalStateChange| callback.
-  //   CS_RUNNING:   if the capturer is started and capturing.
-  //   CS_FAILED:    if the capturer failes to start..
-  //   CS_NO_DEVICE: if the capturer has no device and fails to start.
-  virtual CaptureState Start(const VideoFormat& capture_format) = 0;
-
-  // Get the current capture format, which is set by the Start() call.
-  // Note that the width and height of the captured frames may differ from the
-  // capture format. For example, the capture format is HD but the captured
-  // frames may be smaller than HD.
-  const VideoFormat* GetCaptureFormat() const { return capture_format_.get(); }
-
-  // Stop the video capturer.
-  virtual void Stop() = 0;
-  // Check if the video capturer is running.
-  virtual bool IsRunning() = 0;
-  CaptureState capture_state() const { return capture_state_; }
-
-  virtual bool apply_rotation();
-
-  // Returns true if the capturer is screencasting. This can be used to
-  // implement screencast specific behavior.
-  virtual bool IsScreencast() const = 0;
-
-  // Caps the VideoCapturer's format according to max_format. It can e.g. be
-  // used to prevent cameras from capturing at a resolution or framerate that
-  // the capturer is capable of but not performing satisfactorily at.
-  // The capping is an upper bound for each component of the capturing format.
-  // The fourcc component is ignored.
-  void ConstrainSupportedFormats(const VideoFormat& max_format);
-
-  void set_enable_camera_list(bool enable_camera_list) {
-    enable_camera_list_ = enable_camera_list;
-  }
-  bool enable_camera_list() { return enable_camera_list_; }
-
-  // Signal all capture state changes that are not a direct result of calling
-  // Start().
-  sigslot::signal2<VideoCapturer*, CaptureState> SignalStateChange;
-
-  // If true, run video adaptation. By default, video adaptation is enabled
-  // and users must call video_adapter()->OnOutputFormatRequest()
-  // to receive frames.
-  bool enable_video_adapter() const { return enable_video_adapter_; }
-  void set_enable_video_adapter(bool enable_video_adapter) {
-    enable_video_adapter_ = enable_video_adapter;
-  }
-
-  bool GetInputSize(int* width, int* height);
-
-  // Implements VideoSourceInterface
-  void AddOrUpdateSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
-                       const rtc::VideoSinkWants& wants) override;
-  void RemoveSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override;
-
- protected:
-  // OnSinkWantsChanged can be overridden to change the default behavior
-  // when a sink changes its VideoSinkWants by calling AddOrUpdateSink.
-  virtual void OnSinkWantsChanged(const rtc::VideoSinkWants& wants);
-
-  // Reports the appropriate frame size after adaptation. Returns true
-  // if a frame is wanted. Returns false if there are no interested
-  // sinks, or if the VideoAdapter decides to drop the frame.
-
-  // This function also implements timestamp translation/filtering.
-  // |camera_time_ns| is the camera's timestamp for the captured
-  // frame; it is expected to have good accuracy, but it may use an
-  // arbitrary epoch and a small possibly free-running with a frequency
-  // slightly different from the system clock. |system_time_us| is the
-  // monotonic system time (in the same scale as rtc::TimeMicros) when
-  // the frame was captured; the application is expected to read the
-  // system time as soon as possible after frame capture, but it may
-  // suffer scheduling jitter or poor system clock resolution. The
-  // output |translated_camera_time_us| is a combined timestamp,
-  // taking advantage of the supposedly higher accuracy in the camera
-  // timestamp, but using the same epoch and frequency as system time.
-  bool AdaptFrame(int width,
-                  int height,
-                  int64_t camera_time_us,
-                  int64_t system_time_us,
-                  int* out_width,
-                  int* out_height,
-                  int* crop_width,
-                  int* crop_height,
-                  int* crop_x,
-                  int* crop_y,
-                  int64_t* translated_camera_time_us);
-
-  // Called when a frame has been captured and converted to a
-  // VideoFrame. OnFrame can be called directly by an implementation
-  // that does not use SignalFrameCaptured or OnFrameCaptured. The
-  // orig_width and orig_height are used only to produce stats.
-  void OnFrame(const webrtc::VideoFrame& frame,
-               int orig_width,
-               int orig_height);
-
-  VideoAdapter* video_adapter() { return &video_adapter_; }
-
-  void SetCaptureState(CaptureState state);
-
-  // subclasses override this virtual method to provide a vector of fourccs, in
-  // order of preference, that are expected by the media engine.
-  virtual bool GetPreferredFourccs(std::vector<uint32_t>* fourccs) = 0;
-
-  // mutators to set private attributes
-  void SetId(const std::string& id) { id_ = id; }
-
-  void SetCaptureFormat(const VideoFormat* format) {
-    capture_format_.reset(format ? new VideoFormat(*format) : NULL);
-  }
-
-  void SetSupportedFormats(const std::vector<VideoFormat>& formats);
-
- private:
-  void Construct();
-  // Get the distance between the desired format and the supported format.
-  // Return the max distance if they mismatch. See the implementation for
-  // details.
-  int64_t GetFormatDistance(const VideoFormat& desired,
-                            const VideoFormat& supported);
-
-  // Updates filtered_supported_formats_ so that it contains the formats in
-  // supported_formats_ that fulfill all applied restrictions.
-  void UpdateFilteredSupportedFormats();
-  // Returns true if format doesn't fulfill all applied restrictions.
-  bool ShouldFilterFormat(const VideoFormat& format) const;
-
-  void UpdateInputSize(int width, int height);
-
-  rtc::ThreadChecker thread_checker_;
-  std::string id_;
-  CaptureState capture_state_;
-  std::unique_ptr<VideoFormat> capture_format_;
-  std::vector<VideoFormat> supported_formats_;
-  std::unique_ptr<VideoFormat> max_format_;
-  std::vector<VideoFormat> filtered_supported_formats_;
-
-  bool enable_camera_list_;
-  int scaled_width_;  // Current output size from ComputeScale.
-  int scaled_height_;
-
-  rtc::VideoBroadcaster broadcaster_;
-  bool enable_video_adapter_;
-  VideoAdapter video_adapter_;
-
-  rtc::CriticalSection frame_stats_crit_;
-  // The captured frame size before potential adapation.
-  bool input_size_valid_ RTC_GUARDED_BY(frame_stats_crit_) = false;
-  int input_width_ RTC_GUARDED_BY(frame_stats_crit_);
-  int input_height_ RTC_GUARDED_BY(frame_stats_crit_);
-
-  // Whether capturer should apply rotation to the frame before
-  // passing it on to the registered sinks.
-  bool apply_rotation_;
-
-  // State for the timestamp translation.
-  rtc::TimestampAligner timestamp_aligner_;
-  RTC_DISALLOW_COPY_AND_ASSIGN(VideoCapturer);
-};
-
-}  // namespace cricket
-
-#endif  // MEDIA_BASE_VIDEO_CAPTURER_H_
diff --git a/media/base/video_capturer_unittest.cc b/media/base/video_capturer_unittest.cc
deleted file mode 100644
index bb05ca1..0000000
--- a/media/base/video_capturer_unittest.cc
+++ /dev/null
@@ -1,785 +0,0 @@
-/*
- *  Copyright (c) 2008 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 <stdio.h>
-#include <memory>
-#include <vector>
-
-#include "absl/types/optional.h"
-#include "api/video/video_rotation.h"
-#include "media/base/fake_video_capturer.h"
-#include "media/base/fake_video_renderer.h"
-#include "media/base/video_capturer.h"
-#include "rtc_base/gunit.h"
-#include "rtc_base/thread.h"
-#include "test/gtest.h"
-
-using cricket::FakeVideoCapturerWithTaskQueue;
-
-namespace {
-
-const int kMsCallbackWait = 500;
-// For HD only the height matters.
-const int kMinHdHeight = 720;
-
-}  // namespace
-
-class VideoCapturerTest : public sigslot::has_slots<>, public testing::Test {
- public:
-  VideoCapturerTest()
-      : capture_state_(cricket::CS_STOPPED), num_state_changes_(0) {
-    InitCapturer(false);
-  }
-
- protected:
-  void InitCapturer(bool is_screencast) {
-    capturer_ = std::unique_ptr<FakeVideoCapturerWithTaskQueue>(
-        new FakeVideoCapturerWithTaskQueue(is_screencast));
-    capturer_->SignalStateChange.connect(this,
-                                         &VideoCapturerTest::OnStateChange);
-    capturer_->AddOrUpdateSink(&renderer_, rtc::VideoSinkWants());
-  }
-  void InitScreencast() { InitCapturer(true); }
-
-  void OnStateChange(cricket::VideoCapturer*,
-                     cricket::CaptureState capture_state) {
-    capture_state_ = capture_state;
-    ++num_state_changes_;
-  }
-  cricket::CaptureState capture_state() { return capture_state_; }
-  int num_state_changes() { return num_state_changes_; }
-
-  std::unique_ptr<FakeVideoCapturerWithTaskQueue> capturer_;
-  cricket::CaptureState capture_state_;
-  int num_state_changes_;
-  cricket::FakeVideoRenderer renderer_;
-  bool expects_rotation_applied_;
-};
-
-TEST_F(VideoCapturerTest, CaptureState) {
-  EXPECT_TRUE(capturer_->enable_video_adapter());
-  EXPECT_EQ(cricket::CS_RUNNING,
-            capturer_->Start(cricket::VideoFormat(
-                640, 480, cricket::VideoFormat::FpsToInterval(30),
-                cricket::FOURCC_I420)));
-  EXPECT_TRUE(capturer_->IsRunning());
-  EXPECT_EQ_WAIT(cricket::CS_RUNNING, capture_state(), kMsCallbackWait);
-  EXPECT_EQ(1, num_state_changes());
-  capturer_->Stop();
-  EXPECT_EQ_WAIT(cricket::CS_STOPPED, capture_state(), kMsCallbackWait);
-  EXPECT_EQ(2, num_state_changes());
-  capturer_->Stop();
-  rtc::Thread::Current()->ProcessMessages(100);
-  EXPECT_EQ(2, num_state_changes());
-}
-
-TEST_F(VideoCapturerTest, ScreencastScaledOddWidth) {
-  InitScreencast();
-
-  int kWidth = 1281;
-  int kHeight = 720;
-
-  std::vector<cricket::VideoFormat> formats;
-  formats.push_back(cricket::VideoFormat(kWidth, kHeight,
-                                         cricket::VideoFormat::FpsToInterval(5),
-                                         cricket::FOURCC_I420));
-  capturer_->ResetSupportedFormats(formats);
-
-  EXPECT_EQ(cricket::CS_RUNNING,
-            capturer_->Start(cricket::VideoFormat(
-                kWidth, kHeight, cricket::VideoFormat::FpsToInterval(30),
-                cricket::FOURCC_I420)));
-  EXPECT_TRUE(capturer_->IsRunning());
-  EXPECT_EQ(0, renderer_.num_rendered_frames());
-  EXPECT_TRUE(capturer_->CaptureFrame());
-  EXPECT_EQ(1, renderer_.num_rendered_frames());
-  EXPECT_EQ(kWidth, renderer_.width());
-  EXPECT_EQ(kHeight, renderer_.height());
-}
-
-TEST_F(VideoCapturerTest, TestRotationAppliedBySource) {
-  int kWidth = 800;
-  int kHeight = 400;
-  int frame_count = 0;
-
-  std::vector<cricket::VideoFormat> formats;
-  formats.push_back(cricket::VideoFormat(kWidth, kHeight,
-                                         cricket::VideoFormat::FpsToInterval(5),
-                                         cricket::FOURCC_I420));
-
-  capturer_->ResetSupportedFormats(formats);
-  rtc::VideoSinkWants wants;
-  // |capturer_| should compensate rotation.
-  wants.rotation_applied = true;
-  capturer_->AddOrUpdateSink(&renderer_, wants);
-
-  // capturer_ should compensate rotation as default.
-  EXPECT_EQ(cricket::CS_RUNNING,
-            capturer_->Start(cricket::VideoFormat(
-                kWidth, kHeight, cricket::VideoFormat::FpsToInterval(30),
-                cricket::FOURCC_I420)));
-  EXPECT_TRUE(capturer_->IsRunning());
-  EXPECT_EQ(0, renderer_.num_rendered_frames());
-
-  // If the frame's rotation is compensated anywhere in the pipeline based on
-  // the rotation information, the renderer should be given the right dimension
-  // such that the frame could be rendered.
-
-  capturer_->SetRotation(webrtc::kVideoRotation_90);
-  EXPECT_TRUE(capturer_->CaptureFrame());
-  EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
-  // Swapped width and height
-  EXPECT_EQ(kWidth, renderer_.height());
-  EXPECT_EQ(kHeight, renderer_.width());
-  EXPECT_EQ(webrtc::kVideoRotation_0, renderer_.rotation());
-
-  capturer_->SetRotation(webrtc::kVideoRotation_270);
-  EXPECT_TRUE(capturer_->CaptureFrame());
-  EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
-  // Swapped width and height
-  EXPECT_EQ(kWidth, renderer_.height());
-  EXPECT_EQ(kHeight, renderer_.width());
-  EXPECT_EQ(webrtc::kVideoRotation_0, renderer_.rotation());
-
-  capturer_->SetRotation(webrtc::kVideoRotation_180);
-  EXPECT_TRUE(capturer_->CaptureFrame());
-  EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
-  // Back to normal width and height
-  EXPECT_EQ(kWidth, renderer_.width());
-  EXPECT_EQ(kHeight, renderer_.height());
-  EXPECT_EQ(webrtc::kVideoRotation_0, renderer_.rotation());
-}
-
-TEST_F(VideoCapturerTest, TestRotationAppliedBySinkByDefault) {
-  int kWidth = 800;
-  int kHeight = 400;
-
-  std::vector<cricket::VideoFormat> formats;
-  formats.push_back(cricket::VideoFormat(kWidth, kHeight,
-                                         cricket::VideoFormat::FpsToInterval(5),
-                                         cricket::FOURCC_I420));
-
-  capturer_->ResetSupportedFormats(formats);
-
-  EXPECT_EQ(cricket::CS_RUNNING,
-            capturer_->Start(cricket::VideoFormat(
-                kWidth, kHeight, cricket::VideoFormat::FpsToInterval(30),
-                cricket::FOURCC_I420)));
-  EXPECT_TRUE(capturer_->IsRunning());
-  EXPECT_EQ(0, renderer_.num_rendered_frames());
-
-  // If the frame's rotation is compensated anywhere in the pipeline, the frame
-  // won't have its original dimension out from capturer. Since the renderer
-  // here has the same dimension as the capturer, it will skip that frame as the
-  // resolution won't match anymore.
-
-  int frame_count = 0;
-  capturer_->SetRotation(webrtc::kVideoRotation_0);
-  EXPECT_TRUE(capturer_->CaptureFrame());
-  EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
-  EXPECT_EQ(capturer_->GetRotation(), renderer_.rotation());
-
-  capturer_->SetRotation(webrtc::kVideoRotation_90);
-  EXPECT_TRUE(capturer_->CaptureFrame());
-  EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
-  EXPECT_EQ(capturer_->GetRotation(), renderer_.rotation());
-
-  capturer_->SetRotation(webrtc::kVideoRotation_180);
-  EXPECT_TRUE(capturer_->CaptureFrame());
-  EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
-  EXPECT_EQ(capturer_->GetRotation(), renderer_.rotation());
-
-  capturer_->SetRotation(webrtc::kVideoRotation_270);
-  EXPECT_TRUE(capturer_->CaptureFrame());
-  EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
-  EXPECT_EQ(capturer_->GetRotation(), renderer_.rotation());
-}
-
-TEST_F(VideoCapturerTest, TestRotationAppliedBySourceWhenDifferentWants) {
-  int kWidth = 800;
-  int kHeight = 400;
-
-  std::vector<cricket::VideoFormat> formats;
-  formats.push_back(cricket::VideoFormat(kWidth, kHeight,
-                                         cricket::VideoFormat::FpsToInterval(5),
-                                         cricket::FOURCC_I420));
-
-  capturer_->ResetSupportedFormats(formats);
-  rtc::VideoSinkWants wants;
-  // capturer_ should not compensate rotation.
-  wants.rotation_applied = false;
-  capturer_->AddOrUpdateSink(&renderer_, wants);
-
-  EXPECT_EQ(cricket::CS_RUNNING,
-            capturer_->Start(cricket::VideoFormat(
-                kWidth, kHeight, cricket::VideoFormat::FpsToInterval(30),
-                cricket::FOURCC_I420)));
-  EXPECT_TRUE(capturer_->IsRunning());
-  EXPECT_EQ(0, renderer_.num_rendered_frames());
-
-  int frame_count = 0;
-  capturer_->SetRotation(webrtc::kVideoRotation_90);
-  EXPECT_TRUE(capturer_->CaptureFrame());
-  EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
-  EXPECT_EQ(capturer_->GetRotation(), renderer_.rotation());
-
-  // Add another sink that wants frames to be rotated.
-  cricket::FakeVideoRenderer renderer2;
-  wants.rotation_applied = true;
-  capturer_->AddOrUpdateSink(&renderer2, wants);
-
-  EXPECT_TRUE(capturer_->CaptureFrame());
-  EXPECT_EQ(++frame_count, renderer_.num_rendered_frames());
-  EXPECT_EQ(1, renderer2.num_rendered_frames());
-  EXPECT_EQ(webrtc::kVideoRotation_0, renderer_.rotation());
-  EXPECT_EQ(webrtc::kVideoRotation_0, renderer2.rotation());
-}
-
-// TODO(nisse): This test doesn't quite fit here. It tests two things:
-// Aggregation of VideoSinkWants, which is the responsibility of
-// VideoBroadcaster, and translation of VideoSinkWants to actual
-// resolution, which is the responsibility of the VideoAdapter.
-TEST_F(VideoCapturerTest, SinkWantsMaxPixelAndMaxPixelCountStepUp) {
-  EXPECT_EQ(cricket::CS_RUNNING,
-            capturer_->Start(cricket::VideoFormat(
-                1280, 720, cricket::VideoFormat::FpsToInterval(30),
-                cricket::FOURCC_I420)));
-  EXPECT_TRUE(capturer_->IsRunning());
-
-  EXPECT_EQ(0, renderer_.num_rendered_frames());
-  EXPECT_TRUE(capturer_->CaptureFrame());
-  EXPECT_EQ(1, renderer_.num_rendered_frames());
-  EXPECT_EQ(1280, renderer_.width());
-  EXPECT_EQ(720, renderer_.height());
-
-  // Request a lower resolution. The output resolution will have a resolution
-  // with less than or equal to |wants.max_pixel_count| depending on how the
-  // capturer can scale the input frame size.
-  rtc::VideoSinkWants wants;
-  wants.max_pixel_count = 1280 * 720 * 3 / 5;
-  capturer_->AddOrUpdateSink(&renderer_, wants);
-  EXPECT_TRUE(capturer_->CaptureFrame());
-  EXPECT_EQ(2, renderer_.num_rendered_frames());
-  EXPECT_EQ(960, renderer_.width());
-  EXPECT_EQ(540, renderer_.height());
-
-  // Request a lower resolution.
-  wants.max_pixel_count = (renderer_.width() * renderer_.height() * 3) / 5;
-  capturer_->AddOrUpdateSink(&renderer_, wants);
-  EXPECT_TRUE(capturer_->CaptureFrame());
-  EXPECT_EQ(3, renderer_.num_rendered_frames());
-  EXPECT_EQ(640, renderer_.width());
-  EXPECT_EQ(360, renderer_.height());
-
-  // Adding a new renderer should not affect resolution.
-  cricket::FakeVideoRenderer renderer2;
-  capturer_->AddOrUpdateSink(&renderer2, rtc::VideoSinkWants());
-  EXPECT_TRUE(capturer_->CaptureFrame());
-  EXPECT_EQ(4, renderer_.num_rendered_frames());
-  EXPECT_EQ(640, renderer_.width());
-  EXPECT_EQ(360, renderer_.height());
-  EXPECT_EQ(1, renderer2.num_rendered_frames());
-  EXPECT_EQ(640, renderer2.width());
-  EXPECT_EQ(360, renderer2.height());
-
-  // Request higher resolution.
-  wants.target_pixel_count.emplace((wants.max_pixel_count * 5) / 3);
-  wants.max_pixel_count = wants.max_pixel_count * 4;
-  capturer_->AddOrUpdateSink(&renderer_, wants);
-  EXPECT_TRUE(capturer_->CaptureFrame());
-  EXPECT_EQ(5, renderer_.num_rendered_frames());
-  EXPECT_EQ(960, renderer_.width());
-  EXPECT_EQ(540, renderer_.height());
-  EXPECT_EQ(2, renderer2.num_rendered_frames());
-  EXPECT_EQ(960, renderer2.width());
-  EXPECT_EQ(540, renderer2.height());
-
-  // Updating with no wants should not affect resolution.
-  capturer_->AddOrUpdateSink(&renderer2, rtc::VideoSinkWants());
-  EXPECT_TRUE(capturer_->CaptureFrame());
-  EXPECT_EQ(6, renderer_.num_rendered_frames());
-  EXPECT_EQ(960, renderer_.width());
-  EXPECT_EQ(540, renderer_.height());
-  EXPECT_EQ(3, renderer2.num_rendered_frames());
-  EXPECT_EQ(960, renderer2.width());
-  EXPECT_EQ(540, renderer2.height());
-
-  // But resetting the wants should reset the resolution to what the camera is
-  // opened with.
-  capturer_->AddOrUpdateSink(&renderer_, rtc::VideoSinkWants());
-  EXPECT_TRUE(capturer_->CaptureFrame());
-  EXPECT_EQ(7, renderer_.num_rendered_frames());
-  EXPECT_EQ(1280, renderer_.width());
-  EXPECT_EQ(720, renderer_.height());
-  EXPECT_EQ(4, renderer2.num_rendered_frames());
-  EXPECT_EQ(1280, renderer2.width());
-  EXPECT_EQ(720, renderer2.height());
-}
-
-TEST_F(VideoCapturerTest, TestFourccMatch) {
-  cricket::VideoFormat desired(
-      640, 480, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_ANY);
-  cricket::VideoFormat best;
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &best));
-  EXPECT_EQ(640, best.width);
-  EXPECT_EQ(480, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
-
-  desired.fourcc = cricket::FOURCC_MJPG;
-  EXPECT_FALSE(capturer_->GetBestCaptureFormat(desired, &best));
-
-  desired.fourcc = cricket::FOURCC_I420;
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &best));
-}
-
-TEST_F(VideoCapturerTest, TestResolutionMatch) {
-  cricket::VideoFormat desired(
-      1920, 1080, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_ANY);
-  cricket::VideoFormat best;
-  // Ask for 1920x1080. Get HD 1280x720 which is the highest.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &best));
-  EXPECT_EQ(1280, best.width);
-  EXPECT_EQ(720, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
-
-  desired.width = 360;
-  desired.height = 250;
-  // Ask for a little higher than QVGA. Get QVGA.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &best));
-  EXPECT_EQ(320, best.width);
-  EXPECT_EQ(240, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
-
-  desired.width = 480;
-  desired.height = 270;
-  // Ask for HVGA. Get VGA.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &best));
-  EXPECT_EQ(640, best.width);
-  EXPECT_EQ(480, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
-
-  desired.width = 320;
-  desired.height = 240;
-  // Ask for QVGA. Get QVGA.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &best));
-  EXPECT_EQ(320, best.width);
-  EXPECT_EQ(240, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
-
-  desired.width = 80;
-  desired.height = 60;
-  // Ask for lower than QQVGA. Get QQVGA, which is the lowest.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &best));
-  EXPECT_EQ(160, best.width);
-  EXPECT_EQ(120, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
-}
-
-TEST_F(VideoCapturerTest, TestHDResolutionMatch) {
-  // Add some HD formats typical of a mediocre HD webcam.
-  std::vector<cricket::VideoFormat> formats;
-  formats.push_back(cricket::VideoFormat(
-      320, 240, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  formats.push_back(cricket::VideoFormat(
-      640, 480, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  formats.push_back(cricket::VideoFormat(
-      960, 544, cricket::VideoFormat::FpsToInterval(24), cricket::FOURCC_I420));
-  formats.push_back(
-      cricket::VideoFormat(1280, 720, cricket::VideoFormat::FpsToInterval(15),
-                           cricket::FOURCC_I420));
-  formats.push_back(cricket::VideoFormat(2592, 1944,
-                                         cricket::VideoFormat::FpsToInterval(7),
-                                         cricket::FOURCC_I420));
-  capturer_->ResetSupportedFormats(formats);
-
-  cricket::VideoFormat desired(
-      960, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_ANY);
-  cricket::VideoFormat best;
-  // Ask for 960x720 30 fps. Get qHD 24 fps
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &best));
-  EXPECT_EQ(960, best.width);
-  EXPECT_EQ(544, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(24), best.interval);
-
-  desired.width = 960;
-  desired.height = 544;
-  desired.interval = cricket::VideoFormat::FpsToInterval(30);
-  // Ask for qHD 30 fps. Get qHD 24 fps
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &best));
-  EXPECT_EQ(960, best.width);
-  EXPECT_EQ(544, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(24), best.interval);
-
-  desired.width = 360;
-  desired.height = 250;
-  desired.interval = cricket::VideoFormat::FpsToInterval(30);
-  // Ask for a little higher than QVGA. Get QVGA.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &best));
-  EXPECT_EQ(320, best.width);
-  EXPECT_EQ(240, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
-
-  desired.width = 480;
-  desired.height = 270;
-  // Ask for HVGA. Get VGA.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &best));
-  EXPECT_EQ(640, best.width);
-  EXPECT_EQ(480, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
-
-  desired.width = 320;
-  desired.height = 240;
-  // Ask for QVGA. Get QVGA.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &best));
-  EXPECT_EQ(320, best.width);
-  EXPECT_EQ(240, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
-
-  desired.width = 160;
-  desired.height = 120;
-  // Ask for lower than QVGA. Get QVGA, which is the lowest.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &best));
-  EXPECT_EQ(320, best.width);
-  EXPECT_EQ(240, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
-
-  desired.width = 1280;
-  desired.height = 720;
-  // Ask for HD. 720p fps is too low. Get VGA which has 30 fps.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &best));
-  EXPECT_EQ(640, best.width);
-  EXPECT_EQ(480, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
-
-  desired.width = 1280;
-  desired.height = 720;
-  desired.interval = cricket::VideoFormat::FpsToInterval(15);
-  // Ask for HD 15 fps. Fps matches. Get HD
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &best));
-  EXPECT_EQ(1280, best.width);
-  EXPECT_EQ(720, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(15), best.interval);
-
-  desired.width = 1920;
-  desired.height = 1080;
-  desired.interval = cricket::VideoFormat::FpsToInterval(30);
-  // Ask for 1080p. Fps of HD formats is too low. Get VGA which can do 30 fps.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(desired, &best));
-  EXPECT_EQ(640, best.width);
-  EXPECT_EQ(480, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
-}
-
-// Some cameras support 320x240 and 320x640. Verify we choose 320x240.
-TEST_F(VideoCapturerTest, TestStrangeFormats) {
-  std::vector<cricket::VideoFormat> supported_formats;
-  supported_formats.push_back(cricket::VideoFormat(
-      320, 240, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      320, 640, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  capturer_->ResetSupportedFormats(supported_formats);
-
-  std::vector<cricket::VideoFormat> required_formats;
-  required_formats.push_back(cricket::VideoFormat(
-      320, 240, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  required_formats.push_back(cricket::VideoFormat(
-      320, 200, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  required_formats.push_back(cricket::VideoFormat(
-      320, 180, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  cricket::VideoFormat best;
-  for (size_t i = 0; i < required_formats.size(); ++i) {
-    EXPECT_TRUE(capturer_->GetBestCaptureFormat(required_formats[i], &best));
-    EXPECT_EQ(320, best.width);
-    EXPECT_EQ(240, best.height);
-  }
-
-  supported_formats.clear();
-  supported_formats.push_back(cricket::VideoFormat(
-      320, 640, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      320, 240, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  capturer_->ResetSupportedFormats(supported_formats);
-
-  for (size_t i = 0; i < required_formats.size(); ++i) {
-    EXPECT_TRUE(capturer_->GetBestCaptureFormat(required_formats[i], &best));
-    EXPECT_EQ(320, best.width);
-    EXPECT_EQ(240, best.height);
-  }
-}
-
-// Some cameras only have very low fps. Verify we choose something sensible.
-TEST_F(VideoCapturerTest, TestPoorFpsFormats) {
-  // all formats are low framerate
-  std::vector<cricket::VideoFormat> supported_formats;
-  supported_formats.push_back(cricket::VideoFormat(
-      320, 240, cricket::VideoFormat::FpsToInterval(10), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 480, cricket::VideoFormat::FpsToInterval(7), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      1280, 720, cricket::VideoFormat::FpsToInterval(2), cricket::FOURCC_I420));
-  capturer_->ResetSupportedFormats(supported_formats);
-
-  std::vector<cricket::VideoFormat> required_formats;
-  required_formats.push_back(cricket::VideoFormat(
-      320, 240, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  required_formats.push_back(cricket::VideoFormat(
-      640, 480, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  cricket::VideoFormat best;
-  for (size_t i = 0; i < required_formats.size(); ++i) {
-    EXPECT_TRUE(capturer_->GetBestCaptureFormat(required_formats[i], &best));
-    EXPECT_EQ(required_formats[i].width, best.width);
-    EXPECT_EQ(required_formats[i].height, best.height);
-  }
-
-  // Increase framerate of 320x240. Expect low fps VGA avoided.
-  supported_formats.clear();
-  supported_formats.push_back(cricket::VideoFormat(
-      320, 240, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 480, cricket::VideoFormat::FpsToInterval(7), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      1280, 720, cricket::VideoFormat::FpsToInterval(2), cricket::FOURCC_I420));
-  capturer_->ResetSupportedFormats(supported_formats);
-
-  for (size_t i = 0; i < required_formats.size(); ++i) {
-    EXPECT_TRUE(capturer_->GetBestCaptureFormat(required_formats[i], &best));
-    EXPECT_EQ(320, best.width);
-    EXPECT_EQ(240, best.height);
-  }
-}
-
-// Some cameras support same size with different frame rates. Verify we choose
-// the frame rate properly.
-TEST_F(VideoCapturerTest, TestSameSizeDifferentFpsFormats) {
-  std::vector<cricket::VideoFormat> supported_formats;
-  supported_formats.push_back(cricket::VideoFormat(
-      320, 240, cricket::VideoFormat::FpsToInterval(10), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      320, 240, cricket::VideoFormat::FpsToInterval(20), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      320, 240, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  capturer_->ResetSupportedFormats(supported_formats);
-
-  std::vector<cricket::VideoFormat> required_formats = supported_formats;
-  cricket::VideoFormat best;
-  for (size_t i = 0; i < required_formats.size(); ++i) {
-    EXPECT_TRUE(capturer_->GetBestCaptureFormat(required_formats[i], &best));
-    EXPECT_EQ(320, best.width);
-    EXPECT_EQ(240, best.height);
-    EXPECT_EQ(required_formats[i].interval, best.interval);
-  }
-}
-
-// Some cameras support the correct resolution but at a lower fps than
-// we'd like. This tests we get the expected resolution and fps.
-TEST_F(VideoCapturerTest, TestFpsFormats) {
-  // We have VGA but low fps. Choose VGA, not HD
-  std::vector<cricket::VideoFormat> supported_formats;
-  supported_formats.push_back(
-      cricket::VideoFormat(1280, 720, cricket::VideoFormat::FpsToInterval(30),
-                           cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 480, cricket::VideoFormat::FpsToInterval(15), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 400, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 360, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  capturer_->ResetSupportedFormats(supported_formats);
-
-  std::vector<cricket::VideoFormat> required_formats;
-  required_formats.push_back(cricket::VideoFormat(
-      640, 480, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_ANY));
-  required_formats.push_back(cricket::VideoFormat(
-      640, 480, cricket::VideoFormat::FpsToInterval(20), cricket::FOURCC_ANY));
-  required_formats.push_back(cricket::VideoFormat(
-      640, 480, cricket::VideoFormat::FpsToInterval(10), cricket::FOURCC_ANY));
-  cricket::VideoFormat best;
-
-  // Expect 30 fps to choose 30 fps format.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(required_formats[0], &best));
-  EXPECT_EQ(640, best.width);
-  EXPECT_EQ(400, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
-
-  // Expect 20 fps to choose 30 fps format.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(required_formats[1], &best));
-  EXPECT_EQ(640, best.width);
-  EXPECT_EQ(400, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), best.interval);
-
-  // Expect 10 fps to choose 15 fps format and set fps to 15.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(required_formats[2], &best));
-  EXPECT_EQ(640, best.width);
-  EXPECT_EQ(480, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(15), best.interval);
-
-  // We have VGA 60 fps and 15 fps. Choose best fps.
-  supported_formats.clear();
-  supported_formats.push_back(
-      cricket::VideoFormat(1280, 720, cricket::VideoFormat::FpsToInterval(30),
-                           cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 480, cricket::VideoFormat::FpsToInterval(60), cricket::FOURCC_MJPG));
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 480, cricket::VideoFormat::FpsToInterval(15), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 400, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 360, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  capturer_->ResetSupportedFormats(supported_formats);
-
-  // Expect 30 fps to choose 60 fps format and will set best fps to 60.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(required_formats[0], &best));
-  EXPECT_EQ(640, best.width);
-  EXPECT_EQ(480, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(60), best.interval);
-
-  // Expect 20 fps to choose 60 fps format, and will set best fps to 60.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(required_formats[1], &best));
-  EXPECT_EQ(640, best.width);
-  EXPECT_EQ(480, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(60), best.interval);
-
-  // Expect 10 fps to choose 15 fps.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(required_formats[2], &best));
-  EXPECT_EQ(640, best.width);
-  EXPECT_EQ(480, best.height);
-  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(15), best.interval);
-}
-
-TEST_F(VideoCapturerTest, TestRequest16x10_9) {
-  std::vector<cricket::VideoFormat> supported_formats;
-  // We do not support HD, expect 4x3 for 4x3, 16x10, and 16x9 requests.
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 480, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 400, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 360, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  capturer_->ResetSupportedFormats(supported_formats);
-
-  std::vector<cricket::VideoFormat> required_formats = supported_formats;
-  cricket::VideoFormat best;
-  // Expect 4x3, 16x10, and 16x9 requests are respected.
-  for (size_t i = 0; i < required_formats.size(); ++i) {
-    EXPECT_TRUE(capturer_->GetBestCaptureFormat(required_formats[i], &best));
-    EXPECT_EQ(required_formats[i].width, best.width);
-    EXPECT_EQ(required_formats[i].height, best.height);
-  }
-
-  // We do not support 16x9 HD, expect 4x3 for 4x3, 16x10, and 16x9 requests.
-  supported_formats.clear();
-  supported_formats.push_back(cricket::VideoFormat(
-      960, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 480, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 400, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 360, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  capturer_->ResetSupportedFormats(supported_formats);
-
-  // Expect 4x3, 16x10, and 16x9 requests are respected.
-  for (size_t i = 0; i < required_formats.size(); ++i) {
-    EXPECT_TRUE(capturer_->GetBestCaptureFormat(required_formats[i], &best));
-    EXPECT_EQ(required_formats[i].width, best.width);
-    EXPECT_EQ(required_formats[i].height, best.height);
-  }
-
-  // We support 16x9HD, Expect 4x3, 16x10, and 16x9 requests are respected.
-  supported_formats.clear();
-  supported_formats.push_back(
-      cricket::VideoFormat(1280, 720, cricket::VideoFormat::FpsToInterval(30),
-                           cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 480, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 400, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  supported_formats.push_back(cricket::VideoFormat(
-      640, 360, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420));
-  capturer_->ResetSupportedFormats(supported_formats);
-
-  // Expect 4x3 for 4x3 and 16x10 requests.
-  for (size_t i = 0; i < required_formats.size() - 1; ++i) {
-    EXPECT_TRUE(capturer_->GetBestCaptureFormat(required_formats[i], &best));
-    EXPECT_EQ(required_formats[i].width, best.width);
-    EXPECT_EQ(required_formats[i].height, best.height);
-  }
-
-  // Expect 16x9 for 16x9 request.
-  EXPECT_TRUE(capturer_->GetBestCaptureFormat(required_formats[2], &best));
-  EXPECT_EQ(640, best.width);
-  EXPECT_EQ(360, best.height);
-}
-
-bool HdFormatInList(const std::vector<cricket::VideoFormat>& formats) {
-  for (std::vector<cricket::VideoFormat>::const_iterator found =
-           formats.begin();
-       found != formats.end(); ++found) {
-    if (found->height >= kMinHdHeight) {
-      return true;
-    }
-  }
-  return false;
-}
-
-TEST_F(VideoCapturerTest, Whitelist) {
-  // The definition of HD only applies to the height. Set the HD width to the
-  // smallest legal number to document this fact in this test.
-  const int kMinHdWidth = 1;
-  cricket::VideoFormat hd_format(kMinHdWidth, kMinHdHeight,
-                                 cricket::VideoFormat::FpsToInterval(30),
-                                 cricket::FOURCC_I420);
-  cricket::VideoFormat vga_format(
-      640, 480, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420);
-  std::vector<cricket::VideoFormat> formats = *capturer_->GetSupportedFormats();
-  formats.push_back(hd_format);
-
-  // Enable whitelist. Expect HD not in list.
-  capturer_->set_enable_camera_list(true);
-  capturer_->ResetSupportedFormats(formats);
-  EXPECT_TRUE(HdFormatInList(*capturer_->GetSupportedFormats()));
-  capturer_->ConstrainSupportedFormats(vga_format);
-  EXPECT_FALSE(HdFormatInList(*capturer_->GetSupportedFormats()));
-
-  // Disable whitelist. Expect HD in list.
-  capturer_->set_enable_camera_list(false);
-  capturer_->ResetSupportedFormats(formats);
-  EXPECT_TRUE(HdFormatInList(*capturer_->GetSupportedFormats()));
-  capturer_->ConstrainSupportedFormats(vga_format);
-  EXPECT_TRUE(HdFormatInList(*capturer_->GetSupportedFormats()));
-}
-
-TEST_F(VideoCapturerTest, BlacklistAllFormats) {
-  cricket::VideoFormat vga_format(
-      640, 480, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420);
-  std::vector<cricket::VideoFormat> supported_formats;
-  // Mock a device that only supports HD formats.
-  supported_formats.push_back(
-      cricket::VideoFormat(1280, 720, cricket::VideoFormat::FpsToInterval(30),
-                           cricket::FOURCC_I420));
-  supported_formats.push_back(
-      cricket::VideoFormat(1920, 1080, cricket::VideoFormat::FpsToInterval(30),
-                           cricket::FOURCC_I420));
-  capturer_->ResetSupportedFormats(supported_formats);
-  EXPECT_EQ(2u, capturer_->GetSupportedFormats()->size());
-  // Now, enable the list, which would exclude both formats. However, since
-  // only HD formats are available, we refuse to filter at all, so we don't
-  // break this camera.
-  capturer_->set_enable_camera_list(true);
-  capturer_->ConstrainSupportedFormats(vga_format);
-  EXPECT_EQ(2u, capturer_->GetSupportedFormats()->size());
-  // To make sure it's not just the camera list being broken, add in VGA and
-  // try again. This time, only the VGA format should be there.
-  supported_formats.push_back(vga_format);
-  capturer_->ResetSupportedFormats(supported_formats);
-  ASSERT_EQ(1u, capturer_->GetSupportedFormats()->size());
-  EXPECT_EQ(vga_format.height, capturer_->GetSupportedFormats()->at(0).height);
-}
diff --git a/pc/peer_connection_interface_unittest.cc b/pc/peer_connection_interface_unittest.cc
index 8e22261..3803b7f 100644
--- a/pc/peer_connection_interface_unittest.cc
+++ b/pc/peer_connection_interface_unittest.cc
@@ -49,7 +49,6 @@
 #include "media/base/media_config.h"
 #include "media/base/media_engine.h"
 #include "media/base/stream_params.h"
-#include "media/base/video_capturer.h"
 #include "media/engine/webrtc_media_engine.h"
 #include "media/sctp/sctp_transport_internal.h"
 #include "modules/audio_device/include/audio_device.h"