[chrome.displaySource][WiFi Display] Send media stream to sink (renderer part)

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"
 #include "content/public/renderer/media_stream_utils.h"
 #include "content/public/renderer/media_stream_video_sink.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/video_encode_accelerator.h"
 #include "extensions/common/mojo/wifi_display_session_service.mojom.h"
 #include "extensions/renderer/api/display_source/wifi_display/wifi_display_elementary_stream_info.h"
 #include "extensions/renderer/api/display_source/wifi_display/wifi_display_media_pipeline.h"
 #include "media/base/bind_to_current_loop.h"
 
 namespace extensions {
@@ skipping 39 matching lines @@
  private:
   blink::WebMediaStreamTrack track_;
   bool sink_added_;
   content::VideoCaptureDeliverFrameCB callback_;
   DISALLOW_COPY_AND_ASSIGN(WiFiDisplayVideoSink);
 };
 
 WiFiDisplayMediaManager::WiFiDisplayMediaManager(
     const blink::WebMediaStreamTrack& video_track,
     const blink::WebMediaStreamTrack& audio_track,
+    const std::string& sink_ip_address,
+    content::ServiceRegistry* service_registry,
     const ErrorCallback& error_callback)
   : video_track_(video_track),
     audio_track_(audio_track),
+    service_registry_(service_registry),
+    sink_ip_address_(sink_ip_address),
     player_(nullptr),
     io_task_runner_(content::RenderThread::Get()->GetIOMessageLoopProxy()),
     error_callback_(error_callback),
     is_playing_(false),
     is_initialized_(false),
     weak_factory_(this) {
   DCHECK(!video_track.isNull() || !audio_track.isNull());
+  DCHECK(service_registry_);
   DCHECK(!error_callback_.is_null());
 }
 
 WiFiDisplayMediaManager::~WiFiDisplayMediaManager() {
   Teardown();
 }
 
 void WiFiDisplayMediaManager::Play() {
   is_playing_ = true;
   if (!player_) {
+    auto service_callback = base::Bind(
+        &WiFiDisplayMediaManager::RegisterMediaService,
+        base::Unretained(this),
+        base::ThreadTaskRunnerHandle::Get());
     base::PostTaskAndReplyWithResult(io_task_runner_.get(), FROM_HERE,
         base::Bind(
             &WiFiDisplayMediaPipeline::Create,
             GetSessionType(),
             video_encoder_parameters_,
             optimal_audio_codec_,
+            sink_ip_address_,
+            sink_rtp_ports_,
+            service_callback,  // To be invoked on IO thread.
             media::BindToCurrentLoop(error_callback_)),
         base::Bind(&WiFiDisplayMediaManager::OnPlayerCreated,
                    weak_factory_.GetWeakPtr()));
     return;
   }
 
   if (!is_initialized_) {
     return;  // Waiting for initialization being completed.
   }
 
@@ skipping 284 matching lines @@
 
   if (!is_initialized_) {
     error_callback_.Run(kErrorMediaPipelineFailure);
     return;
   }
 
   if (is_playing_)
     Play();
 }
 
+// Note: invoked on IO thread
+void WiFiDisplayMediaManager::RegisterMediaService(
+    const scoped_refptr<base::SingleThreadTaskRunner>& main_runner,
+    WiFiDisplayMediaServiceRequest request,
+    const base::Closure& on_completed) {
+  auto connect_service_callback =
+      base::Bind(&WiFiDisplayMediaManager::ConnectToRemoteService,
+                 base::Unretained(this),
+                 base::Passed(&request));
+  main_runner->PostTaskAndReply(FROM_HERE,
+      connect_service_callback,
+      media::BindToCurrentLoop(on_completed));
+}
+
+void WiFiDisplayMediaManager::ConnectToRemoteService(
+    WiFiDisplayMediaServiceRequest request) {
+  DCHECK(content::RenderThread::Get());
+  service_registry_->ConnectToRemoteService(std::move(request));
+}
 
 }  // namespace extensions