// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/components/arc/compat_mode/arc_resize_lock_manager.h"
#include "ash/components/arc/arc_browser_context_keyed_service_factory_base.h"
#include "ash/components/arc/arc_features.h"
#include "ash/components/arc/compat_mode/arc_splash_screen_dialog_view.h"
#include "ash/components/arc/compat_mode/arc_window_property_util.h"
#include "ash/components/arc/compat_mode/compat_mode_button_controller.h"
#include "ash/components/arc/compat_mode/metrics.h"
#include "ash/components/arc/compat_mode/overlay_dialog.h"
#include "ash/components/arc/compat_mode/touch_mode_mouse_rewriter.h"
#include "ash/game_dashboard/game_dashboard_controller.h"
#include "ash/public/cpp/app_types_util.h"
#include "ash/public/cpp/arc_resize_lock_type.h"
#include "ash/public/cpp/resize_shadow_type.h"
#include "ash/public/cpp/window_properties.h"
#include "ash/shell.h"
#include "ash/wm/resize_shadow_controller.h"
#include "base/functional/bind.h"
#include "base/functional/callback_forward.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/singleton.h"
#include "base/memory/weak_ptr.h"
#include "base/notreached.h"
#include "base/task/sequenced_task_runner.h"
#include "chromeos/ui/base/window_properties.h"
#include "ui/aura/window_observer.h"
#include "ui/aura/window_tree_host.h"
#include "ui/wm/public/activation_client.h"
namespace arc {
namespace {
// Singleton factory for ArcResizeLockManager.
class ArcResizeLockManagerFactory
: public internal::ArcBrowserContextKeyedServiceFactoryBase<
ArcResizeLockManager,
ArcResizeLockManagerFactory> {
public:
static constexpr const char* kName = "ArcResizeLockManagerFactory";
static ArcResizeLockManagerFactory* GetInstance() {
return base::Singleton<ArcResizeLockManagerFactory>::get();
}
private:
friend struct base::DefaultSingletonTraits<ArcResizeLockManagerFactory>;
ArcResizeLockManagerFactory() = default;
~ArcResizeLockManagerFactory() override = default;
};
// A self-deleting window activation observer that runs the given callback when
// its associated window gets activated.
class WindowActivationObserver : public wm::ActivationChangeObserver,
public aura::WindowObserver {
public:
WindowActivationObserver(const WindowActivationObserver&) = delete;
WindowActivationObserver& operator=(const WindowActivationObserver&) = delete;
static void RunOnActivated(aura::Window* window,
base::OnceClosure on_activated) {
// ash::Shell can be null in unittests.
if (!ash::Shell::HasInstance())
return;
if (ash::Shell::Get()->activation_client()->GetActiveWindow() == window) {
std::move(on_activated).Run();
return;
}
// The following instance self-destructs when the window gets activated or
// destroyed before getting activated.
new WindowActivationObserver(window, std::move(on_activated));
}
// aura::WindowObserver:
void OnWindowDestroying(aura::Window* window) override {
DCHECK(observer_.IsObservingSource(window));
delete this;
}
// wm::ActivationChangeObserver:
void OnWindowActivated(ActivationReason reason,
aura::Window* gained_active,
aura::Window* lost_active) override {
if (gained_active != window_)
return;
RemoveAllObservers();
// To avoid nested-activation, here we post the task to the queue.
base::SequencedTaskRunner::GetCurrentDefault()->PostTask(
FROM_HERE, std::move(on_activated_));
delete this;
}
private:
WindowActivationObserver(aura::Window* window, base::OnceClosure on_activated)
: window_(window), on_activated_(std::move(on_activated)) {
DCHECK(!on_activated_.is_null());
ash::Shell::Get()->activation_client()->AddObserver(this);
observer_.Observe(window_.get());
}
~WindowActivationObserver() override { RemoveAllObservers(); }
void RemoveAllObservers() {
observer_.Reset();
ash::Shell::Get()->activation_client()->RemoveObserver(this);
}
const raw_ptr<aura::Window> window_;
base::OnceClosure on_activated_;
base::ScopedObservation<aura::Window, aura::WindowObserver> observer_{this};
};
// A self-deleting window property observer that runs the given callback when
// its ash::kAppIDKey is set to non-null value.
class AppIdObserver : public aura::WindowObserver {
public:
AppIdObserver(const AppIdObserver&) = delete;
AppIdObserver& operator=(const AppIdObserver&) = delete;
static void RunOnReady(aura::Window* window,
base::OnceCallback<void(aura::Window*)> on_ready) {
if (GetAppId(window)) {
std::move(on_ready).Run(window);
return;
}
// The following instance self-destructs when the window gets activated or
// destroyed before getting activated.
new AppIdObserver(window, std::move(on_ready));
}
// aura::WindowObserver:
void OnWindowDestroying(aura::Window* window) override {
DCHECK(observer_.IsObservingSource(window));
delete this;
}
void OnWindowPropertyChanged(aura::Window* window,
const void* key,
intptr_t old) override {
DCHECK(observer_.IsObservingSource(window));
if (key != ash::kAppIDKey)
return;
if (!GetAppId(window))
return;
observer_.Reset();
std::move(on_ready_).Run(window);
delete this;
}
private:
AppIdObserver(aura::Window* window,
base::OnceCallback<void(aura::Window*)> on_ready)
: window_(window), on_ready_(std::move(on_ready)) {
DCHECK(!on_ready_.is_null());
observer_.Observe(window_.get());
}
~AppIdObserver() override { observer_.Reset(); }
const raw_ptr<aura::Window> window_;
base::OnceCallback<void(aura::Window*)> on_ready_;
base::ScopedObservation<aura::Window, aura::WindowObserver> observer_{this};
};
bool ShouldEnableResizeLock(ash::ArcResizeLockType type) {
return type != ash::ArcResizeLockType::NONE &&
type != ash::ArcResizeLockType::RESIZE_ENABLED_TOGGLABLE;
}
} // namespace
// static
ArcResizeLockManager* ArcResizeLockManager::GetForBrowserContext(
content::BrowserContext* context) {
return ArcResizeLockManagerFactory::GetForBrowserContext(context);
}
ArcResizeLockManager::ArcResizeLockManager(
content::BrowserContext* browser_context,
ArcBridgeService* arc_bridge_service)
: compat_mode_button_controller_(
std::make_unique<CompatModeButtonController>()),
touch_mode_mouse_rewriter_(std::make_unique<TouchModeMouseRewriter>()) {
if (aura::Env::HasInstance())
env_observation.Observe(aura::Env::GetInstance());
}
ArcResizeLockManager::~ArcResizeLockManager() = default;
void ArcResizeLockManager::OnWindowInitialized(aura::Window* new_window) {
if (!ash::IsArcWindow(new_window))
return;
if (window_observations_.IsObservingSource(new_window))
return;
window_observations_.AddObservation(new_window);
AppIdObserver::RunOnReady(
new_window,
base::BindOnce(
[](base::WeakPtr<ArcResizeLockManager> manager,
aura::Window* window) {
if (!manager)
return;
if (!manager->pref_delegate_)
return;
const auto state =
manager->pref_delegate_->GetResizeLockState(*GetAppId(window));
RecordResizeLockStateHistogram(
ResizeLockStateHistogramType::InitialState, state);
},
weak_ptr_factory_.GetWeakPtr()));
}
void ArcResizeLockManager::OnWindowPropertyChanged(aura::Window* window,
const void* key,
intptr_t old) {
// TODO(b/344640055): Replace below simple fix.
// The overlay layer might be added before `chromeos::kIsGameKey` is set for
// splash screen dialog. Once `chromeos::kIsGameKey` is set to true, remove
// the overlay layer.
if (key == chromeos::kIsGameKey &&
window->GetProperty(chromeos::kIsGameKey)) {
OverlayDialog::CloseIfAny(window);
return;
}
if (key != ash::kArcResizeLockTypeKey)
return;
const auto new_value = window->GetProperty(ash::kArcResizeLockTypeKey);
const auto old_value = static_cast<ash::ArcResizeLockType>(old);
if (new_value != old_value) {
AppIdObserver::RunOnReady(
window, base::BindOnce(
[](base::WeakPtr<ArcResizeLockManager> manager,
aura::Window* window) {
if (!manager)
return;
if (ShouldEnableResizeLock(window->GetProperty(
ash::kArcResizeLockTypeKey))) {
manager->EnableResizeLock(window);
} else {
manager->DisableResizeLock(window);
}
// EnableResizeLock() and DisableResizeLock() are supposed
// to be called only when resizability is toggled while
// resize lock state may need to be updated even when
// resizability doesn't change (e.g.NONE ->
// RESIZE_ENABLED_TOGGLABLE)
manager->UpdateResizeLockState(window);
},
weak_ptr_factory_.GetWeakPtr()));
}
// We need to always trigger UpdateCompatModeButton regardless of value
// change because it need to be called even when the property is set to
// ArcResizeLockType::NONE, which is the the default value of
// kArcResizeLockTypeKey, and the new value is the same as |old| in that case.
AppIdObserver::RunOnReady(
window, base::BindOnce(&CompatModeButtonController::Update,
compat_mode_button_controller_->GetWeakPtr()));
}
void ArcResizeLockManager::Shutdown() {
compat_mode_button_controller_->ClearPrefDelegate();
pref_delegate_ = nullptr;
}
void ArcResizeLockManager::OnWindowBoundsChanged(
aura::Window* window,
const gfx::Rect& old_bounds,
const gfx::Rect& new_bounds,
ui::PropertyChangeReason reason) {
compat_mode_button_controller_->Update(window);
}
void ArcResizeLockManager::OnWindowDestroying(aura::Window* window) {
resize_lock_enabled_windows_.erase(window);
if (window_observations_.IsObservingSource(window))
window_observations_.RemoveObservation(window);
}
void ArcResizeLockManager::SetPrefDelegate(
ArcResizeLockPrefDelegate* delegate) {
CHECK(!pref_delegate_);
pref_delegate_ = delegate;
compat_mode_button_controller_->SetPrefDelegate(delegate);
}
void ArcResizeLockManager::EnableResizeLock(aura::Window* window) {
const bool inserted = resize_lock_enabled_windows_.insert(window).second;
if (!inserted)
return;
// TODO(tetsui): Reconsider the trigger condition after experimenting i.e.
// whether it is reasonable to have it enabled when ResizeLock is enabled.
if (touch_mode_mouse_rewriter_)
touch_mode_mouse_rewriter_->EnableForWindow(window);
const auto app_id = GetAppId(window);
DCHECK(app_id);
const bool is_fully_locked =
window->GetProperty(ash::kArcResizeLockTypeKey) ==
ash::ArcResizeLockType::RESIZE_DISABLED_NONTOGGLABLE;
// The state is |ArcResizeLockState::READY| only when we enable the resize
// lock for an app for the first time. UpdateResizeLockState() may overwrite
// the ResizeLockState so this check must be done before it's called.
const bool is_first_launch = pref_delegate_->GetResizeLockState(*app_id) ==
mojom::ArcResizeLockState::READY;
UpdateResizeLockState(window);
// No need to show splash screen dialog for game apps.
if (is_first_launch && ShouldShowSplashScreenDialog(pref_delegate_) &&
!ash::GameDashboardController::IsGameWindow(window)) {
// UpdateResizeLockState() must be called beforehand as compat-mode button
// must exist before showing the splash dialog because it's used as the
// anchoring target.
ShowSplashScreenDialog(window, is_fully_locked);
}
if (!is_fully_locked) {
window->SetProperty(ash::kUnresizableSnappedSizeKey,
new gfx::Size(GetUnresizableSnappedWidth(window), 0));
} else {
window->ClearProperty(ash::kUnresizableSnappedSizeKey);
}
}
void ArcResizeLockManager::DisableResizeLock(aura::Window* window) {
const bool erased = resize_lock_enabled_windows_.erase(window);
if (!erased)
return;
window->SetProperty(ash::kResizeShadowTypeKey,
ash::ResizeShadowType::kUnlock);
// Hide shadow effect on window. ash::Shell may not exist in tests.
if (ash::Shell::HasInstance())
ash::Shell::Get()->resize_shadow_controller()->HideShadow(window);
if (touch_mode_mouse_rewriter_)
touch_mode_mouse_rewriter_->DisableForWindow(window);
window->ClearProperty(ash::kUnresizableSnappedSizeKey);
}
void ArcResizeLockManager::UpdateResizeLockState(aura::Window* window) {
const auto app_id = GetAppId(window);
DCHECK(app_id);
const auto resize_lock_type = window->GetProperty(ash::kArcResizeLockTypeKey);
switch (resize_lock_type) {
case ash::ArcResizeLockType::RESIZE_DISABLED_TOGGLABLE:
pref_delegate_->SetResizeLockState(*app_id,
mojom::ArcResizeLockState::ON);
break;
case ash::ArcResizeLockType::RESIZE_DISABLED_NONTOGGLABLE:
pref_delegate_->SetResizeLockState(
*app_id, mojom::ArcResizeLockState::FULLY_LOCKED);
break;
case ash::ArcResizeLockType::RESIZE_ENABLED_TOGGLABLE:
pref_delegate_->SetResizeLockState(*app_id,
mojom::ArcResizeLockState::OFF);
break;
case ash::ArcResizeLockType::NONE:
// Maximizing an app with RESIZE_ENABLED_TOGGLABLE can lead to this case.
// Resize lock state shouldn't be updated as the pre-maximized state
// needs to be restored later.
break;
}
// As we updated the resize lock state above, we need to update compat mode
// button.
compat_mode_button_controller_->Update(window);
// Even if resize lock doesn't get enabled or disabled, we need to ensure to
// update this as resize shadow can be updated in an intermediate state when
// exo commites the next state.
UpdateShadow(window);
}
void ArcResizeLockManager::UpdateShadow(aura::Window* window) {
const auto resize_lock_type = window->GetProperty(ash::kArcResizeLockTypeKey);
const bool resize_lock_enabled =
resize_lock_type == ash::ArcResizeLockType::RESIZE_DISABLED_TOGGLABLE ||
resize_lock_type == ash::ArcResizeLockType::RESIZE_DISABLED_NONTOGGLABLE;
const auto resize_shadow_type = resize_lock_enabled
? ash::ResizeShadowType::kLock
: ash::ResizeShadowType::kUnlock;
window->SetProperty(ash::kResizeShadowTypeKey, resize_shadow_type);
// ash::Shell may not exist in tests.
if (ash::Shell::HasInstance()) {
if (resize_lock_enabled) {
ash::Shell::Get()->resize_shadow_controller()->ShowShadow(window);
} else {
ash::Shell::Get()->resize_shadow_controller()->HideShadow(window);
}
}
}
void ArcResizeLockManager::ShowSplashScreenDialog(aura::Window* window,
bool is_fully_locked) {
WindowActivationObserver::RunOnActivated(
window, base::BindOnce(&ArcSplashScreenDialogView::Show, window,
is_fully_locked));
}
// static
void ArcResizeLockManager::EnsureFactoryBuilt() {
ArcResizeLockManagerFactory::GetInstance();
}
} // namespace arc
Codebase Browser
chromium