[chrome.displaySource] Integrate audio encoders into media pipeline.

extensions/renderer/api/display_source/wifi_display/wifi_display_media_manager.cc

 // Copyright 2016 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 "extensions/renderer/api/display_source/wifi_display/wifi_display_media_manager.h"
 
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/task_runner_util.h"
 #include "content/public/common/service_registry.h"
@@ skipping 13 matching lines @@
 const char kErrorNoVideoFormatData[] =
     "Failed to get video format data from the given MediaStreamTrack object";
 const char kErrorSinkCannotPlayVideo[] =
     "The sink cannot play video from the given MediaStreamTrack object";
 const char kErrorSinkCannotPlayAudio[] =
     "The sink cannot play audio from the given MediaStreamTrack object";
 const char kErrorMediaPipelineFailure[] =
     "Failed to initialize media pipeline for the session";
 }  // namespace
 
+class WiFiDisplayAudioSink {
+ public:
+  WiFiDisplayAudioSink(const blink::WebMediaStreamTrack& track,
+                       content::MediaStreamAudioSink* delegate)
+      : track_(track), delegate_(delegate), sink_added_(false) {}
+
+  ~WiFiDisplayAudioSink() { Stop(); }
+
+  void Start() {
+    DCHECK(!sink_added_);
+    sink_added_ = true;
+    delegate_->AddToAudioTrack(delegate_, track_);
+  }
+
+  void Stop() {
+    if (sink_added_) {
+      delegate_->RemoveFromAudioTrack(delegate_, track_);
+      sink_added_ = false;
+    }
+  }
+
+ private:
+  blink::WebMediaStreamTrack track_;
+  content::MediaStreamAudioSink* delegate_;
+  bool sink_added_;
+};
+
 class WiFiDisplayVideoSink : public content::MediaStreamVideoSink {
  public:
   WiFiDisplayVideoSink(
       const blink::WebMediaStreamTrack& track,
       const content::VideoCaptureDeliverFrameCB& callback)
       : track_(track),
         callback_(callback) {
   }
 
   ~WiFiDisplayVideoSink() override {
@@ skipping 55 matching lines @@
             media::BindToCurrentLoop(error_callback_)),
         base::Bind(&WiFiDisplayMediaManager::OnPlayerCreated,
                    weak_factory_.GetWeakPtr()));
     return;
   }
 
   if (!is_initialized_) {
     return;  // Waiting for initialization being completed.
   }
 
+  if (!audio_track_.isNull()) {
+    audio_sink_.reset(
+        new WiFiDisplayAudioSink(audio_track_, player_->audio_sink()));
+    audio_sink_->Start();
+  }
+
   if (!video_track_.isNull()) {
     // To be called on IO thread.
     auto on_raw_video_frame = base::Bind(
         &WiFiDisplayMediaPipeline::InsertRawVideoFrame,
         base::Unretained(player_));
     video_sink_.reset(
         new WiFiDisplayVideoSink(video_track_, on_raw_video_frame));
     video_sink_->Start();
   }
 }
 
 void WiFiDisplayMediaManager::Teardown() {
   Pause();
   if (player_) {
     io_task_runner_->DeleteSoon(FROM_HERE, player_);
     player_ = nullptr;
   }
   is_initialized_ = false;
   session_id_.clear();
 }
 
 void WiFiDisplayMediaManager::Pause() {
   is_playing_ = false;
+  audio_sink_.reset();
   video_sink_.reset();
 }
 
 bool WiFiDisplayMediaManager::IsPaused() const {
   return !is_playing_;
 }
 
 wds::SessionType WiFiDisplayMediaManager::GetSessionType() const {
   uint16_t session_type = 0;
   if (!video_track_.isNull())
@@ skipping 272 matching lines @@
       media::BindToCurrentLoop(on_completed));
 }
 
 void WiFiDisplayMediaManager::ConnectToRemoteService(
     WiFiDisplayMediaServiceRequest request) {
   DCHECK(content::RenderThread::Get());
   service_registry_->ConnectToRemoteService(std::move(request));
 }
 
 }  // namespace extensions