[chrome.displaySource] Use WDS for Wi-Fi Display implementation

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 "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";
+const char kErrorTimeout[] = "Sink became unresponsive";
+
+static void LogWDSError(const char* format, ...) {
+  va_list args;
+  va_start(args, format);
+  char buffer[256];
+  vsnprintf(buffer, 256, format, args);
+  va_end(args);
+  LOG(ERROR) << "[WDS] " << buffer;
+}
+
 }  // namespace
 
 namespace extensions {
 
 using api::display_source::ErrorType;
 
 WiFiDisplaySession::WiFiDisplaySession(
     const DisplaySourceSessionParams& params)
   : binding_(this),
     params_(params),
     weak_factory_(this) {
   DCHECK(params_.render_frame);
+  wds::LogSystem::set_error_func(&LogWDSError);
   params.render_frame->GetServiceRegistry()->ConnectToRemoteService(
       mojo::GetProxy(&service_));
   service_.set_connection_error_handler(base::Bind(
-          &WiFiDisplaySession::OnConnectionError,
+          &WiFiDisplaySession::OnIPCConnectionError,
           weak_factory_.GetWeakPtr()));
 
   service_->SetClient(binding_.CreateInterfacePtrAndBind());
   binding_.set_connection_error_handler(base::Bind(
-          &WiFiDisplaySession::OnConnectionError,
+          &WiFiDisplaySession::OnIPCConnectionError,
           weak_factory_.GetWeakPtr()));
 }
 
 WiFiDisplaySession::~WiFiDisplaySession() {
 }
 
 void WiFiDisplaySession::Start() {
   DCHECK(state_ == DisplaySourceSession::Idle);
   service_->Connect(params_.sink_id, params_.auth_method, params_.auth_data);
   state_ = DisplaySourceSession::Establishing;
@@ skipping 14 matching lines @@
     state_ = DisplaySourceSession::Terminating;
     break;
   default:
     NOTREACHED();
   }
 }
 
 void WiFiDisplaySession::OnEstablished(const mojo::String& ip_address) {
   DCHECK(state_ != DisplaySourceSession::Established);
   ip_address_ = ip_address;
+  media_manager_.reset(new WiFiDisplayMediaManager());
+  wfd_source_.reset(wds::Source::Create(this, media_manager_.get(), this));
+  wfd_source_->Start();
   state_ = DisplaySourceSession::Established;
 }
 
 void WiFiDisplaySession::OnTerminated() {
   DCHECK(state_ != DisplaySourceSession::Idle);
   state_ = DisplaySourceSession::Idle;
+  media_manager_.reset();
+  wfd_source_.reset();
   if (!terminated_callback_.is_null())
     terminated_callback_.Run(params_.sink_id);
 }
 
 void WiFiDisplaySession::OnError(int32_t type,
                                  const mojo::String& description) {
   DCHECK(type > api::display_source::ERROR_TYPE_NONE
          && type <= api::display_source::ERROR_TYPE_LAST);
   if (!error_callback_.is_null())
     error_callback_.Run(params_.sink_id, static_cast<ErrorType>(type),
                         description);
 }
 
 void WiFiDisplaySession::OnMessage(const mojo::String& data) {
   DCHECK(state_ == DisplaySourceSession::Established);
+  DCHECK(wfd_source_);
+  wfd_source_->RTSPDataReceived(data);
 }
 
-void WiFiDisplaySession::OnConnectionError() {
+std::string WiFiDisplaySession::GetLocalIPAddress() const {
+  return ip_address_;
+}
+
+int WiFiDisplaySession::GetNextCSeq(int* initial_peer_cseq) const {
+  static int sCseq = 0;

[shalamov, 2016/02/15 10:29:02]

Make cseq a member.

+  return ++sCseq;
+}
+
+void WiFiDisplaySession::SendRTSPData(const std::string& message) {
+  service_->SendMessage(message);
+}
+
+uint WiFiDisplaySession::CreateTimer(int seconds) {
+  static uint sTimerId = 0;

[shalamov, 2016/02/15 10:29:02]

Make timerId as a class member.

+  scoped_ptr<base::Timer> timer(new base::Timer(true, true));
+  auto insert_ret = timers_.insert(
+      std::pair<uint, scoped_ptr<base::Timer>>(
+          ++sTimerId, std::move(timer)));
+  DCHECK(insert_ret.second);
+  timer->Start(FROM_HERE,
+               base::TimeDelta::FromSeconds(seconds),
+               base::Bind(&wds::Source::OnTimerEvent,
+                          base::Unretained(wfd_source_.get()),
+                          sTimerId));
+  return sTimerId;
+}
+
+void WiFiDisplaySession::ReleaseTimer(uint timer_id) {
+  auto it = timers_.find(timer_id);
+  if (it != timers_.end())
+    timers_.erase(it);
+}
+
+void WiFiDisplaySession::ErrorOccurred(wds::ErrorType error) {
+  if (!error_callback_.is_null()) {
+    if (error == wds::TimeoutError) {
+      error_callback_.Run(params_.sink_id,
+                          api::display_source::ERROR_TYPE_TIMEOUT_ERROR,
+                          kErrorTimeout);
+    } else {
+      error_callback_.Run(params_.sink_id,
+                          api::display_source::ERROR_TYPE_UNKNOWN_ERROR,
+                          kErrorInternal);
+    }
+  }
+
+  Terminate();
+}
+
+void WiFiDisplaySession::SessionCompleted() {
+  Terminate();
+}
+
+void WiFiDisplaySession::OnIPCConnectionError() {
   if (!error_callback_.is_null()) {
     error_callback_.Run(params_.sink_id,
                         api::display_source::ERROR_TYPE_UNKNOWN_ERROR,
                         kErrorInternal);
   }
 
   if (state_ != DisplaySourceSession::Idle) {
     // We must explicitly notify the session termination as it will never
     // arrive from browser process (IPC is broken).
     if (!terminated_callback_.is_null())
       terminated_callback_.Run(params_.sink_id);
   }
 }
 
 }  // namespace extensions