Replace SetCapturer and SetCaptureDevice by SetSource.

webrtc/media/base/videosourceinterface.h

 /*
  *  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 18 matching lines @@
   // Tells the source the maximum number of pixels the sink wants.
   rtc::Optional<int> max_pixel_count;
   // Like |max_pixel_count| but relative to the given value. The source is
   // requested to produce frames with a resolution one "step up" from the given
   // value. In practice, this means that the sink can consume this amount of
   // pixels but wants more and the source should produce a resolution one
   // "step" higher than this but not higher.
   rtc::Optional<int> max_pixel_count_step_up;
 };
 
+struct VideoSourceInfo {
+  // Original frame size, before video adaptation.
+  int orig_width = 0;
+  int orig_height = 0;
+};
+
 template <typename VideoFrameT>
 class VideoSourceInterface {
  public:
   virtual void AddOrUpdateSink(VideoSinkInterface<VideoFrameT>* sink,
                                const VideoSinkWants& wants) = 0;
   // RemoveSink must guarantee that at the time the method returns,
   // there is no current and no future calls to VideoSinkInterface::OnFrame.
   virtual void RemoveSink(VideoSinkInterface<VideoFrameT>* sink) = 0;
-
+  virtual void GetInfo(VideoSourceInfo *info) = 0;

[perkj_webrtc, 2016/03/20 15:01:46]

So we have the option of adding some kind of stats API here. It might make sense
to me but if there are other options lets discuss them. 

Another option is to have the original size in the frame. But that does not make
sense to me in the case when a frame has already been scaled. Ie, it does not
make sence to have information about an original frame size when the memory used
by the actual frame buffer do not have the original size. Ie, say that two sinks
wants the same frame size and therefore the frame is scaled in the source. In
that case, the stats API should probably still say that the original size is the
size the capturer runs at. Also - a capturer may choose to only color convert as
much as is needed by a sink, that may be less than the original size.

A third option - why bother at all? Why not just store the frame size first seen
in webrtcvideoengine2::sendstream before any CPU adaptation or bandwidth
estimation kicks in? That would of course not give you the correct size if the
capturer actually reconfigure itself but that currently does not happen. I think
I vote for this option because it is the simplest.

[nisse-webrtc, 2016/03/21 09:18:50]

I've tried the third approach now. I like the simplicity.

The input_frame_width and _height now gets the size of the first frame seen
after SetSource. I guess this won't be totally correct in all cases (e.g., set a
source, have it undergo some adaptation, switch to a different source, then
switch back to the first one). But maybe it's good enough for now? And there
seems to be no tests for this feature. 

  protected:
   virtual ~VideoSourceInterface() {}
 };
 
 }  // namespace rtc
 #endif  // WEBRTC_MEDIA_BASE_VIDEOSOURCEINTERFACE_H_