Move parts of OpenScreen platform implementation to //components.

This is a preliminary change to share the implementation across
multiple Chromium content embedders.

Bug: 1042501
Change-Id: I398c0810de589529a0037875a30ad33c2f65aa50
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2013725
Commit-Queue: Fabrice de Gans-Riberi <fdegans@chromium.org>
Reviewed-by: Ryan Sleevi <rsleevi@chromium.org>
Reviewed-by: Yuri Wiitala <miu@chromium.org>
Reviewed-by: Jochen Eisinger <jochen@chromium.org>
Reviewed-by: mark a. foltz <mfoltz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#735672}

chrome/browser/media/router/BUILD.gn

@@ -176,19 +176,12 @@ static_library("router") {
 if (enable_openscreen) {
   source_set("openscreen_platform_impl") {
     sources = [
-      "providers/openscreen/platform/chrome_task_runner.cc",
-      "providers/openscreen/platform/chrome_task_runner.h",
       "providers/openscreen/platform/chrome_tls_client_connection.cc",
       "providers/openscreen/platform/chrome_tls_client_connection.h",
       "providers/openscreen/platform/chrome_tls_connection_factory.cc",
       "providers/openscreen/platform/chrome_tls_connection_factory.h",
       "providers/openscreen/platform/chrome_udp_socket.cc",
       "providers/openscreen/platform/chrome_udp_socket.h",
-      "providers/openscreen/platform/logging.cc",
-      "providers/openscreen/platform/network_util.cc",
-      "providers/openscreen/platform/network_util.h",
-      "providers/openscreen/platform/time.cc",
-      "providers/openscreen/platform/trace_logging_platform.cc",
     ]
 
     public_configs =
@@ -196,6 +189,7 @@ if (enable_openscreen) {
 
     deps = [
       "//base",
+      "//components/openscreen_platform",
       "//net/traffic_annotation",
       "//services/network:network_service",
       "//services/network/public/mojom",

chrome/browser/media/router/DEPS

 include_rules = [
+  "+components/openscreen_platform",
   "+services/network",
   "+third_party/openscreen/src/cast/common/certificate/proto",
   "+third_party/openscreen/src/cast/common/channel/proto",

chrome/browser/media/router/providers/openscreen/platform/chrome_tls_client_connection_unittest.cc

@@ -15,7 +15,7 @@
 #include "base/sequenced_task_runner.h"
 #include "base/task/post_task.h"
 #include "base/test/task_environment.h"
-#include "chrome/browser/media/router/providers/openscreen/platform/chrome_task_runner.h"
+#include "components/openscreen_platform/platform_task_runner.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -144,7 +144,7 @@ class ChromeTlsClientConnectionTest : public ::testing::Test {
   ~ChromeTlsClientConnectionTest() override = default;
 
   void SetUp() override {
-    task_runner_ = std::make_unique<ChromeTaskRunner>(
+    task_runner_ = std::make_unique<openscreen_platform::PlatformTaskRunner>(
         task_environment_.GetMainThreadTaskRunner());
     socket_streams_ = std::make_unique<FakeSocketStreams>();
     connection_ = std::make_unique<ChromeTlsClientConnection>(
@@ -165,7 +165,7 @@ class ChromeTlsClientConnectionTest : public ::testing::Test {
 
  private:
   base::test::TaskEnvironment task_environment_;
-  std::unique_ptr<ChromeTaskRunner> task_runner_;
+  std::unique_ptr<openscreen_platform::PlatformTaskRunner> task_runner_;
 
   std::unique_ptr<FakeSocketStreams> socket_streams_;
   std::unique_ptr<ChromeTlsClientConnection> connection_;

chrome/browser/media/router/providers/openscreen/platform/chrome_tls_connection_factory.cc

@@ -8,8 +8,8 @@
 
 #include "base/logging.h"
 #include "chrome/browser/media/router/providers/openscreen/platform/chrome_tls_client_connection.h"
-#include "chrome/browser/media/router/providers/openscreen/platform/network_util.h"
 #include "chrome/browser/net/system_network_context_manager.h"
+#include "components/openscreen_platform/network_util.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/ssl/ssl_info.h"
@@ -85,7 +85,7 @@ void ChromeTlsConnectionFactory::Connect(const IPEndpoint& remote_address,
                             mojo::Remote<network::mojom::TCPConnectedSocket>{});
 
   const net::AddressList address_list(
-      media_router::network_util::ToChromeNetEndpoint(remote_address));
+      openscreen_platform::ToNetEndPoint(remote_address));
 
   network_context->CreateTCPConnectedSocket(
       base::nullopt /* local_addr */, address_list,
@@ -162,7 +162,7 @@ void ChromeTlsConnectionFactory::OnTcpConnect(
   }
 
   net::HostPortPair host_port_pair = net::HostPortPair::FromIPEndPoint(
-      network_util::ToChromeNetEndpoint(request.remote_address));
+      openscreen_platform::ToNetEndPoint(request.remote_address));
   network::mojom::TLSClientSocketOptionsPtr options =
       network::mojom::TLSClientSocketOptions::New();
   options->unsafely_skip_cert_verification =
@@ -170,7 +170,8 @@ void ChromeTlsConnectionFactory::OnTcpConnect(
 
   openscreen::IPEndpoint local_endpoint{};
   if (local_address) {
-    local_endpoint = network_util::ToOpenScreenEndpoint(local_address.value());
+    local_endpoint =
+        openscreen_platform::ToOpenScreenEndPoint(local_address.value());
   }
 
   TlsUpgradeRequest upgrade_request(

chrome/browser/media/router/providers/openscreen/platform/chrome_tls_connection_factory_unittest.cc

@@ -12,8 +12,8 @@
 #include "base/sequenced_task_runner.h"
 #include "base/task/post_task.h"
 #include "base/test/task_environment.h"
-#include "chrome/browser/media/router/providers/openscreen/platform/chrome_task_runner.h"
 #include "chrome/browser/media/router/providers/openscreen/platform/chrome_tls_client_connection.h"
+#include "components/openscreen_platform/platform_task_runner.h"
 #include "net/base/net_errors.h"
 #include "services/network/public/mojom/network_context.mojom.h"
 #include "services/network/test/test_network_context.h"
@@ -91,13 +91,13 @@ class ChromeTlsConnectionFactoryTest : public ::testing::Test {
   void SetUp() override {
     task_environment_ = std::make_unique<base::test::TaskEnvironment>();
 
-    task_runner = std::make_unique<ChromeTaskRunner>(
+    task_runner = std::make_unique<openscreen_platform::PlatformTaskRunner>(
         task_environment_->GetMainThreadTaskRunner());
 
     mock_network_context = std::make_unique<FakeNetworkContext>();
   }
 
-  std::unique_ptr<ChromeTaskRunner> task_runner;
+  std::unique_ptr<openscreen_platform::PlatformTaskRunner> task_runner;
   std::unique_ptr<FakeNetworkContext> mock_network_context;
 
  private:

chrome/browser/media/router/providers/openscreen/platform/chrome_udp_socket.cc

@@ -8,8 +8,8 @@
 
 #include "base/bind.h"
 #include "base/containers/span.h"
-#include "chrome/browser/media/router/providers/openscreen/platform/network_util.h"
 #include "chrome/browser/net/system_network_context_manager.h"
+#include "components/openscreen_platform/network_util.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "net/base/address_family.h"
 #include "net/base/ip_endpoint.h"
@@ -112,7 +112,7 @@ IPEndpoint ChromeUdpSocket::GetLocalEndpoint() const {
 }
 
 void ChromeUdpSocket::Bind() {
-  udp_socket_->Bind(network_util::ToChromeNetEndpoint(local_endpoint_),
+  udp_socket_->Bind(openscreen_platform::ToNetEndPoint(local_endpoint_),
                     nullptr /* socket_options */,
                     base::BindOnce(&ChromeUdpSocket::BindCallback,
                                    weak_ptr_factory_.GetWeakPtr()));
@@ -128,7 +128,7 @@ void ChromeUdpSocket::SetMulticastOutboundInterface(
 void ChromeUdpSocket::JoinMulticastGroup(
     const IPAddress& address,
     openscreen::NetworkInterfaceIndex ifindex) {
-  const auto join_address = network_util::ToChromeNetAddress(address);
+  const auto join_address = openscreen_platform::ToNetAddress(address);
   udp_socket_->JoinGroup(join_address,
                          base::BindOnce(&ChromeUdpSocket::JoinGroupCallback,
                                         weak_ptr_factory_.GetWeakPtr()));
@@ -137,7 +137,7 @@ void ChromeUdpSocket::JoinMulticastGroup(
 void ChromeUdpSocket::SendMessage(const void* data,
                                   size_t length,
                                   const IPEndpoint& dest) {
-  const auto send_to_address = network_util::ToChromeNetEndpoint(dest);
+  const auto send_to_address = openscreen_platform::ToNetEndPoint(dest);
   base::span<const uint8_t> data_span(static_cast<const uint8_t*>(data),
                                       length);
 
@@ -166,7 +166,7 @@ void ChromeUdpSocket::OnReceived(
     packet.set_socket(this);
     if (source_endpoint) {
       packet.set_source(
-          network_util::ToOpenScreenEndpoint(source_endpoint.value()));
+          openscreen_platform::ToOpenScreenEndPoint(source_endpoint.value()));
     }
     client_->OnRead(this, std::move(packet));
   }
@@ -194,7 +194,8 @@ void ChromeUdpSocket::BindCallback(
   }
 
   if (address) {
-    local_endpoint_ = network_util::ToOpenScreenEndpoint(address.value());
+    local_endpoint_ =
+        openscreen_platform::ToOpenScreenEndPoint(address.value());
     if (pending_listener_.is_valid()) {
       listener_.Bind(std::move(pending_listener_));
     }

components/openscreen_platform/BUILD.gn

+# Copyright 2020 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.
+
+import("//testing/test.gni")
+
+source_set("openscreen_platform") {
+  sources = [
+    "logging.cc",
+    "network_util.cc",
+    "network_util.h",
+    "platform_task_runner.cc",
+    "platform_task_runner.h",
+    "time.cc",
+    "trace_logging_platform.cc",
+  ]
+
+  deps = [
+    "//base",
+    "//net",
+    "//third_party/openscreen/src/platform",
+  ]
+}

components/openscreen_platform/DEPS

+include_rules = [
+  "+net",
+  "+third_party/openscreen/src/platform/base",
+  "+third_party/openscreen/src/platform/api",
+]

components/openscreen_platform/OWNERS

+file://third_party/openscreen/OWNERS

components/openscreen_platform/README.md

+This directory contains an implementation of the
+[Open Screen](../../third_party/openscreen) platform API along with utility
+functions, using the `//base` and `//net` directories in Chromium.

chrome/browser/media/router/providers/openscreen/platform/network_util.cc → components/openscreen_platform/network_util.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/media/router/providers/openscreen/platform/network_util.h"
+#include "components/openscreen_platform/network_util.h"
 
 #include <array>
 #include <memory>
@@ -11,10 +11,9 @@
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 
-namespace media_router {
-namespace network_util {
+namespace openscreen_platform {
 
-const net::IPAddress ToChromeNetAddress(const openscreen::IPAddress& address) {
+const net::IPAddress ToNetAddress(const openscreen::IPAddress& address) {
   switch (address.version()) {
     case openscreen::IPAddress::Version::kV4: {
       std::array<uint8_t, openscreen::IPAddress::kV4Size> bytes_v4;
@@ -29,9 +28,8 @@ const net::IPAddress ToChromeNetAddress(const openscreen::IPAddress& address) {
   }
 }
 
-const net::IPEndPoint ToChromeNetEndpoint(
-    const openscreen::IPEndpoint& endpoint) {
-  return net::IPEndPoint(ToChromeNetAddress(endpoint.address), endpoint.port);
+const net::IPEndPoint ToNetEndPoint(const openscreen::IPEndpoint& endpoint) {
+  return net::IPEndPoint(ToNetAddress(endpoint.address), endpoint.port);
 }
 
 openscreen::IPAddress::Version ToOpenScreenVersion(
@@ -48,7 +46,7 @@ openscreen::IPAddress::Version ToOpenScreenVersion(
   }
 }
 
-const openscreen::IPEndpoint ToOpenScreenEndpoint(
+const openscreen::IPEndpoint ToOpenScreenEndPoint(
     const net::IPEndPoint& endpoint) {
   const openscreen::IPAddress::Version version =
       ToOpenScreenVersion(endpoint.GetFamily());
@@ -57,5 +55,4 @@ const openscreen::IPEndpoint ToOpenScreenEndpoint(
       endpoint.port()};
 }
 
-}  // namespace network_util
-}  // namespace media_router
+}  // namespace openscreen_platform

chrome/browser/media/router/providers/openscreen/platform/network_util.h → components/openscreen_platform/network_util.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_MEDIA_ROUTER_PROVIDERS_OPENSCREEN_PLATFORM_NETWORK_UTIL_H_
-#define CHROME_BROWSER_MEDIA_ROUTER_PROVIDERS_OPENSCREEN_PLATFORM_NETWORK_UTIL_H_
+#ifndef COMPONENTS_OPENSCREEN_PLATFORM_NETWORK_UTIL_H_
+#define COMPONENTS_OPENSCREEN_PLATFORM_NETWORK_UTIL_H_
 
 #include <memory>
 
@@ -15,20 +15,16 @@ class IPAddress;
 class IPEndPoint;
 }  // namespace net
 
-// Helper namespace for stateless methods that convert between Open Screen
-// and Chrome net types.
-namespace media_router {
-namespace network_util {
+// Helper methods that convert between Open Screen and Chromium //net types.
+namespace openscreen_platform {
 
-const net::IPAddress ToChromeNetAddress(const openscreen::IPAddress& address);
-const net::IPEndPoint ToChromeNetEndpoint(
-    const openscreen::IPEndpoint& endpoint);
+const net::IPAddress ToNetAddress(const openscreen::IPAddress& address);
+const net::IPEndPoint ToNetEndPoint(const openscreen::IPEndpoint& endpoint);
 openscreen::IPAddress::Version ToOpenScreenVersion(
     const net::AddressFamily family);
-const openscreen::IPEndpoint ToOpenScreenEndpoint(
+const openscreen::IPEndpoint ToOpenScreenEndPoint(
     const net::IPEndPoint& endpoint);
 
-}  // namespace network_util
-}  // namespace media_router
+}  // namespace openscreen_platform
 
-#endif  // CHROME_BROWSER_MEDIA_ROUTER_PROVIDERS_OPENSCREEN_PLATFORM_NETWORK_UTIL_H_
+#endif  // COMPONENTS_OPENSCREEN_PLATFORM_NETWORK_UTIL_H_

chrome/browser/media/router/providers/openscreen/platform/chrome_task_runner.cc → components/openscreen_platform/platform_task_runner.cc

@@ -11,9 +11,9 @@
 #include "base/task/task_traits.h"
 #include "base/time/time.h"
 
-#include "chrome/browser/media/router/providers/openscreen/platform/chrome_task_runner.h"
+#include "components/openscreen_platform/platform_task_runner.h"
 
-namespace media_router {
+namespace openscreen_platform {
 
 using openscreen::Clock;
 using openscreen::TaskRunner;
@@ -24,19 +24,19 @@ void ExecuteTask(TaskRunner::Task task) {
 }
 }  // namespace
 
-ChromeTaskRunner::ChromeTaskRunner(
+PlatformTaskRunner::PlatformTaskRunner(
     scoped_refptr<base::SequencedTaskRunner> task_runner) {
   task_runner_ = task_runner;
 }
 
-ChromeTaskRunner::~ChromeTaskRunner() = default;
+PlatformTaskRunner::~PlatformTaskRunner() = default;
 
-void ChromeTaskRunner::PostPackagedTask(TaskRunner::Task task) {
+void PlatformTaskRunner::PostPackagedTask(TaskRunner::Task task) {
   task_runner_->PostTask(FROM_HERE,
                          base::BindOnce(ExecuteTask, std::move(task)));
 }
 
-void ChromeTaskRunner::PostPackagedTaskWithDelay(TaskRunner::Task task,
+void PlatformTaskRunner::PostPackagedTaskWithDelay(TaskRunner::Task task,
                                                    Clock::duration delay) {
   auto time_delta = base::TimeDelta::FromMicroseconds(
       std::chrono::duration_cast<std::chrono::microseconds>(delay).count());
@@ -44,4 +44,4 @@ void ChromeTaskRunner::PostPackagedTaskWithDelay(TaskRunner::Task task,
       FROM_HERE, base::BindOnce(ExecuteTask, std::move(task)), time_delta);
 }
 
-}  // namespace media_router
+}  // namespace openscreen_platform

chrome/browser/media/router/providers/openscreen/platform/chrome_task_runner.h → components/openscreen_platform/platform_task_runner.h

@@ -2,27 +2,27 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_MEDIA_ROUTER_PROVIDERS_OPENSCREEN_PLATFORM_CHROME_TASK_RUNNER_H_
-#define CHROME_BROWSER_MEDIA_ROUTER_PROVIDERS_OPENSCREEN_PLATFORM_CHROME_TASK_RUNNER_H_
+#ifndef COMPONENTS_OPENSCREEN_PLATFORM_PLATFORM_TASK_RUNNER_H_
+#define COMPONENTS_OPENSCREEN_PLATFORM_PLATFORM_TASK_RUNNER_H_
 
 #include "base/single_thread_task_runner.h"
 #include "third_party/openscreen/src/platform/api/task_runner.h"
 #include "third_party/openscreen/src/platform/api/time.h"
 
-namespace media_router {
+namespace openscreen_platform {
 
-class ChromeTaskRunner final : public openscreen::TaskRunner {
+class PlatformTaskRunner final : public openscreen::TaskRunner {
  public:
-  explicit ChromeTaskRunner(
+  explicit PlatformTaskRunner(
       scoped_refptr<base::SequencedTaskRunner> task_runner);
 
-  ChromeTaskRunner(const ChromeTaskRunner&) = delete;
-  ChromeTaskRunner(ChromeTaskRunner&&) = delete;
-  ChromeTaskRunner& operator=(const ChromeTaskRunner&) = delete;
-  ChromeTaskRunner& operator=(ChromeTaskRunner&&) = delete;
+  PlatformTaskRunner(const PlatformTaskRunner&) = delete;
+  PlatformTaskRunner(PlatformTaskRunner&&) = delete;
+  PlatformTaskRunner& operator=(const PlatformTaskRunner&) = delete;
+  PlatformTaskRunner& operator=(PlatformTaskRunner&&) = delete;
 
   // TaskRunner overrides
-  ~ChromeTaskRunner() final;
+  ~PlatformTaskRunner() final;
   void PostPackagedTask(openscreen::TaskRunner::Task task) final;
   void PostPackagedTaskWithDelay(openscreen::TaskRunner::Task task,
                                  openscreen::Clock::duration delay) final;
@@ -31,6 +31,6 @@ class ChromeTaskRunner final : public openscreen::TaskRunner {
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 };
 
-}  // namespace media_router
+}  // namespace openscreen_platform
 
-#endif  // CHROME_BROWSER_MEDIA_ROUTER_PROVIDERS_OPENSCREEN_PLATFORM_CHROME_TASK_RUNNER_H_
+#endif  // COMPONENTS_OPENSCREEN_PLATFORM_PLATFORM_TASK_RUNNER_H_

chrome/browser/media/router/providers/openscreen/platform/time.cc → components/openscreen_platform/time.cc

@@ -14,9 +14,9 @@ using std::chrono::seconds;
 namespace openscreen {
 
 Clock::time_point Clock::now() noexcept {
-  // Open Screen requires at least 10,000
-  // ticks per second, according to the docs. If IsHighResolution is false, the
-  // supplied resolution is much worse than that (potentially up to ~15.6ms).
+  // Open Screen requires at least 10,000 ticks per second, according to the
+  // docs. If IsHighResolution is false, the supplied resolution is much worse
+  // than that (potentially up to ~15.6ms).
   if (UNLIKELY(!base::TimeTicks::IsHighResolution())) {
     static bool need_to_log_once = true;
     LOG_IF(ERROR, need_to_log_once)