// 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.
#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/351564777): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif
#include "ui/ozone/platform/flatland/flatland_surface_canvas.h"
#include <fuchsia/sysmem2/cpp/fidl.h>
#include <fuchsia/ui/composition/cpp/fidl.h>
#include "base/fuchsia/fuchsia_logging.h"
#include "base/functional/bind.h"
#include "base/location.h"
#include "base/memory/weak_ptr.h"
#include "base/memory/writable_shared_memory_region.h"
#include "base/unguessable_token.h"
#include "mojo/public/cpp/platform/platform_handle.h"
#include "third_party/skia/include/core/SkColorType.h"
#include "ui/gfx/geometry/skia_conversions.h"
#include "ui/gfx/vsync_provider.h"
namespace ui {
size_t RoundUp(size_t value, size_t alignment) {
return ((value + alignment - 1) / alignment) * alignment;
}
// How long we want to wait for release-fence from scenic for previous frames.
constexpr base::TimeDelta kFrameReleaseTimeout = base::Milliseconds(500);
FlatlandSurfaceCanvas::Frame::Frame() = default;
FlatlandSurfaceCanvas::Frame::~Frame() = default;
class FlatlandSurfaceCanvas::VSyncProviderImpl : public gfx::VSyncProvider {
public:
VSyncProviderImpl() = default;
~VSyncProviderImpl() override {}
base::WeakPtr<VSyncProviderImpl> GetWeakPtr() {
return weak_ptr_factory_.GetWeakPtr();
}
void SetState(base::TimeTicks timebase, base::TimeDelta interval) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
timebase_ = timebase;
interval_ = interval;
if (get_params_callback_) {
std::move(get_params_callback_).Run(timebase_, interval_);
}
}
// gfx::VSyncProvider implementation.
void GetVSyncParameters(UpdateVSyncCallback callback) override {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
if (timebase_.is_null()) {
get_params_callback_ = std::move(callback);
return;
}
std::move(callback).Run(timebase_, interval_);
}
bool GetVSyncParametersIfAvailable(base::TimeTicks* timebase,
base::TimeDelta* interval) override {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
if (!timebase_.is_null()) {
return false;
}
*timebase = timebase_;
*interval = interval_;
return true;
}
bool SupportGetVSyncParametersIfAvailable() const override { return true; }
bool IsHWClock() const override { return false; }
private:
base::TimeTicks timebase_;
base::TimeDelta interval_;
UpdateVSyncCallback get_params_callback_;
THREAD_CHECKER(thread_checker_);
base::WeakPtrFactory<VSyncProviderImpl> weak_ptr_factory_{this};
};
void FlatlandSurfaceCanvas::Frame::InitializeBuffer(
fuchsia::sysmem2::VmoBuffer vmo,
gfx::Size size,
size_t stride) {
size_t buffer_size = stride * size.height();
base::WritableSharedMemoryRegion memory_region =
base::WritableSharedMemoryRegion::Deserialize(
base::subtle::PlatformSharedMemoryRegion::Take(
std::move(*vmo.mutable_vmo()),
base::subtle::PlatformSharedMemoryRegion::Mode::kWritable,
buffer_size, base::UnguessableToken::Create()));
memory_mapping = memory_region.Map();
if (!memory_mapping.IsValid()) {
LOG(WARNING) << "Failed to map memory for FlatlandSurfaceCanvas.";
Reset();
return;
}
// Initialize `surface`.
SkSurfaceProps props;
surface = SkSurfaces::WrapPixels(
SkImageInfo::MakeN32Premul(size.width(), size.height()),
memory_mapping.memory(), stride, &props);
dirty_region.setRect(gfx::RectToSkIRect(gfx::Rect(size)));
}
void FlatlandSurfaceCanvas::Frame::Reset() {
memory_mapping = {};
surface = nullptr;
dirty_region = {};
}
void FlatlandSurfaceCanvas::Frame::CopyDirtyRegionFrom(const Frame& frame) {
int stride = surface->width() * SkColorTypeBytesPerPixel(kN32_SkColorType);
for (SkRegion::Iterator i(dirty_region); !i.done(); i.next()) {
uint8_t* dst_ptr =
static_cast<uint8_t*>(memory_mapping.memory()) +
i.rect().x() * SkColorTypeBytesPerPixel(kN32_SkColorType) +
i.rect().y() * stride;
frame.surface->readPixels(
SkImageInfo::MakeN32Premul(i.rect().width(), i.rect().height()),
dst_ptr, stride, i.rect().x(), i.rect().y());
}
dirty_region.setEmpty();
}
FlatlandSurfaceCanvas::FlatlandSurfaceCanvas(
fuchsia::sysmem2::Allocator_Sync* sysmem_allocator,
fuchsia::ui::composition::Allocator* flatland_allocator)
: sysmem_allocator_(sysmem_allocator),
flatland_allocator_(flatland_allocator),
flatland_("Chromium FlatlandSurface",
base::BindOnce(&FlatlandSurfaceCanvas::OnFlatlandError,
base::Unretained(this))) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
root_transform_id_ = flatland_.NextTransformId();
flatland_.flatland()->CreateTransform(root_transform_id_);
flatland_.flatland()->SetRootTransform(root_transform_id_);
}
FlatlandSurfaceCanvas::~FlatlandSurfaceCanvas() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
}
mojo::PlatformHandle FlatlandSurfaceCanvas::CreateView() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
fuchsia::ui::views::ViewportCreationToken parent_token;
fuchsia::ui::views::ViewCreationToken child_token;
auto status = zx::channel::create(0, &parent_token.value, &child_token.value);
DCHECK_EQ(status, ZX_OK);
flatland_.flatland()->CreateView(std::move(child_token),
parent_viewport_watcher_.NewRequest());
return mojo::PlatformHandle(std::move(parent_token.value));
}
void FlatlandSurfaceCanvas::ResizeCanvas(const gfx::Size& viewport_size,
float scale) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
// Drop old images if any.
for (auto& frame : frames_) {
if (frame.image_id.value) {
flatland_.flatland()->ReleaseImage(frame.image_id);
frame.image_id = {};
}
}
viewport_size_ = viewport_size;
viewport_size_.SetToMax(gfx::Size(1, 1));
fuchsia::sysmem2::BufferCollectionTokenSyncPtr collection_token;
sysmem_allocator_->AllocateSharedCollection(
std::move(fuchsia::sysmem2::AllocatorAllocateSharedCollectionRequest{}
.set_token_request(collection_token.NewRequest())));
fuchsia::sysmem2::BufferCollectionTokenSyncPtr collection_token_for_flatland;
collection_token->Duplicate(std::move(
fuchsia::sysmem2::BufferCollectionTokenDuplicateRequest{}
.set_rights_attenuation_mask(ZX_RIGHT_SAME_RIGHTS)
.set_token_request(collection_token_for_flatland.NewRequest())));
fuchsia::sysmem2::Node_Sync_Result sync_result;
collection_token->Sync(&sync_result);
fuchsia::ui::composition::BufferCollectionExportToken export_token;
zx_status_t status =
zx::eventpair::create(0, &export_token.value, &import_token_.value);
ZX_DCHECK(status == ZX_OK, status);
fuchsia::ui::composition::RegisterBufferCollectionArgs args;
args.set_export_token(std::move(export_token));
args.set_buffer_collection_token(fuchsia::sysmem::BufferCollectionTokenHandle(
collection_token_for_flatland.Unbind().TakeChannel()));
args.set_usage(
fuchsia::ui::composition::RegisterBufferCollectionUsage::DEFAULT);
flatland_allocator_->RegisterBufferCollection(
std::move(args),
[](fuchsia::ui::composition::Allocator_RegisterBufferCollection_Result
result) {
if (result.is_err()) {
LOG(FATAL) << "RegisterBufferCollection failed";
}
});
sysmem_allocator_->BindSharedCollection(std::move(
fuchsia::sysmem2::AllocatorBindSharedCollectionRequest{}
.set_token(std::move(collection_token))
.set_buffer_collection_request(buffer_collection_.NewRequest())));
fuchsia::sysmem2::BufferCollectionConstraints constraints;
constraints.mutable_usage()->set_cpu(fuchsia::sysmem2::CPU_USAGE_READ |
fuchsia::sysmem2::CPU_USAGE_WRITE);
constraints.set_min_buffer_count(kNumBuffers);
auto& memory_constraints = *constraints.mutable_buffer_memory_constraints();
memory_constraints.set_ram_domain_supported(true);
memory_constraints.set_cpu_domain_supported(true);
auto& image_constraints =
constraints.mutable_image_format_constraints()->emplace_back();
image_constraints.mutable_color_spaces()->emplace_back(
fuchsia::images2::ColorSpace::SRGB);
image_constraints.set_pixel_format(fuchsia::images2::PixelFormat::B8G8R8A8);
image_constraints.set_pixel_format_modifier(
fuchsia::images2::PixelFormatModifier::LINEAR);
image_constraints.set_min_size(
fuchsia::math::SizeU{static_cast<uint32_t>(viewport_size_.width()),
static_cast<uint32_t>(viewport_size_.height())});
buffer_collection_->SetConstraints(std::move(
fuchsia::sysmem2::BufferCollectionSetConstraintsRequest{}.set_constraints(
std::move(constraints))));
}
void FlatlandSurfaceCanvas::FinalizeBufferAllocation() {
fuchsia::sysmem2::BufferCollection_WaitForAllBuffersAllocated_Result
wait_result;
zx_status_t status =
buffer_collection_->WaitForAllBuffersAllocated(&wait_result);
ZX_LOG_IF(FATAL, status != ZX_OK, status)
<< "Sysmem connection failed (status).";
if (!wait_result.is_response()) {
if (wait_result.is_framework_err()) {
LOG(ERROR) << "WaitForBuffersAllocated (framework_err): "
<< fidl::ToUnderlying(wait_result.framework_err());
} else {
LOG(ERROR) << "WaitForBuffersAllocated (err): "
<< static_cast<uint32_t>(wait_result.err());
}
return;
}
auto buffer_info =
std::move(*wait_result.response().mutable_buffer_collection_info());
buffer_collection_->Release();
buffer_collection_.Unbind();
CHECK_GE(buffer_info.buffers().size(), kNumBuffers);
DCHECK(import_token_.value.is_valid());
for (size_t i = 0; i < kNumBuffers; ++i) {
fuchsia::ui::composition::ImageProperties image_properties;
image_properties.set_size(
fuchsia::math::SizeU{static_cast<uint32_t>(viewport_size_.width()),
static_cast<uint32_t>(viewport_size_.height())});
frames_[i].image_id = flatland_.NextContentId();
fuchsia::ui::composition::BufferCollectionImportToken token;
status = import_token_.Clone(&token);
ZX_DCHECK(status == ZX_OK, status);
flatland_.flatland()->CreateImage(frames_[i].image_id, std::move(token), i,
std::move(image_properties));
// TODO(crbug.com/42050483): We should set SRC blend mode when Chrome has a
// reliable signal for opaque background.
flatland_.flatland()->SetImageBlendingFunction(
frames_[i].image_id, fuchsia::ui::composition::BlendMode::SRC_OVER);
}
import_token_.value.reset();
const fuchsia::sysmem2::ImageFormatConstraints& format =
buffer_info.settings().image_format_constraints();
size_t stride =
RoundUp(std::max(format.min_bytes_per_row(), viewport_size_.width() * 4U),
format.bytes_per_row_divisor());
for (size_t i = 0; i < kNumBuffers; ++i) {
frames_[i].InitializeBuffer(std::move(buffer_info.mutable_buffers()->at(i)),
viewport_size_, stride);
}
}
SkCanvas* FlatlandSurfaceCanvas::GetCanvas() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
if (buffer_collection_) {
FinalizeBufferAllocation();
}
if (viewport_size_.IsEmpty() || frames_[current_frame_].is_empty()) {
return nullptr;
}
// Wait for the buffer to become available. This call has to be blocking
// because GetSurface() and PresentCanvas() are synchronous.
if (frames_[current_frame_].release_fence) {
auto status = frames_[current_frame_].release_fence.wait_one(
ZX_EVENT_SIGNALED,
zx::deadline_after(zx::duration(kFrameReleaseTimeout.InNanoseconds())),
nullptr);
if (status == ZX_ERR_TIMED_OUT) {
// Timeout here indicates that Scenic is most likely broken. If it still
// works, then in the worst case returning before |release_fence| is
// signaled will cause screen tearing.
LOG(WARNING) << "Release fence from previous frame timed out after 500ms";
} else {
ZX_CHECK(status == ZX_OK, status);
}
}
return frames_[current_frame_].surface->getCanvas();
}
void FlatlandSurfaceCanvas::PresentCanvas(const gfx::Rect& damage) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
// Subtract |damage| from the dirty region in the current frame since it's
// been repainted.
SkIRect sk_damage = gfx::RectToSkIRect(damage);
frames_[current_frame_].dirty_region.op(sk_damage, SkRegion::kDifference_Op);
// Copy dirty region from the previous buffer to make sure the whole frame
// is up to date.
int prev_frame =
current_frame_ == 0 ? (kNumBuffers - 1) : (current_frame_ - 1);
frames_[current_frame_].CopyDirtyRegionFrom(frames_[prev_frame]);
// |damage| rect was updated in the current frame. It means that the rect is
// no longer valid in all other buffers. Add |damage| to |dirty_region| in all
// buffers except the current one.
for (size_t i = 0; i < kNumBuffers; ++i) {
if (i != current_frame_) {
frames_[i].dirty_region.op(sk_damage, SkRegion::kUnion_Op);
}
}
flatland_.flatland()->SetContent(root_transform_id_,
frames_[current_frame_].image_id);
// Create release fence for the current buffer or reset it if it already
// exists.
if (!frames_[current_frame_].release_fence) {
auto status = zx::event::create(
/*options=*/0u, &(frames_[current_frame_].release_fence));
ZX_CHECK(status == ZX_OK, status);
} else {
auto status = frames_[current_frame_].release_fence.signal(
/*clear_mask=*/ZX_EVENT_SIGNALED, /*set_mask=*/0);
ZX_CHECK(status == ZX_OK, status);
}
// Add release-fence for the Present() call below. The fence is used in
// GetCanvas() to ensure that we reuse the buffer only after it's released
// from scenic.
zx::event release_fence_dup;
auto status = frames_[current_frame_].release_fence.duplicate(
ZX_RIGHT_SAME_RIGHTS, &release_fence_dup);
ZX_CHECK(status == ZX_OK, status);
fuchsia::ui::composition::PresentArgs present_args;
present_args.set_requested_presentation_time(0);
present_args.mutable_release_fences()->push_back(
std::move(release_fence_dup));
present_args.set_unsquashable(false);
flatland_.Present(std::move(present_args),
base::BindOnce(&FlatlandSurfaceCanvas::OnFramePresented,
base::Unretained(this)));
// Move to the next buffer.
current_frame_ = (current_frame_ + 1) % kNumBuffers;
}
std::unique_ptr<gfx::VSyncProvider>
FlatlandSurfaceCanvas::CreateVSyncProvider() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
auto result = std::make_unique<VSyncProviderImpl>();
vsync_provider_ = result->GetWeakPtr();
return std::move(result);
}
void FlatlandSurfaceCanvas::OnFramePresented(
base::TimeTicks actual_presentation_time,
base::TimeDelta future_presentation_interval) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
if (vsync_provider_) {
vsync_provider_->SetState(actual_presentation_time,
future_presentation_interval);
}
}
void FlatlandSurfaceCanvas::OnFlatlandError(
fuchsia::ui::composition::FlatlandError error) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
LOG(ERROR) << "Flatland error: " << static_cast<int>(error);
base::LogFidlErrorAndExitProcess(FROM_HERE,
"fuchsia::ui::composition::Flatland");
}
} // namespace ui
Codebase Browser
chromium