blob: d3bca8a3b505832270a10eb058c68b6ba1c50a64 [file] [log] [blame]
// Copyright (c) 2012 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.
#include "content/browser/renderer_host/compositor_impl_android.h"
#include <android/bitmap.h>
#include <android/native_window_jni.h>
#include <stdint.h>
#include <string>
#include <unordered_set>
#include <utility>
#include <vector>
#include "base/android/application_status_listener.h"
#include "base/android/jni_android.h"
#include "base/android/scoped_java_ref.h"
#include "base/auto_reset.h"
#include "base/bind.h"
#include "base/command_line.h"
#include "base/containers/hash_tables.h"
#include "base/lazy_instance.h"
#include "base/logging.h"
#include "base/memory/weak_ptr.h"
#include "base/no_destructor.h"
#include "base/single_thread_task_runner.h"
#include "base/synchronization/lock.h"
#include "base/system/sys_info.h"
#include "base/task/post_task.h"
#include "base/threading/simple_thread.h"
#include "base/threading/thread.h"
#include "base/threading/thread_checker.h"
#include "base/threading/thread_task_runner_handle.h"
#include "cc/animation/animation_host.h"
#include "cc/base/switches.h"
#include "cc/input/input_handler.h"
#include "cc/layers/layer.h"
#include "cc/mojo_embedder/async_layer_tree_frame_sink.h"
#include "cc/raster/single_thread_task_graph_runner.h"
#include "cc/resources/ui_resource_manager.h"
#include "cc/trees/layer_tree_host.h"
#include "cc/trees/layer_tree_settings.h"
#include "components/viz/client/frame_eviction_manager.h"
#include "components/viz/client/hit_test_data_provider_draw_quad.h"
#include "components/viz/client/local_surface_id_provider.h"
#include "components/viz/common/features.h"
#include "components/viz/common/gpu/context_provider.h"
#include "components/viz/common/quads/compositor_frame.h"
#include "components/viz/common/surfaces/frame_sink_id_allocator.h"
#include "components/viz/common/surfaces/local_surface_id_allocation.h"
#include "components/viz/host/host_display_client.h"
#include "components/viz/host/host_frame_sink_manager.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/compositor_overlay_candidate_validator_android.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/browser_gpu_channel_host_factory.h"
#include "content/browser/gpu/compositor_util.h"
#include "content/browser/gpu/gpu_data_manager_impl.h"
#include "content/browser/gpu/gpu_process_host.h"
#include "content/browser/renderer_host/render_widget_host_impl.h"
#include "content/public/browser/android/compositor.h"
#include "content/public/browser/android/compositor_client.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/common/content_switches.h"
#include "content/public/common/gpu_stream_constants.h"
#include "gpu/command_buffer/client/context_support.h"
#include "gpu/command_buffer/client/gles2_interface.h"
#include "gpu/command_buffer/common/swap_buffers_complete_params.h"
#include "gpu/command_buffer/common/swap_buffers_flags.h"
#include "gpu/ipc/client/command_buffer_proxy_impl.h"
#include "gpu/ipc/client/gpu_channel_host.h"
#include "gpu/ipc/common/gpu_surface_tracker.h"
#include "services/viz/privileged/interfaces/compositing/frame_sink_manager.mojom.h"
#include "services/viz/public/interfaces/compositing/compositor_frame_sink.mojom.h"
#include "services/ws/public/cpp/gpu/context_provider_command_buffer.h"
#include "third_party/khronos/GLES2/gl2.h"
#include "third_party/khronos/GLES2/gl2ext.h"
#include "third_party/skia/include/core/SkMallocPixelRef.h"
#include "ui/android/window_android.h"
#include "ui/compositor/host/external_begin_frame_controller_client_impl.h"
#include "ui/display/display.h"
#include "ui/display/screen.h"
#include "ui/gfx/ca_layer_params.h"
#include "ui/gfx/swap_result.h"
#include "ui/gl/gl_utils.h"
#include "ui/latency/latency_tracker.h"
namespace content {
namespace {
static const char* kBrowser = "Browser";
// These functions are called based on application visibility status.
void SendOnBackgroundedToGpuService() {
content::GpuProcessHost::CallOnIO(
content::GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
false /* force_create */,
base::BindRepeating([](content::GpuProcessHost* host) {
if (host) {
host->gpu_service()->OnBackgrounded();
}
}));
}
void SendOnForegroundedToGpuService() {
content::GpuProcessHost::CallOnIO(
content::GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
false /* force_create */,
base::BindRepeating([](content::GpuProcessHost* host) {
if (host) {
host->gpu_service()->OnForegrounded();
}
}));
}
void BrowserGpuChannelHostFactorySetApplicationVisible(bool is_visible) {
// This code relies on the browser's GpuChannelEstablishFactory being the
// BrowserGpuChannelHostFactory.
DCHECK_EQ(BrowserMainLoop::GetInstance()->gpu_channel_establish_factory(),
BrowserGpuChannelHostFactory::instance());
BrowserGpuChannelHostFactory::instance()->SetApplicationVisible(is_visible);
}
// The client_id used here should not conflict with the client_id generated
// from RenderWidgetHostImpl.
constexpr uint32_t kDefaultClientId = 0u;
class SingleThreadTaskGraphRunner : public cc::SingleThreadTaskGraphRunner {
public:
SingleThreadTaskGraphRunner() {
Start("CompositorTileWorker1", base::SimpleThread::Options());
}
~SingleThreadTaskGraphRunner() override { Shutdown(); }
};
// An implementation of HostDisplayClient which handles swap callbacks.
class AndroidHostDisplayClient : public viz::HostDisplayClient {
public:
explicit AndroidHostDisplayClient(
base::RepeatingCallback<void(const gfx::Size&)> on_swap,
base::RepeatingCallback<void(gpu::ContextResult)>
on_context_creation_failure)
: HostDisplayClient(gfx::kNullAcceleratedWidget),
on_swap_(std::move(on_swap)),
on_context_creation_failure_(std::move(on_context_creation_failure)) {}
// viz::mojom::DisplayClient implementation:
void DidCompleteSwapWithSize(const gfx::Size& pixel_size) override {
if (on_swap_)
on_swap_.Run(pixel_size);
}
void OnFatalOrSurfaceContextCreationFailure(
gpu::ContextResult context_result) override {
if (on_context_creation_failure_)
on_context_creation_failure_.Run(context_result);
}
private:
base::RepeatingCallback<void(const gfx::Size&)> on_swap_;
base::RepeatingCallback<void(gpu::ContextResult)>
on_context_creation_failure_;
};
class CompositorDependencies {
public:
static CompositorDependencies& Get() {
static base::NoDestructor<CompositorDependencies> instance;
return *instance;
}
void CreateVizFrameSinkManager() {
viz::mojom::FrameSinkManagerPtr frame_sink_manager;
viz::mojom::FrameSinkManagerRequest frame_sink_manager_request =
mojo::MakeRequest(&frame_sink_manager);
viz::mojom::FrameSinkManagerClientPtr frame_sink_manager_client;
viz::mojom::FrameSinkManagerClientRequest
frame_sink_manager_client_request =
mojo::MakeRequest(&frame_sink_manager_client);
// Setup HostFrameSinkManager with interface endpoints.
host_frame_sink_manager.BindAndSetManager(
std::move(frame_sink_manager_client_request),
base::ThreadTaskRunnerHandle::Get(), std::move(frame_sink_manager));
// Set up a callback to automatically re-connect if we lose our
// connection.
host_frame_sink_manager.SetConnectionLostCallback(base::BindRepeating(
[]() { CompositorDependencies::Get().CreateVizFrameSinkManager(); }));
// Set up a pending request which will be run once we've successfully
// connected to the GPU process.
pending_connect_viz_on_io_thread_ = base::BindOnce(
&CompositorDependencies::ConnectVizFrameSinkManagerOnIOThread,
std::move(frame_sink_manager_request),
frame_sink_manager_client.PassInterface());
}
void TryEstablishVizConnectionIfNeeded() {
if (!pending_connect_viz_on_io_thread_)
return;
base::PostTaskWithTraits(FROM_HERE, {BrowserThread::IO},
std::move(pending_connect_viz_on_io_thread_));
}
void OnCompositorVisible(CompositorImpl* compositor) {
bool element_inserted = visible_compositors_.insert(compositor).second;
DCHECK(element_inserted);
if (visible_compositors_.size() == 1)
OnVisibilityChanged();
}
void OnCompositorHidden(CompositorImpl* compositor) {
size_t elements_removed = visible_compositors_.erase(compositor);
DCHECK_EQ(1u, elements_removed);
if (visible_compositors_.size() == 0)
OnVisibilityChanged();
}
SingleThreadTaskGraphRunner task_graph_runner;
viz::HostFrameSinkManager host_frame_sink_manager;
viz::FrameSinkIdAllocator frame_sink_id_allocator;
viz::ParentLocalSurfaceIdAllocator surface_id_allocator;
// Non-viz members:
// This is owned here so that SurfaceManager will be accessible in process
// when display is in the same process. Other than using SurfaceManager,
// access to |in_process_frame_sink_manager_| should happen via
// |host_frame_sink_manager_| instead which uses Mojo. See
// http://crbug.com/657959.
std::unique_ptr<viz::FrameSinkManagerImpl> frame_sink_manager_impl;
private:
friend class base::NoDestructor<CompositorDependencies>;
CompositorDependencies() : frame_sink_id_allocator(kDefaultClientId) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
bool enable_viz =
base::FeatureList::IsEnabled(features::kVizDisplayCompositor);
if (!enable_viz) {
// The SharedBitmapManager can be null as software compositing is not
// supported or used on Android.
frame_sink_manager_impl = std::make_unique<viz::FrameSinkManagerImpl>(
/*shared_bitmap_manager=*/nullptr);
surface_utils::ConnectWithLocalFrameSinkManager(
&host_frame_sink_manager, frame_sink_manager_impl.get());
} else {
CreateVizFrameSinkManager();
}
}
// Called on IO thread, after a GPU connection has already been established.
// |gpu_process_host| should only be invalid if a channel has been
// established and lost. In this case the ConnectionLost callback will be
// re-run when the request is deleted (goes out of scope).
static void ConnectVizFrameSinkManagerOnIOThread(
viz::mojom::FrameSinkManagerRequest request,
viz::mojom::FrameSinkManagerClientPtrInfo client) {
auto* gpu_process_host = GpuProcessHost::Get();
if (!gpu_process_host)
return;
gpu_process_host->gpu_host()->ConnectFrameSinkManager(std::move(request),
std::move(client));
}
void EnqueueLowEndBackgroundCleanup() {
if (base::SysInfo::IsLowEndDevice()) {
low_end_background_cleanup_task_.Reset(
base::BindOnce(&CompositorDependencies::DoLowEndBackgroundCleanup,
base::Unretained(this)));
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE, low_end_background_cleanup_task_.callback(),
base::TimeDelta::FromSeconds(5));
}
}
void DoLowEndBackgroundCleanup() {
// When we become visible, we immediately cancel the callback that runs this
// code. First, evict all unlocked frames, allowing resources to be
// reclaimed.
viz::FrameEvictionManager::GetInstance()->PurgeAllUnlockedFrames();
// Next, notify the GPU process to do background processing, which will
// lose all renderer contexts.
content::GpuProcessHost::CallOnIO(
content::GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
false /* force_create */,
base::BindRepeating([](content::GpuProcessHost* host) {
if (host) {
host->gpu_service()->OnBackgroundCleanup();
}
}));
}
// This function runs when our first CompositorImpl becomes visible or when
// our last Compositormpl is hidden.
void OnVisibilityChanged() {
if (visible_compositors_.size() > 0) {
GpuDataManagerImpl::GetInstance()->SetApplicationVisible(true);
BrowserGpuChannelHostFactorySetApplicationVisible(true);
SendOnForegroundedToGpuService();
low_end_background_cleanup_task_.Cancel();
} else {
GpuDataManagerImpl::GetInstance()->SetApplicationVisible(false);
BrowserGpuChannelHostFactorySetApplicationVisible(false);
SendOnBackgroundedToGpuService();
EnqueueLowEndBackgroundCleanup();
}
}
// A task which runs cleanup tasks on low-end Android after a delay. Enqueued
// when we hide, canceled when we're shown.
base::CancelableOnceClosure low_end_background_cleanup_task_;
// A callback which connects to the viz service on the IO thread.
base::OnceClosure pending_connect_viz_on_io_thread_;
// The set of visible CompositorImpls.
base::flat_set<CompositorImpl*> visible_compositors_;
};
const unsigned int kMaxDisplaySwapBuffers = 1U;
gpu::SharedMemoryLimits GetCompositorContextSharedMemoryLimits(
gfx::NativeWindow window) {
const gfx::Size screen_size = display::Screen::GetScreen()
->GetDisplayNearestWindow(window)
.GetSizeInPixel();
return gpu::SharedMemoryLimits::ForDisplayCompositor(screen_size);
}
gpu::ContextCreationAttribs GetCompositorContextAttributes(
const gfx::ColorSpace& display_color_space,
bool requires_alpha_channel) {
// This is used for the browser compositor (offscreen) and for the display
// compositor (onscreen), so ask for capabilities needed by either one.
// The default framebuffer for an offscreen context is not used, so it does
// not need alpha, stencil, depth, antialiasing. The display compositor does
// not use these things either, except for alpha when it has a transparent
// background.
gpu::ContextCreationAttribs attributes;
attributes.alpha_size = -1;
attributes.stencil_size = 0;
attributes.depth_size = 0;
attributes.samples = 0;
attributes.sample_buffers = 0;
attributes.bind_generates_resource = false;
if (display_color_space == gfx::ColorSpace::CreateSRGB()) {
attributes.color_space = gpu::COLOR_SPACE_SRGB;
} else if (display_color_space == gfx::ColorSpace::CreateDisplayP3D65()) {
attributes.color_space = gpu::COLOR_SPACE_DISPLAY_P3;
} else {
attributes.color_space = gpu::COLOR_SPACE_UNSPECIFIED;
DLOG(ERROR) << "Android color space is neither sRGB nor P3, output color "
"will be incorrect.";
}
if (requires_alpha_channel) {
attributes.alpha_size = 8;
} else if (base::SysInfo::AmountOfPhysicalMemoryMB() <= 512) {
// In this case we prefer to use RGB565 format instead of RGBA8888 if
// possible.
// TODO(danakj): CommandBufferStub constructor checks for alpha == 0
// in order to enable 565, but it should avoid using 565 when -1s are
// specified
// (IOW check that a <= 0 && rgb > 0 && rgb <= 565) then alpha should be
// -1.
// TODO(liberato): This condition is memorized in ComositorView.java, to
// avoid using two surfaces temporarily during alpha <-> no alpha
// transitions. If these mismatch, then we risk a power regression if the
// SurfaceView is not marked as eOpaque (FORMAT_OPAQUE), and we have an
// EGL surface with an alpha channel. SurfaceFlinger needs at least one of
// those hints to optimize out alpha blending.
attributes.alpha_size = 0;
attributes.red_size = 5;
attributes.green_size = 6;
attributes.blue_size = 5;
}
attributes.enable_swap_timestamps_if_supported = true;
return attributes;
}
void CreateContextProviderAfterGpuChannelEstablished(
gpu::SurfaceHandle handle,
gpu::ContextCreationAttribs attributes,
gpu::SharedMemoryLimits shared_memory_limits,
Compositor::ContextProviderCallback callback,
scoped_refptr<gpu::GpuChannelHost> gpu_channel_host) {
if (!gpu_channel_host)
callback.Run(nullptr);
gpu::GpuChannelEstablishFactory* factory =
BrowserMainLoop::GetInstance()->gpu_channel_establish_factory();
int32_t stream_id = kGpuStreamIdDefault;
gpu::SchedulingPriority stream_priority = kGpuStreamPriorityUI;
constexpr bool automatic_flushes = false;
constexpr bool support_locking = false;
constexpr bool support_grcontext = false;
auto context_provider =
base::MakeRefCounted<ws::ContextProviderCommandBuffer>(
std::move(gpu_channel_host), factory->GetGpuMemoryBufferManager(),
stream_id, stream_priority, handle,
GURL(std::string("chrome://gpu/Compositor::CreateContextProvider")),
automatic_flushes, support_locking, support_grcontext,
shared_memory_limits, attributes,
ws::command_buffer_metrics::ContextType::UNKNOWN);
callback.Run(std::move(context_provider));
}
class AndroidOutputSurface : public viz::OutputSurface {
public:
AndroidOutputSurface(
scoped_refptr<ws::ContextProviderCommandBuffer> context_provider,
base::RepeatingCallback<void(const gfx::Size&)> swap_buffers_callback)
: viz::OutputSurface(std::move(context_provider)),
swap_buffers_callback_(std::move(swap_buffers_callback)),
overlay_candidate_validator_(
new viz::CompositorOverlayCandidateValidatorAndroid()),
weak_ptr_factory_(this) {
capabilities_.max_frames_pending = kMaxDisplaySwapBuffers;
}
~AndroidOutputSurface() override = default;
void SwapBuffers(viz::OutputSurfaceFrame frame) override {
auto callback =
base::BindOnce(&AndroidOutputSurface::OnSwapBuffersCompleted,
weak_ptr_factory_.GetWeakPtr(),
std::move(frame.latency_info), frame.size);
uint32_t flags = 0;
gpu::ContextSupport::PresentationCallback presentation_callback;
presentation_callback = base::BindOnce(
&AndroidOutputSurface::OnPresentation, weak_ptr_factory_.GetWeakPtr());
if (frame.sub_buffer_rect) {
DCHECK(frame.sub_buffer_rect->IsEmpty());
context_provider_->ContextSupport()->CommitOverlayPlanes(
flags, std::move(callback), std::move(presentation_callback));
} else {
context_provider_->ContextSupport()->Swap(
flags, std::move(callback), std::move(presentation_callback));
}
}
#if BUILDFLAG(ENABLE_VULKAN)
gpu::VulkanSurface* GetVulkanSurface() override {
NOTIMPLEMENTED();
return nullptr;
}
#endif
void BindToClient(viz::OutputSurfaceClient* client) override {
DCHECK(client);
DCHECK(!client_);
client_ = client;
}
void EnsureBackbuffer() override {}
void DiscardBackbuffer() override {
context_provider()->ContextGL()->DiscardBackbufferCHROMIUM();
}
void BindFramebuffer() override {
context_provider()->ContextGL()->BindFramebuffer(GL_FRAMEBUFFER, 0);
}
void SetDrawRectangle(const gfx::Rect& rect) override {}
void Reshape(const gfx::Size& size,
float device_scale_factor,
const gfx::ColorSpace& color_space,
bool has_alpha,
bool use_stencil) override {
context_provider()->ContextGL()->ResizeCHROMIUM(
size.width(), size.height(), device_scale_factor,
gl::GetGLColorSpace(color_space), has_alpha);
}
viz::OverlayCandidateValidator* GetOverlayCandidateValidator()
const override {
return overlay_candidate_validator_.get();
}
bool IsDisplayedAsOverlayPlane() const override { return false; }
unsigned GetOverlayTextureId() const override { return 0; }
gfx::BufferFormat GetOverlayBufferFormat() const override {
return gfx::BufferFormat::RGBX_8888;
}
bool HasExternalStencilTest() const override { return false; }
void ApplyExternalStencil() override {}
uint32_t GetFramebufferCopyTextureFormat() override {
auto* gl =
static_cast<ws::ContextProviderCommandBuffer*>(context_provider());
return gl->GetCopyTextureInternalFormat();
}
unsigned UpdateGpuFence() override { return 0; }
private:
gpu::CommandBufferProxyImpl* GetCommandBufferProxy() {
ws::ContextProviderCommandBuffer* provider_command_buffer =
static_cast<ws::ContextProviderCommandBuffer*>(context_provider_.get());
gpu::CommandBufferProxyImpl* command_buffer_proxy =
provider_command_buffer->GetCommandBufferProxy();
DCHECK(command_buffer_proxy);
return command_buffer_proxy;
}
void OnSwapBuffersCompleted(std::vector<ui::LatencyInfo> latency_info,
gfx::Size swap_size,
const gpu::SwapBuffersCompleteParams& params) {
client_->DidReceiveSwapBuffersAck();
swap_buffers_callback_.Run(swap_size);
UpdateLatencyInfoOnSwap(params.swap_response, &latency_info);
latency_tracker_.OnGpuSwapBuffersCompleted(latency_info);
}
void OnPresentation(const gfx::PresentationFeedback& feedback) {
client_->DidReceivePresentationFeedback(feedback);
}
private:
viz::OutputSurfaceClient* client_ = nullptr;
base::RepeatingCallback<void(const gfx::Size&)> swap_buffers_callback_;
std::unique_ptr<viz::OverlayCandidateValidator> overlay_candidate_validator_;
ui::LatencyTracker latency_tracker_;
base::WeakPtrFactory<AndroidOutputSurface> weak_ptr_factory_;
};
static bool g_initialized = false;
} // anonymous namespace
// static
Compositor* Compositor::Create(CompositorClient* client,
gfx::NativeWindow root_window) {
return client ? new CompositorImpl(client, root_window) : NULL;
}
// static
void Compositor::Initialize() {
DCHECK(!CompositorImpl::IsInitialized());
g_initialized = true;
}
// static
void Compositor::CreateContextProvider(
gpu::SurfaceHandle handle,
gpu::ContextCreationAttribs attributes,
gpu::SharedMemoryLimits shared_memory_limits,
ContextProviderCallback callback) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
BrowserMainLoop::GetInstance()
->gpu_channel_establish_factory()
->EstablishGpuChannel(
base::BindOnce(&CreateContextProviderAfterGpuChannelEstablished,
handle, attributes, shared_memory_limits, callback));
}
// static
viz::FrameSinkManagerImpl* CompositorImpl::GetFrameSinkManager() {
return CompositorDependencies::Get().frame_sink_manager_impl.get();
}
// static
viz::HostFrameSinkManager* CompositorImpl::GetHostFrameSinkManager() {
return &CompositorDependencies::Get().host_frame_sink_manager;
}
// static
viz::FrameSinkId CompositorImpl::AllocateFrameSinkId() {
return CompositorDependencies::Get()
.frame_sink_id_allocator.NextFrameSinkId();
}
// static
bool CompositorImpl::IsInitialized() {
return g_initialized;
}
CompositorImpl::CompositorImpl(CompositorClient* client,
gfx::NativeWindow root_window)
: frame_sink_id_(AllocateFrameSinkId()),
resource_manager_(root_window),
window_(NULL),
surface_handle_(gpu::kNullSurfaceHandle),
client_(client),
needs_animate_(false),
pending_frames_(0U),
layer_tree_frame_sink_request_pending_(false),
lock_manager_(base::ThreadTaskRunnerHandle::Get()),
enable_surface_synchronization_(
features::IsSurfaceSynchronizationEnabled()),
enable_viz_(
base::FeatureList::IsEnabled(features::kVizDisplayCompositor)),
weak_factory_(this) {
DCHECK(client);
SetRootWindow(root_window);
// Listen to display density change events and update painted device scale
// factor accordingly.
display::Screen::GetScreen()->AddObserver(this);
}
CompositorImpl::~CompositorImpl() {
display::Screen::GetScreen()->RemoveObserver(this);
DetachRootWindow();
// Clean-up any surface references.
SetSurface(NULL);
}
void CompositorImpl::DetachRootWindow() {
root_window_->DetachCompositor();
root_window_->SetLayer(nullptr);
}
ui::UIResourceProvider& CompositorImpl::GetUIResourceProvider() {
return *this;
}
ui::ResourceManager& CompositorImpl::GetResourceManager() {
return resource_manager_;
}
void CompositorImpl::SetRootWindow(gfx::NativeWindow root_window) {
DCHECK(root_window);
DCHECK(!root_window->GetLayer());
// TODO(mthiesse): Right now we only support swapping the root window without
// a surface. If we want to support swapping with a surface we need to
// 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;
if (root_window_) {
root_layer = root_window_->GetLayer();
DetachRootWindow();
}
root_window_ = root_window;
root_window_->SetLayer(root_layer ? root_layer : cc::Layer::Create());
root_window_->GetLayer()->SetBounds(size_);
if (!readback_layer_tree_) {
readback_layer_tree_ = cc::Layer::Create();
readback_layer_tree_->SetHideLayerAndSubtree(true);
}
root_window->GetLayer()->AddChild(readback_layer_tree_);
root_window->AttachCompositor(this);
if (!host_) {
CreateLayerTreeHost();
resource_manager_.Init(host_->GetUIResourceManager());
}
host_->SetRootLayer(root_window_->GetLayer());
host_->SetViewportSizeAndScale(size_, root_window_->GetDipScale(),
GenerateLocalSurfaceId());
}
void CompositorImpl::SetRootLayer(scoped_refptr<cc::Layer> root_layer) {
if (subroot_layer_.get()) {
subroot_layer_->RemoveFromParent();
subroot_layer_ = nullptr;
}
if (root_window_->GetLayer()) {
subroot_layer_ = root_window_->GetLayer();
subroot_layer_->AddChild(root_layer);
}
}
void CompositorImpl::SetSurface(jobject surface) {
JNIEnv* env = base::android::AttachCurrentThread();
gpu::GpuSurfaceTracker* tracker = gpu::GpuSurfaceTracker::Get();
if (window_) {
// Shut down GL context before unregistering surface.
SetVisible(false);
tracker->RemoveSurface(surface_handle_);
ANativeWindow_release(window_);
window_ = NULL;
surface_handle_ = gpu::kNullSurfaceHandle;
}
ANativeWindow* window = NULL;
if (surface) {
// Note: This ensures that any local references used by
// ANativeWindow_fromSurface are released immediately. This is needed as a
// workaround for https://code.google.com/p/android/issues/detail?id=68174
base::android::ScopedJavaLocalFrame scoped_local_reference_frame(env);
window = ANativeWindow_fromSurface(env, surface);
}
if (window) {
window_ = window;
ANativeWindow_acquire(window);
// Register first, SetVisible() might create a LayerTreeFrameSink.
surface_handle_ = tracker->AddSurfaceForNativeWidget(
gpu::GpuSurfaceTracker::SurfaceRecord(window, surface));
SetVisible(true);
ANativeWindow_release(window);
}
}
void CompositorImpl::SetBackgroundColor(int color) {
DCHECK(host_);
host_->set_background_color(color);
}
void CompositorImpl::CreateLayerTreeHost() {
DCHECK(!host_);
cc::LayerTreeSettings settings;
settings.use_zero_copy = true;
settings.enable_surface_synchronization = enable_surface_synchronization_;
settings.build_hit_test_data = features::IsVizHitTestingSurfaceLayerEnabled();
base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
settings.initial_debug_state.SetRecordRenderingStats(
command_line->HasSwitch(cc::switches::kEnableGpuBenchmarking));
settings.initial_debug_state.show_fps_counter =
command_line->HasSwitch(cc::switches::kUIShowFPSCounter);
if (command_line->HasSwitch(cc::switches::kUIShowCompositedLayerBorders))
settings.initial_debug_state.show_debug_borders.set();
settings.single_thread_proxy_scheduler = true;
settings.use_painted_device_scale_factor = true;
animation_host_ = cc::AnimationHost::CreateMainInstance();
cc::LayerTreeHost::InitParams params;
params.client = this;
params.task_graph_runner = &CompositorDependencies::Get().task_graph_runner;
params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
params.settings = &settings;
params.mutator_host = animation_host_.get();
host_ = cc::LayerTreeHost::CreateSingleThreaded(this, std::move(params));
DCHECK(!host_->IsVisible());
host_->SetViewportSizeAndScale(size_, root_window_->GetDipScale(),
GenerateLocalSurfaceId());
if (needs_animate_)
host_->SetNeedsAnimate();
}
void CompositorImpl::SetVisible(bool visible) {
TRACE_EVENT1("cc", "CompositorImpl::SetVisible", "visible", visible);
if (!visible) {
DCHECK(host_->IsVisible());
CompositorDependencies::Get().OnCompositorHidden(this);
// Tear down the display first, synchronously completing any pending
// draws/readbacks if poosible.
TearDownDisplayAndUnregisterRootFrameSink();
// Hide the LayerTreeHost and release its frame sink.
host_->SetVisible(false);
host_->ReleaseLayerTreeFrameSink();
has_layer_tree_frame_sink_ = false;
pending_frames_ = 0;
} else {
DCHECK(!host_->IsVisible());
CompositorDependencies::Get().OnCompositorVisible(this);
RegisterRootFrameSink();
host_->SetVisible(true);
has_submitted_frame_since_became_visible_ = false;
if (layer_tree_frame_sink_request_pending_)
HandlePendingLayerTreeFrameSinkRequest();
}
}
void CompositorImpl::TearDownDisplayAndUnregisterRootFrameSink() {
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_) {
GetFrameSinkManager()->UnregisterBeginFrameSource(
root_window_->GetBeginFrameSource());
}
GetHostFrameSinkManager()->InvalidateFrameSinkId(frame_sink_id_);
display_.reset();
}
}
void CompositorImpl::RegisterRootFrameSink() {
GetHostFrameSinkManager()->RegisterFrameSinkId(
frame_sink_id_, this, viz::ReportFirstSurfaceActivation::kNo);
GetHostFrameSinkManager()->SetFrameSinkDebugLabel(frame_sink_id_,
"CompositorImpl");
}
void CompositorImpl::SetWindowBounds(const gfx::Size& size) {
if (size_ == size)
return;
size_ = size;
if (host_) {
// TODO(ccameron): Ensure a valid LocalSurfaceId here.
host_->SetViewportSizeAndScale(size_, root_window_->GetDipScale(),
GenerateLocalSurfaceId());
}
if (display_)
display_->Resize(size);
if (display_private_)
display_private_->Resize(size);
root_window_->GetLayer()->SetBounds(size);
}
void CompositorImpl::SetRequiresAlphaChannel(bool flag) {
requires_alpha_channel_ = flag;
}
void CompositorImpl::SetNeedsComposite() {
if (!host_->IsVisible())
return;
TRACE_EVENT0("compositor", "Compositor::SetNeedsComposite");
host_->SetNeedsAnimate();
}
void CompositorImpl::UpdateLayerTreeHost(bool record_main_frame_metrics) {
client_->UpdateLayerTreeHost();
if (needs_animate_) {
needs_animate_ = false;
root_window_->Animate(base::TimeTicks::Now());
}
}
void CompositorImpl::RequestNewLayerTreeFrameSink() {
DCHECK(!layer_tree_frame_sink_request_pending_)
<< "LayerTreeFrameSink request is already pending?";
layer_tree_frame_sink_request_pending_ = true;
HandlePendingLayerTreeFrameSinkRequest();
}
void CompositorImpl::DidInitializeLayerTreeFrameSink() {
layer_tree_frame_sink_request_pending_ = false;
has_layer_tree_frame_sink_ = true;
for (auto& frame_sink_id : pending_child_frame_sink_ids_)
AddChildFrameSink(frame_sink_id);
pending_child_frame_sink_ids_.clear();
}
void CompositorImpl::DidFailToInitializeLayerTreeFrameSink() {
// The context is bound/initialized before handing it to the
// LayerTreeFrameSink.
NOTREACHED();
}
void CompositorImpl::HandlePendingLayerTreeFrameSinkRequest() {
DCHECK(layer_tree_frame_sink_request_pending_);
// We might have been made invisible now.
if (!host_->IsVisible())
return;
DCHECK(surface_handle_ != gpu::kNullSurfaceHandle);
BrowserMainLoop::GetInstance()
->gpu_channel_establish_factory()
->EstablishGpuChannel(
base::BindOnce(&CompositorImpl::OnGpuChannelEstablished,
weak_factory_.GetWeakPtr()));
}
void CompositorImpl::OnGpuChannelEstablished(
scoped_refptr<gpu::GpuChannelHost> gpu_channel_host) {
// At this point we know we have a valid GPU process, establish our viz
// connection if needed.
CompositorDependencies::Get().TryEstablishVizConnectionIfNeeded();
// We might end up queing multiple GpuChannel requests for the same
// LayerTreeFrameSink request as the visibility of the compositor changes, so
// the LayerTreeFrameSink request could have been handled already.
if (!layer_tree_frame_sink_request_pending_)
return;
if (!gpu_channel_host) {
HandlePendingLayerTreeFrameSinkRequest();
return;
}
// We don't need the context anymore if we are invisible.
if (!host_->IsVisible()) {
return;
}
DCHECK(window_);
DCHECK_NE(surface_handle_, gpu::kNullSurfaceHandle);
gpu::GpuChannelEstablishFactory* factory =
BrowserMainLoop::GetInstance()->gpu_channel_establish_factory();
int32_t stream_id = kGpuStreamIdDefault;
gpu::SchedulingPriority stream_priority = kGpuStreamPriorityUI;
constexpr bool support_locking = false;
constexpr bool automatic_flushes = false;
constexpr bool support_grcontext = true;
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<ws::ContextProviderCommandBuffer>(
std::move(gpu_channel_host), factory->GetGpuMemoryBufferManager(),
stream_id, stream_priority, surface_handle,
GURL(std::string("chrome://gpu/CompositorImpl::") +
std::string("CompositorContextProvider")),
automatic_flushes, support_locking, support_grcontext,
GetCompositorContextSharedMemoryLimits(root_window_),
GetCompositorContextAttributes(display_color_space_,
requires_alpha_channel_),
ws::command_buffer_metrics::ContextType::BROWSER_COMPOSITOR);
auto result = context_provider->BindToCurrentThread();
if (result != gpu::ContextResult::kSuccess) {
if (gpu::IsFatalOrSurfaceFailure(result))
OnFatalOrSurfaceContextCreationFailure(result);
HandlePendingLayerTreeFrameSinkRequest();
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 = GetFrameSinkManager();
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, features::IsVizHitTestingEnabled());
display_->SetVisible(true);
display_->Resize(size_);
display_->SetColorSpace(display_color_space_, display_color_space_);
if (should_register_begin_frame_source) {
GetFrameSinkManager()->RegisterBeginFrameSource(
root_window_->GetBeginFrameSource(), frame_sink_id_);
}
host_->SetLayerTreeFrameSink(std::move(layer_tree_frame_sink));
}
void CompositorImpl::DidSwapBuffers(const gfx::Size& swap_size) {
client_->DidSwapBuffers(swap_size);
if (swap_completed_with_size_for_testing_)
swap_completed_with_size_for_testing_.Run(swap_size);
}
cc::UIResourceId CompositorImpl::CreateUIResource(
cc::UIResourceClient* client) {
TRACE_EVENT0("compositor", "CompositorImpl::CreateUIResource");
return host_->GetUIResourceManager()->CreateUIResource(client);
}
void CompositorImpl::DeleteUIResource(cc::UIResourceId resource_id) {
TRACE_EVENT0("compositor", "CompositorImpl::DeleteUIResource");
host_->GetUIResourceManager()->DeleteUIResource(resource_id);
}
bool CompositorImpl::SupportsETC1NonPowerOfTwo() const {
return gpu_capabilities_.texture_format_etc1_npot;
}
void CompositorImpl::DidSubmitCompositorFrame() {
TRACE_EVENT0("compositor", "CompositorImpl::DidSubmitCompositorFrame");
pending_frames_++;
has_submitted_frame_since_became_visible_ = true;
}
void CompositorImpl::DidReceiveCompositorFrameAck() {
TRACE_EVENT0("compositor", "CompositorImpl::DidReceiveCompositorFrameAck");
DCHECK_GT(pending_frames_, 0U);
pending_frames_--;
client_->DidSwapFrame(pending_frames_);
}
void CompositorImpl::DidLoseLayerTreeFrameSink() {
TRACE_EVENT0("compositor", "CompositorImpl::DidLoseLayerTreeFrameSink");
has_layer_tree_frame_sink_ = false;
client_->DidSwapFrame(0);
}
void CompositorImpl::DidCommit() {
root_window_->OnCompositingDidCommit();
}
void CompositorImpl::AttachLayerForReadback(scoped_refptr<cc::Layer> layer) {
readback_layer_tree_->AddChild(layer);
}
void CompositorImpl::RequestCopyOfOutputOnRootLayer(
std::unique_ptr<viz::CopyOutputRequest> request) {
root_window_->GetLayer()->RequestCopyOfOutput(std::move(request));
}
void CompositorImpl::SetNeedsAnimate() {
needs_animate_ = true;
if (!host_->IsVisible())
return;
TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
host_->SetNeedsAnimate();
}
viz::FrameSinkId CompositorImpl::GetFrameSinkId() {
return frame_sink_id_;
}
void CompositorImpl::AddChildFrameSink(const viz::FrameSinkId& frame_sink_id) {
if (has_layer_tree_frame_sink_) {
GetHostFrameSinkManager()->RegisterFrameSinkHierarchy(frame_sink_id_,
frame_sink_id);
} else {
pending_child_frame_sink_ids_.insert(frame_sink_id);
}
}
void CompositorImpl::RemoveChildFrameSink(
const viz::FrameSinkId& frame_sink_id) {
auto it = pending_child_frame_sink_ids_.find(frame_sink_id);
if (it != pending_child_frame_sink_ids_.end()) {
pending_child_frame_sink_ids_.erase(it);
return;
}
GetHostFrameSinkManager()->UnregisterFrameSinkHierarchy(frame_sink_id_,
frame_sink_id);
}
void CompositorImpl::OnDisplayMetricsChanged(const display::Display& display,
uint32_t changed_metrics) {
if (changed_metrics & display::DisplayObserver::DisplayMetric::
DISPLAY_METRIC_DEVICE_SCALE_FACTOR &&
display.id() == display::Screen::GetScreen()
->GetDisplayNearestWindow(root_window_)
.id()) {
// TODO(ccameron): This is transiently incorrect -- |size_| must be
// recalculated here as well. Is the call in SetWindowBounds sufficient?
host_->SetViewportSizeAndScale(size_, root_window_->GetDipScale(),
GenerateLocalSurfaceId());
}
}
bool CompositorImpl::HavePendingReadbacks() {
return !readback_layer_tree_->children().empty();
}
std::unique_ptr<ui::CompositorLock> CompositorImpl::GetCompositorLock(
ui::CompositorLockClient* client,
base::TimeDelta timeout) {
std::unique_ptr<cc::ScopedDeferMainFrameUpdate>
scoped_defer_main_frame_update =
host_ ? host_->DeferMainFrameUpdate() : nullptr;
return lock_manager_.GetCompositorLock(
client, timeout, std::move(scoped_defer_main_frame_update));
}
bool CompositorImpl::IsDrawingFirstVisibleFrame() const {
return !has_submitted_frame_since_became_visible_;
}
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;
vsync_paused_ = paused;
if (display_private_)
display_private_->SetVSyncPaused(paused);
}
void CompositorImpl::InitializeVizLayerTreeFrameSink(
scoped_refptr<ws::ContextProviderCommandBuffer> context_provider) {
DCHECK(enable_viz_);
pending_frames_ = 0;
gpu_capabilities_ = context_provider->ContextCapabilities();
scoped_refptr<base::SingleThreadTaskRunner> task_runner =
base::ThreadTaskRunnerHandle::Get();
auto root_params = viz::mojom::RootCompositorFrameSinkParams::New();
// Android requires swap size notifications.
root_params->send_swap_size_notifications = true;
// Create interfaces for a root CompositorFrameSink.
viz::mojom::CompositorFrameSinkAssociatedPtrInfo sink_info;
root_params->compositor_frame_sink = mojo::MakeRequest(&sink_info);
viz::mojom::CompositorFrameSinkClientRequest client_request =
mojo::MakeRequest(&root_params->compositor_frame_sink_client);
root_params->display_private = mojo::MakeRequest(&display_private_);
display_client_ = std::make_unique<AndroidHostDisplayClient>(
base::BindRepeating(&CompositorImpl::DidSwapBuffers,
weak_factory_.GetWeakPtr()),
base::BindRepeating(
&CompositorImpl::OnFatalOrSurfaceContextCreationFailure,
weak_factory_.GetWeakPtr()));
root_params->display_client =
display_client_->GetBoundPtr(task_runner).PassInterface();
viz::RendererSettings renderer_settings;
renderer_settings.allow_antialiasing = false;
renderer_settings.highp_threshold_min = 2048;
renderer_settings.requires_alpha_channel = requires_alpha_channel_;
renderer_settings.initial_screen_size =
display::Screen::GetScreen()
->GetDisplayNearestWindow(root_window_)
.GetSizeInPixel();
renderer_settings.use_skia_renderer = features::IsUsingSkiaRenderer();
root_params->frame_sink_id = frame_sink_id_;
root_params->widget = surface_handle_;
root_params->gpu_compositing = true;
root_params->renderer_settings = renderer_settings;
GetHostFrameSinkManager()->CreateRootCompositorFrameSink(
std::move(root_params));
// Create LayerTreeFrameSink with the browser end of CompositorFrameSink.
cc::mojo_embedder::AsyncLayerTreeFrameSink::InitParams params;
params.compositor_task_runner = task_runner;
params.gpu_memory_buffer_manager = BrowserMainLoop::GetInstance()
->gpu_channel_establish_factory()
->GetGpuMemoryBufferManager();
params.pipes.compositor_frame_sink_associated_info = std::move(sink_info);
params.pipes.client_request = std::move(client_request);
params.local_surface_id_provider =
std::make_unique<viz::DefaultLocalSurfaceIdProvider>();
params.enable_surface_synchronization = true;
params.hit_test_data_provider =
std::make_unique<viz::HitTestDataProviderDrawQuad>(
false /* should_ask_for_child_region */,
true /* root_accepts_events */);
params.client_name = kBrowser;
auto layer_tree_frame_sink =
std::make_unique<cc::mojo_embedder::AsyncLayerTreeFrameSink>(
std::move(context_provider), nullptr, &params);
host_->SetLayerTreeFrameSink(std::move(layer_tree_frame_sink));
display_private_->SetDisplayVisible(true);
display_private_->Resize(size_);
display_private_->SetVSyncPaused(vsync_paused_);
}
viz::LocalSurfaceIdAllocation CompositorImpl::GenerateLocalSurfaceId() const {
if (enable_surface_synchronization_) {
viz::ParentLocalSurfaceIdAllocator& allocator =
CompositorDependencies::Get().surface_id_allocator;
allocator.GenerateId();
return allocator.GetCurrentLocalSurfaceIdAllocation();
}
return viz::LocalSurfaceIdAllocation();
}
void CompositorImpl::OnFatalOrSurfaceContextCreationFailure(
gpu::ContextResult context_result) {
DCHECK(gpu::IsFatalOrSurfaceFailure(context_result));
LOG_IF(FATAL, context_result == gpu::ContextResult::kFatalFailure)
<< "Fatal error making Gpu context";
if (context_result == gpu::ContextResult::kSurfaceFailure) {
SetSurface(nullptr);
client_->RecreateSurface();
}
}
void CompositorImpl::OnFirstSurfaceActivation(const viz::SurfaceInfo& info) {
NOTREACHED();
}
} // namespace content