[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;

[asargent_no_longer_on_chrome, 2016/02/25 22:09:39]

nit: the general policy is not to leave in logging statements that might be
useful in the future but aren't being actively used to help track down a
specific bug.  Instead the advice is to prefer things like DVLOG or VLOG which
allow selective enabling as needed, with DVLOG being best because it doesn't
bloat release binaries. 

http://dev.chromium.org/developers/coding-style#TOC-Logging

+}
+
 }  // namespace
 
 namespace extensions {
 
 using api::display_source::ErrorType;
 
 WiFiDisplaySession::WiFiDisplaySession(
     const DisplaySourceSessionParams& params)
   : binding_(this),
     params_(params),
+    cseq_(0),
+    timer_id_(0),
     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 {
+  return ++cseq_;
+}
+
+void WiFiDisplaySession::SendRTSPData(const std::string& message) {
+  service_->SendMessage(message);
+}
+
+unsigned WiFiDisplaySession::CreateTimer(int seconds) {
+  scoped_ptr<base::Timer> timer(new base::Timer(true, true));
+  auto insert_ret = timers_.insert(
+      std::pair<unsigned, scoped_ptr<base::Timer>>(
+          ++timer_id_, 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()),
+                          timer_id_));
+  return timer_id_;
+}
+
+void WiFiDisplaySession::ReleaseTimer(unsigned 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