Remove CaptureManager and related calls in ChannelManager.

webrtc/pc/channel.cc

 /*
  *  Copyright 2004 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 22 matching lines @@
 bool SetRawAudioSink_w(VoiceMediaChannel* channel,
                        uint32_t ssrc,
                        rtc::scoped_ptr<webrtc::AudioSinkInterface>* sink) {
   channel->SetRawAudioSink(ssrc, rtc::ScopedToUnique(std::move(*sink)));
   return true;
 }
 }  // namespace
 
 enum {
   MSG_EARLYMEDIATIMEOUT = 1,
-  MSG_SCREENCASTWINDOWEVENT,
   MSG_RTPPACKET,
   MSG_RTCPPACKET,
   MSG_CHANNEL_ERROR,
   MSG_READYTOSENDDATA,
   MSG_DATARECEIVED,
   MSG_FIRSTPACKETRECEIVED,
   MSG_STREAMCLOSEDREMOTELY,
 };
 
 // Value specified in RFC 5764.
 static const char kDtlsSrtpExporterLabel[] = "EXTRACTOR-dtls_srtp";
 
 static const int kAgcMinus10db = -10;
 
 static void SafeSetError(const std::string& message, std::string* error_desc) {
   if (error_desc) {
     *error_desc = message;
   }
 }
 
 struct PacketMessageData : public rtc::MessageData {
   rtc::Buffer packet;
   rtc::PacketOptions options;
 };
 
-struct ScreencastEventMessageData : public rtc::MessageData {
-  ScreencastEventMessageData(uint32_t s, rtc::WindowEvent we)
-      : ssrc(s), event(we) {}
-  uint32_t ssrc;
-  rtc::WindowEvent event;
-};
-
 struct VoiceChannelErrorMessageData : public rtc::MessageData {
   VoiceChannelErrorMessageData(uint32_t in_ssrc,
                                VoiceMediaChannel::Error in_error)
       : ssrc(in_ssrc), error(in_error) {}
   uint32_t ssrc;
   VoiceMediaChannel::Error error;
 };
 
 struct VideoChannelErrorMessageData : public rtc::MessageData {
   VideoChannelErrorMessageData(uint32_t in_ssrc,
@@ skipping 1539 matching lines @@
 
 VideoChannel::VideoChannel(rtc::Thread* thread,
                            VideoMediaChannel* media_channel,
                            TransportController* transport_controller,
                            const std::string& content_name,
                            bool rtcp)
     : BaseChannel(thread,
                   media_channel,
                   transport_controller,
                   content_name,
-                  rtcp),
-      previous_we_(rtc::WE_CLOSE) {}
+                  rtcp) {}
 
 bool VideoChannel::Init() {
   if (!BaseChannel::Init()) {
     return false;
   }
   return true;
 }
 
 VideoChannel::~VideoChannel() {
-  std::vector<uint32_t> screencast_ssrcs;
-  ScreencastMap::iterator iter;
-  while (!screencast_capturers_.empty()) {
-    if (!RemoveScreencast(screencast_capturers_.begin()->first)) {
-      LOG(LS_ERROR) << "Unable to delete screencast with ssrc "
-                    << screencast_capturers_.begin()->first;
-      ASSERT(false);
-      break;
-    }
-  }
-
   StopMediaMonitor();
   // this can't be done in the base class, since it calls a virtual
   DisableMedia_w();
 
   Deinit();
 }
 
 bool VideoChannel::SetSink(uint32_t ssrc,
                            rtc::VideoSinkInterface<VideoFrame>* sink) {
   worker_thread()->Invoke<void>(
       Bind(&VideoMediaChannel::SetSink, media_channel(), ssrc, sink));
   return true;
 }
 
-bool VideoChannel::AddScreencast(uint32_t ssrc, VideoCapturer* capturer) {
-  return worker_thread()->Invoke<bool>(Bind(
-      &VideoChannel::AddScreencast_w, this, ssrc, capturer));
-}
-
 bool VideoChannel::SetCapturer(uint32_t ssrc, VideoCapturer* capturer) {
   return InvokeOnWorker(Bind(&VideoMediaChannel::SetCapturer,
                              media_channel(), ssrc, capturer));
 }
 
-bool VideoChannel::RemoveScreencast(uint32_t ssrc) {
-  return InvokeOnWorker(Bind(&VideoChannel::RemoveScreencast_w, this, ssrc));
-}
-
-bool VideoChannel::IsScreencasting() {
-  return InvokeOnWorker(Bind(&VideoChannel::IsScreencasting_w, this));
-}
-
 bool VideoChannel::SetVideoSend(uint32_t ssrc,
                                 bool mute,
                                 const VideoOptions* options) {
   return InvokeOnWorker(Bind(&VideoMediaChannel::SetVideoSend, media_channel(),
                              ssrc, mute, options));
 }
 
 void VideoChannel::ChangeState() {
   // Send outgoing data if we're the active call, we have the remote content,
   // and we have had some form of connectivity.
@@ skipping 119 matching lines @@
 
   if (video->rtp_header_extensions_set()) {
     MaybeCacheRtpAbsSendTimeHeaderExtension(video->rtp_header_extensions());
   }
 
   set_remote_content_direction(content->direction());
   ChangeState();
   return true;
 }
 
-bool VideoChannel::AddScreencast_w(uint32_t ssrc, VideoCapturer* capturer) {
-  if (screencast_capturers_.find(ssrc) != screencast_capturers_.end()) {
-    return false;
-  }
-  capturer->SignalStateChange.connect(this, &VideoChannel::OnStateChange);
-  screencast_capturers_[ssrc] = capturer;
-  return true;
-}
-
-bool VideoChannel::RemoveScreencast_w(uint32_t ssrc) {
-  ScreencastMap::iterator iter = screencast_capturers_.find(ssrc);
-  if (iter  == screencast_capturers_.end()) {
-    return false;
-  }
-  // Clean up VideoCapturer.
-  delete iter->second;
-  screencast_capturers_.erase(iter);
-  return true;
-}
-
-bool VideoChannel::IsScreencasting_w() const {
-  return !screencast_capturers_.empty();
-}
-
-void VideoChannel::OnScreencastWindowEvent_s(uint32_t ssrc,
-                                             rtc::WindowEvent we) {
-  ASSERT(signaling_thread() == rtc::Thread::Current());
-  SignalScreencastWindowEvent(ssrc, we);
-}
-
 void VideoChannel::OnMessage(rtc::Message *pmsg) {
   switch (pmsg->message_id) {
-    case MSG_SCREENCASTWINDOWEVENT: {
-      const ScreencastEventMessageData* data =
-          static_cast<ScreencastEventMessageData*>(pmsg->pdata);
-      OnScreencastWindowEvent_s(data->ssrc, data->event);
-      delete data;
-      break;
-    }
     case MSG_CHANNEL_ERROR: {
       const VideoChannelErrorMessageData* data =
           static_cast<VideoChannelErrorMessageData*>(pmsg->pdata);
       delete data;
       break;
     }
     default:
       BaseChannel::OnMessage(pmsg);
       break;
   }
 }
 
 void VideoChannel::OnConnectionMonitorUpdate(
     ConnectionMonitor* monitor, const std::vector<ConnectionInfo> &infos) {
   SignalConnectionMonitor(this, infos);
 }
 
 // TODO(pthatcher): Look into removing duplicate code between
 // audio, video, and data, perhaps by using templates.
 void VideoChannel::OnMediaMonitorUpdate(
     VideoMediaChannel* media_channel, const VideoMediaInfo &info) {
   ASSERT(media_channel == this->media_channel());
   SignalMediaMonitor(this, info);
 }
 
-void VideoChannel::OnScreencastWindowEvent(uint32_t ssrc,
-                                           rtc::WindowEvent event) {
-  ScreencastEventMessageData* pdata =
-      new ScreencastEventMessageData(ssrc, event);
-  signaling_thread()->Post(this, MSG_SCREENCASTWINDOWEVENT, pdata);
-}
-
-void VideoChannel::OnStateChange(VideoCapturer* capturer, CaptureState ev) {
-  // Map capturer events to window events. In the future we may want to simply
-  // pass these events up directly.
-  rtc::WindowEvent we;
-  if (ev == CS_STOPPED) {
-    we = rtc::WE_CLOSE;
-  } else if (ev == CS_PAUSED) {
-    we = rtc::WE_MINIMIZE;
-  } else if (ev == CS_RUNNING && previous_we_ == rtc::WE_MINIMIZE) {
-    we = rtc::WE_RESTORE;
-  } else {
-    return;
-  }
-  previous_we_ = we;
-
-  uint32_t ssrc = 0;
-  if (!GetLocalSsrc(capturer, &ssrc)) {
-    return;
-  }
-
-  OnScreencastWindowEvent(ssrc, we);
-}
-
-bool VideoChannel::GetLocalSsrc(const VideoCapturer* capturer, uint32_t* ssrc) {
-  *ssrc = 0;
-  for (ScreencastMap::iterator iter = screencast_capturers_.begin();
-       iter != screencast_capturers_.end(); ++iter) {
-    if (iter->second == capturer) {
-      *ssrc = iter->first;
-      return true;
-    }
-  }
-  return false;
-}
-
 void VideoChannel::GetSrtpCryptoSuites(std::vector<int>* crypto_suites) const {
   GetSupportedVideoCryptoSuites(crypto_suites);
 }
 
 DataChannel::DataChannel(rtc::Thread* thread,
                          DataMediaChannel* media_channel,
                          TransportController* transport_controller,
                          const std::string& content_name,
                          bool rtcp)
     : BaseChannel(thread,
@@ skipping 304 matching lines @@
   return (data_channel_type_ == DCT_RTP) && BaseChannel::ShouldSetupDtlsSrtp();
 }
 
 void DataChannel::OnStreamClosedRemotely(uint32_t sid) {
   rtc::TypedMessageData<uint32_t>* message =
       new rtc::TypedMessageData<uint32_t>(sid);
   signaling_thread()->Post(this, MSG_STREAMCLOSEDREMOTELY, message);
 }
 
 }  // namespace cricket