(Auto)update libjingle 73927658-> 73927775

git-svn-id: http://webrtc.googlecode.com/svn/trunk@6958 4adac7df-926f-26a2-2b94-8c16560cd09d

talk/examples/call/callclient.cc

@@ -889,10 +889,8 @@ bool CallClient::PlaceCall(const std::string& name,
     AddSession(call_->InitiateSession(jid, media_client_->jid(), options));
   }
   media_client_->SetFocus(call_);
-  if (call_->has_video() && render_) {
-    if (!options.is_muc) {
-      call_->SetLocalRenderer(local_renderer_);
-    }
+  if (call_->has_video() && render_ && !options.is_muc) {
+    // TODO(pthatcher): Hookup local_render_ to the local capturer.
   }
   if (options.is_muc) {
     const std::string& nick = mucs_[jid]->local_jid().resource();
@@ -1086,7 +1084,7 @@ void CallClient::Accept(const cricket::CallOptions& options) {
   call_->AcceptSession(session, options);
   media_client_->SetFocus(call_);
   if (call_->has_video() && render_) {
-    call_->SetLocalRenderer(local_renderer_);
+    // TODO(pthatcher): Hookup local_render_ to the local capturer.
     RenderAllStreams(call_, session, true);
   }
   SetupAcceptedCall();

talk/media/base/fakemediaengine.h

@@ -868,7 +868,7 @@ class FakeVoiceEngine : public FakeBaseEngine {
 
 class FakeVideoEngine : public FakeBaseEngine {
  public:
-  FakeVideoEngine() : renderer_(NULL), capture_(false), processor_(NULL) {
+  FakeVideoEngine() : capture_(false), processor_(NULL) {
     // Add a fake video codec. Note that the name must not be "" as there are
     // sanity checks against that.
     codecs_.push_back(VideoCodec(0, "fake_video_codec", 0, 0, 0, 0));
@@ -926,10 +926,6 @@ class FakeVideoEngine : public FakeBaseEngine {
     options_changed_ = true;
     return true;
   }
-  bool SetLocalRenderer(VideoRenderer* r) {
-    renderer_ = r;
-    return true;
-  }
   bool SetCapture(bool capture) {
     capture_ = capture;
     return true;
@@ -946,7 +942,6 @@ class FakeVideoEngine : public FakeBaseEngine {
   std::vector<VideoCodec> codecs_;
   VideoEncoderConfig default_encoder_config_;
   std::string in_device_;
-  VideoRenderer* renderer_;
   bool capture_;
   VideoProcessor* processor_;
   VideoOptions options_;
@@ -994,7 +989,6 @@ class FakeMediaEngine :
   }
   const std::string& audio_in_device() const { return voice_.in_device_; }
   const std::string& audio_out_device() const { return voice_.out_device_; }
-  VideoRenderer* local_renderer() { return video_.renderer_; }
   int voice_loglevel() const { return voice_.loglevel_; }
   const std::string& voice_logfilter() const { return voice_.logfilter_; }
   int video_loglevel() const { return video_.loglevel_; }

talk/media/base/filemediaengine.h

@@ -113,7 +113,6 @@ class FileMediaEngine : public MediaEngineInterface {
   virtual bool SetOutputVolume(int level) { return true; }
   virtual int GetInputLevel() { return 0; }
   virtual bool SetLocalMonitor(bool enable) { return true; }
-  virtual bool SetLocalRenderer(VideoRenderer* renderer) { return true; }
   // TODO(whyuan): control channel send?
   virtual bool SetVideoCapture(bool capture) { return true; }
   virtual const std::vector<AudioCodec>& audio_codecs() {

talk/media/base/filemediaengine_unittest.cc

@@ -232,7 +232,6 @@ TEST_F(FileMediaEngineTest, TestDefaultImplementation) {
   EXPECT_TRUE(engine_->SetOutputVolume(0));
   EXPECT_EQ(0, engine_->GetInputLevel());
   EXPECT_TRUE(engine_->SetLocalMonitor(true));
-  EXPECT_TRUE(engine_->SetLocalRenderer(NULL));
   EXPECT_TRUE(engine_->SetVideoCapture(true));
   EXPECT_EQ(0U, engine_->audio_codecs().size());
   EXPECT_EQ(0U, engine_->video_codecs().size());

talk/media/base/hybridvideoengine.h

@@ -245,9 +245,6 @@ class HybridVideoEngine : public HybridVideoEngineInterface {
   VideoCapturer* GetVideoCapturer() const {
     return video2_.GetVideoCapturer();
   }
-  bool SetLocalRenderer(VideoRenderer* renderer) {
-    return video2_.SetLocalRenderer(renderer);
-  }
   sigslot::repeater2<VideoCapturer*, CaptureState> SignalCaptureStateChange;
 
   virtual bool HasCodec1(const VideoCodec& codec) {

talk/media/base/mediaengine.h

@@ -124,7 +124,6 @@ class MediaEngineInterface {
   // when a VoiceMediaChannel starts sending.
   virtual bool SetLocalMonitor(bool enable) = 0;
   // Installs a callback for raw frames from the local camera.
-  virtual bool SetLocalRenderer(VideoRenderer* renderer) = 0;
 
   virtual const std::vector<AudioCodec>& audio_codecs() = 0;
   virtual const std::vector<RtpHeaderExtension>&
@@ -245,10 +244,6 @@ class CompositeMediaEngine : public MediaEngineInterface {
   virtual bool SetLocalMonitor(bool enable) {
     return voice_.SetLocalMonitor(enable);
   }
-  virtual bool SetLocalRenderer(VideoRenderer* renderer) {
-    return video_.SetLocalRenderer(renderer);
-  }
-
   virtual const std::vector<AudioCodec>& audio_codecs() {
     return voice_.codecs();
   }
@@ -361,7 +356,6 @@ class NullVideoEngine {
   bool SetDefaultEncoderConfig(const VideoEncoderConfig& config) {
     return true;
   }
-  bool SetLocalRenderer(VideoRenderer* renderer) { return true; }
   const std::vector<VideoCodec>& codecs() { return codecs_; }
   const std::vector<RtpHeaderExtension>& rtp_header_extensions() {
     return rtp_header_extensions_;

talk/media/other/linphonemediaengine.h

@@ -81,7 +81,6 @@ class LinphoneMediaEngine : public MediaEngineInterface {
   virtual bool SetOutputVolume(int level) { return true; }
   virtual int GetInputLevel() { return 0; }
   virtual bool SetLocalMonitor(bool enable) { return true; }
-  virtual bool SetLocalRenderer(VideoRenderer* renderer) { return true; }
   // TODO: control channel send?
   virtual bool SetVideoCapture(bool capture) { return true; }
   virtual const std::vector<AudioCodec>& audio_codecs() {

talk/media/webrtc/webrtcvideoengine.cc

@@ -926,8 +926,6 @@ void WebRtcVideoEngine::Construct(ViEWrapper* vie_wrapper,
   initialized_ = false;
   SetTraceFilter(SeverityToFilter(kDefaultLogSeverity));
   render_module_.reset(new WebRtcPassthroughRender());
-  local_renderer_w_ = local_renderer_h_ = 0;
-  local_renderer_ = NULL;
   capture_started_ = false;
   decoder_factory_ = NULL;
   encoder_factory_ = NULL;
@@ -1109,12 +1107,6 @@ WebRtcVideoMediaChannel* WebRtcVideoEngine::CreateChannel(
   return channel;
 }
 
-bool WebRtcVideoEngine::SetLocalRenderer(VideoRenderer* renderer) {
-  local_renderer_w_ = local_renderer_h_ = 0;
-  local_renderer_ = renderer;
-  return true;
-}
-
 const std::vector<VideoCodec>& WebRtcVideoEngine::codecs() const {
   return video_codecs_;
 }

talk/media/webrtc/webrtcvideoengine.h

@@ -115,7 +115,6 @@ class WebRtcVideoEngine : public sigslot::has_slots<>,
   const std::vector<RtpHeaderExtension>& rtp_header_extensions() const;
   void SetLogging(int min_sev, const char* filter);
 
-  bool SetLocalRenderer(VideoRenderer* renderer);
   sigslot::repeater2<VideoCapturer*, CaptureState> SignalCaptureStateChange;
 
   // Set the VoiceEngine for A/V sync. This can only be called before Init.
@@ -225,9 +224,6 @@ class WebRtcVideoEngine : public sigslot::has_slots<>,
   VideoChannels channels_;
 
   bool capture_started_;
-  int local_renderer_w_;
-  int local_renderer_h_;
-  VideoRenderer* local_renderer_;
 
   rtc::scoped_ptr<rtc::CpuMonitor> cpu_monitor_;
 };

talk/media/webrtc/webrtcvideoengine2.cc

@@ -429,12 +429,6 @@ bool WebRtcVideoEngine2::EnableTimedRender() {
   return true;
 }
 
-bool WebRtcVideoEngine2::SetLocalRenderer(VideoRenderer* renderer) {
-  // TODO(pbos): Implement or remove. Unclear which stream should be rendered
-  // locally even.
-  return true;
-}
-
 // Checks to see whether we comprehend and could receive a particular codec
 bool WebRtcVideoEngine2::FindCodec(const VideoCodec& in) {
   // TODO(pbos): Probe encoder factory to figure out that the codec is supported

talk/media/webrtc/webrtcvideoengine2.h

@@ -154,8 +154,6 @@ class WebRtcVideoEngine2 : public sigslot::has_slots<> {
   void SetLogging(int min_sev, const char* filter);
 
   bool EnableTimedRender();
-  // No-op, never used.
-  bool SetLocalRenderer(VideoRenderer* renderer);
   // This is currently ignored.
   sigslot::repeater2<VideoCapturer*, CaptureState> SignalCaptureStateChange;
 

talk/session/media/call.cc

@@ -94,7 +94,6 @@ void AudioSourceProxy::OnMediaStreamsUpdate(Call* call, Session* session,
 Call::Call(MediaSessionClient* session_client)
     : id_(rtc::CreateRandomId()),
       session_client_(session_client),
-      local_renderer_(NULL),
       has_video_(false),
       has_data_(false),
       muted_(false),
@@ -207,13 +206,6 @@ bool Call::SendViewRequest(Session* session,
   return session->SendInfoMessage(elems, session->remote_name());
 }
 
-void Call::SetLocalRenderer(VideoRenderer* renderer) {
-  local_renderer_ = renderer;
-  if (session_client_->GetFocus() == this) {
-    session_client_->channel_manager()->SetLocalRenderer(renderer);
-  }
-}
-
 void Call::SetVideoRenderer(Session* session, uint32 ssrc,
                             VideoRenderer* renderer) {
   VideoChannel* video_channel = GetVideoChannel(session);
@@ -418,8 +410,6 @@ void Call::EnableChannels(bool enable) {
   for (it = media_session_map_.begin(); it != media_session_map_.end(); ++it) {
     EnableSessionChannels(it->second.session, enable);
   }
-  session_client_->channel_manager()->SetLocalRenderer(
-      (enable) ? local_renderer_ : NULL);
 }
 
 void Call::EnableSessionChannels(Session* session, bool enable) {

talk/session/media/call.h

@@ -96,7 +96,6 @@ class Call : public rtc::MessageHandler, public sigslot::has_slots<> {
   void Terminate();
   bool SendViewRequest(Session* session,
                        const ViewRequest& view_request);
-  void SetLocalRenderer(VideoRenderer* renderer);
   void SetVideoRenderer(Session* session, uint32 ssrc,
                         VideoRenderer* renderer);
   void StartConnectionMonitor(Session* session, int cms);
@@ -284,7 +283,6 @@ class Call : public rtc::MessageHandler, public sigslot::has_slots<> {
   MediaSessionMap media_session_map_;
 
   std::map<std::string, CurrentSpeakerMonitor*> speaker_monitor_map_;
-  VideoRenderer* local_renderer_;
   bool has_video_;
   bool has_data_;
   bool muted_;

talk/session/media/channelmanager.cc

@@ -277,10 +277,6 @@ bool ChannelManager::Init() {
       if (default_video_encoder_config_.max_codec.id != 0) {
         SetDefaultVideoEncoderConfig(default_video_encoder_config_);
       }
-      // And the local renderer.
-      if (local_renderer_) {
-        SetLocalRenderer(local_renderer_);
-      }
     }
   }
   return initialized_;
@@ -750,19 +746,6 @@ bool ChannelManager::SetLocalMonitor(bool enable) {
   return ret;
 }
 
-bool ChannelManager::SetLocalRenderer(VideoRenderer* renderer) {
-  bool ret = true;
-  if (initialized_) {
-    ret = worker_thread_->Invoke<bool>(
-        Bind(&MediaEngineInterface::SetLocalRenderer,
-             media_engine_.get(), renderer));
-  }
-  if (ret) {
-    local_renderer_ = renderer;
-  }
-  return ret;
-}
-
 void ChannelManager::SetVoiceLogging(int level, const char* filter) {
   if (initialized_) {
     worker_thread_->Invoke<void>(

talk/session/media/channelmanager.h

@@ -170,8 +170,6 @@ class ChannelManager : public rtc::MessageHandler,
   // Starts/stops the local microphone and enables polling of the input level.
   bool SetLocalMonitor(bool enable);
   bool monitoring() const { return monitoring_; }
-  // Sets the local renderer where to renderer the local camera.
-  bool SetLocalRenderer(VideoRenderer* renderer);
   bool capturing() const { return capturing_; }
 
   // Configures the logging output of the mediaengine(s).

talk/session/media/channelmanager_unittest.cc

@@ -509,22 +509,6 @@ TEST_F(ChannelManagerTest, GetSetOutputVolume) {
   EXPECT_EQ(60, level);
 }
 
-// Test that a value set before Init is applied properly.
-TEST_F(ChannelManagerTest, SetLocalRendererBeforeInit) {
-  cricket::NullVideoRenderer renderer;
-  EXPECT_TRUE(cm_->SetLocalRenderer(&renderer));
-  EXPECT_TRUE(cm_->Init());
-  EXPECT_EQ(&renderer, fme_->local_renderer());
-}
-
-// Test that a value set after init is passed through properly.
-TEST_F(ChannelManagerTest, SetLocalRenderer) {
-  cricket::NullVideoRenderer renderer;
-  EXPECT_TRUE(cm_->Init());
-  EXPECT_TRUE(cm_->SetLocalRenderer(&renderer));
-  EXPECT_EQ(&renderer, fme_->local_renderer());
-}
-
 // Test that logging options set before Init are applied properly,
 // and retained even after Init.
 TEST_F(ChannelManagerTest, SetLoggingBeforeInit) {