// Copyright 2023 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/browser/chromeos/extensions/telemetry/api/events/event_manager.h"
#include <utility>
#include "base/check.h"
#include "base/functional/bind.h"
#include "base/no_destructor.h"
#include "chrome/browser/chromeos/extensions/telemetry/api/common/app_ui_observer.h"
#include "chrome/browser/chromeos/extensions/telemetry/api/common/util.h"
#include "chrome/browser/chromeos/extensions/telemetry/api/events/event_router.h"
#include "chrome/browser/chromeos/extensions/telemetry/api/events/remote_event_service_strategy.h"
#include "chromeos/crosapi/mojom/telemetry_event_service.mojom.h"
#include "chromeos/crosapi/mojom/telemetry_extension_exception.mojom.h"
#include "content/public/browser/browser_context.h"
#include "content/public/browser/web_contents.h"
#include "extensions/browser/browser_context_keyed_api_factory.h"
#include "extensions/browser/extension_registry.h"
#include "extensions/common/extension.h"
#include "extensions/common/extension_id.h"
#include "extensions/common/features/feature_provider.h"
#include "extensions/common/manifest_handlers/externally_connectable.h"
#include "mojo/public/cpp/bindings/remote.h"
namespace chromeos {
namespace {
namespace crosapi = ::crosapi::mojom;
std::string GetFeatureName(crosapi::TelemetryEventCategoryEnum category) {
switch (category) {
case crosapi::TelemetryEventCategoryEnum::kUnmappedEnumField:
return "";
case crosapi::TelemetryEventCategoryEnum::kAudioJack:
return "os.events.onAudioJackEvent";
case crosapi::TelemetryEventCategoryEnum::kLid:
return "os.events.onLidEvent";
case crosapi::TelemetryEventCategoryEnum::kUsb:
return "os.events.onUsbEvent";
case crosapi::TelemetryEventCategoryEnum::kExternalDisplay:
return "os.events.onExternalDisplayEvent";
case crosapi::TelemetryEventCategoryEnum::kSdCard:
return "os.events.onSdCardEvent";
case crosapi::TelemetryEventCategoryEnum::kPower:
return "os.events.onPowerEvent";
case crosapi::TelemetryEventCategoryEnum::kKeyboardDiagnostic:
return "os.events.onKeyboardDiagnosticEvent";
case crosapi::TelemetryEventCategoryEnum::kStylusGarage:
return "os.events.onStylusGarageEvent";
case crosapi::TelemetryEventCategoryEnum::kTouchpadButton:
return "os.events.onTouchpadButtonEvent";
case crosapi::TelemetryEventCategoryEnum::kTouchpadTouch:
return "os.events.onTouchpadTouchEvent";
case crosapi::TelemetryEventCategoryEnum::kTouchpadConnected:
return "os.events.onTouchpadConnectedEvent";
case crosapi::TelemetryEventCategoryEnum::kTouchscreenTouch:
return "os.events.onTouchscreenTouchEvent";
case crosapi::TelemetryEventCategoryEnum::kTouchscreenConnected:
return "os.events.onTouchscreenConnectedEvent";
case crosapi::TelemetryEventCategoryEnum::kStylusTouch:
return "os.events.onStylusTouchEvent";
case crosapi::TelemetryEventCategoryEnum::kStylusConnected:
return "os.events.onStylusConnectedEvent";
}
NOTREACHED();
}
} // namespace
// static
extensions::BrowserContextKeyedAPIFactory<EventManager>*
EventManager::GetFactoryInstance() {
static base::NoDestructor<
extensions::BrowserContextKeyedAPIFactory<EventManager>>
instance;
return instance.get();
}
// static
EventManager* EventManager::Get(content::BrowserContext* browser_context) {
return extensions::BrowserContextKeyedAPIFactory<EventManager>::Get(
browser_context);
}
EventManager::EventManager(content::BrowserContext* context)
: event_router_(context), browser_context_(context) {
extensions::ExtensionRegistry::Get(context)->AddObserver(this);
}
EventManager::~EventManager() = default;
void EventManager::OnExtensionUnloaded(
content::BrowserContext* browser_context,
const extensions::Extension* extension,
extensions::UnloadedExtensionReason reason) {
app_ui_observers_.erase(extension->id());
event_router_.ResetReceiversForExtension(extension->id());
}
EventManager::RegisterEventResult EventManager::RegisterExtensionForEvent(
extensions::ExtensionId extension_id,
crosapi::TelemetryEventCategoryEnum category) {
if (kCategoriesWithFocusRestriction.contains(category)) {
// Always check if there is a focused UI for focus-restricted events.
auto observer =
CreateAppUiObserver(extension_id, /*focused_ui_required=*/true);
if (!observer) {
return kAppUiNotFocused;
}
if (auto it = app_ui_observers_.find(extension_id);
it == app_ui_observers_.end() ||
it->second->web_contents() != observer->web_contents()) {
app_ui_observers_.insert_or_assign(extension_id, std::move(observer));
}
// The existing observation may be restricted if the previous App UI was
// unfocused.
event_router_.UnrestrictReceiversOfExtension(extension_id);
if (event_router_.IsExtensionObservingForCategory(extension_id, category)) {
// Same extension and category can only have one observer.
return kSuccess;
}
} else {
// Existing observation can be reused for regular (non-focus-restricted)
// events.
if (event_router_.IsExtensionObservingForCategory(extension_id, category)) {
// Early return in case the category is already observed by the extension.
return kSuccess;
}
if (app_ui_observers_.find(extension_id) == app_ui_observers_.end()) {
auto observer =
CreateAppUiObserver(extension_id, /*focused_ui_required=*/false);
if (!observer) {
return kAppUiClosed;
}
app_ui_observers_.emplace(extension_id, std::move(observer));
}
}
GetRemoteService()->AddEventObserver(
category, event_router_.GetPendingRemoteForCategoryAndExtension(
category, extension_id));
return kSuccess;
}
void EventManager::RemoveObservationsForExtensionAndCategory(
extensions::ExtensionId extension_id,
crosapi::TelemetryEventCategoryEnum category) {
event_router_.ResetReceiversOfExtensionByCategory(extension_id, category);
if (!event_router_.IsExtensionObserving(extension_id)) {
app_ui_observers_.erase(extension_id);
}
}
void EventManager::IsEventSupported(
crosapi::TelemetryEventCategoryEnum category,
crosapi::TelemetryEventService::IsEventSupportedCallback callback) {
std::string feature_name = GetFeatureName(category);
const auto* feature =
extensions::FeatureProvider::GetAPIFeatures()->GetFeature(feature_name);
// Healthd team uses feature flag "TelemetryExtensionPendingApprovalApi" for
// pending APIs. "os.events" API has been released, and we keep adding API
// under it like "os.events.abc" and use the feature flag for pending
// approval. Once it's approved, we remove it from the "_api_features.json"
// file.
//
// Hence, for the API under "os.events", as long as we can find it in the
// "_api_features.json" file, it means it's behind a feature flag and then we
// should report it as "unsupported".
//
// Note 1: This check is based on the above assumption. That is, if we need to
// add the feature into _api_features.json due to other reasons, this check
// will report incorrect answer.
//
// TODO(b/296816372): Retrieve the feature flag name to see if it's really
// behind a flag.
//
// Note 2: Indeed this will not work if we control feature access using ways
// other than adding feature flag (such as through blocklist).
if (feature) {
auto unsupported = crosapi::TelemetryExtensionSupportStatus::NewUnsupported(
crosapi::TelemetryExtensionUnsupported::New());
std::move(callback).Run(std::move(unsupported));
return;
}
GetRemoteService()->IsEventSupported(category, std::move(callback));
}
mojo::Remote<crosapi::TelemetryEventService>& EventManager::GetRemoteService() {
if (!remote_event_service_strategy_) {
remote_event_service_strategy_ = RemoteEventServiceStrategy::Create();
}
return remote_event_service_strategy_->GetRemoteService();
}
void EventManager::OnAppUiClosed(extensions::ExtensionId extension_id) {
// As only the focused UI is tracked, all focus-restricted events' connections
// should be cut when `OnAppUiClosed` is called.
for (const auto category : kCategoriesWithFocusRestriction) {
if (event_router_.IsExtensionObservingForCategory(extension_id, category)) {
event_router_.ResetReceiversOfExtensionByCategory(extension_id, category);
}
}
// Try to find another open UI.
auto observer =
CreateAppUiObserver(extension_id, /*focused_ui_required=*/false);
if (observer) {
app_ui_observers_.insert_or_assign(extension_id, std::move(observer));
return;
}
app_ui_observers_.erase(extension_id);
event_router_.ResetReceiversForExtension(extension_id);
}
void EventManager::OnAppUiFocusChanged(extensions::ExtensionId extension_id,
bool is_focused) {
if (is_focused) {
event_router_.UnrestrictReceiversOfExtension(extension_id);
} else {
event_router_.RestrictReceiversOfExtension(extension_id);
}
}
std::unique_ptr<AppUiObserver> EventManager::CreateAppUiObserver(
extensions::ExtensionId extension_id,
bool focused_ui_required) {
const extensions::Extension* extension =
extensions::ExtensionRegistry::Get(browser_context_)
->GetExtensionById(extension_id,
extensions::ExtensionRegistry::EVERYTHING);
if (!extension) {
// If the extension has been unloaded from the registry, there
// won't be any related app UI.
return nullptr;
}
content::WebContents* contents = FindTelemetryExtensionOpenAndSecureAppUi(
browser_context_, extension, focused_ui_required);
if (!contents) {
return nullptr;
}
return std::make_unique<AppUiObserver>(
contents,
extensions::ExternallyConnectableInfo::Get(extension)->matches.Clone(),
// Unretained is safe here because `this` will own the observer.
base::BindOnce(&EventManager::OnAppUiClosed, base::Unretained(this),
extension_id),
base::BindRepeating(&EventManager::OnAppUiFocusChanged,
base::Unretained(this), extension_id));
}
} // namespace chromeos
Codebase Browser
chromium