// 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 "ui/ozone/platform/flatland/flatland_window.h"
#include <fidl/fuchsia.ui.pointer/cpp/hlcpp_conversion.h>
#include <fidl/fuchsia.ui.views/cpp/hlcpp_conversion.h>
#include <lib/async/default.h>
#include <algorithm>
#include <cstdint>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "base/check_op.h"
#include "base/fuchsia/fuchsia_component_connect.h"
#include "base/fuchsia/fuchsia_logging.h"
#include "base/functional/bind.h"
#include "base/memory/scoped_refptr.h"
#include "ui/base/cursor/platform_cursor.h"
#include "ui/display/types/display_constants.h"
#include "ui/events/event.h"
#include "ui/events/ozone/events_ozone.h"
#include "ui/events/platform/platform_event_source.h"
#include "ui/ozone/platform/flatland/flatland_window_manager.h"
#include "ui/platform_window/fuchsia/scenic_window_delegate.h"
namespace ui {
namespace {
// Converts and scales Scenic's rect-based representation of insets to
// gfx::Insets. Returns zero-width insets if |view_inset| information was not
// provided in the |GetLayout()| call.
gfx::Insets ConvertInsets(float device_pixel_ratio,
const fuchsia::math::Inset& view_inset) {
return gfx::ScaleToRoundedInsets(
gfx::Insets::TLBR(view_inset.top, view_inset.left, view_inset.bottom,
view_inset.right),
device_pixel_ratio);
}
} // namespace
FlatlandWindow::FlatlandWindow(FlatlandWindowManager* window_manager,
PlatformWindowDelegate* platform_window_delegate,
PlatformWindowInitProperties properties)
: manager_(window_manager),
platform_window_delegate_(platform_window_delegate),
scenic_window_delegate_(properties.scenic_window_delegate),
window_id_(manager_->AddWindow(this)),
view_ref_(std::move(properties.view_ref_pair.view_ref)),
view_controller_(std::move(properties.view_controller)),
flatland_("Chromium FlatlandWindow",
base::BindOnce(&FlatlandWindow::OnFlatlandError,
base::Unretained(this))),
bounds_(
platform_window_delegate->ConvertRectToPixels(properties.bounds)) {
if (view_controller_) {
view_controller_.set_error_handler(
fit::bind_member(this, &FlatlandWindow::OnViewControllerDisconnected));
}
fuchsia::ui::views::ViewIdentityOnCreation view_identity = {
.view_ref = CloneViewRef(),
.view_ref_control = std::move(properties.view_ref_pair.control_ref)};
fuchsia::ui::composition::ViewBoundProtocols view_bound_protocols;
view_bound_protocols.set_view_ref_focused(view_ref_focused_.NewRequest());
view_ref_focused_.set_error_handler([](zx_status_t status) {
ZX_LOG(ERROR, status) << "ViewRefFocused disconnected.";
});
auto touch_source_endpoints =
fidl::CreateEndpoints<fuchsia_ui_pointer::TouchSource>();
ZX_CHECK(touch_source_endpoints.is_ok(),
touch_source_endpoints.status_value());
view_bound_protocols.set_touch_source(
fidl::NaturalToHLCPP(std::move(touch_source_endpoints->server)));
auto mouse_source_endpoints =
fidl::CreateEndpoints<fuchsia_ui_pointer::MouseSource>();
ZX_CHECK(mouse_source_endpoints.is_ok(),
mouse_source_endpoints.status_value());
view_bound_protocols.set_mouse_source(
fidl::NaturalToHLCPP(std::move(mouse_source_endpoints->server)));
pointer_handler_ = std::make_unique<PointerEventsHandler>(
std::move(touch_source_endpoints->client),
std::move(mouse_source_endpoints->client));
pointer_handler_->StartWatching(base::BindRepeating(
&FlatlandWindow::DispatchEvent,
// This is safe since |pointer_handler_| is a class member.
base::Unretained(this)));
flatland_.flatland()->CreateView2(
std::move(properties.view_creation_token), std::move(view_identity),
std::move(view_bound_protocols), parent_viewport_watcher_.NewRequest());
parent_viewport_watcher_->GetLayout(
fit::bind_member(this, &FlatlandWindow::OnGetLayout));
parent_viewport_watcher_->GetStatus(
fit::bind_member(this, &FlatlandWindow::OnGetStatus));
view_ref_focused_->Watch(
fit::bind_member(this, &FlatlandWindow::OnViewRefFocusedWatchResult));
root_transform_id_ = flatland_.NextTransformId();
flatland_.flatland()->CreateTransform(root_transform_id_);
// Create the infinite hit region that will cover the surface. Do not set clip
// boundaries on this transform, so that the hit region retains maximal size.
shield_transform_id_ = flatland_.NextTransformId();
flatland_.flatland()->CreateTransform(shield_transform_id_);
flatland_.flatland()->SetInfiniteHitRegion(
shield_transform_id_,
fuchsia::ui::composition::HitTestInteraction::DEFAULT);
platform_window_delegate_->OnAcceleratedWidgetAvailable(window_id_);
if (properties.enable_keyboard) {
is_virtual_keyboard_enabled_ = properties.enable_virtual_keyboard;
auto keyboard_client_end =
base::fuchsia_component::Connect<fuchsia_ui_input3::Keyboard>();
CHECK(keyboard_client_end.is_ok())
<< base::FidlConnectionErrorMessage(keyboard_client_end);
keyboard_fidl_client_.Bind(std::move(keyboard_client_end.value()),
async_get_default_dispatcher(),
&fidl_error_event_logger_);
keyboard_client_ = std::make_unique<KeyboardClient>(
keyboard_fidl_client_, fidl::HLCPPToNatural(CloneViewRef()), this);
} else {
DCHECK(!properties.enable_virtual_keyboard);
}
}
FlatlandWindow::~FlatlandWindow() {
manager_->RemoveWindow(window_id_, this);
}
void FlatlandWindow::ResetSurfaceContent() {
if (!surface_content_id_.value) {
return;
}
flatland_.flatland()->RemoveChild(root_transform_id_, surface_transform_id_);
flatland_.flatland()->RemoveChild(root_transform_id_, shield_transform_id_);
flatland_.flatland()->ReleaseViewport(surface_content_id_, [](auto) {});
flatland_.flatland()->ReleaseTransform(surface_transform_id_);
surface_content_id_ = {};
surface_transform_id_ = {};
}
void FlatlandWindow::AttachSurfaceContent(
fuchsia::ui::views::ViewportCreationToken token) {
// 0x0 is not a valid Viewport size for Flatland. Sending these commands will
// cause an error that results in channel closure. We will receive a non-zero
// size at OnGetLayout(), so we wait until then to run these commands.
if (!logical_size_) {
pending_attach_surface_content_closure_ =
base::BindOnce(&FlatlandWindow::AttachSurfaceContent,
base::Unretained(this), std::move(token));
return;
}
ResetSurfaceContent();
surface_transform_id_ = flatland_.NextTransformId();
flatland_.flatland()->CreateTransform(surface_transform_id_);
// Hit-testing starts from the last child transform added, and propagates
// forward to the first. Adding the shield transform last therefore allows it
// to consume all hit-tests, preventing the surface from handling them to
// capture input.
flatland_.flatland()->AddChild(root_transform_id_, surface_transform_id_);
flatland_.flatland()->AddChild(root_transform_id_, shield_transform_id_);
fuchsia::ui::composition::ViewportProperties properties;
properties.set_logical_size({static_cast<uint32_t>(logical_size_->width()),
static_cast<uint32_t>(logical_size_->height())});
surface_content_id_ = flatland_.NextContentId();
fuchsia::ui::composition::ChildViewWatcherPtr content_link;
flatland_.flatland()->CreateViewport(surface_content_id_, std::move(token),
std::move(properties),
content_link.NewRequest());
flatland_.flatland()->SetContent(surface_transform_id_, surface_content_id_);
flatland_.Present();
}
fuchsia::ui::views::ViewRef FlatlandWindow::CloneViewRef() {
fuchsia::ui::views::ViewRef dup;
zx_status_t status =
view_ref_.reference.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup.reference);
ZX_CHECK(status == ZX_OK, status) << "zx_object_duplicate";
return dup;
}
gfx::Rect FlatlandWindow::GetBoundsInPixels() const {
return bounds_;
}
void FlatlandWindow::SetBoundsInPixels(const gfx::Rect& bounds) {
// This path should only be reached in tests.
bounds_ = bounds;
}
gfx::Rect FlatlandWindow::GetBoundsInDIP() const {
// TODO(crbug.com/42050542): Remove the hardcoded values and return
// |logical_size_|.
return platform_window_delegate_->ConvertRectToDIP(bounds_);
}
void FlatlandWindow::SetBoundsInDIP(const gfx::Rect& bounds) {
// This path should only be reached in tests.
bounds_ = platform_window_delegate_->ConvertRectToPixels(bounds);
}
void FlatlandWindow::SetTitle(const std::u16string& title) {
NOTIMPLEMENTED();
}
void FlatlandWindow::Show(bool inactive) {
if (is_visible_)
return;
is_visible_ = true;
flatland_.flatland()->SetRootTransform(root_transform_id_);
flatland_.Present();
}
void FlatlandWindow::Hide() {
if (!is_visible_)
return;
is_visible_ = false;
flatland_.flatland()->SetRootTransform({0});
flatland_.Present();
}
void FlatlandWindow::Close() {
if (view_controller_) {
view_controller_->Dismiss();
view_controller_ = nullptr;
}
Hide();
platform_window_delegate_->OnClosed();
}
bool FlatlandWindow::IsVisible() const {
return is_visible_;
}
void FlatlandWindow::PrepareForShutdown() {
NOTIMPLEMENTED();
}
void FlatlandWindow::SetCapture() {
has_capture_ = true;
}
void FlatlandWindow::ReleaseCapture() {
has_capture_ = false;
}
bool FlatlandWindow::HasCapture() const {
return has_capture_;
}
void FlatlandWindow::SetFullscreen(bool fullscreen, int64_t target_display_id) {
NOTIMPLEMENTED_LOG_ONCE();
DCHECK_EQ(target_display_id, display::kInvalidDisplayId);
is_fullscreen_ = fullscreen;
}
void FlatlandWindow::Maximize() {
NOTIMPLEMENTED();
}
void FlatlandWindow::Minimize() {
NOTIMPLEMENTED();
}
void FlatlandWindow::Restore() {
NOTIMPLEMENTED();
}
PlatformWindowState FlatlandWindow::GetPlatformWindowState() const {
if (is_fullscreen_)
return PlatformWindowState::kFullScreen;
if (!is_view_attached_)
return PlatformWindowState::kMinimized;
// TODO(crbug.com/42050332): We cannot tell what portion of the screen is
// occupied by the View, so report is as maximized to reduce the space used
// by any browser chrome.
return PlatformWindowState::kMaximized;
}
void FlatlandWindow::Activate() {
NOTIMPLEMENTED_LOG_ONCE();
}
void FlatlandWindow::Deactivate() {
NOTIMPLEMENTED_LOG_ONCE();
}
void FlatlandWindow::SetUseNativeFrame(bool use_native_frame) {}
bool FlatlandWindow::ShouldUseNativeFrame() const {
NOTIMPLEMENTED_LOG_ONCE();
return false;
}
void FlatlandWindow::SetCursor(scoped_refptr<PlatformCursor> cursor) {
NOTIMPLEMENTED_LOG_ONCE();
}
void FlatlandWindow::MoveCursorTo(const gfx::Point& location) {
NOTIMPLEMENTED_LOG_ONCE();
}
void FlatlandWindow::ConfineCursorToBounds(const gfx::Rect& bounds) {
NOTIMPLEMENTED();
}
void FlatlandWindow::SetRestoredBoundsInDIP(const gfx::Rect& bounds) {
NOTIMPLEMENTED();
}
gfx::Rect FlatlandWindow::GetRestoredBoundsInDIP() const {
NOTIMPLEMENTED();
return gfx::Rect();
}
void FlatlandWindow::SetWindowIcons(const gfx::ImageSkia& window_icon,
const gfx::ImageSkia& app_icon) {
NOTIMPLEMENTED();
}
void FlatlandWindow::SizeConstraintsChanged() {
NOTIMPLEMENTED();
}
void FlatlandWindow::OnGetLayout(fuchsia::ui::composition::LayoutInfo info) {
logical_size_ =
gfx::Size(info.logical_size().width, info.logical_size().height);
device_pixel_ratio_ =
std::max(info.device_pixel_ratio().x, info.device_pixel_ratio().y);
DCHECK_EQ(info.device_pixel_ratio().x, info.device_pixel_ratio().y);
if (info.has_inset()) {
view_inset_ = ConvertInsets(device_pixel_ratio_, info.inset());
}
if (scenic_window_delegate_) {
scenic_window_delegate_->OnScenicPixelScale(this, device_pixel_ratio_);
}
UpdateSize();
// Size update is sent via |delegate_| and SetViewportProperties().
if (surface_content_id_.value) {
fuchsia::ui::composition::ViewportProperties properties;
properties.set_logical_size(info.logical_size());
flatland_.flatland()->SetViewportProperties(surface_content_id_,
std::move(properties));
flatland_.Present();
}
parent_viewport_watcher_->GetLayout(
fit::bind_member(this, &FlatlandWindow::OnGetLayout));
}
void FlatlandWindow::OnGetStatus(
fuchsia::ui::composition::ParentViewportStatus status) {
switch (status) {
case fuchsia::ui::composition::ParentViewportStatus::CONNECTED_TO_DISPLAY:
OnViewAttachedChanged(true);
break;
case fuchsia::ui::composition::ParentViewportStatus::
DISCONNECTED_FROM_DISPLAY:
// We may get here after the initial `GetStatus()` call. There is no need
// to do anything in this case.
if (!is_view_attached_) {
break;
}
OnViewAttachedChanged(false);
// Detach the surface view. This is necessary to ensure that the
// current content doesn't become visible when the view is attached
// again.
ResetSurfaceContent();
flatland_.Present();
pending_attach_surface_content_closure_.Reset();
// Destroy and recreate AcceleratedWidget. This will force the
// compositor drop the current LayerTreeFrameSink together with the
// corresponding ScenicSurface. They will be created again only after
// the window becomes visible again.
platform_window_delegate_->OnAcceleratedWidgetDestroyed();
platform_window_delegate_->OnAcceleratedWidgetAvailable(window_id_);
break;
default:
NOTIMPLEMENTED();
break;
}
parent_viewport_watcher_->GetStatus(
fit::bind_member(this, &FlatlandWindow::OnGetStatus));
}
void FlatlandWindow::OnViewRefFocusedWatchResult(
fuchsia::ui::views::FocusState focus_state) {
platform_window_delegate_->OnActivationChanged(focus_state.focused());
view_ref_focused_->Watch(
fit::bind_member(this, &FlatlandWindow::OnViewRefFocusedWatchResult));
}
void FlatlandWindow::UpdateSize() {
DCHECK(logical_size_);
if (pending_attach_surface_content_closure_) {
std::move(pending_attach_surface_content_closure_).Run();
}
const auto old_bounds = bounds_;
bounds_ = gfx::Rect(
gfx::ScaleToCeiledSize(logical_size_.value(), device_pixel_ratio_));
PlatformWindowDelegate::BoundsChange bounds(old_bounds.origin() !=
bounds_.origin());
bounds.system_ui_overlap = view_inset_;
platform_window_delegate_->OnBoundsChanged(bounds);
}
void FlatlandWindow::OnViewAttachedChanged(bool is_view_attached) {
PlatformWindowState old_state = GetPlatformWindowState();
is_view_attached_ = is_view_attached;
PlatformWindowState new_state = GetPlatformWindowState();
if (old_state != new_state) {
platform_window_delegate_->OnWindowStateChanged(old_state, new_state);
}
}
void FlatlandWindow::DispatchEvent(ui::Event* event) {
if (event->IsLocatedEvent()) {
ui::LocatedEvent* located_event = event->AsLocatedEvent();
gfx::PointF location = located_event->location_f();
location.Scale(device_pixel_ratio_);
located_event->set_location_f(location);
}
platform_window_delegate_->DispatchEvent(event);
}
void FlatlandWindow::OnFlatlandError(
fuchsia::ui::composition::FlatlandError error) {
LOG(ERROR) << "Flatland error: " << static_cast<int>(error);
platform_window_delegate_->OnClosed();
}
void FlatlandWindow::OnViewControllerDisconnected(zx_status_t status) {
view_controller_ = nullptr;
platform_window_delegate_->OnClosed();
}
} // namespace ui
Codebase Browser
chromium