Move direct use of VideoCapturer::VideoAdapter to VideoSinkWants.

webrtc/media/base/videoadapter.cc

 /*
  *  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.
  */
 
@@ skipping 477 matching lines @@
 
   LOG(LS_INFO) << "VAdapt GD Request: "
                << (DOWNGRADE == request ? "down" :
                    (UPGRADE == request ? "up" : "keep"))
                << " From: " << width << "x" << height
                << " Pixels: " << encoder_desired_num_pixels_
                << " Changed: " << (changed ? "true" : "false")
                << " To: " << new_width << "x" << new_height;
 }
 
+void CoordinatedVideoAdapter::OnCpuResolutionRequest(
+    rtc::Optional<int> max_pixel_count,
+    rtc::Optional<int> max_pixel_count_step_up) {
+  rtc::CritScope cs(&request_critical_section_);
+  // TODO(perkj): We should support taking larger steps up and down and
+  // actually look at the values set in max_pixel_count and
+  // max_pixel_count_step_up.
+  if (max_pixel_count && *max_pixel_count < GetOutputNumPixels()) {
+    OnCpuResolutionRequest(DOWNGRADE);
+  } else if (max_pixel_count_step_up &&
+             *max_pixel_count_step_up >= GetOutputNumPixels()) {
+    OnCpuResolutionRequest(UPGRADE);

[pbos-webrtc, 2016/02/26 14:26:18]

Should we take this lock recursively or can you annotate OnCpuResolutionRequest?

+  }
+}
+
 // A Bandwidth GD request for new resolution
 void CoordinatedVideoAdapter::OnCpuResolutionRequest(AdaptRequest request) {
   rtc::CritScope cs(&request_critical_section_);
   if (!cpu_adaptation_) {
     return;
   }
+
   // Update how many times we have downgraded due to the cpu load.
   switch (request) {
     case DOWNGRADE:
       // Ignore downgrades if we have downgraded the maximum times.
       if (cpu_downgrade_count_ < kMaxCpuDowngrades) {
         ++cpu_downgrade_count_;
       } else {
         LOG(LS_VERBOSE) << "VAdapt CPU load high but do not downgrade "
                            "because maximum downgrades reached";
         SignalCpuAdaptationUnable();
@@ skipping 179 matching lines @@
     // When any adaptation occurs, historic CPU load levels are no longer
     // accurate. Clear out our state so we can re-learn at the new normal.
     cpu_load_num_samples_ = 0;
     system_load_average_ = kCpuLoadInitialAverage;
   }
 
   return changed;
 }
 
 }  // namespace cricket