Replace AudioScheduler with AudioPump.

remoting/host/client_session.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/host/client_session.h"
 
 #include <algorithm>
 
 #include "base/message_loop/message_loop_proxy.h"
 #include "remoting/base/capabilities.h"
 #include "remoting/base/logging.h"
 #include "remoting/codec/audio_encoder.h"
 #include "remoting/codec/audio_encoder_opus.h"
 #include "remoting/codec/audio_encoder_verbatim.h"
 #include "remoting/codec/video_encoder.h"
 #include "remoting/codec/video_encoder_verbatim.h"
 #include "remoting/codec/video_encoder_vpx.h"
 #include "remoting/host/audio_capturer.h"
-#include "remoting/host/audio_scheduler.h"
+#include "remoting/host/audio_pump.h"
 #include "remoting/host/desktop_capturer_proxy.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/host_extension_session.h"
 #include "remoting/host/input_injector.h"
 #include "remoting/host/mouse_shape_pump.h"
 #include "remoting/host/screen_controls.h"
 #include "remoting/host/screen_resolution.h"
 #include "remoting/host/video_frame_pump.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/clipboard_thread_proxy.h"
 #include "remoting/protocol/pairing_registry.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor_monitor.h"
 
 // Default DPI to assume for old clients that use notifyClientDimensions.
 const int kDefaultDPI = 96;
 
 namespace remoting {
 
+namespace {
+
+scoped_ptr<VideoEncoder> CreateVideoEncoder(
+    const protocol::SessionConfig& config) {
+  const protocol::ChannelConfig& video_config = config.video_config();
+
+  if (video_config.codec == protocol::ChannelConfig::CODEC_VP8) {
+    return VideoEncoderVpx::CreateForVP8().Pass();
+  } else if (video_config.codec == protocol::ChannelConfig::CODEC_VP9) {
+    return VideoEncoderVpx::CreateForVP9().Pass();
+  } else if (video_config.codec == protocol::ChannelConfig::CODEC_VERBATIM) {
+    return make_scoped_ptr(new VideoEncoderVerbatim());
+  }
+
+  NOTREACHED();
+  return nullptr;
+}
+
+scoped_ptr<AudioEncoder> CreateAudioEncoder(
+    const protocol::SessionConfig& config) {
+  const protocol::ChannelConfig& audio_config = config.audio_config();
+
+  if (audio_config.codec == protocol::ChannelConfig::CODEC_VERBATIM) {
+    return make_scoped_ptr(new AudioEncoderVerbatim());
+  } else if (audio_config.codec == protocol::ChannelConfig::CODEC_OPUS) {
+    return make_scoped_ptr(new AudioEncoderOpus());
+  }
+
+  NOTREACHED();
+  return nullptr;
+}
+
+}  // namespace
+
 ClientSession::ClientSession(
     EventHandler* event_handler,
     scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     scoped_ptr<protocol::ConnectionToClient> connection,
     DesktopEnvironmentFactory* desktop_environment_factory,
@@ skipping 42 matching lines @@
 
 #if defined(OS_WIN)
   // LocalInputMonitorWin filters out an echo of the injected input before it
   // reaches |remote_input_filter_|.
   remote_input_filter_.SetExpectLocalEcho(false);
 #endif  // defined(OS_WIN)
 }
 
 ClientSession::~ClientSession() {
   DCHECK(CalledOnValidThread());
-  DCHECK(!audio_scheduler_.get());
+  DCHECK(!audio_pump_);
   DCHECK(!desktop_environment_);
   DCHECK(!input_injector_);
   DCHECK(!screen_controls_);
-  DCHECK(!video_frame_pump_.get());
+  DCHECK(!video_frame_pump_);
 
   connection_.reset();
 }
 
 void ClientSession::NotifyClientResolution(
     const protocol::ClientResolution& resolution) {
   DCHECK(CalledOnValidThread());
 
   // TODO(sergeyu): Move these checks to protocol layer.
   if (!resolution.has_dips_width() || !resolution.has_dips_height() ||
@@ skipping 45 matching lines @@
       video_frame_pump_->SetLosslessColor(lossless_video_color_);
   }
 }
 
 void ClientSession::ControlAudio(const protocol::AudioControl& audio_control) {
   DCHECK(CalledOnValidThread());
 
   if (audio_control.has_enable()) {
     VLOG(1) << "Received AudioControl (enable="
             << audio_control.enable() << ")";
-    if (audio_scheduler_.get())
-      audio_scheduler_->Pause(!audio_control.enable());
+    if (audio_pump_)
+      audio_pump_->Pause(!audio_control.enable());
   }
 }
 
 void ClientSession::SetCapabilities(
     const protocol::Capabilities& capabilities) {
   DCHECK(CalledOnValidThread());
 
   // Ignore all the messages but the 1st one.
   if (client_capabilities_) {
     LOG(WARNING) << "protocol::Capabilities has been received already.";
@@ skipping 57 matching lines @@
 
 void ClientSession::OnConnectionAuthenticating(
     protocol::ConnectionToClient* connection) {
   event_handler_->OnSessionAuthenticating(this);
 }
 
 void ClientSession::OnConnectionAuthenticated(
     protocol::ConnectionToClient* connection) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(connection_.get(), connection);
-  DCHECK(!audio_scheduler_.get());
+  DCHECK(!audio_pump_);
   DCHECK(!desktop_environment_);
   DCHECK(!input_injector_);
   DCHECK(!screen_controls_);
-  DCHECK(!video_frame_pump_.get());
+  DCHECK(!video_frame_pump_);
 
   auth_input_filter_.set_enabled(true);
   auth_clipboard_filter_.set_enabled(true);
 
   clipboard_echo_filter_.set_client_stub(connection_->client_stub());
   mouse_clamping_filter_.set_video_stub(connection_->video_stub());
 
   if (max_duration_ > base::TimeDelta()) {
     // TODO(simonmorris): Let Disconnect() tell the client that the
     // disconnection was caused by the session exceeding its maximum duration.
@@ skipping 25 matching lines @@
   // Create the object that controls the screen resolution.
   screen_controls_ = desktop_environment_->CreateScreenControls();
 
   // Create the event executor.
   input_injector_ = desktop_environment_->CreateInputInjector();
 
   // Connect the host clipboard and input stubs.
   host_input_filter_.set_input_stub(input_injector_.get());
   clipboard_echo_filter_.set_host_stub(input_injector_.get());
 
-  // Create an AudioScheduler if audio is enabled, to pump audio samples.
-  if (connection_->session()->config().is_audio_enabled()) {
-    scoped_ptr<AudioEncoder> audio_encoder =
-        CreateAudioEncoder(connection_->session()->config());
-    audio_scheduler_ = new AudioScheduler(
-        audio_task_runner_,
-        network_task_runner_,
-        desktop_environment_->CreateAudioCapturer(),
-        audio_encoder.Pass(),
-        connection_->audio_stub());
-  }
-
   // Create a GnubbyAuthHandler to proxy gnubbyd messages.
   gnubby_auth_handler_ = desktop_environment_->CreateGnubbyAuthHandler(
       connection_->client_stub());
 }
 
 void ClientSession::OnConnectionChannelsConnected(
     protocol::ConnectionToClient* connection) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(connection_.get(), connection);
 
   // Negotiate capabilities with the client.
   VLOG(1) << "Host capabilities: " << host_capabilities_;
 
   protocol::Capabilities capabilities;
   capabilities.set_capabilities(host_capabilities_);
   connection_->client_stub()->SetCapabilities(capabilities);
 
   // Start the event executor.
   input_injector_->Start(CreateClipboardProxy());
   SetDisableInputs(false);
 
   // Start recording video.
   ResetVideoPipeline();
 
-  // Start recording audio.
-  if (connection_->session()->config().is_audio_enabled())
-    audio_scheduler_->Start();
+  // Create an AudioPump if audio is enabled, to pump audio samples.
+  if (connection_->session()->config().is_audio_enabled()) {
+    scoped_ptr<AudioEncoder> audio_encoder =
+        CreateAudioEncoder(connection_->session()->config());
+    audio_pump_.reset(new AudioPump(
+        audio_task_runner_, desktop_environment_->CreateAudioCapturer(),
+        audio_encoder.Pass(), connection_->audio_stub()));
+  }
 
   // Notify the event handler that all our channels are now connected.
   event_handler_->OnSessionChannelsConnected(this);
 }
 
 void ClientSession::OnConnectionClosed(
     protocol::ConnectionToClient* connection,
     protocol::ErrorCode error) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(connection_.get(), connection);
 
   // Ignore any further callbacks.
   weak_factory_.InvalidateWeakPtrs();
 
   // If the client never authenticated then the session failed.
   if (!auth_input_filter_.enabled())
     event_handler_->OnSessionAuthenticationFailed(this);
 
   // Block any further input events from the client.
   // TODO(wez): Fix ChromotingHost::OnSessionClosed not to check our
   // is_authenticated(), so that we can disable |auth_*_filter_| here.
   disable_input_filter_.set_enabled(false);
   disable_clipboard_filter_.set_enabled(false);
 
   // Ensure that any pressed keys or buttons are released.
   input_tracker_.ReleaseAll();
 
   // Stop components access the client, audio or video stubs, which are no
   // longer valid once ConnectionToClient calls OnConnectionClosed().
-  if (audio_scheduler_.get()) {
-    audio_scheduler_->Stop();
-    audio_scheduler_ = nullptr;
-  }
-
+  audio_pump_.reset();
   video_frame_pump_.reset();
   mouse_shape_pump_.reset();
-
   client_clipboard_factory_.InvalidateWeakPtrs();
   input_injector_.reset();
   screen_controls_.reset();
   desktop_environment_.reset();
 
   // Notify the ChromotingHost that this client is disconnected.
   // TODO(sergeyu): Log failure reason?
   event_handler_->OnSessionClosed(this);
 }
 
@@ skipping 95 matching lines @@
 }
 
 scoped_ptr<protocol::ClipboardStub> ClientSession::CreateClipboardProxy() {
   DCHECK(CalledOnValidThread());
 
   return make_scoped_ptr(
       new protocol::ClipboardThreadProxy(client_clipboard_factory_.GetWeakPtr(),
                                          base::MessageLoopProxy::current()));
 }
 
