// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/services/sharing/sharing_impl.h"
#include <utility>
#include "base/functional/callback.h"
#include "base/metrics/histogram_functions.h"
#include "base/task/sequenced_task_runner.h"
#include "chrome/services/sharing/nearby/decoder/nearby_decoder.h"
#include "chrome/services/sharing/nearby/nearby_connections.h"
#include "chrome/services/sharing/nearby/nearby_presence.h"
#include "chrome/services/sharing/nearby/quick_start_decoder/quick_start_decoder.h"
#include "chromeos/ash/services/nearby/public/mojom/nearby_decoder.mojom.h"
#include "chromeos/ash/services/nearby/public/mojom/quick_start_decoder.mojom.h"
namespace sharing {
SharingImpl::SharingImpl(
mojo::PendingReceiver<mojom::Sharing> receiver,
scoped_refptr<base::SequencedTaskRunner> io_task_runner)
: receiver_(this, std::move(receiver)),
io_task_runner_(std::move(io_task_runner)) {}
SharingImpl::~SharingImpl() {
// No need to call DoShutDown() from the destructor because SharingImpl should
// only be destroyed after SharingImpl::ShutDown() has been called.
CHECK(!nearby_connections_ && !nearby_presence_ && !nearby_decoder_);
}
void SharingImpl::Connect(
NearbyDependenciesPtr deps,
mojo::PendingReceiver<NearbyConnectionsMojom> connections_receiver,
mojo::PendingReceiver<NearbyPresenceMojom> presence_receiver,
mojo::PendingReceiver<::sharing::mojom::NearbySharingDecoder>
decoder_receiver,
mojo::PendingReceiver<ash::quick_start::mojom::QuickStartDecoder>
quick_start_decoder_receiver) {
CHECK(!nearby_connections_);
CHECK(!nearby_presence_);
CHECK(!nearby_decoder_);
nearby::api::LogMessage::Severity min_log_severity = deps->min_log_severity;
InitializeNearbySharedRemotes(std::move(deps));
nearby_presence_ = std::make_unique<NearbyPresence>(
std::move(presence_receiver),
base::BindOnce(&SharingImpl::OnDisconnect, weak_ptr_factory_.GetWeakPtr(),
MojoDependencyName::kNearbyPresence));
nearby_connections_ = std::make_unique<NearbyConnections>(
std::move(connections_receiver),
nearby_presence_->GetLocalDeviceProvider(), min_log_severity,
base::BindOnce(&SharingImpl::OnDisconnect, weak_ptr_factory_.GetWeakPtr(),
MojoDependencyName::kNearbyConnections));
nearby_decoder_ = std::make_unique<NearbySharingDecoder>(
std::move(decoder_receiver),
base::BindOnce(&SharingImpl::OnDisconnect, weak_ptr_factory_.GetWeakPtr(),
MojoDependencyName::kNearbyShareDecoder));
quick_start_decoder_ = std::make_unique<ash::quick_start::QuickStartDecoder>(
std::move(quick_start_decoder_receiver),
base::BindOnce(&SharingImpl::OnDisconnect, weak_ptr_factory_.GetWeakPtr(),
MojoDependencyName::kQuickStartDecoder));
}
void SharingImpl::ShutDown(ShutDownCallback callback) {
DoShutDown(/*is_expected=*/true);
std::move(callback).Run();
}
void SharingImpl::DoShutDown(bool is_expected) {
nearby::NearbySharedRemotes::SetInstance(nullptr);
if (!nearby_connections_ && !nearby_presence_ && !nearby_decoder_) {
return;
}
nearby_connections_.reset();
nearby_presence_.reset();
nearby_decoder_.reset();
// Leave |receiver_| valid. Its disconnection is reserved as a signal that the
// Sharing utility process has crashed.
}
void SharingImpl::OnDisconnect(MojoDependencyName mojo_dependency_name) {
LOG(WARNING) << "The utility process has detected that the browser process "
"has disconnected from a mojo pipe: ["
<< GetMojoDependencyName(mojo_dependency_name) << "]";
base::UmaHistogramEnumeration(
"Nearby.Connections.UtilityProcessShutdownReason."
"DisconnectedMojoDependency",
mojo_dependency_name);
LOG(ERROR) << "A Sharing process dependency has unexpectedly disconnected.";
DoShutDown(/*is_expected=*/false);
}
void SharingImpl::InitializeNearbySharedRemotes(NearbyDependenciesPtr deps) {
nearby_shared_remotes_ = std::make_unique<nearby::NearbySharedRemotes>();
nearby::NearbySharedRemotes::SetInstance(nearby_shared_remotes_.get());
if (deps->bluetooth_adapter) {
nearby_shared_remotes_->bluetooth_adapter.Bind(
std::move(deps->bluetooth_adapter), io_task_runner_);
nearby_shared_remotes_->bluetooth_adapter.set_disconnect_handler(
base::BindOnce(&SharingImpl::OnDisconnect,
weak_ptr_factory_.GetWeakPtr(),
MojoDependencyName::kBluetoothAdapter),
base::SequencedTaskRunner::GetCurrentDefault());
}
if (deps->nearby_presence_credential_storage) {
nearby_shared_remotes_->nearby_presence_credential_storage.Bind(
std::move(deps->nearby_presence_credential_storage), io_task_runner_);
nearby_shared_remotes_->nearby_presence_credential_storage
.set_disconnect_handler(
base::BindOnce(
&SharingImpl::OnDisconnect, weak_ptr_factory_.GetWeakPtr(),
MojoDependencyName::kNearbyPresenceCredentialStorage),
base::SequencedTaskRunner::GetCurrentDefault());
}
nearby_shared_remotes_->socket_manager.Bind(
std::move(deps->webrtc_dependencies->socket_manager), io_task_runner_);
nearby_shared_remotes_->socket_manager.set_disconnect_handler(
base::BindOnce(&SharingImpl::OnDisconnect, weak_ptr_factory_.GetWeakPtr(),
MojoDependencyName::kSocketManager),
base::SequencedTaskRunner::GetCurrentDefault());
nearby_shared_remotes_->mdns_responder_factory.Bind(
std::move(deps->webrtc_dependencies->mdns_responder_factory),
io_task_runner_);
nearby_shared_remotes_->mdns_responder_factory.set_disconnect_handler(
base::BindOnce(&SharingImpl::OnDisconnect, weak_ptr_factory_.GetWeakPtr(),
MojoDependencyName::kMdnsResponder),
base::SequencedTaskRunner::GetCurrentDefault());
nearby_shared_remotes_->ice_config_fetcher.Bind(
std::move(deps->webrtc_dependencies->ice_config_fetcher),
io_task_runner_);
nearby_shared_remotes_->ice_config_fetcher.set_disconnect_handler(
base::BindOnce(&SharingImpl::OnDisconnect, weak_ptr_factory_.GetWeakPtr(),
MojoDependencyName::kIceConfigFetcher),
base::SequencedTaskRunner::GetCurrentDefault());
nearby_shared_remotes_->webrtc_signaling_messenger.Bind(
std::move(deps->webrtc_dependencies->messenger), io_task_runner_);
nearby_shared_remotes_->webrtc_signaling_messenger.set_disconnect_handler(
base::BindOnce(&SharingImpl::OnDisconnect, weak_ptr_factory_.GetWeakPtr(),
MojoDependencyName::kWebRtcSignalingMessenger),
base::SequencedTaskRunner::GetCurrentDefault());
// TODO(https://crbug.com/1261238): This should always be true when the
// WifiLan feature flag is enabled. Remove when flag is enabled by default.
if (deps->wifilan_dependencies) {
nearby_shared_remotes_->cros_network_config.Bind(
std::move(deps->wifilan_dependencies->cros_network_config),
io_task_runner_);
nearby_shared_remotes_->cros_network_config.set_disconnect_handler(
base::BindOnce(&SharingImpl::OnDisconnect,
weak_ptr_factory_.GetWeakPtr(),
MojoDependencyName::kCrosNetworkConfig),
base::SequencedTaskRunner::GetCurrentDefault());
nearby_shared_remotes_->firewall_hole_factory.Bind(
std::move(deps->wifilan_dependencies->firewall_hole_factory),
io_task_runner_);
nearby_shared_remotes_->firewall_hole_factory.set_disconnect_handler(
base::BindOnce(&SharingImpl::OnDisconnect,
weak_ptr_factory_.GetWeakPtr(),
MojoDependencyName::kFirewallHoleFactory),
base::SequencedTaskRunner::GetCurrentDefault());
nearby_shared_remotes_->tcp_socket_factory.Bind(
std::move(deps->wifilan_dependencies->tcp_socket_factory),
io_task_runner_);
nearby_shared_remotes_->tcp_socket_factory.set_disconnect_handler(
base::BindOnce(&SharingImpl::OnDisconnect,
weak_ptr_factory_.GetWeakPtr(),
MojoDependencyName::kTcpSocketFactory),
base::SequencedTaskRunner::GetCurrentDefault());
if (deps->wifilan_dependencies->mdns_manager) {
nearby_shared_remotes_->mdns_manager.Bind(
std::move(deps->wifilan_dependencies->mdns_manager), io_task_runner_);
nearby_shared_remotes_->mdns_manager.set_disconnect_handler(
base::BindOnce(&SharingImpl::OnDisconnect,
weak_ptr_factory_.GetWeakPtr(),
MojoDependencyName::kMdnsManager),
base::SequencedTaskRunner::GetCurrentDefault());
}
}
if (deps->wifidirect_dependencies) {
nearby_shared_remotes_->wifi_direct_firewall_hole_factory.Bind(
std::move(deps->wifidirect_dependencies->firewall_hole_factory),
io_task_runner_);
nearby_shared_remotes_->wifi_direct_firewall_hole_factory
.set_disconnect_handler(
base::BindOnce(&SharingImpl::OnDisconnect,
weak_ptr_factory_.GetWeakPtr(),
MojoDependencyName::kFirewallHoleFactory),
base::SequencedTaskRunner::GetCurrentDefault());
nearby_shared_remotes_->wifi_direct_manager.Bind(
std::move(deps->wifidirect_dependencies->wifi_direct_manager),
io_task_runner_);
nearby_shared_remotes_->wifi_direct_manager.set_disconnect_handler(
base::BindOnce(&SharingImpl::OnDisconnect,
weak_ptr_factory_.GetWeakPtr(),
MojoDependencyName::kWifiDirectManager),
base::SequencedTaskRunner::GetCurrentDefault());
}
}
std::string SharingImpl::GetMojoDependencyName(
MojoDependencyName dependency_name) {
switch (dependency_name) {
case MojoDependencyName::kNearbyConnections:
return "Nearby Connections";
case MojoDependencyName::kBluetoothAdapter:
return "Bluetooth Adapter";
case MojoDependencyName::kSocketManager:
return "Socket Manager";
case MojoDependencyName::kMdnsResponder:
return "MDNS Responder";
case MojoDependencyName::kIceConfigFetcher:
return "ICE Config Fetcher";
case MojoDependencyName::kWebRtcSignalingMessenger:
return "WebRTC Signaling Messenger";
case MojoDependencyName::kCrosNetworkConfig:
return "CrOS Network Config";
case MojoDependencyName::kFirewallHoleFactory:
return "Firewall Hole Factory";
case MojoDependencyName::kTcpSocketFactory:
return "TCP socket Factory";
case MojoDependencyName::kNearbyPresence:
return "Nearby Presence";
case MojoDependencyName::kNearbyShareDecoder:
return "Decoder";
case MojoDependencyName::kQuickStartDecoder:
return "Quick Start Decoder";
case MojoDependencyName::kNearbyPresenceCredentialStorage:
return "Nearby Presence Credential Storage";
case MojoDependencyName::kWifiDirectManager:
return "WiFi Direct Manager";
case MojoDependencyName::kMdnsManager:
return "mDNS Manager";
}
}
} // namespace sharing
Codebase Browser
chromium