Move direct use of VideoCapturer::VideoAdapter to VideoSinkWants.

webrtc/media/base/videoadapter.h

 /*
  *  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 83 matching lines @@
   typedef int AdaptReason;
 
   CoordinatedVideoAdapter();
   virtual ~CoordinatedVideoAdapter() {}
 
   virtual void SetInputFormat(const VideoFormat& format);
 
   // Enable or disable video adaptation due to the change of the CPU load.
   void set_cpu_adaptation(bool enable) { cpu_adaptation_ = enable; }
   bool cpu_adaptation() const { return cpu_adaptation_; }
-  // Enable or disable smoothing when doing CPU adaptation. When smoothing is
-  // enabled, system CPU load is tracked using an exponential weighted
-  // average.
-  void set_cpu_smoothing(bool enable);
-  bool cpu_smoothing() const { return cpu_smoothing_; }
   // Enable or disable video adaptation due to the change of the GD
   void set_gd_adaptation(bool enable) { gd_adaptation_ = enable; }
   bool gd_adaptation() const { return gd_adaptation_; }
   // Enable or disable video adaptation due to the change of the View
   void set_view_adaptation(bool enable) { view_adaptation_ = enable; }
   bool view_adaptation() const { return view_adaptation_; }
   // Enable or disable video adaptation to fast switch View
   void set_view_switch(bool enable) { view_switch_ = enable; }
   bool view_switch() const { return view_switch_; }
 
   CoordinatedVideoAdapter::AdaptReason adapt_reason() const {
     return adapt_reason_;
   }
 
-  // When the video is decreased, set the waiting time for CPU adaptation to
-  // decrease video again.
-  void set_cpu_load_min_samples(int cpu_load_min_samples);
-  int cpu_load_min_samples() const { return cpu_load_min_samples_; }
-  // CPU system load high threshold for reducing resolution.  e.g. 0.85f
-  void set_high_system_threshold(float high_system_threshold);
-  float high_system_threshold() const { return high_system_threshold_; }
-  // CPU system load low threshold for increasing resolution.  e.g. 0.70f
-  void set_low_system_threshold(float low_system_threshold);
-  float low_system_threshold() const { return low_system_threshold_; }
-  // CPU process load threshold for reducing resolution.  e.g. 0.10f
-  void set_process_threshold(float process_threshold);
-  float process_threshold() const { return process_threshold_; }

[pthatcher1, 2016/02/17 23:05:56]

Do we not need all this anymore, or did it get moved?

[perkj_webrtc, 2016/02/18 13:22:46]

void OnCpuResolutionRequest(AdaptRequest request) and 
void OnOutputFormatRequest(const VideoFormat& format) seems to be the only one
we use. 
I  added void OnLimitResolution(int max_number_of_pixels) and removed
OnCpuResolutionRequest and removed void OnCpuLoadUpdated(int current_cpus, int
max_cpus, float process_load, float system_load); 

But then all those other setters and getters did not do anything so I removed
them.

[nisse-webrtc, 2016/02/18 14:03:42]

Would it simplify things with a separate cl deleting the unused functions?

[pthatcher1, 2016/02/19 06:08:39]

That's exactly what I was thinking.

-
   // Handle the format request from the server via Jingle update message.
   void OnOutputFormatRequest(const VideoFormat& format);
+  void OnLimitResolution(int max_number_of_pixels);
   // Handle the resolution request from the encoder due to bandwidth changes.
   void OnEncoderResolutionRequest(int width, int height, AdaptRequest request);
-  // Handle the resolution request for CPU overuse.
-  void OnCpuResolutionRequest(AdaptRequest request);
-  // Handle the CPU load provided by a CPU monitor.
-  void OnCpuLoadUpdated(int current_cpus, int max_cpus,
-                        float process_load, float system_load);
-
-  sigslot::signal0<> SignalCpuAdaptationUnable;
 
  private:
   // Adapt to the minimum of the formats the server requests, the CPU wants, and
   // the encoder wants. Returns true if resolution changed.
   bool AdaptToMinimumFormat(int* new_width, int* new_height);
   bool IsMinimumFormat(int pixels);
   void StepPixelCount(CoordinatedVideoAdapter::AdaptRequest request,
                       int* num_pixels);
   CoordinatedVideoAdapter::AdaptRequest FindCpuRequest(
     int current_cpus, int max_cpus,
     float process_load, float system_load);
 
   bool cpu_adaptation_;  // True if cpu adaptation is enabled.
   bool cpu_smoothing_;  // True if cpu smoothing is enabled (with adaptation).
   bool gd_adaptation_;  // True if gd adaptation is enabled.
   bool view_adaptation_;  // True if view adaptation is enabled.
   bool view_switch_;  // True if view switch is enabled.
-  int cpu_downgrade_count_;
-  int cpu_load_min_samples_;
-  int cpu_load_num_samples_;
-  // cpu system load thresholds relative to max cpus.
-  float high_system_threshold_;
-  float low_system_threshold_;
-  // cpu process load thresholds relative to current cpus.
-  float process_threshold_;
+
   // Video formats that the server view requests, the CPU wants, and the encoder
   // wants respectively. The adapted output format is the minimum of these.
   int view_desired_num_pixels_;
   int64_t view_desired_interval_;
   int encoder_desired_num_pixels_;
   int cpu_desired_num_pixels_;
   CoordinatedVideoAdapter::AdaptReason adapt_reason_;
   // The critical section to protect handling requests.
   rtc::CriticalSection request_critical_section_;
 
   // The weighted average of cpu load over time. It's always updated (if cpu
   // adaptation is on), but only used if cpu_smoothing_ is set.
   float system_load_average_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(CoordinatedVideoAdapter);
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_BASE_VIDEOADAPTER_H_  // NOLINT