| // 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 "ui/ozone/platform/wayland/host/wayland_output.h" |
| |
| #include <xdg-output-unstable-v1-client-protocol.h> |
| |
| #include "base/logging.h" |
| #include "base/strings/string_util.h" |
| #include "ui/display/display.h" |
| #include "ui/gfx/color_space.h" |
| #include "ui/ozone/platform/wayland/host/dump_util.h" |
| #include "ui/ozone/platform/wayland/host/wayland_connection.h" |
| #include "ui/ozone/platform/wayland/host/wayland_output_manager.h" |
| #include "ui/ozone/platform/wayland/host/wayland_wp_color_management_output.h" |
| #include "ui/ozone/platform/wayland/host/wayland_wp_color_manager.h" |
| #include "ui/ozone/platform/wayland/host/xdg_output.h" |
| |
| namespace ui { |
| |
| namespace { |
| constexpr uint32_t kMinVersion = 2; |
| constexpr uint32_t kMaxVersion = 4; |
| } // namespace |
| |
| using Metrics = WaylandOutput::Metrics; |
| |
| // static |
| constexpr char WaylandOutput::kInterfaceName[]; |
| |
| // static |
| void WaylandOutput::Instantiate(WaylandConnection* connection, |
| wl_registry* registry, |
| uint32_t name, |
| const std::string& interface, |
| uint32_t version) { |
| CHECK_EQ(interface, kInterfaceName) << "Expected \"" << kInterfaceName |
| << "\" but got \"" << interface << "\""; |
| |
| if (!wl::CanBind(interface, version, kMinVersion, kMaxVersion)) { |
| return; |
| } |
| |
| auto output = |
| wl::Bind<wl_output>(registry, name, std::min(version, kMaxVersion)); |
| if (!output) { |
| LOG(ERROR) << "Failed to bind to wl_output global"; |
| return; |
| } |
| |
| if (!connection->output_manager_) { |
| connection->output_manager_ = |
| std::make_unique<WaylandOutputManager>(connection); |
| } |
| connection->output_manager_->AddWaylandOutput(name, output.release()); |
| } |
| |
| Metrics::Metrics() = default; |
| Metrics::Metrics(Id output_id, |
| int64_t display_id, |
| gfx::Point origin, |
| gfx::Size logical_size, |
| gfx::Size physical_size, |
| gfx::Insets insets, |
| gfx::Insets physical_overscan_insets, |
| float scale_factor, |
| int32_t panel_transform, |
| int32_t logical_transform, |
| const std::string& description) |
| : output_id(output_id), |
| display_id(display_id), |
| origin(origin), |
| logical_size(logical_size), |
| physical_size(physical_size), |
| insets(insets), |
| physical_overscan_insets(physical_overscan_insets), |
| scale_factor(scale_factor), |
| panel_transform(panel_transform), |
| logical_transform(logical_transform), |
| description(description) {} |
| Metrics::Metrics(const Metrics&) = default; |
| Metrics& Metrics::operator=(const Metrics&) = default; |
| Metrics::Metrics(Metrics&&) = default; |
| Metrics& Metrics::operator=(Metrics&&) = default; |
| Metrics::~Metrics() = default; |
| |
| void Metrics::DumpState(std::ostream& out) const { |
| constexpr auto kTransformMap = base::MakeFixedFlatMap<int32_t, const char*>({ |
| {WL_OUTPUT_TRANSFORM_NORMAL, "normal"}, |
| {WL_OUTPUT_TRANSFORM_90, "90"}, |
| {WL_OUTPUT_TRANSFORM_180, "180"}, |
| {WL_OUTPUT_TRANSFORM_270, "270"}, |
| {WL_OUTPUT_TRANSFORM_FLIPPED, "flipped"}, |
| {WL_OUTPUT_TRANSFORM_FLIPPED_90, "flipped 90"}, |
| {WL_OUTPUT_TRANSFORM_FLIPPED_180, "flipped 180"}, |
| {WL_OUTPUT_TRANSFORM_FLIPPED_270, "flipped 270"}, |
| }); |
| |
| out << "output_id=" << output_id << ", display_id=" << display_id |
| << ", description=" << description << ", origin=" << origin.ToString() |
| << ", logical_size=" << logical_size.ToString() |
| << ", physicacl_size=" << physical_size.ToString() |
| << ", scale_factor=" << scale_factor |
| << ", work_area_insets=" << insets.ToString() |
| << ", overscacn_insets=" << physical_overscan_insets.ToString() |
| << ", panel_transform=" |
| << GetMapValueOrDefault(kTransformMap, panel_transform) |
| << ", logical_transform=" |
| << GetMapValueOrDefault(kTransformMap, logical_transform); |
| } |
| |
| WaylandOutput::WaylandOutput(Id output_id, |
| wl_output* output, |
| WaylandConnection* connection) |
| : output_id_(output_id), output_(output), connection_(connection) { |
| wl_output_set_user_data(output_.get(), this); |
| } |
| |
| WaylandOutput::~WaylandOutput() { |
| wl_output_set_user_data(output_.get(), nullptr); |
| } |
| |
| void WaylandOutput::InitializeXdgOutput( |
| zxdg_output_manager_v1* xdg_output_manager) { |
| DCHECK(!xdg_output_); |
| xdg_output_ = std::make_unique<XDGOutput>( |
| zxdg_output_manager_v1_get_xdg_output(xdg_output_manager, output_.get())); |
| } |
| |
| void WaylandOutput::InitializeWpColorManagementOutput( |
| WaylandWpColorManager* wp_color_manager) { |
| DCHECK(!wp_color_management_output_); |
| wp_color_management_output_ = |
| std::make_unique<WaylandWpColorManagementOutput>( |
| wp_color_manager->CreateColorManagementOutput(output_.get()) |
| .release(), |
| this, connection_); |
| } |
| |
| void WaylandOutput::Initialize(Delegate* delegate) { |
| DCHECK(!delegate_); |
| delegate_ = delegate; |
| static constexpr wl_output_listener kOutputListener = { |
| .geometry = &OnGeometry, |
| .mode = &OnMode, |
| .done = &OnDone, |
| .scale = &OnScale, |
| .name = &OnName, |
| .description = &OnDescription, |
| }; |
| wl_output_add_listener(output_.get(), &kOutputListener, this); |
| } |
| |
| const Metrics& WaylandOutput::GetMetrics() const { |
| return metrics_; |
| } |
| |
| void WaylandOutput::SetMetrics(const Metrics& metrics) { |
| metrics_ = metrics; |
| } |
| |
| float WaylandOutput::scale_factor() const { |
| return metrics_.scale_factor; |
| } |
| |
| bool WaylandOutput::IsReady() const { |
| return is_ready_; |
| } |
| |
| void WaylandOutput::SetScaleFactorForTesting(float scale_factor) { |
| metrics_.scale_factor = scale_factor; |
| } |
| |
| void WaylandOutput::TriggerDelegateNotifications() { |
| // Wait until the all outputs receives enough information to generate display |
| // information. |
| if (!IsReady()) |
| return; |
| |
| delegate_->OnOutputHandleMetrics(GetMetrics()); |
| } |
| |
| void WaylandOutput::DumpState(std::ostream& out) const { |
| metrics_.DumpState(out); |
| } |
| |
| void WaylandOutput::UpdateMetrics() { |
| metrics_.output_id = output_id_; |
| // For the non-aura case we map the global output "name" to the display_id. |
| metrics_.display_id = output_id_; |
| metrics_.origin = origin_; |
| metrics_.physical_size = physical_size_; |
| metrics_.scale_factor = scale_factor_; |
| metrics_.panel_transform = panel_transform_; |
| metrics_.logical_transform = panel_transform_; |
| metrics_.name = name_; |
| metrics_.description = description_; |
| |
| if (xdg_output_) { |
| xdg_output_->UpdateMetrics( |
| connection_->supports_viewporter_surface_scaling(), metrics_); |
| } |
| } |
| |
| // static |
| void WaylandOutput::OnGeometry(void* data, |
| wl_output* output, |
| int32_t x, |
| int32_t y, |
| int32_t physical_width, |
| int32_t physical_height, |
| int32_t subpixel, |
| const char* make, |
| const char* model, |
| int32_t output_transform) { |
| if (auto* self = static_cast<WaylandOutput*>(data)) { |
| // It looks like there is a bug in libffi - only the 8th arg is affected. |
| // Possibly it is not following the calling convention of the ABI? Eg. the |
| // lib has some off-by-1-error where it's supposed to pass 8 args in regs |
| // and the rest on the stack but instead it's passing 7 in regs. This is |
| // out of our control. Given the output_transform is always correct, |
| // unpoison the value to make MSAN happy. |
| MSAN_UNPOISON(&output_transform, sizeof(int32_t)); |
| self->origin_ = gfx::Point(x, y); |
| self->panel_transform_ = output_transform; |
| } |
| } |
| |
| // static |
| void WaylandOutput::OnMode(void* data, |
| wl_output* wl_output, |
| uint32_t flags, |
| int32_t width, |
| int32_t height, |
| int32_t refresh) { |
| auto* self = static_cast<WaylandOutput*>(data); |
| if (self && (flags & WL_OUTPUT_MODE_CURRENT)) { |
| self->physical_size_ = gfx::Size(width, height); |
| } |
| } |
| |
| // static |
| void WaylandOutput::OnDone(void* data, wl_output* output) { |
| auto* self = static_cast<WaylandOutput*>(data); |
| if (!self) { |
| return; |
| } |
| |
| self->is_ready_ = true; |
| |
| if (auto& xdg_output = self->xdg_output_) { |
| xdg_output->HandleDone(); |
| } |
| |
| // Once all metrics have been received perform an atomic update on this |
| // output's `metrics_`. |
| self->UpdateMetrics(); |
| |
| self->TriggerDelegateNotifications(); |
| } |
| |
| // static |
| void WaylandOutput::OnScale(void* data, wl_output* output, int32_t factor) { |
| if (auto* self = static_cast<WaylandOutput*>(data)) { |
| self->scale_factor_ = factor; |
| } |
| } |
| |
| // static |
| void WaylandOutput::OnName(void* data, wl_output* output, const char* name) { |
| if (auto* self = static_cast<WaylandOutput*>(data)) { |
| self->name_ = name ? std::string(name) : std::string{}; |
| } |
| } |
| |
| // static |
| void WaylandOutput::OnDescription(void* data, |
| wl_output* output, |
| const char* description) { |
| if (auto* self = static_cast<WaylandOutput*>(data)) { |
| self->description_ = description ? std::string(description) : std::string{}; |
| } |
| } |
| |
| } // namespace ui |
