Skip to content

GitLab

T
tangled
Commit b6d3d74d authored by Eric Karl's avatar Eric Karl Committed by Commit Bot
Browse files
Options

Android Viz Clean-up: Remove non-viz from CompositorImpl+DFHA 

Now that viz is required, remove non-viz code from CompositorImpl
and DelegatedFrameHostAndroid.

Bug: 978640
Change-Id: Ia18074ea6d43baaaa0129cd48593db9a93db27c8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1677233
Commit-Queue: Eric Karl <ericrk@chromium.org>
Reviewed-by: default avatarKhushal <khushalsagar@chromium.org>
Cr-Commit-Position: refs/heads/master@{#678460}
parent ee755598
Hide whitespace changes
Inline Side-by-side
Showing with 45 additions and 379 deletions
content/browser/renderer_host/compositor_impl_android.cc
View file @ b6d3d74d
......@@ -45,14 +45,12 @@
#include "components/viz/common/surfaces/local_surface_id_allocation.h"
#include "components/viz/common/viz_utils.h"
#include "components/viz/host/host_display_client.h"
#include "components/viz/service/display/display.h"
#include "components/viz/service/display/display_scheduler.h"
#include "components/viz/service/display/output_surface.h"
#include "components/viz/service/display/output_surface_client.h"
#include "components/viz/service/display/output_surface_frame.h"
#include "components/viz/service/display_embedder/server_shared_bitmap_manager.h"
#include "components/viz/service/frame_sinks/direct_layer_tree_frame_sink.h"
#include "components/viz/service/frame_sinks/frame_sink_manager_impl.h"
#include "content/browser/browser_main_loop.h"
#include "content/browser/compositor/surface_utils.h"
#include "content/browser/gpu/compositor_util.h"
......@@ -415,10 +413,9 @@ CompositorImpl::CompositorImpl(CompositorClient* client,
needs_animate_(false),
pending_frames_(0U),
layer_tree_frame_sink_request_pending_(false),
enable_surface_synchronization_(
features::IsSurfaceSynchronizationEnabled()),
enable_viz_(features::IsVizDisplayCompositorEnabled()),
weak_factory_(this) {
CHECK(features::IsVizDisplayCompositorEnabled());
CHECK(features::IsSurfaceSynchronizationEnabled());
DCHECK(client);
SetRootWindow(root_window);
......@@ -457,7 +454,6 @@ void CompositorImpl::SetRootWindow(gfx::NativeWindow root_window) {
// handle visibility, swapping begin frame sources, etc.
// These checks ensure we have no begin frame source, and that we don't need
// to register one on the new window.
DCHECK(!display_);
DCHECK(!window_);
scoped_refptr<cc::Layer> root_layer;
......@@ -542,7 +538,7 @@ void CompositorImpl::CreateLayerTreeHost() {
cc::LayerTreeSettings settings;
settings.use_zero_copy = true;
settings.enable_surface_synchronization = enable_surface_synchronization_;
settings.enable_surface_synchronization = true;
settings.build_hit_test_data = features::IsVizHitTestingSurfaceLayerEnabled();
base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
......@@ -614,38 +610,21 @@ void CompositorImpl::TearDownDisplayAndUnregisterRootFrameSink() {
// https://crbug.com/899705
SCOPED_UMA_HISTOGRAM_LONG_TIMER("CompositorImplAndroid.TearDownDisplayTime");
if (enable_viz_) {
// Make a best effort to try to complete pending readbacks.
// TODO(crbug.com/637035): Consider doing this in a better way,
// ideally with the guarantee of readbacks completing.
if (display_private_ && HavePendingReadbacks()) {
// Note that while this is not a Sync IPC, the call to
// InvalidateFrameSinkId below will end up triggering a sync call to
// FrameSinkManager::DestroyCompositorFrameSink, as this is the root
// frame sink. Because |display_private_| is an associated interface to
// FrameSinkManager, this subsequent sync call will ensure ordered
// execution of this call.
display_private_->ForceImmediateDrawAndSwapIfPossible();
}
GetHostFrameSinkManager()->InvalidateFrameSinkId(frame_sink_id_);
display_private_.reset();
} else {
// Make a best effort to try to complete pending readbacks.
// TODO(crbug.com/637035): Consider doing this in a better way,
// ideally with the guarantee of readbacks completing.
if (display_ && HavePendingReadbacks())
display_->ForceImmediateDrawAndSwapIfPossible();
if (display_) {
CompositorDependenciesAndroid::Get()
.frame_sink_manager_impl()
->UnregisterBeginFrameSource(root_window_->GetBeginFrameSource());
}
GetHostFrameSinkManager()->InvalidateFrameSinkId(frame_sink_id_);
display_.reset();
// Make a best effort to try to complete pending readbacks.
// TODO(crbug.com/637035): Consider doing this in a better way,
// ideally with the guarantee of readbacks completing.
if (display_private_ && HavePendingReadbacks()) {
// Note that while this is not a Sync IPC, the call to
// InvalidateFrameSinkId below will end up triggering a sync call to
// FrameSinkManager::DestroyCompositorFrameSink, as this is the root
// frame sink. Because |display_private_| is an associated interface to
// FrameSinkManager, this subsequent sync call will ensure ordered
// execution of this call.
display_private_->ForceImmediateDrawAndSwapIfPossible();
}
GetHostFrameSinkManager()->InvalidateFrameSinkId(frame_sink_id_);
display_private_.reset();
}
void CompositorImpl::RegisterRootFrameSink() {
......@@ -665,8 +644,6 @@ void CompositorImpl::SetWindowBounds(const gfx::Size& size) {
host_->SetViewportSizeAndScale(size_, root_window_->GetDipScale(),
GenerateLocalSurfaceId());
}
if (display_)
display_->Resize(size);
if (display_private_)
display_private_->Resize(size);
......@@ -779,12 +756,10 @@ void CompositorImpl::OnGpuChannelEstablished(
display_color_space_ = display::Screen::GetScreen()
->GetDisplayNearestWindow(root_window_)
.color_space();
gpu::SurfaceHandle surface_handle =
enable_viz_ ? gpu::kNullSurfaceHandle : surface_handle_;
auto context_provider =
base::MakeRefCounted<viz::ContextProviderCommandBuffer>(
std::move(gpu_channel_host), factory->GetGpuMemoryBufferManager(),
stream_id, stream_priority, surface_handle,
stream_id, stream_priority, gpu::kNullSurfaceHandle,
GURL(std::string("chrome://gpu/CompositorImpl::") +
std::string("CompositorContextProvider")),
automatic_flushes, support_locking, support_grcontext,
......@@ -794,12 +769,7 @@ void CompositorImpl::OnGpuChannelEstablished(
viz::command_buffer_metrics::ContextType::BROWSER_COMPOSITOR);
auto result = context_provider->BindToCurrentThread();
if (surface_handle != gpu::kNullSurfaceHandle) {
// Only use OnContextCreationResult for onscreen contexts, where recovering
// from a surface initialization failure is possible by re-creating the
// native window.
OnContextCreationResult(result);
} else if (result == gpu::ContextResult::kFatalFailure) {
if (result == gpu::ContextResult::kFatalFailure) {
LOG(FATAL) << "Fatal failure in creating offscreen context";
}
......@@ -808,72 +778,7 @@ void CompositorImpl::OnGpuChannelEstablished(
return;
}
if (enable_viz_) {
InitializeVizLayerTreeFrameSink(std::move(context_provider));
} else {
// Unretained is safe this owns viz::Display which owns OutputSurface.
auto display_output_surface = std::make_unique<AndroidOutputSurface>(
context_provider, base::BindRepeating(&CompositorImpl::DidSwapBuffers,
base::Unretained(this)));
InitializeDisplay(std::move(display_output_surface),
std::move(context_provider));
}
}
void CompositorImpl::InitializeDisplay(
std::unique_ptr<viz::OutputSurface> display_output_surface,
scoped_refptr<viz::ContextProvider> context_provider) {
DCHECK(layer_tree_frame_sink_request_pending_);
pending_frames_ = 0;
if (context_provider) {
gpu_capabilities_ = context_provider->ContextCapabilities();
}
viz::FrameSinkManagerImpl* manager =
CompositorDependenciesAndroid::Get().frame_sink_manager_impl();
scoped_refptr<base::SingleThreadTaskRunner> task_runner =
base::ThreadTaskRunnerHandle::Get();
auto scheduler = std::make_unique<viz::DisplayScheduler>(
root_window_->GetBeginFrameSource(), task_runner.get(),
display_output_surface->capabilities().max_frames_pending);
viz::RendererSettings renderer_settings;
renderer_settings.allow_antialiasing = false;
renderer_settings.highp_threshold_min = 2048;
renderer_settings.auto_resize_output_surface = false;
renderer_settings.initial_screen_size =
display::Screen::GetScreen()
->GetDisplayNearestWindow(root_window_)
.GetSizeInPixel();
auto* gpu_memory_buffer_manager = BrowserMainLoop::GetInstance()
->gpu_channel_establish_factory()
->GetGpuMemoryBufferManager();
// Don't re-register BeginFrameSource on context loss.
const bool should_register_begin_frame_source = !display_;
display_ = std::make_unique<viz::Display>(
nullptr, renderer_settings, frame_sink_id_,
std::move(display_output_surface), std::move(scheduler), task_runner);
auto layer_tree_frame_sink = std::make_unique<viz::DirectLayerTreeFrameSink>(
frame_sink_id_, GetHostFrameSinkManager(), manager, display_.get(),
nullptr /* display_client */, context_provider,
nullptr /* worker_context_provider */, task_runner,
gpu_memory_buffer_manager);
display_->SetVisible(true);
display_->Resize(size_);
display_->SetColorSpace(display_color_space_, display_color_space_);
if (should_register_begin_frame_source) {
CompositorDependenciesAndroid::Get()
.frame_sink_manager_impl()
->RegisterBeginFrameSource(root_window_->GetBeginFrameSource(),
frame_sink_id_);
}
host_->SetLayerTreeFrameSink(std::move(layer_tree_frame_sink));
InitializeVizLayerTreeFrameSink(std::move(context_provider));
}
void CompositorImpl::DidSwapBuffers(const gfx::Size& swap_size) {
......@@ -996,10 +901,6 @@ bool CompositorImpl::IsDrawingFirstVisibleFrame() const {
}
void CompositorImpl::SetVSyncPaused(bool paused) {
// No action needed in non-Viz mode, as VSync is handled in WindowAndroid.
if (!enable_viz_)
return;
if (vsync_paused_ == paused)
return;
......@@ -1021,7 +922,6 @@ void CompositorImpl::OnUpdateSupportedRefreshRates(
void CompositorImpl::InitializeVizLayerTreeFrameSink(
scoped_refptr<viz::ContextProviderCommandBuffer> context_provider) {
DCHECK(enable_viz_);
DCHECK(root_window_);
pending_frames_ = 0;
......@@ -1095,12 +995,8 @@ void CompositorImpl::InitializeVizLayerTreeFrameSink(
}
viz::LocalSurfaceIdAllocation CompositorImpl::GenerateLocalSurfaceId() {
if (enable_surface_synchronization_) {
local_surface_id_allocator_.GenerateId();
return local_surface_id_allocator_.GetCurrentLocalSurfaceIdAllocation();
}
return viz::LocalSurfaceIdAllocation();
local_surface_id_allocator_.GenerateId();
return local_surface_id_allocator_.GetCurrentLocalSurfaceIdAllocation();
}
void CompositorImpl::OnContextCreationResult(
......
content/browser/renderer_host/compositor_impl_android.h
View file @ b6d3d74d
......@@ -53,7 +53,6 @@ class ExternalBeginFrameControllerClientImpl;
}
namespace viz {
class Display;
class FrameSinkId;
class HostDisplayClient;
class OutputSurface;
......@@ -221,8 +220,6 @@ class CONTENT_EXPORT CompositorImpl
std::unique_ptr<cc::LayerTreeHost> host_;
ui::ResourceManagerImpl resource_manager_;
std::unique_ptr<viz::Display> display_;
gfx::ColorSpace display_color_space_;
gfx::Size size_;
bool requires_alpha_channel_ = false;
......@@ -254,12 +251,6 @@ class CONTENT_EXPORT CompositorImpl
pending_child_frame_sink_ids_;
bool has_submitted_frame_since_became_visible_ = false;
// If true, we are using surface synchronization.
const bool enable_surface_synchronization_;
// If true, we are using a Viz process.
const bool enable_viz_;
// Viz-specific members for communicating with the display.
viz::mojom::DisplayPrivateAssociatedPtr display_private_;
std::unique_ptr<viz::HostDisplayClient> display_client_;
......
content/browser/renderer_host/delegated_frame_host_client_android.cc
View file @ b6d3d74d
......@@ -15,26 +15,6 @@ DelegatedFrameHostClientAndroid::DelegatedFrameHostClientAndroid(
DelegatedFrameHostClientAndroid::~DelegatedFrameHostClientAndroid() {}
void DelegatedFrameHostClientAndroid::SetBeginFrameSource(
viz::BeginFrameSource* begin_frame_source) {
render_widget_host_view_->SetBeginFrameSource(begin_frame_source);
}
void DelegatedFrameHostClientAndroid::DidReceiveCompositorFrameAck(
const std::vector<viz::ReturnedResource>& resources) {
render_widget_host_view_->DidReceiveCompositorFrameAck(resources);
}
void DelegatedFrameHostClientAndroid::DidPresentCompositorFrames(
const viz::FrameTimingDetailsMap& timing_details) {
render_widget_host_view_->DidPresentCompositorFrames(timing_details);
}
void DelegatedFrameHostClientAndroid::ReclaimResources(
const std::vector<viz::ReturnedResource>& resources) {
render_widget_host_view_->ReclaimResources(resources);
}
void DelegatedFrameHostClientAndroid::OnFrameTokenChanged(
uint32_t frame_token) {
render_widget_host_view_->OnFrameTokenChangedForView(frame_token);
......
content/browser/renderer_host/delegated_frame_host_client_android.h
View file @ b6d3d74d
......@@ -23,13 +23,6 @@ class CONTENT_EXPORT DelegatedFrameHostClientAndroid
private:
// DelegatedFrameHostAndroid::Client implementation.
void SetBeginFrameSource(viz::BeginFrameSource* begin_frame_source) override;
void DidPresentCompositorFrames(
const viz::FrameTimingDetailsMap& timing_details) override;
void DidReceiveCompositorFrameAck(
const std::vector<viz::ReturnedResource>& resources) override;
void ReclaimResources(
const std::vector<viz::ReturnedResource>& resources) override;
void OnFrameTokenChanged(uint32_t frame_token) override;
void WasEvicted() override;
......
content/browser/renderer_host/render_widget_host_view_android.cc
View file @ b6d3d74d
......@@ -244,9 +244,10 @@ RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
if (using_browser_compositor_) {
delegated_frame_host_client_ =
std::make_unique<DelegatedFrameHostClientAndroid>(this);
DCHECK(features::IsSurfaceSynchronizationEnabled());
delegated_frame_host_ = std::make_unique<ui::DelegatedFrameHostAndroid>(
&view_, GetHostFrameSinkManager(), delegated_frame_host_client_.get(),
host()->GetFrameSinkId(), features::IsSurfaceSynchronizationEnabled());
host()->GetFrameSinkId());
if (is_showing_) {
delegated_frame_host_->WasShown(
local_surface_id_allocator_.GetCurrentLocalSurfaceIdAllocation()
......@@ -1083,25 +1084,7 @@ void RenderWidgetHostViewAndroid::SubmitCompositorFrame(
const viz::LocalSurfaceId& local_surface_id,
viz::CompositorFrame frame,
base::Optional<viz::HitTestRegionList> hit_test_region_list) {
if (!delegated_frame_host_) {
DCHECK(!using_browser_compositor_);
return;
}
DCHECK(!frame.render_pass_list.empty());
viz::RenderPass* root_pass = frame.render_pass_list.back().get();
current_surface_size_ = root_pass->output_rect.size();
bool is_transparent = root_pass->has_transparent_background;
viz::CompositorFrameMetadata metadata = frame.metadata.Clone();
delegated_frame_host_->SubmitCompositorFrame(
local_surface_id, std::move(frame), std::move(hit_test_region_list));
// As the metadata update may trigger view invalidation, always call it after
// any potential compositor scheduling.
OnFrameMetadataUpdated(std::move(metadata), is_transparent);
NOTREACHED();
}
void RenderWidgetHostViewAndroid::OnDidNotProduceFrame(
......@@ -1112,8 +1095,7 @@ void RenderWidgetHostViewAndroid::OnDidNotProduceFrame(
DCHECK(!using_browser_compositor_);
return;
}
delegated_frame_host_->DidNotProduceFrame(ack);
NOTREACHED();
}
void RenderWidgetHostViewAndroid::ClearCompositorFrame() {
......
ui/android/delegated_frame_host_android.cc
View file @ b6d3d74d
......@@ -50,87 +50,34 @@ DelegatedFrameHostAndroid::DelegatedFrameHostAndroid(
ui::ViewAndroid* view,
viz::HostFrameSinkManager* host_frame_sink_manager,
Client* client,
const viz::FrameSinkId& frame_sink_id,
bool enable_surface_synchronization)
const viz::FrameSinkId& frame_sink_id)
: frame_sink_id_(frame_sink_id),
view_(view),
host_frame_sink_manager_(host_frame_sink_manager),
client_(client),
begin_frame_source_(this),
enable_surface_synchronization_(enable_surface_synchronization),
enable_viz_(features::IsVizDisplayCompositorEnabled()),
frame_evictor_(std::make_unique<viz::FrameEvictor>(this)) {
DCHECK(view_);
DCHECK(client_);
DCHECK(features::IsVizDisplayCompositorEnabled());
if (enable_surface_synchronization_) {
constexpr bool is_transparent = false;
content_layer_ = CreateSurfaceLayer(
viz::SurfaceId(), viz::SurfaceId(), gfx::Size(),
cc::DeadlinePolicy::UseDefaultDeadline(), is_transparent);
view_->GetLayer()->AddChild(content_layer_);
}
constexpr bool is_transparent = false;
content_layer_ = CreateSurfaceLayer(
viz::SurfaceId(), viz::SurfaceId(), gfx::Size(),
cc::DeadlinePolicy::UseDefaultDeadline(), is_transparent);
view_->GetLayer()->AddChild(content_layer_);
host_frame_sink_manager_->RegisterFrameSinkId(
frame_sink_id_, this, viz::ReportFirstSurfaceActivation::kNo);
host_frame_sink_manager_->SetFrameSinkDebugLabel(frame_sink_id_,
"DelegatedFrameHostAndroid");
CreateCompositorFrameSinkSupport();
}
DelegatedFrameHostAndroid::~DelegatedFrameHostAndroid() {
EvictDelegatedFrame();
DetachFromCompositor();
support_.reset();
host_frame_sink_manager_->InvalidateFrameSinkId(frame_sink_id_);
}
void DelegatedFrameHostAndroid::SubmitCompositorFrame(
const viz::LocalSurfaceId& local_surface_id,
viz::CompositorFrame frame,
base::Optional<viz::HitTestRegionList> hit_test_region_list) {
DCHECK(!enable_viz_);
bool id_changed = (local_surface_id_ != local_surface_id);
viz::RenderPass* root_pass = frame.render_pass_list.back().get();
const bool has_transparent_background = root_pass->has_transparent_background;
const gfx::Size surface_size_in_pixels = frame.size_in_pixels();
// Reset |content_layer_| only if surface-sync is not used. When surface-sync
// is turned on, |content_layer_| is updated with the appropriate states (see
// in EmbedSurface()) instead of being recreated.
if (!enable_surface_synchronization_ && content_layer_ && id_changed) {
EvictDelegatedFrame();
}
support_->SubmitCompositorFrame(local_surface_id, std::move(frame),
std::move(hit_test_region_list));
if (enable_surface_synchronization_) {
DCHECK(content_layer_);
return;
}
if (!content_layer_) {
local_surface_id_ = local_surface_id;
surface_size_in_pixels_ = surface_size_in_pixels;
has_transparent_background_ = has_transparent_background;
content_layer_ = CreateSurfaceLayer(
viz::SurfaceId(frame_sink_id_, local_surface_id_),
viz::SurfaceId(frame_sink_id_, local_surface_id_),
surface_size_in_pixels_, cc::DeadlinePolicy::UseDefaultDeadline(),
!has_transparent_background_);
view_->GetLayer()->AddChild(content_layer_);
}
content_layer_->SetContentsOpaque(!has_transparent_background_);
if (id_changed)
frame_evictor_->OnNewSurfaceEmbedded();
}
void DelegatedFrameHostAndroid::DidNotProduceFrame(
const viz::BeginFrameAck& ack) {
DCHECK(!enable_viz_);
support_->DidNotProduceFrame(ack);
}
const viz::FrameSinkId& DelegatedFrameHostAndroid::GetFrameSinkId() const {
return frame_sink_id_;
}
......@@ -183,10 +130,6 @@ void DelegatedFrameHostAndroid::EvictDelegatedFrame() {
if (content_layer_) {
content_layer_->SetSurfaceId(viz::SurfaceId(),
cc::DeadlinePolicy::UseDefaultDeadline());
if (!enable_surface_synchronization_) {
content_layer_->RemoveFromParent();
content_layer_ = nullptr;
}
}
if (!HasSavedFrame() || frame_evictor_->visible())
return;
......@@ -225,7 +168,6 @@ bool DelegatedFrameHostAndroid::HasDelegatedContent() const {
void DelegatedFrameHostAndroid::CompositorFrameSinkChanged() {
EvictDelegatedFrame();
CreateCompositorFrameSinkSupport();
if (registered_parent_compositor_)
AttachToCompositor(registered_parent_compositor_);
}
......@@ -235,18 +177,12 @@ void DelegatedFrameHostAndroid::AttachToCompositor(
if (registered_parent_compositor_)
DetachFromCompositor();
compositor->AddChildFrameSink(frame_sink_id_);
if (!enable_viz_)
client_->SetBeginFrameSource(&begin_frame_source_);
registered_parent_compositor_ = compositor;
}
void DelegatedFrameHostAndroid::DetachFromCompositor() {
if (!registered_parent_compositor_)
return;
if (!enable_viz_) {
client_->SetBeginFrameSource(nullptr);
support_->SetNeedsBeginFrame(false);
}
registered_parent_compositor_->RemoveChildFrameSink(frame_sink_id_);
registered_parent_compositor_ = nullptr;
}
......@@ -268,9 +204,6 @@ void DelegatedFrameHostAndroid::WasShown(
const gfx::Size& new_size_in_pixels) {
frame_evictor_->SetVisible(true);
if (!enable_surface_synchronization_)
return;
EmbedSurface(
new_local_surface_id, new_size_in_pixels,
cc::DeadlinePolicy::UseSpecifiedDeadline(FirstFrameTimeoutFrames()));
......@@ -280,9 +213,6 @@ void DelegatedFrameHostAndroid::EmbedSurface(
const viz::LocalSurfaceId& new_local_surface_id,
const gfx::Size& new_size_in_pixels,
cc::DeadlinePolicy deadline_policy) {
if (!enable_surface_synchronization_)
return;
// We should never attempt to embed an invalid surface. Catch this here to
// track down the root cause. Otherwise we will have vague crashes later on
// at serialization time.
......@@ -333,36 +263,6 @@ void DelegatedFrameHostAndroid::EmbedSurface(
}
}
void DelegatedFrameHostAndroid::DidReceiveCompositorFrameAck(
const std::vector<viz::ReturnedResource>& resources) {
client_->DidReceiveCompositorFrameAck(resources);
}
void DelegatedFrameHostAndroid::OnBeginFrame(
const viz::BeginFrameArgs& args,
const viz::FrameTimingDetailsMap& timing_details) {
client_->DidPresentCompositorFrames(timing_details);
if (enable_viz_) {
NOTREACHED();
return;
}
begin_frame_source_.OnBeginFrame(args);
}
void DelegatedFrameHostAndroid::ReclaimResources(
const std::vector<viz::ReturnedResource>& resources) {
client_->ReclaimResources(resources);
}
void DelegatedFrameHostAndroid::OnBeginFramePausedChanged(bool paused) {
begin_frame_source_.OnSetBeginFrameSourcePaused(paused);
}
void DelegatedFrameHostAndroid::OnNeedsBeginFrames(bool needs_begin_frames) {
DCHECK(!enable_viz_);
support_->SetNeedsBeginFrame(needs_begin_frames);
}
void DelegatedFrameHostAndroid::OnFirstSurfaceActivation(
const viz::SurfaceInfo& surface_info) {
NOTREACHED();
......@@ -372,17 +272,6 @@ void DelegatedFrameHostAndroid::OnFrameTokenChanged(uint32_t frame_token) {
client_->OnFrameTokenChanged(frame_token);
}
void DelegatedFrameHostAndroid::CreateCompositorFrameSinkSupport() {
if (enable_viz_)
return;
constexpr bool is_root = false;
constexpr bool needs_sync_points = true;
support_.reset();
support_ = host_frame_sink_manager_->CreateCompositorFrameSinkSupport(
this, frame_sink_id_, is_root, needs_sync_points);
}
viz::SurfaceId DelegatedFrameHostAndroid::SurfaceId() const {
return viz::SurfaceId(frame_sink_id_, local_surface_id_);
}
......@@ -401,45 +290,21 @@ void DelegatedFrameHostAndroid::TakeFallbackContentFrom(
if (HasFallbackSurface() || !other->HasPrimarySurface())
return;
if (enable_surface_synchronization_) {
const viz::SurfaceId& other_primary = other->content_layer_->surface_id();
const base::Optional<viz::SurfaceId>& other_fallback =
other->content_layer_->oldest_acceptable_fallback();
viz::SurfaceId desired_fallback;
if (!other->HasFallbackSurface() ||
!other_primary.IsSameOrNewerThan(*other_fallback)) {
desired_fallback = other_primary.ToSmallestId();
} else {
desired_fallback = *other_fallback;
}
content_layer_->SetOldestAcceptableFallback(
other->content_layer_->surface_id().ToSmallestId());
return;
}
if (content_layer_) {
content_layer_->SetSurfaceId(
*other->content_layer_->oldest_acceptable_fallback(),
cc::DeadlinePolicy::UseDefaultDeadline());
const viz::SurfaceId& other_primary = other->content_layer_->surface_id();
const base::Optional<viz::SurfaceId>& other_fallback =
other->content_layer_->oldest_acceptable_fallback();
viz::SurfaceId desired_fallback;
if (!other->HasFallbackSurface() ||
!other_primary.IsSameOrNewerThan(*other_fallback)) {
desired_fallback = other_primary.ToSmallestId();
} else {
const auto& surface_id = other->SurfaceId();
local_surface_id_ = surface_id.local_surface_id();
surface_size_in_pixels_ = other->surface_size_in_pixels_;
has_transparent_background_ = other->has_transparent_background_;
content_layer_ = CreateSurfaceLayer(
surface_id, surface_id, other->content_layer_->bounds(),
cc::DeadlinePolicy::UseDefaultDeadline(),
other->content_layer_->contents_opaque());
view_->GetLayer()->AddChild(content_layer_);
desired_fallback = *other_fallback;
}
content_layer_->SetOldestAcceptableFallback(
*other->content_layer_->oldest_acceptable_fallback());
other->content_layer_->surface_id().ToSmallestId());
}
void DelegatedFrameHostAndroid::DidNavigate() {
if (!enable_surface_synchronization_)
return;
first_local_surface_id_after_navigation_ = local_surface_id_;
}
......
ui/android/delegated_frame_host_android.h
View file @ b6d3d74d
......@@ -9,13 +9,12 @@
#include "base/memory/ref_counted.h"
#include "cc/layers/deadline_policy.h"
#include "components/viz/client/frame_evictor.h"
#include "components/viz/common/frame_sinks/begin_frame_args.h"
#include "components/viz/common/frame_sinks/copy_output_request.h"
#include "components/viz/common/frame_timing_details_map.h"
#include "components/viz/common/resources/returned_resource.h"
#include "components/viz/common/surfaces/surface_info.h"
#include "components/viz/host/host_frame_sink_client.h"
#include "components/viz/service/frame_sinks/compositor_frame_sink_support.h"
#include "services/viz/public/interfaces/compositing/compositor_frame_sink.mojom.h"
#include "ui/android/ui_android_export.h"
namespace cc {
......@@ -24,7 +23,6 @@ enum class SurfaceDrawStatus;
} // namespace cc
namespace viz {
class CompositorFrame;
class HostFrameSinkManager;
} // namespace viz
......@@ -33,22 +31,12 @@ class ViewAndroid;
class WindowAndroidCompositor;
class UI_ANDROID_EXPORT DelegatedFrameHostAndroid
: public viz::mojom::CompositorFrameSinkClient,
public viz::ExternalBeginFrameSourceClient,
public viz::HostFrameSinkClient,
: public viz::HostFrameSinkClient,
public viz::FrameEvictorClient {
public:
class Client {
public:
virtual ~Client() {}
virtual void SetBeginFrameSource(
viz::BeginFrameSource* begin_frame_source) = 0;
virtual void DidPresentCompositorFrames(
const viz::FrameTimingDetailsMap& timing_details) = 0;
virtual void DidReceiveCompositorFrameAck(
const std::vector<viz::ReturnedResource>& resources) = 0;
virtual void ReclaimResources(
const std::vector<viz::ReturnedResource>& resources) = 0;
virtual void OnFrameTokenChanged(uint32_t frame_token) = 0;
virtual void WasEvicted() = 0;
};
......@@ -56,8 +44,7 @@ class UI_ANDROID_EXPORT DelegatedFrameHostAndroid
DelegatedFrameHostAndroid(ViewAndroid* view,
viz::HostFrameSinkManager* host_frame_sink_manager,
Client* client,
const viz::FrameSinkId& frame_sink_id,
bool enable_surface_synchronization);
const viz::FrameSinkId& frame_sink_id);
~DelegatedFrameHostAndroid() override;
......@@ -81,12 +68,6 @@ class UI_ANDROID_EXPORT DelegatedFrameHostAndroid
return ResizeTimeout() / viz::BeginFrameArgs::DefaultInterval();
}
void SubmitCompositorFrame(
const viz::LocalSurfaceId& local_surface_id,
viz::CompositorFrame frame,
base::Optional<viz::HitTestRegionList> hit_test_region_list);
void DidNotProduceFrame(const viz::BeginFrameAck& ack);
// FrameEvictorClient implementation.
void EvictDelegatedFrame() override;
......@@ -138,24 +119,10 @@ class UI_ANDROID_EXPORT DelegatedFrameHostAndroid
void DidNavigate();
private:
// viz::mojom::CompositorFrameSinkClient implementation.
void DidReceiveCompositorFrameAck(
const std::vector<viz::ReturnedResource>& resources) override;
void OnBeginFrame(const viz::BeginFrameArgs& args,
const viz::FrameTimingDetailsMap& timing_details) override;
void ReclaimResources(
const std::vector<viz::ReturnedResource>& resources) override;
void OnBeginFramePausedChanged(bool paused) override;
// viz::ExternalBeginFrameSourceClient implementation.
void OnNeedsBeginFrames(bool needs_begin_frames) override;
// viz::HostFrameSinkClient implementation.
void OnFirstSurfaceActivation(const viz::SurfaceInfo& surface_info) override;
void OnFrameTokenChanged(uint32_t frame_token) override;
void CreateCompositorFrameSinkSupport();
void ProcessCopyOutputRequest(
std::unique_ptr<viz::CopyOutputRequest> request);
......@@ -167,16 +134,8 @@ class UI_ANDROID_EXPORT DelegatedFrameHostAndroid
WindowAndroidCompositor* registered_parent_compositor_ = nullptr;
Client* client_;
std::unique_ptr<viz::CompositorFrameSinkSupport> support_;
viz::ExternalBeginFrameSource begin_frame_source_;
bool has_transparent_background_ = false;
scoped_refptr<cc::SurfaceLayer> content_layer_;
const bool enable_surface_synchronization_;
const bool enable_viz_;
// Whether we've received a frame from the renderer since navigating.
// Only used when surface synchronization is on.
viz::LocalSurfaceId first_local_surface_id_after_navigation_;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment