[chrome.displaySource][WiFi Display] Video formats capability negotiation

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

 // Copyright 2015 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_session.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "base/timer/timer.h"
 #include "content/public/common/service_registry.h"
 #include "content/public/renderer/render_frame.h"
 #include "extensions/renderer/api/display_source/wifi_display/wifi_display_media_manager.h"
 #include "third_party/wds/src/libwds/public/logging.h"
 #include "third_party/wds/src/libwds/public/media_manager.h"
 
 namespace {
 const char kErrorInternal[] = "An internal error has occurred";
@@ skipping 45 matching lines @@
   DCHECK(!error_callback_.is_null())
       << "Should be set with 'SetNotificationCallbacks'";
 
   service_->Connect(params_.sink_id, params_.auth_method, params_.auth_data);
   state_ = DisplaySourceSession::Establishing;
   start_completion_callback_ = callback;
 }
 
 void WiFiDisplaySession::Terminate(const CompletionCallback& callback) {
   DCHECK_EQ(DisplaySourceSession::Established, state_);
-  service_->Disconnect();
-  state_ = DisplaySourceSession::Terminating;
+  Terminate();
   teminate_completion_callback_ = callback;
 }
 
 void WiFiDisplaySession::OnConnected(const mojo::String& ip_address) {
   DCHECK_EQ(DisplaySourceSession::Established, state_);
   ip_address_ = ip_address;
-  media_manager_.reset(new WiFiDisplayMediaManager());
+  media_manager_.reset(
+      new WiFiDisplayMediaManager(
+          params_.video_track,
+          params_.audio_track,
+          base::Bind(
+              &WiFiDisplaySession::OnMediaError,
+              weak_factory_.GetWeakPtr())));
   wfd_source_.reset(wds::Source::Create(this, media_manager_.get(), this));
   wfd_source_->Start();
 }
 
 void WiFiDisplaySession::OnConnectRequestHandled(bool success,
                                                  const mojo::String& error) {
   DCHECK_EQ(DisplaySourceSession::Establishing, state_);
   state_ =
       success ? DisplaySourceSession::Established : DisplaySourceSession::Idle;
   RunStartCallback(success, error);
@@ skipping 19 matching lines @@
   DCHECK_EQ(DisplaySourceSession::Established, state_);
   error_callback_.Run(static_cast<ErrorType>(type), description);
 }
 
 void WiFiDisplaySession::OnMessage(const mojo::String& data) {
   DCHECK_EQ(DisplaySourceSession::Established, state_);
   DCHECK(wfd_source_);
   wfd_source_->RTSPDataReceived(data);
 }
 
-void WiFiDisplaySession::OnIPCConnectionError() {
-  // We must explicitly notify the session termination as it will never
-  // arrive from browser process (IPC is broken).
-  switch (state_) {
-    case DisplaySourceSession::Idle:
-    case DisplaySourceSession::Establishing:
-      RunStartCallback(false, kErrorInternal);
-      break;
-    case DisplaySourceSession::Terminating:
-    case DisplaySourceSession::Established:
-      error_callback_.Run(api::display_source::ERROR_TYPE_UNKNOWN_ERROR,
-                          kErrorInternal);
-      state_ = DisplaySourceSession::Idle;
-      terminated_callback_.Run();
-      break;
-    default:
-      NOTREACHED();
-  }
-}
-
 std::string WiFiDisplaySession::GetLocalIPAddress() const {
   return ip_address_;
 }
 
 int WiFiDisplaySession::GetNextCSeq(int* initial_peer_cseq) const {
   return ++cseq_;
 }
 
 void WiFiDisplaySession::SendRTSPData(const std::string& message) {
   service_->SendMessage(message);
@@ skipping 21 matching lines @@
 
 void WiFiDisplaySession::ErrorOccurred(wds::ErrorType error) {
   DCHECK_NE(DisplaySourceSession::Idle, state_);
   if (error == wds::TimeoutError) {
     error_callback_.Run(api::display_source::ERROR_TYPE_TIMEOUT_ERROR,
                         kErrorTimeout);
   } else {
     error_callback_.Run(api::display_source::ERROR_TYPE_UNKNOWN_ERROR,
                         kErrorInternal);
   }
-
-  if (state_ == DisplaySourceSession::Established) {
-    // The session cannot continue.
-    service_->Disconnect();
-    state_ = DisplaySourceSession::Terminating;
-  }
+  // The session cannot continue.
+  Terminate();
 }
 
 void WiFiDisplaySession::SessionCompleted() {
   DCHECK_NE(DisplaySourceSession::Idle, state_);
+  // The session has finished normally.
+  Terminate();
+}
+
+void WiFiDisplaySession::OnIPCConnectionError() {
+  // We must explicitly notify the session termination as it will never
+  // arrive from browser process (IPC is broken).
+  switch (state_) {
+    case DisplaySourceSession::Idle:
+    case DisplaySourceSession::Establishing:
+      RunStartCallback(false, kErrorInternal);
+      break;
+    case DisplaySourceSession::Terminating:
+    case DisplaySourceSession::Established:
+      error_callback_.Run(api::display_source::ERROR_TYPE_UNKNOWN_ERROR,
+                          kErrorInternal);
+      state_ = DisplaySourceSession::Idle;
+      terminated_callback_.Run();
+      break;
+    default:
+      NOTREACHED();
+  }
+}
+
+void WiFiDisplaySession::OnMediaError(const std::string& error) {
+  DCHECK_NE(DisplaySourceSession::Idle, state_);
+  error_callback_.Run(api::display_source::ERROR_TYPE_MEDIA_PIPELINE_ERROR,
+                      error);
+  Terminate();
+}
+
+void WiFiDisplaySession::Terminate() {
   if (state_ == DisplaySourceSession::Established) {
-    // The session has finished normally.
     service_->Disconnect();
     state_ = DisplaySourceSession::Terminating;
   }
 }
 
 void WiFiDisplaySession::RunStartCallback(bool success,
                                           const std::string& error_message) {
   if (!start_completion_callback_.is_null())
     start_completion_callback_.Run(success, error_message);
 }
 
 void WiFiDisplaySession::RunTerminateCallback(
     bool success,
     const std::string& error_message) {
   if (!teminate_completion_callback_.is_null())
     teminate_completion_callback_.Run(success, error_message);
 }
 
 }  // namespace extensions