-// TODO(sergeyu): Move this to SessionManager?
-// static
-scoped_ptr<VideoEncoder> ClientSession::CreateVideoEncoder(
-    const protocol::SessionConfig& config) {
-  const protocol::ChannelConfig& video_config = config.video_config();
-
-  if (video_config.codec == protocol::ChannelConfig::CODEC_VP8) {
-    return remoting::VideoEncoderVpx::CreateForVP8().Pass();
-  } else if (video_config.codec == protocol::ChannelConfig::CODEC_VP9) {
-    return remoting::VideoEncoderVpx::CreateForVP9().Pass();
-  } else if (video_config.codec == protocol::ChannelConfig::CODEC_VERBATIM) {
-    return make_scoped_ptr(new remoting::VideoEncoderVerbatim());
-  }
-
-  NOTREACHED();
-  return nullptr;
-}
-
-// static
-scoped_ptr<AudioEncoder> ClientSession::CreateAudioEncoder(
-    const protocol::SessionConfig& config) {
-  const protocol::ChannelConfig& audio_config = config.audio_config();
-
-  if (audio_config.codec == protocol::ChannelConfig::CODEC_VERBATIM) {
-    return make_scoped_ptr(new AudioEncoderVerbatim());
-  } else if (audio_config.codec == protocol::ChannelConfig::CODEC_OPUS) {
-    return make_scoped_ptr(new AudioEncoderOpus());
-  }
-
-  NOTREACHED();
-  return nullptr;
-}
-
 }  // namespace remoting