Skip to content

GitLab

T
tangled
Commit 25718190 authored by Peng Huang's avatar Peng Huang Committed by Commit Bot
Browse files
Options

Using PaintCanvas for HUD 

To support OOPR, we need switch from SkCanvas to PaintCanvas which is for
OOPR.

Bug: 895568
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: I94b5430c7ee8ed2f5140d352214ec43f2ff0f8ad
Reviewed-on: https://chromium-review.googlesource.com/c/1286950
Commit-Queue: Peng Huang <penghuang@chromium.org>
Reviewed-by: default avatarenne <enne@chromium.org>
Cr-Commit-Position: refs/heads/master@{#609033}
parent c7bee6dc
Hide whitespace changes
Inline Side-by-side
Showing with 304 additions and 229 deletions
cc/layers/heads_up_display_layer_impl.cc
View file @ 25718190
...@@ -11,13 +11,19 @@ ...@@ -11,13 +11,19 @@
#include <vector> #include <vector>
#include "base/numerics/safe_conversions.h" #include "base/numerics/safe_conversions.h"
#include "base/optional.h"
#include "base/single_thread_task_runner.h" #include "base/single_thread_task_runner.h"
#include "base/stl_util.h"
#include "base/strings/stringprintf.h" #include "base/strings/stringprintf.h"
#include "base/trace_event/process_memory_dump.h" #include "base/trace_event/process_memory_dump.h"
#include "base/trace_event/trace_event.h" #include "base/trace_event/trace_event.h"
#include "base/trace_event/traced_value.h" #include "base/trace_event/traced_value.h"
#include "cc/debug/debug_colors.h" #include "cc/debug/debug_colors.h"
#include "cc/paint/display_item_list.h"
#include "cc/paint/paint_canvas.h"
#include "cc/paint/paint_flags.h"
#include "cc/paint/paint_shader.h"
#include "cc/paint/record_paint_canvas.h"
#include "cc/paint/skia_paint_canvas.h"
#include "cc/raster/scoped_gpu_raster.h" #include "cc/raster/scoped_gpu_raster.h"
#include "cc/resources/memory_history.h" #include "cc/resources/memory_history.h"
#include "cc/trees/frame_rate_counter.h" #include "cc/trees/frame_rate_counter.h"
...@@ -33,28 +39,30 @@ ...@@ -33,28 +39,30 @@
#include "components/viz/common/resources/platform_color.h" #include "components/viz/common/resources/platform_color.h"
#include "gpu/command_buffer/client/context_support.h" #include "gpu/command_buffer/client/context_support.h"
#include "gpu/command_buffer/client/gles2_interface.h" #include "gpu/command_buffer/client/gles2_interface.h"
#include "gpu/command_buffer/client/raster_interface.h"
#include "gpu/command_buffer/client/shared_image_interface.h" #include "gpu/command_buffer/client/shared_image_interface.h"
#include "gpu/command_buffer/common/shared_image_trace_utils.h" #include "gpu/command_buffer/common/shared_image_trace_utils.h"
#include "gpu/command_buffer/common/shared_image_usage.h" #include "gpu/command_buffer/common/shared_image_usage.h"
#include "skia/ext/platform_canvas.h" #include "gpu/config/gpu_feature_info.h"
#include "third_party/skia/include/core/SkCanvas.h" #include "third_party/skia/include/core/SkFont.h"
#include "third_party/skia/include/core/SkPaint.h" #include "third_party/skia/include/core/SkPaint.h"
#include "third_party/skia/include/core/SkPath.h" #include "third_party/skia/include/core/SkPath.h"
#include "third_party/skia/include/core/SkTypeface.h" #include "third_party/skia/include/core/SkTypeface.h"
#include "third_party/skia/include/effects/SkColorMatrixFilter.h"
#include "third_party/skia/include/effects/SkGradientShader.h"
#include "ui/gfx/geometry/point.h" #include "ui/gfx/geometry/point.h"
#include "ui/gfx/geometry/size.h" #include "ui/gfx/geometry/size.h"
#include "ui/gfx/geometry/size_conversions.h" #include "ui/gfx/geometry/size_conversions.h"
#include "ui/gfx/skia_util.h"
#include "ui/gl/trace_util.h" #include "ui/gl/trace_util.h"
namespace cc { namespace cc {
static inline SkPaint CreatePaint() { namespace {
SkPaint paint;
PaintFlags CreatePaintFlags() {
PaintFlags flags;
#if (SK_R32_SHIFT || SK_B32_SHIFT != 16) #if (SK_R32_SHIFT || SK_B32_SHIFT != 16)
// The SkCanvas is in RGBA but the shader is expecting BGRA, so we need to // The PaintCanvas is in RGBA but the shader is expecting BGRA, so we need to
// swizzle our colors when drawing to the SkCanvas. // swizzle our colors when drawing to the PaintCanvas.
SkScalar color_matrix[20]; SkScalar color_matrix[20];
for (int i = 0; i < 20; ++i) for (int i = 0; i < 20; ++i)
color_matrix[i] = 0; color_matrix[i] = 0;
...@@ -63,12 +71,39 @@ static inline SkPaint CreatePaint() { ...@@ -63,12 +71,39 @@ static inline SkPaint CreatePaint() {
color_matrix[2 + 5 * 0] = 1; color_matrix[2 + 5 * 0] = 1;
color_matrix[3 + 5 * 3] = 1; color_matrix[3 + 5 * 3] = 1;
paint.setColorFilter( flags.setColorFilter(
SkColorFilter::MakeMatrixFilterRowMajor255(color_matrix)); SkColorFilter::MakeMatrixFilterRowMajor255(color_matrix));
#endif #endif
return paint; return flags;
} }
void DrawArc(PaintCanvas* canvas,
const SkRect& oval,
SkScalar start_angle,
SkScalar sweep_angle,
const PaintFlags& flags) {
DCHECK_GT(sweep_angle, 0.f);
DCHECK_LT(sweep_angle, 360.f);
SkPath path;
path.moveTo(oval.centerX(), oval.centerY());
path.arcTo(oval, start_angle, sweep_angle, false /* forceMoveTo */);
path.close();
canvas->drawPath(path, flags);
}
class DummyImageProvider : public ImageProvider {
public:
DummyImageProvider() = default;
~DummyImageProvider() override = default;
ScopedDecodedDrawImage GetDecodedDrawImage(
const DrawImage& draw_image) override {
NOTREACHED();
return ScopedDecodedDrawImage();
}
};
} // namespace
HeadsUpDisplayLayerImpl::Graph::Graph(double indicator_value, HeadsUpDisplayLayerImpl::Graph::Graph(double indicator_value,
double start_upper_bound) double start_upper_bound)
: value(0.0), : value(0.0),
...@@ -90,7 +125,9 @@ HeadsUpDisplayLayerImpl::HeadsUpDisplayLayerImpl(LayerTreeImpl* tree_impl, ...@@ -90,7 +125,9 @@ HeadsUpDisplayLayerImpl::HeadsUpDisplayLayerImpl(LayerTreeImpl* tree_impl,
internal_contents_scale_(1.f), internal_contents_scale_(1.f),
fps_graph_(60.0, 80.0), fps_graph_(60.0, 80.0),
paint_time_graph_(16.0, 48.0), paint_time_graph_(16.0, 48.0),
fade_step_(0) {} fade_step_(0),
raster_color_space_(gfx::ColorSpace::CreateSRGB(),
gfx::ColorSpace::GetNextId()) {}
HeadsUpDisplayLayerImpl::~HeadsUpDisplayLayerImpl() { HeadsUpDisplayLayerImpl::~HeadsUpDisplayLayerImpl() {
ReleaseResources(); ReleaseResources();
...@@ -106,11 +143,10 @@ class HudGpuBacking : public ResourcePool::GpuBacking { ...@@ -106,11 +143,10 @@ class HudGpuBacking : public ResourcePool::GpuBacking {
~HudGpuBacking() override { ~HudGpuBacking() override {
if (mailbox.IsZero()) if (mailbox.IsZero())
return; return;
auto* sii = compositor_context_provider->SharedImageInterface();
if (returned_sync_token.HasData()) if (returned_sync_token.HasData())
sii->DestroySharedImage(returned_sync_token, mailbox); shared_image_interface->DestroySharedImage(returned_sync_token, mailbox);
else if (mailbox_sync_token.HasData()) else if (mailbox_sync_token.HasData())
sii->DestroySharedImage(mailbox_sync_token, mailbox); shared_image_interface->DestroySharedImage(mailbox_sync_token, mailbox);
} }
void OnMemoryDump( void OnMemoryDump(
...@@ -126,7 +162,7 @@ class HudGpuBacking : public ResourcePool::GpuBacking { ...@@ -126,7 +162,7 @@ class HudGpuBacking : public ResourcePool::GpuBacking {
pmd->AddOwnershipEdge(buffer_dump_guid, tracing_guid, importance); pmd->AddOwnershipEdge(buffer_dump_guid, tracing_guid, importance);
} }
viz::ContextProvider* compositor_context_provider; gpu::SharedImageInterface* shared_image_interface = nullptr;
}; };
class HudSoftwareBacking : public ResourcePool::SoftwareBacking { class HudSoftwareBacking : public ResourcePool::SoftwareBacking {
...@@ -198,14 +234,33 @@ void HeadsUpDisplayLayerImpl::UpdateHudTexture( ...@@ -198,14 +234,33 @@ void HeadsUpDisplayLayerImpl::UpdateHudTexture(
// Update state that will be drawn. // Update state that will be drawn.
UpdateHudContents(); UpdateHudContents();
// TODO(penghuang): Do not use worker_context_provider() when context_provider
// is changed to RasterContextProvider.
// https://crbug.com/c/1286950
auto* raster_context_provider =
gpu_raster ? layer_tree_frame_sink->worker_context_provider() : nullptr;
base::Optional<viz::RasterContextProvider::ScopedRasterContextLock> lock;
bool use_oopr = false;
if (raster_context_provider) {
lock.emplace(raster_context_provider);
use_oopr = raster_context_provider->GetGpuFeatureInfo()
.status_values[gpu::GPU_FEATURE_TYPE_GPU_RASTERIZATION] ==
gpu::kGpuFeatureStatusEnabled;
if (!use_oopr) {
raster_context_provider = nullptr;
lock.reset();
}
}
auto* context_provider = layer_tree_frame_sink->context_provider();
if (!pool_) { if (!pool_) {
scoped_refptr<base::SingleThreadTaskRunner> task_runner = scoped_refptr<base::SingleThreadTaskRunner> task_runner =
layer_tree_impl()->task_runner_provider()->HasImplThread() layer_tree_impl()->task_runner_provider()->HasImplThread()
? layer_tree_impl()->task_runner_provider()->ImplThreadTaskRunner() ? layer_tree_impl()->task_runner_provider()->ImplThreadTaskRunner()
: layer_tree_impl()->task_runner_provider()->MainThreadTaskRunner(); : layer_tree_impl()->task_runner_provider()->MainThreadTaskRunner();
pool_ = std::make_unique<ResourcePool>( pool_ = std::make_unique<ResourcePool>(
resource_provider, layer_tree_frame_sink->context_provider(), resource_provider, context_provider, std::move(task_runner),
std::move(task_runner), ResourcePool::kDefaultExpirationDelay, ResourcePool::kDefaultExpirationDelay,
layer_tree_impl()->settings().disallow_non_exact_resource_reuse); layer_tree_impl()->settings().disallow_non_exact_resource_reuse);
} }
...@@ -220,39 +275,58 @@ void HeadsUpDisplayLayerImpl::UpdateHudTexture( ...@@ -220,39 +275,58 @@ void HeadsUpDisplayLayerImpl::UpdateHudTexture(
// compositing. // compositing.
ResourcePool::InUsePoolResource pool_resource; ResourcePool::InUsePoolResource pool_resource;
if (draw_mode == DRAW_MODE_HARDWARE) { if (draw_mode == DRAW_MODE_HARDWARE) {
viz::ContextProvider* context_provider = DCHECK(raster_context_provider || context_provider);
layer_tree_impl()->context_provider(); const auto& caps = raster_context_provider
DCHECK(context_provider); ? raster_context_provider->ContextCapabilities()
: context_provider->ContextCapabilities();
viz::ResourceFormat format = viz::ResourceFormat format =
viz::PlatformColor::BestSupportedRenderBufferFormat( viz::PlatformColor::BestSupportedRenderBufferFormat(caps);
context_provider->ContextCapabilities());
pool_resource = pool_->AcquireResource(internal_content_bounds_, format, pool_resource = pool_->AcquireResource(internal_content_bounds_, format,
gfx::ColorSpace()); gfx::ColorSpace());
if (!pool_resource.gpu_backing()) { if (!pool_resource.gpu_backing()) {
auto backing = std::make_unique<HudGpuBacking>(); auto backing = std::make_unique<HudGpuBacking>();
backing->compositor_context_provider = context_provider; auto* sii = raster_context_provider
? raster_context_provider->SharedImageInterface()
: context_provider->SharedImageInterface();
backing->shared_image_interface = sii;
backing->InitOverlayCandidateAndTextureTarget( backing->InitOverlayCandidateAndTextureTarget(
pool_resource.format(), context_provider->ContextCapabilities(), pool_resource.format(), caps,
layer_tree_impl() layer_tree_impl()
->settings() ->settings()
.resource_settings.use_gpu_memory_buffer_resources); .resource_settings.use_gpu_memory_buffer_resources);
auto* sii = context_provider->SharedImageInterface();
uint32_t flags = gpu::SHARED_IMAGE_USAGE_GLES2; uint32_t flags = 0;
if (gpu_raster) if (use_oopr) {
flags |= gpu::SHARED_IMAGE_USAGE_GLES2_FRAMEBUFFER_HINT; flags = gpu::SHARED_IMAGE_USAGE_RASTER |
gpu::SHARED_IMAGE_USAGE_OOP_RASTERIZATION;
} else if (gpu_raster) {
flags = gpu::SHARED_IMAGE_USAGE_GLES2 |
gpu::SHARED_IMAGE_USAGE_GLES2_FRAMEBUFFER_HINT;
}
if (backing->overlay_candidate) if (backing->overlay_candidate)
flags |= gpu::SHARED_IMAGE_USAGE_SCANOUT; flags |= gpu::SHARED_IMAGE_USAGE_SCANOUT;
backing->mailbox = backing->mailbox =
sii->CreateSharedImage(pool_resource.format(), pool_resource.size(), sii->CreateSharedImage(pool_resource.format(), pool_resource.size(),
pool_resource.color_space(), flags); pool_resource.color_space(), flags);
gpu::gles2::GLES2Interface* gl = context_provider->ContextGL(); if (raster_context_provider) {
gl->WaitSyncTokenCHROMIUM(sii->GenUnverifiedSyncToken().GetConstData()); auto* ri = raster_context_provider->RasterInterface();
ri->WaitSyncTokenCHROMIUM(sii->GenUnverifiedSyncToken().GetConstData());
} else {
auto* gl = context_provider->ContextGL();
gl->WaitSyncTokenCHROMIUM(sii->GenUnverifiedSyncToken().GetConstData());
}
pool_resource.set_gpu_backing(std::move(backing)); pool_resource.set_gpu_backing(std::move(backing));
} else if (pool_resource.gpu_backing()->returned_sync_token.HasData()) { } else if (pool_resource.gpu_backing()->returned_sync_token.HasData()) {
context_provider->ContextGL()->WaitSyncTokenCHROMIUM( if (raster_context_provider) {
pool_resource.gpu_backing()->returned_sync_token.GetConstData()); auto* ri = raster_context_provider->RasterInterface();
ri->WaitSyncTokenCHROMIUM(
pool_resource.gpu_backing()->returned_sync_token.GetConstData());
} else {
auto* gl = context_provider->ContextGL();
gl->WaitSyncTokenCHROMIUM(
pool_resource.gpu_backing()->returned_sync_token.GetConstData());
}
pool_resource.gpu_backing()->returned_sync_token = gpu::SyncToken(); pool_resource.gpu_backing()->returned_sync_token = gpu::SyncToken();
} }
} else { } else {
...@@ -285,29 +359,60 @@ void HeadsUpDisplayLayerImpl::UpdateHudTexture( ...@@ -285,29 +359,60 @@ void HeadsUpDisplayLayerImpl::UpdateHudTexture(
DCHECK_EQ(draw_mode, DRAW_MODE_HARDWARE); DCHECK_EQ(draw_mode, DRAW_MODE_HARDWARE);
DCHECK(pool_resource.gpu_backing()); DCHECK(pool_resource.gpu_backing());
auto* backing = static_cast<HudGpuBacking*>(pool_resource.gpu_backing()); auto* backing = static_cast<HudGpuBacking*>(pool_resource.gpu_backing());
viz::ContextProvider* context_provider =
layer_tree_impl()->context_provider();
gpu::gles2::GLES2Interface* gl = context_provider->ContextGL();
GLuint mailbox_texture_id =
gl->CreateAndConsumeTextureCHROMIUM(backing->mailbox.name);
{ if (use_oopr) {
ScopedGpuRaster gpu_raster(context_provider); const auto& size = pool_resource.size();
viz::ClientResourceProvider::ScopedSkSurface scoped_surface( auto display_item_list = base::MakeRefCounted<DisplayItemList>(
context_provider->GrContext(), mailbox_texture_id, DisplayItemList::kTopLevelDisplayItemList);
backing->texture_target, pool_resource.size(), pool_resource.format(), RecordPaintCanvas canvas(display_item_list.get(),
false /* can_use_lcd_text */, 0 /* msaa_sample_count */); SkRect::MakeIWH(size.width(), size.height()));
SkSurface* surface = scoped_surface.surface(); display_item_list->StartPaint();
if (!surface) { DrawHudContents(&canvas);
pool_->ReleaseResource(std::move(pool_resource)); display_item_list->EndPaintOfUnpaired(gfx::Rect(size));
return; display_item_list->Finalize();
auto* ri = raster_context_provider->RasterInterface();
constexpr GLuint background_color = SkColorSetARGB(0, 0, 0, 0);
constexpr GLuint msaa_sample_count = -1;
constexpr bool can_use_lcd_text = true;
const auto pixel_config = viz::ResourceFormatToClosestSkColorType(
true /* gpu_compositing */, pool_resource.format());
ri->BeginRasterCHROMIUM(background_color, msaa_sample_count,
can_use_lcd_text, pixel_config,
raster_color_space_, backing->mailbox.name);
gfx::Vector2dF post_translate(0.f, 0.f);
DummyImageProvider image_provider;
ri->RasterCHROMIUM(display_item_list.get(), &image_provider, size,
gfx::Rect(size), gfx::Rect(size), post_translate,
1.f /* post_scale */, false /* requires_clear */);
ri->EndRasterCHROMIUM();
backing->mailbox_sync_token =
viz::ClientResourceProvider::GenerateSyncTokenHelper(ri);
} else {
auto* gl = context_provider->ContextGL();
GLuint mailbox_texture_id =
gl->CreateAndConsumeTextureCHROMIUM(backing->mailbox.name);
{
ScopedGpuRaster gpu_raster(context_provider);
viz::ClientResourceProvider::ScopedSkSurface scoped_surface(
context_provider->GrContext(), mailbox_texture_id,
backing->texture_target, pool_resource.size(),
pool_resource.format(), false /* can_use_lcd_text */,
0 /* msaa_sample_count */);
SkSurface* surface = scoped_surface.surface();
if (!surface) {
pool_->ReleaseResource(std::move(pool_resource));
return;
}
SkiaPaintCanvas canvas(surface->getCanvas());
DrawHudContents(&canvas);
} }
DrawHudContents(surface->getCanvas());
}
gl->DeleteTextures(1, &mailbox_texture_id); gl->DeleteTextures(1, &mailbox_texture_id);
backing->mailbox_sync_token = backing->mailbox_sync_token =
viz::ClientResourceProvider::GenerateSyncTokenHelper(gl); viz::ClientResourceProvider::GenerateSyncTokenHelper(gl);
}
} else if (draw_mode == DRAW_MODE_HARDWARE) { } else if (draw_mode == DRAW_MODE_HARDWARE) {
// If not using |gpu_raster| but using gpu compositing, we DrawHudContents() // If not using |gpu_raster| but using gpu compositing, we DrawHudContents()
// into a software bitmap and upload it to a texture for compositing. // into a software bitmap and upload it to a texture for compositing.
...@@ -324,7 +429,8 @@ void HeadsUpDisplayLayerImpl::UpdateHudTexture( ...@@ -324,7 +429,8 @@ void HeadsUpDisplayLayerImpl::UpdateHudTexture(
pool_resource.size().width(), pool_resource.size().height()); pool_resource.size().width(), pool_resource.size().height());
} }
DrawHudContents(staging_surface_->getCanvas()); SkiaPaintCanvas canvas(staging_surface_->getCanvas());
DrawHudContents(&canvas);
TRACE_EVENT0("cc", "UploadHudTexture"); TRACE_EVENT0("cc", "UploadHudTexture");
SkPixmap pixmap; SkPixmap pixmap;
...@@ -354,7 +460,8 @@ void HeadsUpDisplayLayerImpl::UpdateHudTexture( ...@@ -354,7 +460,8 @@ void HeadsUpDisplayLayerImpl::UpdateHudTexture(
sk_sp<SkSurface> surface = SkSurface::MakeRasterDirect( sk_sp<SkSurface> surface = SkSurface::MakeRasterDirect(
info, backing->shared_memory->memory(), info.minRowBytes()); info, backing->shared_memory->memory(), info.minRowBytes());
DrawHudContents(surface->getCanvas()); SkiaPaintCanvas canvas(surface->getCanvas());
DrawHudContents(&canvas);
} }
// Exports the backing to the ResourceProvider, giving it a ResourceId that // Exports the backing to the ResourceProvider, giving it a ResourceId that
...@@ -457,7 +564,7 @@ void HeadsUpDisplayLayerImpl::UpdateHudContents() { ...@@ -457,7 +564,7 @@ void HeadsUpDisplayLayerImpl::UpdateHudContents() {
paint_time_graph_.UpdateUpperBound(); paint_time_graph_.UpdateUpperBound();
} }
void HeadsUpDisplayLayerImpl::DrawHudContents(SkCanvas* canvas) { void HeadsUpDisplayLayerImpl::DrawHudContents(PaintCanvas* canvas) {
const LayerTreeDebugState& debug_state = layer_tree_impl()->debug_state(); const LayerTreeDebugState& debug_state = layer_tree_impl()->debug_state();
TRACE_EVENT0("cc", "DrawHudContents"); TRACE_EVENT0("cc", "DrawHudContents");
...@@ -487,94 +594,74 @@ void HeadsUpDisplayLayerImpl::DrawHudContents(SkCanvas* canvas) { ...@@ -487,94 +594,74 @@ void HeadsUpDisplayLayerImpl::DrawHudContents(SkCanvas* canvas) {
canvas->restore(); canvas->restore();
} }
int HeadsUpDisplayLayerImpl::MeasureText(SkPaint* paint,
const std::string& text, void HeadsUpDisplayLayerImpl::DrawText(PaintCanvas* canvas,
int size) const { PaintFlags* flags,
DCHECK(typeface_.get());
const bool anti_alias = paint->isAntiAlias();
paint->setAntiAlias(true);
paint->setTextSize(size);
paint->setTypeface(typeface_);
SkScalar text_width = paint->measureText(text.c_str(), text.length());
paint->setAntiAlias(anti_alias);
return SkScalarCeilToInt(text_width);
}
void HeadsUpDisplayLayerImpl::DrawText(SkCanvas* canvas,
SkPaint* paint,
const std::string& text, const std::string& text,
TextAlign align, TextAlign align,
int size, int size,
int x, int x,
int y) const { int y) const {
DCHECK(typeface_.get()); DCHECK(typeface_.get());
const bool anti_alias = paint->isAntiAlias(); flags->setAntiAlias(true);
paint->setAntiAlias(true); flags->setTextSize(size);
flags->setTypeface(typeface_);
paint->setTextSize(size); if (align == TextAlign::kCenter) {
paint->setTypeface(typeface_); auto width = flags->ToSkPaint().measureText(text.c_str(), text.length());
x -= width * 0.5f;
if (align != TextAlign::kLeft) { } else if (align == TextAlign::kRight) {
SkScalar width = paint->measureText(text.c_str(), text.length(), nullptr); auto width = flags->ToSkPaint().measureText(text.c_str(), text.length());
if (align == TextAlign::kCenter) { x -= width;
x -= width * 0.5f;
} else {
DCHECK_EQ(align, TextAlign::kRight);
x -= width;
}
} }
canvas->drawText(text.c_str(), text.length(), x, y, *paint); auto sk_paint = flags->ToSkPaint();
paint->setAntiAlias(anti_alias); auto text_blob = SkTextBlob::MakeFromText(
text.c_str(), text.length(),
SkFont(sk_paint.refTypeface(), sk_paint.getTextSize()));
canvas->drawTextBlob(std::move(text_blob), x, y, *flags);
} }
void HeadsUpDisplayLayerImpl::DrawText(SkCanvas* canvas, void HeadsUpDisplayLayerImpl::DrawText(PaintCanvas* canvas,
SkPaint* paint, PaintFlags* flags,
const std::string& text, const std::string& text,
TextAlign align, TextAlign align,
int size, int size,
const SkPoint& pos) const { const SkPoint& pos) const {
DrawText(canvas, paint, text, align, size, pos.x(), pos.y()); DrawText(canvas, flags, text, align, size, pos.x(), pos.y());
} }
void HeadsUpDisplayLayerImpl::DrawGraphBackground(SkCanvas* canvas, void HeadsUpDisplayLayerImpl::DrawGraphBackground(PaintCanvas* canvas,
SkPaint* paint, PaintFlags* flags,
const SkRect& bounds) const { const SkRect& bounds) const {
paint->setColor(DebugColors::HUDBackgroundColor()); flags->setColor(DebugColors::HUDBackgroundColor());
canvas->drawRect(bounds, *paint); canvas->drawRect(bounds, *flags);
} }
void HeadsUpDisplayLayerImpl::DrawGraphLines(SkCanvas* canvas, void HeadsUpDisplayLayerImpl::DrawGraphLines(PaintCanvas* canvas,
SkPaint* paint, PaintFlags* flags,
const SkRect& bounds, const SkRect& bounds,
const Graph& graph) const { const Graph& graph) const {
// Draw top and bottom line. // Draw top and bottom line.
paint->setColor(DebugColors::HUDSeparatorLineColor()); flags->setColor(DebugColors::HUDSeparatorLineColor());
canvas->drawLine(bounds.left(), canvas->drawLine(bounds.left(), bounds.top() - 1, bounds.right(),
bounds.top() - 1, bounds.top() - 1, *flags);
bounds.right(), canvas->drawLine(bounds.left(), bounds.bottom(), bounds.right(),
bounds.top() - 1, bounds.bottom(), *flags);
*paint);
canvas->drawLine(
bounds.left(), bounds.bottom(), bounds.right(), bounds.bottom(), *paint);
// Draw indicator line (additive blend mode to increase contrast when drawn on // Draw indicator line (additive blend mode to increase contrast when drawn on
// top of graph). // top of graph).
paint->setColor(DebugColors::HUDIndicatorLineColor()); flags->setColor(DebugColors::HUDIndicatorLineColor());
paint->setBlendMode(SkBlendMode::kPlus); flags->setBlendMode(SkBlendMode::kPlus);
const double indicator_top = const double indicator_top =
bounds.height() * (1.0 - graph.indicator / graph.current_upper_bound) - bounds.height() * (1.0 - graph.indicator / graph.current_upper_bound) -
1.0; 1.0;
canvas->drawLine(bounds.left(), canvas->drawLine(bounds.left(), bounds.top() + indicator_top, bounds.right(),
bounds.top() + indicator_top, bounds.top() + indicator_top, *flags);
bounds.right(), flags->setBlendMode(SkBlendMode::kSrcOver);
bounds.top() + indicator_top,
*paint);
paint->setBlendMode(SkBlendMode::kSrcOver);
} }
SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay( SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay(
SkCanvas* canvas, PaintCanvas* canvas,
const FrameRateCounter* fps_counter, const FrameRateCounter* fps_counter,
int right, int right,
int top) const { int top) const {
...@@ -595,8 +682,8 @@ SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay( ...@@ -595,8 +682,8 @@ SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay(
int left = bounds().width() - width - right; int left = bounds().width() - width - right;
SkRect area = SkRect::MakeXYWH(left, top, width, height); SkRect area = SkRect::MakeXYWH(left, top, width, height);
SkPaint paint = CreatePaint(); PaintFlags flags = CreatePaintFlags();
DrawGraphBackground(canvas, &paint, area); DrawGraphBackground(canvas, &flags, area);
SkRect title_bounds = SkRect::MakeXYWH( SkRect title_bounds = SkRect::MakeXYWH(
left + kPadding, top + kPadding, kGraphWidth + kHistogramWidth + kGap + 2, left + kPadding, top + kPadding, kGraphWidth + kHistogramWidth + kGap + 2,
...@@ -621,17 +708,17 @@ SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay( ...@@ -621,17 +708,17 @@ SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay(
VLOG(1) << value_text; VLOG(1) << value_text;
paint.setColor(DebugColors::HUDTitleColor()); flags.setColor(DebugColors::HUDTitleColor());
DrawText(canvas, &paint, title, TextAlign::kLeft, kTitleFontHeight, DrawText(canvas, &flags, title, TextAlign::kLeft, kTitleFontHeight,
title_bounds.left(), title_bounds.bottom()); title_bounds.left(), title_bounds.bottom());
paint.setColor(DebugColors::FPSDisplayTextAndGraphColor()); flags.setColor(DebugColors::FPSDisplayTextAndGraphColor());
DrawText(canvas, &paint, value_text, TextAlign::kLeft, kFontHeight, DrawText(canvas, &flags, value_text, TextAlign::kLeft, kFontHeight,
text_bounds.left(), text_bounds.bottom()); text_bounds.left(), text_bounds.bottom());
DrawText(canvas, &paint, min_max_text, TextAlign::kRight, kFontHeight, DrawText(canvas, &flags, min_max_text, TextAlign::kRight, kFontHeight,
text_bounds.right(), text_bounds.bottom()); text_bounds.right(), text_bounds.bottom());
DrawGraphLines(canvas, &paint, graph_bounds, fps_graph_); DrawGraphLines(canvas, &flags, graph_bounds, fps_graph_);
// Collect graph and histogram data. // Collect graph and histogram data.
SkPath path; SkPath path;
...@@ -674,19 +761,15 @@ SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay( ...@@ -674,19 +761,15 @@ SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay(
} }
// Draw FPS histogram. // Draw FPS histogram.
paint.setColor(DebugColors::HUDSeparatorLineColor()); flags.setColor(DebugColors::HUDSeparatorLineColor());
canvas->drawLine(histogram_bounds.left() - 1, canvas->drawLine(histogram_bounds.left() - 1, histogram_bounds.top() - 1,
histogram_bounds.top() - 1, histogram_bounds.left() - 1, histogram_bounds.bottom() + 1,
histogram_bounds.left() - 1, flags);
histogram_bounds.bottom() + 1, canvas->drawLine(histogram_bounds.right() + 1, histogram_bounds.top() - 1,
paint); histogram_bounds.right() + 1, histogram_bounds.bottom() + 1,
canvas->drawLine(histogram_bounds.right() + 1, flags);
histogram_bounds.top() - 1,
histogram_bounds.right() + 1, flags.setColor(DebugColors::FPSDisplayTextAndGraphColor());
histogram_bounds.bottom() + 1,
paint);
paint.setColor(DebugColors::FPSDisplayTextAndGraphColor());
const double bar_height = histogram_bounds.height() / kHistogramSize; const double bar_height = histogram_bounds.height() / kHistogramSize;
for (int i = kHistogramSize - 1; i >= 0; --i) { for (int i = kHistogramSize - 1; i >= 0; --i) {
...@@ -696,22 +779,21 @@ SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay( ...@@ -696,22 +779,21 @@ SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay(
canvas->drawRect( canvas->drawRect(
SkRect::MakeXYWH(histogram_bounds.left(), SkRect::MakeXYWH(histogram_bounds.left(),
histogram_bounds.bottom() - (i + 1) * bar_height, histogram_bounds.bottom() - (i + 1) * bar_height,
bar_width, bar_width, 1),
1), flags);
paint);
} }
} }
// Draw FPS graph. // Draw FPS graph.
paint.setAntiAlias(true); flags.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style); flags.setStyle(PaintFlags::kStroke_Style);
paint.setStrokeWidth(1); flags.setStrokeWidth(1);
canvas->drawPath(path, paint); canvas->drawPath(path, flags);
return area; return area;
} }
SkRect HeadsUpDisplayLayerImpl::DrawMemoryDisplay(SkCanvas* canvas, SkRect HeadsUpDisplayLayerImpl::DrawMemoryDisplay(PaintCanvas* canvas,
int right, int right,
int top, int top,
int width) const { int width) const {
...@@ -725,8 +807,8 @@ SkRect HeadsUpDisplayLayerImpl::DrawMemoryDisplay(SkCanvas* canvas, ...@@ -725,8 +807,8 @@ SkRect HeadsUpDisplayLayerImpl::DrawMemoryDisplay(SkCanvas* canvas,
const double kMegabyte = 1024.0 * 1024.0; const double kMegabyte = 1024.0 * 1024.0;
SkPaint paint = CreatePaint(); PaintFlags flags = CreatePaintFlags();
DrawGraphBackground(canvas, &paint, area); DrawGraphBackground(canvas, &flags, area);
SkPoint title_pos = SkPoint title_pos =
SkPoint::Make(left + kPadding, top + kFontHeight + kPadding); SkPoint::Make(left + kPadding, top + kFontHeight + kPadding);
...@@ -735,31 +817,32 @@ SkRect HeadsUpDisplayLayerImpl::DrawMemoryDisplay(SkCanvas* canvas, ...@@ -735,31 +817,32 @@ SkRect HeadsUpDisplayLayerImpl::DrawMemoryDisplay(SkCanvas* canvas,
SkPoint stat2_pos = SkPoint::Make(left + width - kPadding - 1, SkPoint stat2_pos = SkPoint::Make(left + width - kPadding - 1,
top + 2 * kPadding + 3 * kFontHeight); top + 2 * kPadding + 3 * kFontHeight);
paint.setColor(DebugColors::HUDTitleColor()); flags.setColor(DebugColors::HUDTitleColor());
DrawText(canvas, &paint, "GPU Memory", TextAlign::kLeft, kTitleFontHeight, DrawText(canvas, &flags, "GPU Memory", TextAlign::kLeft, kTitleFontHeight,
title_pos); title_pos);
paint.setColor(DebugColors::MemoryDisplayTextColor()); flags.setColor(DebugColors::MemoryDisplayTextColor());
std::string text = base::StringPrintf( std::string text = base::StringPrintf(
"%6.1f MB used", memory_entry_.total_bytes_used / kMegabyte); "%6.1f MB used", memory_entry_.total_bytes_used / kMegabyte);
DrawText(canvas, &paint, text, TextAlign::kRight, kFontHeight, stat1_pos); DrawText(canvas, &flags, text, TextAlign::kRight, kFontHeight, stat1_pos);
if (!memory_entry_.had_enough_memory) if (!memory_entry_.had_enough_memory)
paint.setColor(SK_ColorRED); flags.setColor(SK_ColorRED);
text = base::StringPrintf("%6.1f MB max ", text = base::StringPrintf("%6.1f MB max ",
memory_entry_.total_budget_in_bytes / kMegabyte); memory_entry_.total_budget_in_bytes / kMegabyte);
DrawText(canvas, &paint, text, TextAlign::kRight, kFontHeight, stat2_pos);
DrawText(canvas, &flags, text, TextAlign::kRight, kFontHeight, stat2_pos);
// Draw memory graph. // Draw memory graph.
int length = 2 * kFontHeight + kPadding + 12; int length = 2 * kFontHeight + kPadding + 12;
SkRect oval = SkRect oval =
SkRect::MakeXYWH(left + kPadding * 6, SkRect::MakeXYWH(left + kPadding * 6,
top + kTitleFontHeight + kPadding * 3, length, length); top + kTitleFontHeight + kPadding * 3, length, length);
paint.setAntiAlias(true); flags.setAntiAlias(true);
paint.setStyle(SkPaint::kFill_Style); flags.setStyle(PaintFlags::kFill_Style);
paint.setColor(SkColorSetARGB(64, 255, 255, 0)); flags.setColor(SkColorSetARGB(64, 255, 255, 0));
canvas->drawArc(oval, 180, 180, true, paint); DrawArc(canvas, oval, 180, 180, flags);
int radius = length / 2; int radius = length / 2;
int cx = oval.left() + radius; int cx = oval.left() + radius;
...@@ -773,24 +856,25 @@ SkRect HeadsUpDisplayLayerImpl::DrawMemoryDisplay(SkCanvas* canvas, ...@@ -773,24 +856,25 @@ SkRect HeadsUpDisplayLayerImpl::DrawMemoryDisplay(SkCanvas* canvas,
const SkScalar pos[] = {SkFloatToScalar(0.2f), SkFloatToScalar(0.4f), const SkScalar pos[] = {SkFloatToScalar(0.2f), SkFloatToScalar(0.4f),
SkFloatToScalar(0.6f), SkFloatToScalar(0.8f), SkFloatToScalar(0.6f), SkFloatToScalar(0.8f),
SkFloatToScalar(1.0f)}; SkFloatToScalar(1.0f)};
paint.setShader(SkGradientShader::MakeSweep(cx, cy, colors, pos, 5)); flags.setShader(PaintShader::MakeSweepGradient(
paint.setFlags(SkPaint::kAntiAlias_Flag); cx, cy, colors, pos, 5, SkShader::kClamp_TileMode, 0, 360));
flags.setAntiAlias(true);
// Draw current status. // Draw current status.
paint.setStyle(SkPaint::kStroke_Style); flags.setStyle(PaintFlags::kStroke_Style);
paint.setAlpha(32); flags.setAlpha(32);
paint.setStrokeWidth(4); flags.setStrokeWidth(4);
canvas->drawArc(oval, 180, angle, true, paint); DrawArc(canvas, oval, 180, angle, flags);
paint.setStyle(SkPaint::kFill_Style); flags.setStyle(PaintFlags::kFill_Style);
paint.setColor(SkColorSetARGB(255, 0, 255, 0)); flags.setColor(SkColorSetARGB(255, 0, 255, 0));
canvas->drawArc(oval, 180, angle, true, paint); DrawArc(canvas, oval, 180, angle, flags);
paint.setShader(nullptr); flags.setShader(nullptr);
return area; return area;
} }
SkRect HeadsUpDisplayLayerImpl::DrawGpuRasterizationStatus(SkCanvas* canvas, SkRect HeadsUpDisplayLayerImpl::DrawGpuRasterizationStatus(PaintCanvas* canvas,
int right, int right,
int top, int top,
int width) const { int width) const {
...@@ -830,24 +914,24 @@ SkRect HeadsUpDisplayLayerImpl::DrawGpuRasterizationStatus(SkCanvas* canvas, ...@@ -830,24 +914,24 @@ SkRect HeadsUpDisplayLayerImpl::DrawGpuRasterizationStatus(SkCanvas* canvas,
const int left = bounds().width() - width - right; const int left = bounds().width() - width - right;
const SkRect area = SkRect::MakeXYWH(left, top, width, height); const SkRect area = SkRect::MakeXYWH(left, top, width, height);
SkPaint paint = CreatePaint(); PaintFlags flags = CreatePaintFlags();
DrawGraphBackground(canvas, &paint, area); DrawGraphBackground(canvas, &flags, area);
SkPoint gpu_status_pos = SkPoint::Make(left + width - kPadding, SkPoint gpu_status_pos = SkPoint::Make(left + width - kPadding,
top + 2 * kFontHeight + 2 * kPadding); top + 2 * kFontHeight + 2 * kPadding);
paint.setColor(DebugColors::HUDTitleColor()); flags.setColor(DebugColors::HUDTitleColor());
DrawText(canvas, &paint, "GPU Raster", TextAlign::kLeft, kTitleFontHeight, DrawText(canvas, &flags, "GPU Raster", TextAlign::kLeft, kTitleFontHeight,
left + kPadding, top + kFontHeight + kPadding); left + kPadding, top + kFontHeight + kPadding);
paint.setColor(color); flags.setColor(color);
DrawText(canvas, &paint, status, TextAlign::kRight, kFontHeight, DrawText(canvas, &flags, status, TextAlign::kRight, kFontHeight,
gpu_status_pos); gpu_status_pos);
return area; return area;
} }
void HeadsUpDisplayLayerImpl::DrawDebugRect( void HeadsUpDisplayLayerImpl::DrawDebugRect(
SkCanvas* canvas, PaintCanvas* canvas,
SkPaint* paint, PaintFlags* flags,
const DebugRect& rect, const DebugRect& rect,
SkColor stroke_color, SkColor stroke_color,
SkColor fill_color, SkColor fill_color,
...@@ -858,14 +942,14 @@ void HeadsUpDisplayLayerImpl::DrawDebugRect( ...@@ -858,14 +942,14 @@ void HeadsUpDisplayLayerImpl::DrawDebugRect(
gfx::ScaleToEnclosingRect(rect.rect, 1.0 / internal_contents_scale_, gfx::ScaleToEnclosingRect(rect.rect, 1.0 / internal_contents_scale_,
1.0 / internal_contents_scale_); 1.0 / internal_contents_scale_);
SkIRect sk_rect = RectToSkIRect(debug_layer_rect); SkIRect sk_rect = RectToSkIRect(debug_layer_rect);
paint->setColor(fill_color); flags->setColor(fill_color);
paint->setStyle(SkPaint::kFill_Style); flags->setStyle(PaintFlags::kFill_Style);
canvas->drawIRect(sk_rect, *paint); canvas->drawIRect(sk_rect, *flags);
paint->setColor(stroke_color); flags->setColor(stroke_color);
paint->setStyle(SkPaint::kStroke_Style); flags->setStyle(PaintFlags::kStroke_Style);
paint->setStrokeWidth(SkFloatToScalar(stroke_width)); flags->setStrokeWidth(SkFloatToScalar(stroke_width));
canvas->drawIRect(sk_rect, *paint); canvas->drawIRect(sk_rect, *flags);
if (label_text.length()) { if (label_text.length()) {
const int kFontHeight = 12; const int kFontHeight = 12;
...@@ -881,33 +965,29 @@ void HeadsUpDisplayLayerImpl::DrawDebugRect( ...@@ -881,33 +965,29 @@ void HeadsUpDisplayLayerImpl::DrawDebugRect(
canvas->clipRect(sk_clip_rect); canvas->clipRect(sk_clip_rect);
canvas->translate(sk_clip_rect.x(), sk_clip_rect.y()); canvas->translate(sk_clip_rect.x(), sk_clip_rect.y());
SkPaint label_paint = CreatePaint(); PaintFlags label_flags = CreatePaintFlags();
label_paint.setTextSize(kFontHeight); label_flags.setTextSize(kFontHeight);
label_paint.setTypeface(typeface_); label_flags.setTypeface(typeface_);
label_paint.setColor(stroke_color); label_flags.setColor(stroke_color);
const SkScalar label_text_width = const SkScalar label_text_width = label_flags.ToSkPaint().measureText(
label_paint.measureText(label_text.c_str(), label_text.length()); label_text.c_str(), label_text.length());
canvas->drawRect(SkRect::MakeWH(label_text_width + 2 * kPadding, canvas->drawRect(SkRect::MakeWH(label_text_width + 2 * kPadding,
kFontHeight + 2 * kPadding), kFontHeight + 2 * kPadding),
label_paint); label_flags);
label_paint.setAntiAlias(true);
label_paint.setColor(SkColorSetARGB(255, 50, 50, 50));
canvas->drawText(label_text.c_str(),
label_text.length(),
kPadding,
kFontHeight * 0.8f + kPadding,
label_paint);
label_flags.setAntiAlias(true);
label_flags.setColor(SkColorSetARGB(255, 50, 50, 50));
DrawText(canvas, &label_flags, label_text, TextAlign::kLeft, kFontHeight,
kPadding, kFontHeight * 0.8f + kPadding);
canvas->restore(); canvas->restore();
} }
} }
void HeadsUpDisplayLayerImpl::DrawDebugRects( void HeadsUpDisplayLayerImpl::DrawDebugRects(
SkCanvas* canvas, PaintCanvas* canvas,
DebugRectHistory* debug_rect_history) { DebugRectHistory* debug_rect_history) {
SkPaint paint = CreatePaint(); PaintFlags flags = CreatePaintFlags();
const std::vector<DebugRect>& debug_rects = debug_rect_history->debug_rects(); const std::vector<DebugRect>& debug_rects = debug_rect_history->debug_rects();
std::vector<DebugRect> new_paint_rects; std::vector<DebugRect> new_paint_rects;
...@@ -970,13 +1050,8 @@ void HeadsUpDisplayLayerImpl::DrawDebugRects( ...@@ -970,13 +1050,8 @@ void HeadsUpDisplayLayerImpl::DrawDebugRects(
break; break;
} }
DrawDebugRect(canvas, DrawDebugRect(canvas, &flags, debug_rects[i], stroke_color, fill_color,
&paint, stroke_width, label_text);
debug_rects[i],
stroke_color,
fill_color,
stroke_width,
label_text);
} }
if (new_paint_rects.size()) { if (new_paint_rects.size()) {
...@@ -986,13 +1061,10 @@ void HeadsUpDisplayLayerImpl::DrawDebugRects( ...@@ -986,13 +1061,10 @@ void HeadsUpDisplayLayerImpl::DrawDebugRects(
if (fade_step_ > 0) { if (fade_step_ > 0) {
fade_step_--; fade_step_--;
for (size_t i = 0; i < paint_rects_.size(); ++i) { for (size_t i = 0; i < paint_rects_.size(); ++i) {
DrawDebugRect(canvas, DrawDebugRect(canvas, &flags, paint_rects_[i],
&paint,
paint_rects_[i],
DebugColors::PaintRectBorderColor(fade_step_), DebugColors::PaintRectBorderColor(fade_step_),
DebugColors::PaintRectFillColor(fade_step_), DebugColors::PaintRectFillColor(fade_step_),
DebugColors::PaintRectBorderWidth(), DebugColors::PaintRectBorderWidth(), "");
"");
} }
} }
} }
......
cc/layers/heads_up_display_layer_impl.h
View file @ 25718190
...@@ -14,13 +14,12 @@ ...@@ -14,13 +14,12 @@
#include "base/time/time.h" #include "base/time/time.h"
#include "cc/cc_export.h" #include "cc/cc_export.h"
#include "cc/layers/layer_impl.h" #include "cc/layers/layer_impl.h"
#include "cc/paint/color_space_transfer_cache_entry.h"
#include "cc/resources/memory_history.h" #include "cc/resources/memory_history.h"
#include "cc/resources/resource_pool.h" #include "cc/resources/resource_pool.h"
#include "cc/trees/debug_rect_history.h" #include "cc/trees/debug_rect_history.h"
#include "third_party/skia/include/core/SkRefCnt.h" #include "third_party/skia/include/core/SkRefCnt.h"
class SkCanvas;
class SkPaint;
class SkTypeface; class SkTypeface;
struct SkRect; struct SkRect;
...@@ -31,6 +30,8 @@ class ClientResourceProvider; ...@@ -31,6 +30,8 @@ class ClientResourceProvider;
namespace cc { namespace cc {
class FrameRateCounter; class FrameRateCounter;
class LayerTreeFrameSink; class LayerTreeFrameSink;
class PaintCanvas;
class PaintFlags;
enum class TextAlign { kLeft, kCenter, kRight }; enum class TextAlign { kLeft, kCenter, kRight };
...@@ -95,50 +96,49 @@ class CC_EXPORT HeadsUpDisplayLayerImpl : public LayerImpl { ...@@ -95,50 +96,49 @@ class CC_EXPORT HeadsUpDisplayLayerImpl : public LayerImpl {
void AsValueInto(base::trace_event::TracedValue* dict) const override; void AsValueInto(base::trace_event::TracedValue* dict) const override;
void UpdateHudContents(); void UpdateHudContents();
void DrawHudContents(SkCanvas* canvas); void DrawHudContents(PaintCanvas* canvas);
void DrawText(PaintCanvas* canvas,
int MeasureText(SkPaint* paint, const std::string& text, int size) const; PaintFlags* flags,
void DrawText(SkCanvas* canvas,
SkPaint* paint,
const std::string& text, const std::string& text,
TextAlign align, TextAlign align,
int size, int size,
int x, int x,
int y) const; int y) const;
void DrawText(SkCanvas* canvas, void DrawText(PaintCanvas* canvas,
SkPaint* paint, PaintFlags* flags,
const std::string& text, const std::string& text,
TextAlign align, TextAlign align,
int size, int size,
const SkPoint& pos) const; const SkPoint& pos) const;
void DrawGraphBackground(SkCanvas* canvas, void DrawGraphBackground(PaintCanvas* canvas,
SkPaint* paint, PaintFlags* flags,
const SkRect& bounds) const; const SkRect& bounds) const;
void DrawGraphLines(SkCanvas* canvas, void DrawGraphLines(PaintCanvas* canvas,
SkPaint* paint, PaintFlags* flags,
const SkRect& bounds, const SkRect& bounds,
const Graph& graph) const; const Graph& graph) const;
SkRect DrawFPSDisplay(SkCanvas* canvas, SkRect DrawFPSDisplay(PaintCanvas* canvas,
const FrameRateCounter* fps_counter, const FrameRateCounter* fps_counter,
int right, int right,
int top) const; int top) const;
SkRect DrawMemoryDisplay(SkCanvas* canvas, SkRect DrawMemoryDisplay(PaintCanvas* canvas,
int top, int top,
int right, int right,
int width) const; int width) const;
SkRect DrawGpuRasterizationStatus(SkCanvas* canvas, SkRect DrawGpuRasterizationStatus(PaintCanvas* canvas,
int right, int right,
int top, int top,
int width) const; int width) const;
void DrawDebugRect(SkCanvas* canvas, void DrawDebugRect(PaintCanvas* canvas,
SkPaint* paint, PaintFlags* flags,
const DebugRect& rect, const DebugRect& rect,
SkColor stroke_color, SkColor stroke_color,
SkColor fill_color, SkColor fill_color,
float stroke_width, float stroke_width,
const std::string& label_text) const; const std::string& label_text) const;
void DrawDebugRects(SkCanvas* canvas, DebugRectHistory* debug_rect_history); void DrawDebugRects(PaintCanvas* canvas,
DebugRectHistory* debug_rect_history);
ResourcePool::InUsePoolResource in_flight_resource_; ResourcePool::InUsePoolResource in_flight_resource_;
std::unique_ptr<ResourcePool> pool_; std::unique_ptr<ResourcePool> pool_;
...@@ -159,6 +159,9 @@ class CC_EXPORT HeadsUpDisplayLayerImpl : public LayerImpl { ...@@ -159,6 +159,9 @@ class CC_EXPORT HeadsUpDisplayLayerImpl : public LayerImpl {
base::TimeTicks time_of_last_graph_update_; base::TimeTicks time_of_last_graph_update_;
// color space for OOPR
const RasterColorSpace raster_color_space_;
DISALLOW_COPY_AND_ASSIGN(HeadsUpDisplayLayerImpl); DISALLOW_COPY_AND_ASSIGN(HeadsUpDisplayLayerImpl);
}; };
......
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