[CrOS Nearby] Create NearbyConnectionsDependenciesProvider

This KeyedService is responsible for generating dependencies to provide
to the Nearby Connections utility process. Code is based off of the
existing nearby_process_manager.cc file; the only changes are that we
only fetch the Bluetooth adapter once and that we re-organize this code
to be a KeyedService since it is based on the Profile.

Bug: 1130069
Change-Id: I9c1efd2ff93e9a9aadba5c363d0af37097ab5e49
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2454388
Commit-Queue: Kyle Horimoto <khorimoto@chromium.org>
Commit-Queue: Reilly Grant <reillyg@chromium.org>
Auto-Submit: Kyle Horimoto <khorimoto@chromium.org>
Reviewed-by: Reilly Grant <reillyg@chromium.org>
Reviewed-by: James Vecore <vecore@google.com>
Cr-Commit-Position: refs/heads/master@{#815868}

chrome/browser/chromeos/BUILD.gn

@@ -79,6 +79,7 @@ source_set("chromeos") {
     "//chrome/browser/apps/platform_apps",
     "//chrome/browser/apps/platform_apps/api",
     "//chrome/browser/chromeos/child_accounts/time_limits/web_time_limit_error_page",
+    "//chrome/browser/chromeos/nearby:bluetooth_adapter_util",
     "//chrome/browser/chromeos/power/ml/smart_dim",
     "//chrome/browser/chromeos/wilco_dtc_supportd:mojo_utils",
     "//chrome/browser/devtools",
@@ -209,6 +210,7 @@ source_set("chromeos") {
     "//chromeos/services/multidevice_setup/public/cpp:auth_token_validator",
     "//chromeos/services/multidevice_setup/public/cpp:oobe_completion_tracker",
     "//chromeos/services/multidevice_setup/public/cpp:prefs",
+    "//chromeos/services/nearby/public/mojom",
     "//chromeos/services/network_config:in_process_instance",
     "//chromeos/services/network_config/public/cpp:cpp",
     "//chromeos/services/network_health/public/mojom",
@@ -1901,6 +1903,10 @@ source_set("chromeos") {
     "multidevice_setup/multidevice_setup_service_factory.h",
     "multidevice_setup/oobe_completion_tracker_factory.cc",
     "multidevice_setup/oobe_completion_tracker_factory.h",
+    "nearby/nearby_connections_dependencies_provider.cc",
+    "nearby/nearby_connections_dependencies_provider.h",
+    "nearby/nearby_connections_dependencies_provider_factory.cc",
+    "nearby/nearby_connections_dependencies_provider_factory.h",
     "net/client_cert_filter_chromeos.cc",
     "net/client_cert_filter_chromeos.h",
     "net/client_cert_store_chromeos.cc",

chrome/browser/chromeos/browser_context_keyed_service_factories.cc

@@ -20,6 +20,7 @@
 #include "chrome/browser/chromeos/kerberos/kerberos_credentials_manager_factory.h"
 #include "chrome/browser/chromeos/launcher_search_provider/launcher_search_provider_service_factory.h"
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_service_factory.h"
+#include "chrome/browser/chromeos/nearby/nearby_connections_dependencies_provider_factory.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos_factory.h"
 #include "chrome/browser/chromeos/phonehub/phone_hub_manager_factory.h"
 #include "chrome/browser/chromeos/platform_keys/key_permissions/key_permissions_service_factory.h"
@@ -71,6 +72,7 @@ void EnsureBrowserContextKeyedServiceFactoriesBuilt() {
   ash::HoldingSpaceKeyedServiceFactory::GetInstance();
   KerberosCredentialsManagerFactory::GetInstance();
   launcher_search_provider::ServiceFactory::GetInstance();
+  nearby::NearbyConnectionsDependenciesProviderFactory::GetInstance();
   OwnerSettingsServiceChromeOSFactory::GetInstance();
   phonehub::PhoneHubManagerFactory::GetInstance();
   platform_keys::KeyPermissionsServiceFactory::GetInstance();

chrome/browser/chromeos/nearby/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.
+
+# Note: This target is separated from the rest of //chrome/browser/chromeos so
+# that it can depend on the bluetooth::mojom::Adapter interface, which is only
+# visible to a limited set of clients.
+source_set("bluetooth_adapter_util") {
+  sources = [
+    "bluetooth_adapter_util.cc",
+    "bluetooth_adapter_util.h",
+  ]
+
+  deps = [
+    "//base",
+    "//device/bluetooth",
+    "//device/bluetooth:deprecated_experimental_mojo",
+    "//mojo/public/cpp/bindings",
+  ]
+}

chrome/browser/chromeos/nearby/bluetooth_adapter_util.cc

+// 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.
+
+#include "chrome/browser/chromeos/nearby/bluetooth_adapter_util.h"
+
+#include <memory>
+#include <utility>
+
+#include "device/bluetooth/adapter.h"
+#include "mojo/public/cpp/bindings/self_owned_receiver.h"
+
+namespace chromeos {
+namespace nearby {
+
+void MakeSelfOwnedBluetoothAdapter(
+    mojo::PendingReceiver<bluetooth::mojom::Adapter> pending_receiver,
+    scoped_refptr<device::BluetoothAdapter> adapter) {
+  mojo::MakeSelfOwnedReceiver(
+      std::make_unique<bluetooth::Adapter>(std::move(adapter)),
+      std::move(pending_receiver));
+}
+
+}  // namespace nearby
+}  // namespace chromeos

chrome/browser/chromeos/nearby/bluetooth_adapter_util.h

+// 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_NEARBY_BLUETOOTH_ADAPTER_UTIL_H_
+#define CHROME_BROWSER_CHROMEOS_NEARBY_BLUETOOTH_ADAPTER_UTIL_H_
+
+#include "base/memory/ref_counted.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+
+namespace bluetooth {
+namespace mojom {
+class Adapter;
+}  // namespace mojom
+}  // namespace bluetooth
+
+namespace device {
+class BluetoothAdapter;
+}  // namespace device
+
+namespace chromeos {
+namespace nearby {
+
+// Note: This helper function is implemented in its own file so that it can
+// depend on the bluetooth::mojom::Adapter interface, which is only visible to a
+// limited set of clients.
+void MakeSelfOwnedBluetoothAdapter(
+    mojo::PendingReceiver<bluetooth::mojom::Adapter> pending_receiver,
+    scoped_refptr<device::BluetoothAdapter> adapter);
+
+}  // namespace nearby
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_NEARBY_BLUETOOTH_ADAPTER_UTIL_H_

chrome/browser/chromeos/nearby/nearby_connections_dependencies_provider.cc

+// 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.
+
+#include "chrome/browser/chromeos/nearby/nearby_connections_dependencies_provider.h"
+
+#include "chrome/browser/chromeos/nearby/bluetooth_adapter_util.h"
+#include "chrome/browser/nearby_sharing/webrtc_signaling_messenger.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/sharing/webrtc/ice_config_fetcher.h"
+#include "chrome/browser/sharing/webrtc/sharing_mojo_service.h"
+#include "content/public/browser/storage_partition.h"
+#include "device/bluetooth/bluetooth_adapter_factory.h"
+#include "mojo/public/cpp/bindings/self_owned_receiver.h"
+#include "net/base/network_isolation_key.h"
+#include "services/network/public/mojom/network_context.mojom.h"
+#include "services/network/public/mojom/p2p_trusted.mojom.h"
+
+namespace chromeos {
+namespace nearby {
+namespace {
+
+template <typename T>
+struct MojoPipe {
+  mojo::PendingRemote<T> remote;
+  mojo::PendingReceiver<T> receiver{remote.InitWithNewPipeAndPassReceiver()};
+};
+
+class P2PTrustedSocketManagerClientImpl
+    : public network::mojom::P2PTrustedSocketManagerClient {
+ public:
+  explicit P2PTrustedSocketManagerClientImpl(
+      mojo::PendingRemote<network::mojom::P2PTrustedSocketManager>
+          socket_manager)
+      : socket_manager_(std::move(socket_manager)) {}
+  ~P2PTrustedSocketManagerClientImpl() override = default;
+
+  // network::mojom::P2PTrustedSocketManagerClient:
+  void InvalidSocketPortRangeRequested() override { NOTIMPLEMENTED(); }
+  void DumpPacket(const std::vector<uint8_t>& packet_header,
+                  uint64_t packet_length,
+                  bool incoming) override {
+    NOTIMPLEMENTED();
+  }
+
+ private:
+  mojo::Remote<network::mojom::P2PTrustedSocketManager> socket_manager_;
+};
+
+}  // namespace
+
+NearbyConnectionsDependenciesProvider::NearbyConnectionsDependenciesProvider(
+    Profile* profile,
+    signin::IdentityManager* identity_manager)
+    : profile_(profile), identity_manager_(identity_manager) {
+  DCHECK(identity_manager_);
+}
+
+NearbyConnectionsDependenciesProvider::
+    ~NearbyConnectionsDependenciesProvider() = default;
+
+location::nearby::connections::mojom::NearbyConnectionsDependenciesPtr
+NearbyConnectionsDependenciesProvider::GetDependencies() {
+  if (shut_down_)
+    return nullptr;
+
+  auto dependencies = location::nearby::connections::mojom::
+      NearbyConnectionsDependencies::New();
+
+  if (device::BluetoothAdapterFactory::IsBluetoothSupported())
+    dependencies->bluetooth_adapter = GetBluetoothAdapterPendingRemote();
+  else
+    dependencies->bluetooth_adapter = mojo::NullRemote();
+
+  dependencies->webrtc_dependencies = GetWebRtcDependencies();
+
+  return dependencies;
+}
+
+void NearbyConnectionsDependenciesProvider::Shutdown() {
+  shut_down_ = true;
+}
+
+mojo::PendingRemote<bluetooth::mojom::Adapter>
+NearbyConnectionsDependenciesProvider::GetBluetoothAdapterPendingRemote() {
+  mojo::PendingRemote<bluetooth::mojom::Adapter> pending_adapter;
+  device::BluetoothAdapterFactory::Get()->GetAdapter(
+      base::BindOnce(&MakeSelfOwnedBluetoothAdapter,
+                     pending_adapter.InitWithNewPipeAndPassReceiver()));
+
+  return pending_adapter;
+}
+
+location::nearby::connections::mojom::WebRtcDependenciesPtr
+NearbyConnectionsDependenciesProvider::GetWebRtcDependencies() {
+  auto* network_context =
+      content::BrowserContext::GetDefaultStoragePartition(profile_)
+          ->GetNetworkContext();
+
+  MojoPipe<network::mojom::P2PTrustedSocketManagerClient> socket_manager_client;
+  MojoPipe<network::mojom::P2PTrustedSocketManager> trusted_socket_manager;
+  MojoPipe<network::mojom::P2PSocketManager> socket_manager;
+  MojoPipe<network::mojom::MdnsResponder> mdns_responder;
+
+  mojo::MakeSelfOwnedReceiver(
+      std::make_unique<P2PTrustedSocketManagerClientImpl>(
+          std::move(trusted_socket_manager.remote)),
+      std::move(socket_manager_client.receiver));
+
+  // Create socket manager.
+  network_context->CreateP2PSocketManager(
+      net::NetworkIsolationKey::CreateTransient(),
+      std::move(socket_manager_client.remote),
+      std::move(trusted_socket_manager.receiver),
+      std::move(socket_manager.receiver));
+
+  // Create mdns responder.
+  network_context->CreateMdnsResponder(std::move(mdns_responder.receiver));
+
+  // Create ice config fetcher.
+  auto url_loader_factory = profile_->GetURLLoaderFactory();
+  MojoPipe<sharing::mojom::IceConfigFetcher> ice_config_fetcher;
+  mojo::MakeSelfOwnedReceiver(
+      std::make_unique<IceConfigFetcher>(url_loader_factory),
+      std::move(ice_config_fetcher.receiver));
+
+  MojoPipe<sharing::mojom::WebRtcSignalingMessenger> messenger;
+  mojo::MakeSelfOwnedReceiver(std::make_unique<WebRtcSignalingMessenger>(
+                                  identity_manager_, url_loader_factory),
+                              std::move(messenger.receiver));
+
+  return location::nearby::connections::mojom::WebRtcDependencies::New(
+      std::move(socket_manager.remote), std::move(mdns_responder.remote),
+      std::move(ice_config_fetcher.remote), std::move(messenger.remote));
+}
+
+}  // namespace nearby
+}  // namespace chromeos

chrome/browser/chromeos/nearby/nearby_connections_dependencies_provider.h

+// 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_NEARBY_NEARBY_CONNECTIONS_DEPENDENCIES_PROVIDER_H_
+#define CHROME_BROWSER_CHROMEOS_NEARBY_NEARBY_CONNECTIONS_DEPENDENCIES_PROVIDER_H_
+
+#include <memory>
+
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "chromeos/services/nearby/public/mojom/sharing.mojom.h"
+#include "components/keyed_service/core/keyed_service.h"
+
+class Profile;
+
+namespace signin {
+class IdentityManager;
+}  // namespace signin
+
+namespace chromeos {
+namespace nearby {
+
+// Provides dependencies required to initialize Nearby Connections. Implemented
+// as a KeyedService because WebRTC dependencies are linked to the user's
+// identity.
+class NearbyConnectionsDependenciesProvider : public KeyedService {
+ public:
+  NearbyConnectionsDependenciesProvider(
+      Profile* profile,
+      signin::IdentityManager* identity_manager);
+  ~NearbyConnectionsDependenciesProvider() override;
+
+  // Note: Returns null during session shutdown.
+  location::nearby::connections::mojom::NearbyConnectionsDependenciesPtr
+  GetDependencies();
+
+ private:
+  // KeyedService:
+  void Shutdown() override;
+
+  mojo::PendingRemote<bluetooth::mojom::Adapter>
+  GetBluetoothAdapterPendingRemote();
+
+  location::nearby::connections::mojom::WebRtcDependenciesPtr
+  GetWebRtcDependencies();
+
+  bool shut_down_ = false;
+
+  Profile* profile_;
+  signin::IdentityManager* identity_manager_;
+
+  base::WeakPtrFactory<NearbyConnectionsDependenciesProvider> weak_ptr_factory_{
+      this};
+};
+
+}  // namespace nearby
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_NEARBY_NEARBY_CONNECTIONS_DEPENDENCIES_PROVIDER_H_

chrome/browser/chromeos/nearby/nearby_connections_dependencies_provider_factory.cc

+// 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.
+
+#include "chrome/browser/chromeos/nearby/nearby_connections_dependencies_provider_factory.h"
+
+#include "chrome/browser/chromeos/nearby/nearby_connections_dependencies_provider.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/signin/identity_manager_factory.h"
+#include "components/keyed_service/content/browser_context_dependency_manager.h"
+
+namespace chromeos {
+namespace nearby {
+
+// static
+NearbyConnectionsDependenciesProvider*
+NearbyConnectionsDependenciesProviderFactory::GetForProfile(Profile* profile) {
+  return static_cast<NearbyConnectionsDependenciesProvider*>(
+      NearbyConnectionsDependenciesProviderFactory::GetInstance()
+          ->GetServiceForBrowserContext(profile, /*create=*/true));
+}
+
+// static
+NearbyConnectionsDependenciesProviderFactory*
+NearbyConnectionsDependenciesProviderFactory::GetInstance() {
+  return base::Singleton<NearbyConnectionsDependenciesProviderFactory>::get();
+}
+
+NearbyConnectionsDependenciesProviderFactory::
+    NearbyConnectionsDependenciesProviderFactory()
+    : BrowserContextKeyedServiceFactory(
+          "NearbyConnectionsDependenciesProvider",
+          BrowserContextDependencyManager::GetInstance()) {
+  DependsOn(IdentityManagerFactory::GetInstance());
+}
+
+NearbyConnectionsDependenciesProviderFactory::
+    ~NearbyConnectionsDependenciesProviderFactory() = default;
+
+KeyedService*
+NearbyConnectionsDependenciesProviderFactory::BuildServiceInstanceFor(
+    content::BrowserContext* context) const {
+  Profile* profile = Profile::FromBrowserContext(context);
+  return new NearbyConnectionsDependenciesProvider(
+      profile, IdentityManagerFactory::GetForProfile(profile));
+}
+
+bool NearbyConnectionsDependenciesProviderFactory::
+    ServiceIsCreatedWithBrowserContext() const {
+  return true;
+}
+
+}  // namespace nearby
+}  // namespace chromeos

chrome/browser/chromeos/nearby/nearby_connections_dependencies_provider_factory.h

+// 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_NEARBY_NEARBY_CONNECTIONS_DEPENDENCIES_PROVIDER_FACTORY_H_
+#define CHROME_BROWSER_CHROMEOS_NEARBY_NEARBY_CONNECTIONS_DEPENDENCIES_PROVIDER_FACTORY_H_
+
+#include "base/memory/singleton.h"
+#include "components/keyed_service/content/browser_context_keyed_service_factory.h"
+
+class Profile;
+
+namespace chromeos {
+namespace nearby {
+
+class NearbyConnectionsDependenciesProvider;
+
+class NearbyConnectionsDependenciesProviderFactory
+    : public BrowserContextKeyedServiceFactory {
+ public:
+  static NearbyConnectionsDependenciesProvider* GetForProfile(Profile* profile);
+
+  static NearbyConnectionsDependenciesProviderFactory* GetInstance();
+
+ private:
+  friend struct base::DefaultSingletonTraits<
+      NearbyConnectionsDependenciesProviderFactory>;
+
+  NearbyConnectionsDependenciesProviderFactory();
+  NearbyConnectionsDependenciesProviderFactory(
+      const NearbyConnectionsDependenciesProviderFactory&) = delete;
+  NearbyConnectionsDependenciesProviderFactory& operator=(
+      const NearbyConnectionsDependenciesProviderFactory&) = delete;
+  ~NearbyConnectionsDependenciesProviderFactory() override;
+
+  // BrowserContextKeyedServiceFactory:
+  KeyedService* BuildServiceInstanceFor(
+      content::BrowserContext* context) const override;
+  bool ServiceIsCreatedWithBrowserContext() const override;
+};
+
+}  // namespace nearby
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_NEARBY_NEARBY_CONNECTIONS_DEPENDENCIES_PROVIDER_FACTORY_H_

device/bluetooth/BUILD.gn

@@ -59,8 +59,9 @@ source_set("deprecated_experimental_mojo") {
     # Experimental implementation not ready for production use yet. See
     # public/mojom/README.md
 
-    # Single approved client:
+    # Approved clients:
     "//chrome/browser/ui/webui/bluetooth_internals:*",
+    "//chrome/browser/chromeos/nearby:bluetooth_adapter_util",
 
     # Implementation tests
     # Ideally only device_unittests, however android & fushia generate