// Copyright 2017 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef ASH_FAST_INK_FAST_INK_HOST_H_ #define ASH_FAST_INK_FAST_INK_HOST_H_ #include #include #include "base/memory/weak_ptr.h" #include "components/viz/common/quads/compositor_frame_metadata.h" #include "components/viz/common/resources/resource_id.h" #include "ui/gfx/canvas.h" namespace gfx { class GpuMemoryBuffer; struct PresentationFeedback; } // namespace gfx namespace fast_ink { // FastInkHost is used to support low-latency rendering. It supports // 'auto-refresh' mode which provide minimum latency updates for the // associated window. 'auto-refresh' mode will take advantage of HW overlays // when possible and trigger continuous updates. class FastInkHost { public: // Convert the rect in window's coordinate to the buffer's coordinate. If the // window is rotated, the damaged_rect will also be rotated, for example. The // size is clamped by |buffer_size| to ensure it does not exceeds the buffer // size. static gfx::Rect BufferRectFromWindowRect( const gfx::Transform& window_to_buffer_transform, const gfx::Size& buffer_size, const gfx::Rect& damage_rect); using PresentationCallback = base::RepeatingCallback; // Creates a FastInkView. FastInkHost(aura::Window* host_window, const PresentationCallback& presentation_callback); ~FastInkHost(); FastInkHost(const FastInkHost&) = delete; FastInkHost& operator=(const FastInkHost&) = delete; // Update content and damage rectangles for surface. |auto_refresh| should // be set to true if continuous updates are expected within content rectangle. void UpdateSurface(const gfx::Rect& content_rect, const gfx::Rect& damage_rect, bool auto_refresh); aura::Window* host_window() { return host_window_; } const gfx::Transform& window_to_buffer_transform() const { return window_to_buffer_transform_; } gfx::GpuMemoryBuffer* gpu_memory_buffer() { return gpu_memory_buffer_.get(); } private: class LayerTreeFrameSinkHolder; struct Resource; void SubmitCompositorFrame(); void SubmitPendingCompositorFrame(); void ReclaimResource(std::unique_ptr resource); void DidReceiveCompositorFrameAck(); void DidPresentCompositorFrame(const gfx::PresentationFeedback& feedback); aura::Window* host_window_; const PresentationCallback presentation_callback_; gfx::Transform window_to_buffer_transform_; std::unique_ptr gpu_memory_buffer_; // The size of |gpu_memory_buffer_|. gfx::Size buffer_size_; // The bounds of the content to be pushed in window coordinates. gfx::Rect content_rect_; // The damage rect in window coordinates. gfx::Rect damage_rect_; // When true it keeps pushing entire buffer with hw overlay option. bool auto_refresh_ = false; bool pending_compositor_frame_ = false; bool pending_compositor_frame_ack_ = false; viz::ResourceIdGenerator id_generator_; // Cached resources that can be reused. std::vector> returned_resources_; std::unique_ptr frame_sink_holder_; base::WeakPtrFactory weak_ptr_factory_{this}; }; } // namespace fast_ink #endif // ASH_FAST_INK_FAST_INK_HOST_H_