| // Copyright 2015 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/host/ash_window_tree_host_unified.h" |
| #include "base/memory/raw_ptr.h" |
| |
| #include <memory> |
| #include <tuple> |
| #include <utility> |
| |
| #include "ash/host/ash_window_tree_host_delegate.h" |
| #include "ash/host/root_window_transformer.h" |
| #include "base/check.h" |
| #include "base/containers/contains.h" |
| #include "base/notreached.h" |
| #include "base/ranges/algorithm.h" |
| #include "ui/aura/window.h" |
| #include "ui/aura/window_event_dispatcher.h" |
| #include "ui/aura/window_targeter.h" |
| #include "ui/compositor/compositor.h" |
| #include "ui/gfx/geometry/insets.h" |
| #include "ui/platform_window/stub/stub_window.h" |
| |
| namespace ash { |
| |
| class UnifiedEventTargeter : public aura::WindowTargeter { |
| public: |
| UnifiedEventTargeter(aura::Window* src_root, |
| aura::Window* dst_root, |
| AshWindowTreeHostDelegate* delegate) |
| : src_root_(src_root), dst_root_(dst_root), delegate_(delegate) { |
| DCHECK(delegate); |
| } |
| |
| UnifiedEventTargeter(const UnifiedEventTargeter&) = delete; |
| UnifiedEventTargeter& operator=(const UnifiedEventTargeter&) = delete; |
| ~UnifiedEventTargeter() override { delegate_ = nullptr; } |
| |
| // aura::WindowTargeter: |
| ui::EventTarget* FindTargetForEvent(ui::EventTarget* root, |
| ui::Event* event) override { |
| delegate_->SetCurrentEventTargeterSourceHost(nullptr); |
| if (root == src_root_ && !event->target()) { |
| return root; |
| } else { |
| NOTREACHED() << "event type:" << event->type(); |
| return aura::WindowTargeter::FindTargetForEvent(root, event); |
| } |
| } |
| ui::EventSink* GetNewEventSinkForEvent(const ui::EventTarget* current_root, |
| ui::EventTarget* target, |
| ui::Event* in_out_event) override { |
| if (current_root == src_root_ && !in_out_event->target()) { |
| delegate_->SetCurrentEventTargeterSourceHost(src_root_->GetHost()); |
| if (in_out_event->IsLocatedEvent()) { |
| ui::LocatedEvent* located_event = in_out_event->AsLocatedEvent(); |
| located_event->ConvertLocationToTarget( |
| static_cast<aura::Window*>(nullptr), dst_root_.get()); |
| } |
| return dst_root_->GetHost()->GetEventSink(); |
| } |
| return nullptr; |
| } |
| |
| private: |
| raw_ptr<aura::Window> src_root_; |
| raw_ptr<aura::Window> dst_root_; |
| raw_ptr<AshWindowTreeHostDelegate> delegate_; // Not owned. |
| }; |
| |
| AshWindowTreeHostUnified::AshWindowTreeHostUnified( |
| const gfx::Rect& initial_bounds, |
| AshWindowTreeHostDelegate* delegate, |
| size_t compositor_memory_limit_mb) |
| : AshWindowTreeHostPlatform( |
| std::make_unique<ui::StubWindow>(initial_bounds), |
| delegate, |
| compositor_memory_limit_mb) { |
| ui::StubWindow* stub_window = static_cast<ui::StubWindow*>(platform_window()); |
| stub_window->InitDelegate(this, true); |
| } |
| |
| AshWindowTreeHostUnified::~AshWindowTreeHostUnified() { |
| for (ash::AshWindowTreeHost* ash_host : mirroring_hosts_) { |
| ash_host->AsWindowTreeHost()->window()->RemoveObserver(this); |
| } |
| } |
| |
| void AshWindowTreeHostUnified::PrepareForShutdown() { |
| AshWindowTreeHostPlatform::PrepareForShutdown(); |
| |
| for (ash::AshWindowTreeHost* host : mirroring_hosts_) { |
| host->PrepareForShutdown(); |
| } |
| } |
| |
| void AshWindowTreeHostUnified::RegisterMirroringHost( |
| AshWindowTreeHost* mirroring_ash_host) { |
| aura::Window* src_root = mirroring_ash_host->AsWindowTreeHost()->window(); |
| src_root->SetEventTargeter( |
| std::make_unique<UnifiedEventTargeter>(src_root, window(), delegate_)); |
| DCHECK(!base::Contains(mirroring_hosts_, mirroring_ash_host)); |
| mirroring_hosts_.push_back(mirroring_ash_host); |
| src_root->AddObserver(this); |
| mirroring_ash_host->UpdateCursorConfig(); |
| } |
| |
| // Do nothing, since mirroring hosts had their cursor config updated when they |
| // were registered. |
| void AshWindowTreeHostUnified::UpdateCursorConfig() {} |
| |
| void AshWindowTreeHostUnified::ClearCursorConfig() { |
| for (ash::AshWindowTreeHost* host : mirroring_hosts_) { |
| host->ClearCursorConfig(); |
| } |
| } |
| |
| void AshWindowTreeHostUnified::SetCursorNative(gfx::NativeCursor cursor) { |
| for (ash::AshWindowTreeHost* host : mirroring_hosts_) { |
| host->AsWindowTreeHost()->SetCursor(cursor); |
| } |
| } |
| |
| void AshWindowTreeHostUnified::OnCursorVisibilityChangedNative(bool show) { |
| for (ash::AshWindowTreeHost* host : mirroring_hosts_) { |
| host->AsWindowTreeHost()->OnCursorVisibilityChanged(show); |
| } |
| } |
| |
| void AshWindowTreeHostUnified::OnBoundsChanged(const BoundsChange& change) { |
| if (platform_window()) |
| OnHostResizedInPixels(platform_window()->GetBoundsInPixels().size()); |
| } |
| |
| void AshWindowTreeHostUnified::OnWindowDestroying(aura::Window* window) { |
| auto iter = base::ranges::find( |
| mirroring_hosts_, window, [](AshWindowTreeHost* ash_host) { |
| return ash_host->AsWindowTreeHost()->window(); |
| }); |
| DCHECK(iter != mirroring_hosts_.end()); |
| window->RemoveObserver(this); |
| mirroring_hosts_.erase(iter); |
| } |
| |
| } // namespace ash |