services/device/generic_sensor/sensor_provider_impl.cc - chromium/src.git - Git at Google

 // Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "services/device/generic_sensor/sensor_provider_impl.h"

 #include <memory>
 #include <utility>

 #include "base/check_op.h"
 #include "base/containers/contains.h"
 #include "base/feature_list.h"
 #include "base/functional/bind.h"
 #include "base/memory/ptr_util.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "services/device/generic_sensor/platform_sensor_provider.h"
 #include "services/device/generic_sensor/sensor_impl.h"
 #include "services/device/generic_sensor/virtual_platform_sensor.h"
 #include "services/device/generic_sensor/virtual_platform_sensor_provider.h"
 #include "services/device/public/cpp/device_features.h"
 #include "services/device/public/cpp/generic_sensor/sensor_reading_shared_buffer.h"
 #include "services/device/public/cpp/generic_sensor/sensor_traits.h"

 namespace device {

 namespace {

 bool IsExtraSensorClass(mojom::SensorType type) {
   switch (type) {
     case mojom::SensorType::ACCELEROMETER:
     case mojom::SensorType::LINEAR_ACCELERATION:
     case mojom::SensorType::GRAVITY:
     case mojom::SensorType::GYROSCOPE:
     case mojom::SensorType::ABSOLUTE_ORIENTATION_EULER_ANGLES:
     case mojom::SensorType::ABSOLUTE_ORIENTATION_QUATERNION:
     case mojom::SensorType::RELATIVE_ORIENTATION_EULER_ANGLES:
     case mojom::SensorType::RELATIVE_ORIENTATION_QUATERNION:
       return false;
     default:
       return true;
   }
 }

 }  // namespace

 SensorProviderImpl::SensorProviderImpl(
     std::unique_ptr<PlatformSensorProvider> provider)
     : provider_(std::move(provider)) {
   DCHECK(provider_);

   // This is used to clean up VirtualSensorProvider instances if they do not
   // have any pending requests or connected sensors, as this class has
   // DeviceService's lifetime but VirtualSensorProviders are per
   // content::WebContents.
   receivers_.set_disconnect_handler(base::BindRepeating(
       &SensorProviderImpl::OnReceiverDisconnected, base::Unretained(this)));
 }

 SensorProviderImpl::~SensorProviderImpl() = default;

 void SensorProviderImpl::Bind(
     mojo::PendingReceiver<mojom::SensorProvider> receiver) {
   receivers_.Add(this, std::move(receiver));
 }

 void SensorProviderImpl::OnReceiverDisconnected() {
   // If the other side of the pipe has been disconnected, the corresponding
   // VirtualPlatformSensorProvider can be destroyed if it has no connected
   // sensors or pending requests, as it is never going to be referenced again.
   // This is the case in most workflows, as the Blink connections to SensorImpl
   // are shut down before WebContentsSensorProviderProxy in content terminates
   // its Mojo connection, but if a VirtualPlatformSensorProvider cannot be
   // removed it is not a big problem, as the data structure is not big.
   const mojo::ReceiverId receiver_id = receivers_.current_receiver();
   auto it = virtual_providers_.find(receiver_id);
   if (it != virtual_providers_.end()) {
     const auto& provider = it->second;
     if (!provider->has_pending_requests() && !provider->has_sensors()) {
       virtual_providers_.erase(it);
     }
   }
 }

 void SensorProviderImpl::GetSensor(mojom::SensorType type,
                                    GetSensorCallback callback) {
   if (!base::FeatureList::IsEnabled(features::kGenericSensorExtraClasses) &&
       IsExtraSensorClass(type)) {
     std::move(callback).Run(mojom::SensorCreationResult::ERROR_NOT_AVAILABLE,
                             nullptr);
     return;
   }

   PlatformSensorProvider* provider = provider_.get();
   auto it_virtual_provider =
       virtual_providers_.find(receivers_.current_receiver());
   if (it_virtual_provider != virtual_providers_.end() &&
       it_virtual_provider->second->IsOverridingSensor(type)) {
     provider = it_virtual_provider->second.get();
   }

   auto cloned_region = provider->CloneSharedMemoryRegion();
   if (!cloned_region.IsValid()) {
     std::move(callback).Run(mojom::SensorCreationResult::ERROR_NOT_AVAILABLE,
                             nullptr);
     return;
   }

   scoped_refptr<PlatformSensor> sensor = provider->GetSensor(type);
   if (!sensor) {
     // If we are here, it means there is no virtual sensor of this type,
     // otherwise the GetSensor() call above would have returned it.
     provider->CreateSensor(
         type, base::BindOnce(&SensorProviderImpl::SensorCreated,
                              weak_ptr_factory_.GetWeakPtr(),
                              std::move(cloned_region), std::move(callback)));
     return;
   }

   SensorCreated(std::move(cloned_region), std::move(callback),
                 std::move(sensor));
 }

 void SensorProviderImpl::SensorCreated(
     base::ReadOnlySharedMemoryRegion cloned_region,
     GetSensorCallback callback,
     scoped_refptr<PlatformSensor> sensor) {
   if (!sensor) {
     std::move(callback).Run(mojom::SensorCreationResult::ERROR_NOT_AVAILABLE,
                             nullptr);
     return;
   }

   auto init_params = mojom::SensorInitParams::New();

   auto sensor_impl = std::make_unique<SensorImpl>(sensor);
   init_params->client_receiver = sensor_impl->GetClient();

   mojo::PendingRemote<mojom::Sensor> pending_sensor;
   sensor_receivers_.Add(std::move(sensor_impl),
                         pending_sensor.InitWithNewPipeAndPassReceiver());
   init_params->sensor = std::move(pending_sensor);

   init_params->memory = std::move(cloned_region);
   init_params->buffer_offset =
       GetSensorReadingSharedBufferOffset(sensor->GetType());
   init_params->mode = sensor->GetReportingMode();

   double maximum_frequency = sensor->GetMaximumSupportedFrequency();
   DCHECK_GT(maximum_frequency, 0.0);

   double minimum_frequency = sensor->GetMinimumSupportedFrequency();
   DCHECK_GT(minimum_frequency, 0.0);

   const double maximum_allowed_frequency =
       GetSensorMaxAllowedFrequency(sensor->GetType());
   if (maximum_frequency > maximum_allowed_frequency)
     maximum_frequency = maximum_allowed_frequency;
   // These checks are to make sure the following assertion is still true:
   // 'minimum_frequency <= default_frequency <= maximum_frequency'
   // after we capped the maximium frequency to the value from traits
   // (and also in case platform gave us some wacky values).
   if (minimum_frequency > maximum_frequency)
     minimum_frequency = maximum_frequency;

   auto default_configuration = sensor->GetDefaultConfiguration();
   if (default_configuration.frequency() > maximum_frequency)
     default_configuration.set_frequency(maximum_frequency);
   if (default_configuration.frequency() < minimum_frequency)
     default_configuration.set_frequency(minimum_frequency);

   init_params->default_configuration = default_configuration;
   init_params->maximum_frequency = maximum_frequency;
   init_params->minimum_frequency = sensor->GetMinimumSupportedFrequency();
   DCHECK_GT(init_params->minimum_frequency, 0.0);
   DCHECK_GE(init_params->maximum_frequency, init_params->minimum_frequency);

   std::move(callback).Run(mojom::SensorCreationResult::SUCCESS,
                           std::move(init_params));
 }

 void SensorProviderImpl::CreateVirtualSensor(
     mojom::SensorType type,
     mojom::VirtualSensorMetadataPtr metadata,
     CreateVirtualSensorCallback callback) {
   const mojo::ReceiverId receiver_id = receivers_.current_receiver();
   auto& virtual_provider = virtual_providers_[receiver_id];

   if (!virtual_provider) {
     virtual_provider = std::make_unique<VirtualPlatformSensorProvider>();
   }

   mojom::CreateVirtualSensorResult result =
       virtual_provider->AddSensorOverride(type, std::move(metadata))
           ? mojom::CreateVirtualSensorResult::kSuccess
           : mojom::CreateVirtualSensorResult::kSensorTypeAlreadyOverridden;
   std::move(callback).Run(result);
 }

 void SensorProviderImpl::UpdateVirtualSensor(
     mojom::SensorType type,
     const SensorReading& reading,
     UpdateVirtualSensorCallback callback) {
   auto virtual_provider_it =
       virtual_providers_.find(receivers_.current_receiver());

   if (virtual_provider_it == virtual_providers_.end()) {
     std::move(callback).Run(
         mojom::UpdateVirtualSensorResult::kSensorTypeNotOverridden);
     return;
   }

   auto* virtual_provider = virtual_provider_it->second.get();

   if (!virtual_provider->IsOverridingSensor(type)) {
     std::move(callback).Run(
         mojom::UpdateVirtualSensorResult::kSensorTypeNotOverridden);
     return;
   }

   virtual_provider->AddReading(type, reading);
   std::move(callback).Run(mojom::UpdateVirtualSensorResult::kSuccess);
 }

 void SensorProviderImpl::RemoveVirtualSensor(
     mojom::SensorType type,
     RemoveVirtualSensorCallback callback) {
   auto virtual_provider_it =
       virtual_providers_.find(receivers_.current_receiver());

   if (virtual_provider_it == virtual_providers_.end()) {
     std::move(callback).Run();
     return;
   }

   virtual_provider_it->second->RemoveSensorOverride(type);
   std::move(callback).Run();
 }

 void SensorProviderImpl::GetVirtualSensorInformation(
     mojom::SensorType type,
     GetVirtualSensorInformationCallback callback) {
   auto virtual_provider_it =
       virtual_providers_.find(receivers_.current_receiver());

   if (virtual_provider_it == virtual_providers_.end()) {
     std::move(callback).Run(mojom::GetVirtualSensorInformationResult::NewError(
         mojom::GetVirtualSensorInformationError::kSensorTypeNotOverridden));
     return;
   }

   auto* virtual_provider = virtual_provider_it->second.get();

   if (!virtual_provider->IsOverridingSensor(type)) {
     std::move(callback).Run(mojom::GetVirtualSensorInformationResult::NewError(
         mojom::GetVirtualSensorInformationError::kSensorTypeNotOverridden));
     return;
   }

   auto platform_sensor = virtual_provider->GetSensor(type);
   if (!platform_sensor) {
     // The sensor has not been created yet.
     std::move(callback).Run(mojom::GetVirtualSensorInformationResult::NewInfo(
         mojom::VirtualSensorInformation::New(/*sampling_frequency=*/0.0)));
     return;
   }

   auto* virtual_sensor =
       static_cast<VirtualPlatformSensor*>(platform_sensor.get());
   auto sensor_information = mojom::VirtualSensorInformation::New();
   sensor_information->sampling_frequency =
       virtual_sensor->optimal_configuration().has_value()
           ? virtual_sensor->optimal_configuration().value().frequency()
           : 0.0;

   std::move(callback).Run(mojom::GetVirtualSensorInformationResult::NewInfo(
       std::move(sensor_information)));
 }

 size_t SensorProviderImpl::GetVirtualProviderCountForTesting() const {
   return virtual_providers_.size();
 }

 const VirtualPlatformSensorProvider*
 SensorProviderImpl::GetLastVirtualSensorProviderForTesting() const {
   CHECK_EQ(virtual_providers_.size(), 1U);
   return virtual_providers_.begin()->second.get();
 }

 }  // namespace device
	// Copyright 2016 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "services/device/generic_sensor/sensor_provider_impl.h"

	#include <memory>
	#include <utility>

	#include "base/check_op.h"
	#include "base/containers/contains.h"
	#include "base/feature_list.h"
	#include "base/functional/bind.h"
	#include "base/memory/ptr_util.h"
	#include "mojo/public/cpp/bindings/pending_remote.h"
	#include "services/device/generic_sensor/platform_sensor_provider.h"
	#include "services/device/generic_sensor/sensor_impl.h"
	#include "services/device/generic_sensor/virtual_platform_sensor.h"
	#include "services/device/generic_sensor/virtual_platform_sensor_provider.h"
	#include "services/device/public/cpp/device_features.h"
	#include "services/device/public/cpp/generic_sensor/sensor_reading_shared_buffer.h"
	#include "services/device/public/cpp/generic_sensor/sensor_traits.h"

	namespace device {

	namespace {

	bool IsExtraSensorClass(mojom::SensorType type) {
	switch (type) {
	case mojom::SensorType::ACCELEROMETER:
	case mojom::SensorType::LINEAR_ACCELERATION:
	case mojom::SensorType::GRAVITY:
	case mojom::SensorType::GYROSCOPE:
	case mojom::SensorType::ABSOLUTE_ORIENTATION_EULER_ANGLES:
	case mojom::SensorType::ABSOLUTE_ORIENTATION_QUATERNION:
	case mojom::SensorType::RELATIVE_ORIENTATION_EULER_ANGLES:
	case mojom::SensorType::RELATIVE_ORIENTATION_QUATERNION:
	return false;
	default:
	return true;
	}
	}

	} // namespace

	SensorProviderImpl::SensorProviderImpl(
	std::unique_ptr<PlatformSensorProvider> provider)
	: provider_(std::move(provider)) {
	DCHECK(provider_);

	// This is used to clean up VirtualSensorProvider instances if they do not
	// have any pending requests or connected sensors, as this class has
	// DeviceService's lifetime but VirtualSensorProviders are per
	// content::WebContents.
	receivers_.set_disconnect_handler(base::BindRepeating(
	&SensorProviderImpl::OnReceiverDisconnected, base::Unretained(this)));
	}

	SensorProviderImpl::~SensorProviderImpl() = default;

	void SensorProviderImpl::Bind(
	mojo::PendingReceiver<mojom::SensorProvider> receiver) {
	receivers_.Add(this, std::move(receiver));
	}

	void SensorProviderImpl::OnReceiverDisconnected() {
	// If the other side of the pipe has been disconnected, the corresponding
	// VirtualPlatformSensorProvider can be destroyed if it has no connected
	// sensors or pending requests, as it is never going to be referenced again.
	// This is the case in most workflows, as the Blink connections to SensorImpl
	// are shut down before WebContentsSensorProviderProxy in content terminates
	// its Mojo connection, but if a VirtualPlatformSensorProvider cannot be
	// removed it is not a big problem, as the data structure is not big.
	const mojo::ReceiverId receiver_id = receivers_.current_receiver();
	auto it = virtual_providers_.find(receiver_id);
	if (it != virtual_providers_.end()) {
	const auto& provider = it->second;
	if (!provider->has_pending_requests() && !provider->has_sensors()) {
	virtual_providers_.erase(it);
	}
	}
	}

	void SensorProviderImpl::GetSensor(mojom::SensorType type,
	GetSensorCallback callback) {
	if (!base::FeatureList::IsEnabled(features::kGenericSensorExtraClasses) &&
	IsExtraSensorClass(type)) {
	std::move(callback).Run(mojom::SensorCreationResult::ERROR_NOT_AVAILABLE,
	nullptr);
	return;
	}

	PlatformSensorProvider* provider = provider_.get();
	auto it_virtual_provider =
	virtual_providers_.find(receivers_.current_receiver());
	if (it_virtual_provider != virtual_providers_.end() &&
	it_virtual_provider->second->IsOverridingSensor(type)) {
	provider = it_virtual_provider->second.get();
	}

	auto cloned_region = provider->CloneSharedMemoryRegion();
	if (!cloned_region.IsValid()) {
	std::move(callback).Run(mojom::SensorCreationResult::ERROR_NOT_AVAILABLE,
	nullptr);
	return;
	}

	scoped_refptr<PlatformSensor> sensor = provider->GetSensor(type);
	if (!sensor) {
	// If we are here, it means there is no virtual sensor of this type,
	// otherwise the GetSensor() call above would have returned it.
	provider->CreateSensor(
	type, base::BindOnce(&SensorProviderImpl::SensorCreated,
	weak_ptr_factory_.GetWeakPtr(),
	std::move(cloned_region), std::move(callback)));
	return;
	}

	SensorCreated(std::move(cloned_region), std::move(callback),
	std::move(sensor));
	}

	void SensorProviderImpl::SensorCreated(
	base::ReadOnlySharedMemoryRegion cloned_region,
	GetSensorCallback callback,
	scoped_refptr<PlatformSensor> sensor) {
	if (!sensor) {
	std::move(callback).Run(mojom::SensorCreationResult::ERROR_NOT_AVAILABLE,
	nullptr);
	return;
	}

	auto init_params = mojom::SensorInitParams::New();

	auto sensor_impl = std::make_unique<SensorImpl>(sensor);
	init_params->client_receiver = sensor_impl->GetClient();

	mojo::PendingRemote<mojom::Sensor> pending_sensor;
	sensor_receivers_.Add(std::move(sensor_impl),
	pending_sensor.InitWithNewPipeAndPassReceiver());
	init_params->sensor = std::move(pending_sensor);

	init_params->memory = std::move(cloned_region);
	init_params->buffer_offset =
	GetSensorReadingSharedBufferOffset(sensor->GetType());
	init_params->mode = sensor->GetReportingMode();

	double maximum_frequency = sensor->GetMaximumSupportedFrequency();
	DCHECK_GT(maximum_frequency, 0.0);

	double minimum_frequency = sensor->GetMinimumSupportedFrequency();
	DCHECK_GT(minimum_frequency, 0.0);

	const double maximum_allowed_frequency =
	GetSensorMaxAllowedFrequency(sensor->GetType());
	if (maximum_frequency > maximum_allowed_frequency)
	maximum_frequency = maximum_allowed_frequency;
	// These checks are to make sure the following assertion is still true:
	// 'minimum_frequency <= default_frequency <= maximum_frequency'
	// after we capped the maximium frequency to the value from traits
	// (and also in case platform gave us some wacky values).
	if (minimum_frequency > maximum_frequency)
	minimum_frequency = maximum_frequency;

	auto default_configuration = sensor->GetDefaultConfiguration();
	if (default_configuration.frequency() > maximum_frequency)
	default_configuration.set_frequency(maximum_frequency);
	if (default_configuration.frequency() < minimum_frequency)
	default_configuration.set_frequency(minimum_frequency);

	init_params->default_configuration = default_configuration;
	init_params->maximum_frequency = maximum_frequency;
	init_params->minimum_frequency = sensor->GetMinimumSupportedFrequency();
	DCHECK_GT(init_params->minimum_frequency, 0.0);
	DCHECK_GE(init_params->maximum_frequency, init_params->minimum_frequency);

	std::move(callback).Run(mojom::SensorCreationResult::SUCCESS,
	std::move(init_params));
	}

	void SensorProviderImpl::CreateVirtualSensor(
	mojom::SensorType type,
	mojom::VirtualSensorMetadataPtr metadata,
	CreateVirtualSensorCallback callback) {
	const mojo::ReceiverId receiver_id = receivers_.current_receiver();
	auto& virtual_provider = virtual_providers_[receiver_id];

	if (!virtual_provider) {
	virtual_provider = std::make_unique<VirtualPlatformSensorProvider>();
	}

	mojom::CreateVirtualSensorResult result =
	virtual_provider->AddSensorOverride(type, std::move(metadata))
	? mojom::CreateVirtualSensorResult::kSuccess
	: mojom::CreateVirtualSensorResult::kSensorTypeAlreadyOverridden;
	std::move(callback).Run(result);
	}

	void SensorProviderImpl::UpdateVirtualSensor(
	mojom::SensorType type,
	const SensorReading& reading,
	UpdateVirtualSensorCallback callback) {
	auto virtual_provider_it =
	virtual_providers_.find(receivers_.current_receiver());

	if (virtual_provider_it == virtual_providers_.end()) {
	std::move(callback).Run(
	mojom::UpdateVirtualSensorResult::kSensorTypeNotOverridden);
	return;
	}

	auto* virtual_provider = virtual_provider_it->second.get();

	if (!virtual_provider->IsOverridingSensor(type)) {
	std::move(callback).Run(
	mojom::UpdateVirtualSensorResult::kSensorTypeNotOverridden);
	return;
	}

	virtual_provider->AddReading(type, reading);
	std::move(callback).Run(mojom::UpdateVirtualSensorResult::kSuccess);
	}

	void SensorProviderImpl::RemoveVirtualSensor(
	mojom::SensorType type,
	RemoveVirtualSensorCallback callback) {
	auto virtual_provider_it =
	virtual_providers_.find(receivers_.current_receiver());

	if (virtual_provider_it == virtual_providers_.end()) {
	std::move(callback).Run();
	return;
	}

	virtual_provider_it->second->RemoveSensorOverride(type);
	std::move(callback).Run();
	}

	void SensorProviderImpl::GetVirtualSensorInformation(
	mojom::SensorType type,
	GetVirtualSensorInformationCallback callback) {
	auto virtual_provider_it =
	virtual_providers_.find(receivers_.current_receiver());

	if (virtual_provider_it == virtual_providers_.end()) {
	std::move(callback).Run(mojom::GetVirtualSensorInformationResult::NewError(
	mojom::GetVirtualSensorInformationError::kSensorTypeNotOverridden));
	return;
	}

	auto* virtual_provider = virtual_provider_it->second.get();

	if (!virtual_provider->IsOverridingSensor(type)) {
	std::move(callback).Run(mojom::GetVirtualSensorInformationResult::NewError(
	mojom::GetVirtualSensorInformationError::kSensorTypeNotOverridden));
	return;
	}

	auto platform_sensor = virtual_provider->GetSensor(type);
	if (!platform_sensor) {
	// The sensor has not been created yet.
	std::move(callback).Run(mojom::GetVirtualSensorInformationResult::NewInfo(
	mojom::VirtualSensorInformation::New(/sampling_frequency=/0.0)));
	return;
	}

	auto* virtual_sensor =
	static_cast<VirtualPlatformSensor*>(platform_sensor.get());
	auto sensor_information = mojom::VirtualSensorInformation::New();
	sensor_information->sampling_frequency =
	virtual_sensor->optimal_configuration().has_value()
	? virtual_sensor->optimal_configuration().value().frequency()
	: 0.0;

	std::move(callback).Run(mojom::GetVirtualSensorInformationResult::NewInfo(
	std::move(sensor_information)));
	}

	size_t SensorProviderImpl::GetVirtualProviderCountForTesting() const {
	return virtual_providers_.size();
	}

	const VirtualPlatformSensorProvider*
	SensorProviderImpl::GetLastVirtualSensorProviderForTesting() const {
	CHECK_EQ(virtual_providers_.size(), 1U);
	return virtual_providers_.begin()->second.get();
	}

	} // namespace device