Expose MediaSink device ip/port and model name (see issue #2900)

libcef/browser/media_router/media_sink_impl.cc

@@ -4,6 +4,84 @@
 
 #include "libcef/browser/media_router/media_sink_impl.h"
 
+#include "libcef/browser/thread_util.h"
+
+#include "base/strings/string_number_conversions.h"
+#include "chrome/browser/media/router/discovery/dial/dial_media_sink_service_impl.h"
+#include "chrome/browser/media/router/providers/cast/dual_media_sink_service.h"
+#include "chrome/common/media_router/discovery/media_sink_internal.h"
+#include "chrome/common/media_router/discovery/media_sink_service_base.h"
+
+namespace {
+
+using SinkServiceVector = std::vector<media_router::MediaSinkServiceBase*>;
+
+SinkServiceVector GetSinkServices() {
+  CEF_REQUIRE_UIT();
+  auto sink_service = media_router::DualMediaSinkService::GetInstance();
+  return {sink_service->GetCastMediaSinkServiceImpl(),
+          sink_service->GetDialMediaSinkServiceImpl()};
+}
+
+void GetSinkInternalAndContinue(
+    SinkServiceVector services,
+    const media_router::MediaSink::Id& sink_id,
+    CefRefPtr<CefMediaSinkDeviceInfoCallback> callback) {
+  CEF_REQUIRE_IOT();
+
+  CefMediaSinkDeviceInfo device_info;
+  const media_router::MediaSinkInternal* sink_internal = nullptr;
+
+  for (auto service : services) {
+    sink_internal = service->GetSinkById(sink_id);
+    if (sink_internal)
+      break;
+  }
+
+  if (sink_internal) {
+    if (sink_internal->is_cast_sink()) {
+      const auto& cast_data = sink_internal->cast_data();
+      CefString(&device_info.ip_address) =
+          cast_data.ip_endpoint.ToStringWithoutPort();
+      device_info.port = cast_data.ip_endpoint.port();
+      CefString(&device_info.model_name) = cast_data.model_name;
+    } else if (sink_internal->is_dial_sink()) {
+      const auto& dial_data = sink_internal->dial_data();
+      CefString(&device_info.ip_address) = dial_data.ip_address.ToString();
+      if (dial_data.app_url.is_valid() && dial_data.app_url.has_port()) {
+        base::StringToInt(dial_data.app_url.port_piece(), &device_info.port);
+      }
+      CefString(&device_info.model_name) = dial_data.model_name;
+    }
+  }
+
+  // Execute the callback on the UI thread.
+  CEF_POST_TASK(
+      CEF_UIT,
+      base::BindOnce(&CefMediaSinkDeviceInfoCallback::OnMediaSinkDeviceInfo,
+                     callback, device_info));
+}
+
+void GetDeviceInfo(const media_router::MediaSink::Id& sink_id,
+                   CefRefPtr<CefMediaSinkDeviceInfoCallback> callback) {
+  auto next_step = base::BindOnce(
+      [](const media_router::MediaSink::Id& sink_id,
+         CefRefPtr<CefMediaSinkDeviceInfoCallback> callback) {
+        CEF_POST_TASK(CEF_IOT,
+                      base::BindOnce(GetSinkInternalAndContinue,
+                                     GetSinkServices(), sink_id, callback));
+      },
+      sink_id, callback);
+
+  if (CEF_CURRENTLY_ON(CEF_UIT)) {
+    std::move(next_step).Run();
+  } else {
+    CEF_POST_TASK(CEF_UIT, std::move(next_step));
+  }
+}
+
+}  // namespace
+
 CefMediaSinkImpl::CefMediaSinkImpl(const media_router::MediaSink& sink)
     : sink_(sink) {}
 
@@ -32,6 +110,11 @@ CefMediaSink::IconType CefMediaSinkImpl::GetIconType() {
   return static_cast<CefMediaSink::IconType>(sink_.icon_type());
 }
 
+void CefMediaSinkImpl::GetDeviceInfo(
+    CefRefPtr<CefMediaSinkDeviceInfoCallback> callback) {
+  ::GetDeviceInfo(sink_.id(), callback);
+}
+
 bool CefMediaSinkImpl::IsCastSink() {
   return sink_.provider_id() == media_router::CAST;
 }

libcef/browser/media_router/media_sink_impl.h

@@ -22,6 +22,8 @@ class CefMediaSinkImpl : public CefMediaSink {
   CefString GetName() override;
   CefString GetDescription() override;
   IconType GetIconType() override;
+  void GetDeviceInfo(
+      CefRefPtr<CefMediaSinkDeviceInfoCallback> callback) override;
   bool IsCastSink() override;
   bool IsDialSink() override;
   bool IsCompatibleWith(CefRefPtr<CefMediaSource> source) override;