Move direct use of VideoCapturer::VideoAdapter to VideoSinkWants.

webrtc/media/base/videobroadcaster.cc

 /*
  *  Copyright (c) 2016 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 15 matching lines @@
 
   SinkPair* sink_pair = FindSinkPair(sink);
   if (!sink_pair) {
     sinks_.push_back(SinkPair(sink, wants));
   } else {
     sink_pair->wants = wants;
   }
 
   // Rotation must be applied by the source if one sink wants it.
   current_wants_.rotation_applied = false;
+  current_wants_.max_number_of_pixels = std::numeric_limits<int>::max();

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

Would it make more sense to use an Optional<int>?

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

In the interface yes.. but maybe the implementation got worse..

   for (auto& sink_pair : sinks_) {
     current_wants_.rotation_applied |= sink_pair.wants.rotation_applied;
+
+    if (current_wants_.max_number_of_pixels >
+        sink_pair.wants.max_number_of_pixels) {
+      current_wants_.max_number_of_pixels =
+          sink_pair.wants.max_number_of_pixels;
+    }

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

We should document that a local preview sink/renderer will cause the full
resolution to be sent from a track.  So, for this to affect encoding, we need to
make sure that the adapter is attached  down the pipeline after the local
preview is attached to the track.  

I'm not so sure this CL puts the adapter in the right place.

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

This is not intended to change the current behavior or move the adapter. ie -
adaptation affect all sinks - including local preview. 
This selects max_number_of_pixels based on the the sink with lowest
requirements.

   }
 }
 
 void VideoBroadcaster::RemoveSink(
     VideoSinkInterface<cricket::VideoFrame>* sink) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(sink != nullptr);
   RTC_DCHECK(FindSinkPair(sink));
 
   sinks_.erase(std::remove_if(sinks_.begin(), sinks_.end(),
                               [sink](const SinkPair& sink_pair) {
                                 return sink_pair.sink == sink;
                               }),
                sinks_.end());
 }
 
 bool VideoBroadcaster::frame_wanted() const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   return !sinks_.empty();
 }
 
 VideoSinkWants VideoBroadcaster::wants() const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   return current_wants_;
 }
 
 void VideoBroadcaster::OnFrame(const cricket::VideoFrame& frame) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  width_ = frame.GetWidth();
+  height_ = frame.GetHeight();
   for (auto& sink_pair : sinks_) {
     sink_pair.sink->OnFrame(frame);
   }
 }
 
 VideoBroadcaster::SinkPair* VideoBroadcaster::FindSinkPair(
     const VideoSinkInterface<cricket::VideoFrame>* sink) {
   auto sink_pair_it = std::find_if(
       sinks_.begin(), sinks_.end(),
       [sink](const SinkPair& sink_pair) { return sink_pair.sink == sink; });
   if (sink_pair_it != sinks_.end()) {
     return &*sink_pair_it;
   }
   return nullptr;
 }
 
 }  // namespace rtc