Revert "Using PaintCanvas for HUD"

This reverts commit 25718190.

Reason for revert: It breaks FPS counter on Mac
https://bugs.chromium.org/p/chromium/issues/detail?id=906570

Original change's description:
> 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: enne <enne@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#609033}

TBR=penghuang@chromium.org,enne@chromium.org

# Not skipping CQ checks because original CL landed > 1 day ago.

Bug: 895568, 906570
Change-Id: I935de60977c0374139ae1eb22670d234f85e0df6
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;master.tryserver.blink:linux_trusty_blink_rel
Reviewed-on: https://chromium-review.googlesource.com/c/1342049
Commit-Queue: Peng Huang <penghuang@chromium.org>
Reviewed-by: Peng Huang <penghuang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#609333}

cc/layers/heads_up_display_layer_impl.cc

@@ -11,19 +11,13 @@
 #include <vector>
 
 #include "base/numerics/safe_conversions.h"
-#include "base/optional.h"
 #include "base/single_thread_task_runner.h"
+#include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/traced_value.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/resources/memory_history.h"
 #include "cc/trees/frame_rate_counter.h"
@@ -39,30 +33,28 @@
 #include "components/viz/common/resources/platform_color.h"
 #include "gpu/command_buffer/client/context_support.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/common/shared_image_trace_utils.h"
 #include "gpu/command_buffer/common/shared_image_usage.h"
-#include "gpu/config/gpu_feature_info.h"
-#include "third_party/skia/include/core/SkFont.h"
+#include "skia/ext/platform_canvas.h"
+#include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.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/size.h"
 #include "ui/gfx/geometry/size_conversions.h"
-#include "ui/gfx/skia_util.h"
 #include "ui/gl/trace_util.h"
 
 namespace cc {
 
-namespace {
-
-PaintFlags CreatePaintFlags() {
-  PaintFlags flags;
+static inline SkPaint CreatePaint() {
+  SkPaint paint;
 #if (SK_R32_SHIFT || SK_B32_SHIFT != 16)
-  // The PaintCanvas is in RGBA but the shader is expecting BGRA, so we need to
-  // swizzle our colors when drawing to the PaintCanvas.
+  // The SkCanvas is in RGBA but the shader is expecting BGRA, so we need to
+  // swizzle our colors when drawing to the SkCanvas.
   SkScalar color_matrix[20];
   for (int i = 0; i < 20; ++i)
     color_matrix[i] = 0;
@@ -71,39 +63,12 @@ PaintFlags CreatePaintFlags() {
   color_matrix[2 + 5 * 0] = 1;
   color_matrix[3 + 5 * 3] = 1;
 
-  flags.setColorFilter(
+  paint.setColorFilter(
       SkColorFilter::MakeMatrixFilterRowMajor255(color_matrix));
 #endif
-  return flags;
+  return paint;
 }
 
-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,
                                       double start_upper_bound)
     : value(0.0),
@@ -125,9 +90,7 @@ HeadsUpDisplayLayerImpl::HeadsUpDisplayLayerImpl(LayerTreeImpl* tree_impl,
       internal_contents_scale_(1.f),
       fps_graph_(60.0, 80.0),
       paint_time_graph_(16.0, 48.0),
-      fade_step_(0),
-      raster_color_space_(gfx::ColorSpace::CreateSRGB(),
-                          gfx::ColorSpace::GetNextId()) {}
+      fade_step_(0) {}
 
 HeadsUpDisplayLayerImpl::~HeadsUpDisplayLayerImpl() {
   ReleaseResources();
@@ -143,10 +106,11 @@ class HudGpuBacking : public ResourcePool::GpuBacking {
   ~HudGpuBacking() override {
     if (mailbox.IsZero())
       return;
+    auto* sii = compositor_context_provider->SharedImageInterface();
     if (returned_sync_token.HasData())
-      shared_image_interface->DestroySharedImage(returned_sync_token, mailbox);
+      sii->DestroySharedImage(returned_sync_token, mailbox);
     else if (mailbox_sync_token.HasData())
-      shared_image_interface->DestroySharedImage(mailbox_sync_token, mailbox);
+      sii->DestroySharedImage(mailbox_sync_token, mailbox);
   }
 
   void OnMemoryDump(
@@ -162,7 +126,7 @@ class HudGpuBacking : public ResourcePool::GpuBacking {
     pmd->AddOwnershipEdge(buffer_dump_guid, tracing_guid, importance);
   }
 
-  gpu::SharedImageInterface* shared_image_interface = nullptr;
+  viz::ContextProvider* compositor_context_provider;
 };
 
 class HudSoftwareBacking : public ResourcePool::SoftwareBacking {
@@ -234,33 +198,14 @@ void HeadsUpDisplayLayerImpl::UpdateHudTexture(
   // Update state that will be drawn.
   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_) {
     scoped_refptr<base::SingleThreadTaskRunner> task_runner =
         layer_tree_impl()->task_runner_provider()->HasImplThread()
             ? layer_tree_impl()->task_runner_provider()->ImplThreadTaskRunner()
             : layer_tree_impl()->task_runner_provider()->MainThreadTaskRunner();
     pool_ = std::make_unique<ResourcePool>(
-        resource_provider, context_provider, std::move(task_runner),
-        ResourcePool::kDefaultExpirationDelay,
+        resource_provider, layer_tree_frame_sink->context_provider(),
+        std::move(task_runner), ResourcePool::kDefaultExpirationDelay,
         layer_tree_impl()->settings().disallow_non_exact_resource_reuse);
   }
 
@@ -275,58 +220,39 @@ void HeadsUpDisplayLayerImpl::UpdateHudTexture(
   // compositing.
   ResourcePool::InUsePoolResource pool_resource;
   if (draw_mode == DRAW_MODE_HARDWARE) {
-    DCHECK(raster_context_provider || context_provider);
-    const auto& caps = raster_context_provider
-                           ? raster_context_provider->ContextCapabilities()
-                           : context_provider->ContextCapabilities();
+    viz::ContextProvider* context_provider =
+        layer_tree_impl()->context_provider();
+    DCHECK(context_provider);
+
     viz::ResourceFormat format =
-        viz::PlatformColor::BestSupportedRenderBufferFormat(caps);
+        viz::PlatformColor::BestSupportedRenderBufferFormat(
+            context_provider->ContextCapabilities());
     pool_resource = pool_->AcquireResource(internal_content_bounds_, format,
                                            gfx::ColorSpace());
 
     if (!pool_resource.gpu_backing()) {
       auto backing = std::make_unique<HudGpuBacking>();
-      auto* sii = raster_context_provider
-                      ? raster_context_provider->SharedImageInterface()
-                      : context_provider->SharedImageInterface();
-      backing->shared_image_interface = sii;
+      backing->compositor_context_provider = context_provider;
       backing->InitOverlayCandidateAndTextureTarget(
-          pool_resource.format(), caps,
+          pool_resource.format(), context_provider->ContextCapabilities(),
           layer_tree_impl()
               ->settings()
               .resource_settings.use_gpu_memory_buffer_resources);
-
-      uint32_t flags = 0;
-      if (use_oopr) {
-        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;
-      }
+      auto* sii = context_provider->SharedImageInterface();
+      uint32_t flags = gpu::SHARED_IMAGE_USAGE_GLES2;
+      if (gpu_raster)
+        flags |= gpu::SHARED_IMAGE_USAGE_GLES2_FRAMEBUFFER_HINT;
       if (backing->overlay_candidate)
         flags |= gpu::SHARED_IMAGE_USAGE_SCANOUT;
       backing->mailbox =
           sii->CreateSharedImage(pool_resource.format(), pool_resource.size(),
                                  pool_resource.color_space(), flags);
-      if (raster_context_provider) {
-        auto* ri = raster_context_provider->RasterInterface();
-        ri->WaitSyncTokenCHROMIUM(sii->GenUnverifiedSyncToken().GetConstData());
-      } else {
-        auto* gl = context_provider->ContextGL();
-        gl->WaitSyncTokenCHROMIUM(sii->GenUnverifiedSyncToken().GetConstData());
-      }
+      gpu::gles2::GLES2Interface* gl = context_provider->ContextGL();
+      gl->WaitSyncTokenCHROMIUM(sii->GenUnverifiedSyncToken().GetConstData());
       pool_resource.set_gpu_backing(std::move(backing));
     } else if (pool_resource.gpu_backing()->returned_sync_token.HasData()) {
-      if (raster_context_provider) {
-        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());
-      }
+      context_provider->ContextGL()->WaitSyncTokenCHROMIUM(
+          pool_resource.gpu_backing()->returned_sync_token.GetConstData());
       pool_resource.gpu_backing()->returned_sync_token = gpu::SyncToken();
     }
   } else {
@@ -359,60 +285,29 @@ void HeadsUpDisplayLayerImpl::UpdateHudTexture(
     DCHECK_EQ(draw_mode, DRAW_MODE_HARDWARE);
     DCHECK(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) {
-      const auto& size = pool_resource.size();
-      auto display_item_list = base::MakeRefCounted<DisplayItemList>(
-          DisplayItemList::kTopLevelDisplayItemList);
-      RecordPaintCanvas canvas(display_item_list.get(),
-                               SkRect::MakeIWH(size.width(), size.height()));
-      display_item_list->StartPaint();
-      DrawHudContents(&canvas);
-      display_item_list->EndPaintOfUnpaired(gfx::Rect(size));
-      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);
+    {
+      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;
       }
-
-      gl->DeleteTextures(1, &mailbox_texture_id);
-      backing->mailbox_sync_token =
-          viz::ClientResourceProvider::GenerateSyncTokenHelper(gl);
+      DrawHudContents(surface->getCanvas());
     }
+
+    gl->DeleteTextures(1, &mailbox_texture_id);
+    backing->mailbox_sync_token =
+        viz::ClientResourceProvider::GenerateSyncTokenHelper(gl);
   } else if (draw_mode == DRAW_MODE_HARDWARE) {
     // If not using |gpu_raster| but using gpu compositing, we DrawHudContents()
     // into a software bitmap and upload it to a texture for compositing.
@@ -429,8 +324,7 @@ void HeadsUpDisplayLayerImpl::UpdateHudTexture(
           pool_resource.size().width(), pool_resource.size().height());
     }
 
-    SkiaPaintCanvas canvas(staging_surface_->getCanvas());
-    DrawHudContents(&canvas);
+    DrawHudContents(staging_surface_->getCanvas());
 
     TRACE_EVENT0("cc", "UploadHudTexture");
     SkPixmap pixmap;
@@ -460,8 +354,7 @@ void HeadsUpDisplayLayerImpl::UpdateHudTexture(
     sk_sp<SkSurface> surface = SkSurface::MakeRasterDirect(
         info, backing->shared_memory->memory(), info.minRowBytes());
 
-    SkiaPaintCanvas canvas(surface->getCanvas());
-    DrawHudContents(&canvas);
+    DrawHudContents(surface->getCanvas());
   }
 
   // Exports the backing to the ResourceProvider, giving it a ResourceId that
@@ -564,7 +457,7 @@ void HeadsUpDisplayLayerImpl::UpdateHudContents() {
   paint_time_graph_.UpdateUpperBound();
 }
 
-void HeadsUpDisplayLayerImpl::DrawHudContents(PaintCanvas* canvas) {
+void HeadsUpDisplayLayerImpl::DrawHudContents(SkCanvas* canvas) {
   const LayerTreeDebugState& debug_state = layer_tree_impl()->debug_state();
 
   TRACE_EVENT0("cc", "DrawHudContents");
@@ -594,74 +487,94 @@ void HeadsUpDisplayLayerImpl::DrawHudContents(PaintCanvas* canvas) {
 
   canvas->restore();
 }
-
-void HeadsUpDisplayLayerImpl::DrawText(PaintCanvas* canvas,
-                                       PaintFlags* flags,
+int HeadsUpDisplayLayerImpl::MeasureText(SkPaint* paint,
+                                         const std::string& text,
+                                         int size) const {
+  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,
                                        TextAlign align,
                                        int size,
                                        int x,
                                        int y) const {
   DCHECK(typeface_.get());
-  flags->setAntiAlias(true);
-  flags->setTextSize(size);
-  flags->setTypeface(typeface_);
-  if (align == TextAlign::kCenter) {
-    auto width = flags->ToSkPaint().measureText(text.c_str(), text.length());
-    x -= width * 0.5f;
-  } else if (align == TextAlign::kRight) {
-    auto width = flags->ToSkPaint().measureText(text.c_str(), text.length());
-    x -= width;
+  const bool anti_alias = paint->isAntiAlias();
+  paint->setAntiAlias(true);
+
+  paint->setTextSize(size);
+  paint->setTypeface(typeface_);
+
+  if (align != TextAlign::kLeft) {
+    SkScalar width = paint->measureText(text.c_str(), text.length(), nullptr);
+    if (align == TextAlign::kCenter) {
+      x -= width * 0.5f;
+    } else {
+      DCHECK_EQ(align, TextAlign::kRight);
+      x -= width;
+    }
   }
-  auto sk_paint = flags->ToSkPaint();
+  canvas->drawText(text.c_str(), text.length(), x, y, *paint);
 
-  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);
+  paint->setAntiAlias(anti_alias);
 }
 
-void HeadsUpDisplayLayerImpl::DrawText(PaintCanvas* canvas,
-                                       PaintFlags* flags,
+void HeadsUpDisplayLayerImpl::DrawText(SkCanvas* canvas,
+                                       SkPaint* paint,
                                        const std::string& text,
                                        TextAlign align,
                                        int size,
                                        const SkPoint& pos) const {
-  DrawText(canvas, flags, text, align, size, pos.x(), pos.y());
+  DrawText(canvas, paint, text, align, size, pos.x(), pos.y());
 }
 
-void HeadsUpDisplayLayerImpl::DrawGraphBackground(PaintCanvas* canvas,
-                                                  PaintFlags* flags,
+void HeadsUpDisplayLayerImpl::DrawGraphBackground(SkCanvas* canvas,
+                                                  SkPaint* paint,
                                                   const SkRect& bounds) const {
-  flags->setColor(DebugColors::HUDBackgroundColor());
-  canvas->drawRect(bounds, *flags);
+  paint->setColor(DebugColors::HUDBackgroundColor());
+  canvas->drawRect(bounds, *paint);
 }
 
-void HeadsUpDisplayLayerImpl::DrawGraphLines(PaintCanvas* canvas,
-                                             PaintFlags* flags,
+void HeadsUpDisplayLayerImpl::DrawGraphLines(SkCanvas* canvas,
+                                             SkPaint* paint,
                                              const SkRect& bounds,
                                              const Graph& graph) const {
   // Draw top and bottom line.
-  flags->setColor(DebugColors::HUDSeparatorLineColor());
-  canvas->drawLine(bounds.left(), bounds.top() - 1, bounds.right(),
-                   bounds.top() - 1, *flags);
-  canvas->drawLine(bounds.left(), bounds.bottom(), bounds.right(),
-                   bounds.bottom(), *flags);
+  paint->setColor(DebugColors::HUDSeparatorLineColor());
+  canvas->drawLine(bounds.left(),
+                   bounds.top() - 1,
+                   bounds.right(),
+                   bounds.top() - 1,
+                   *paint);
+  canvas->drawLine(
+      bounds.left(), bounds.bottom(), bounds.right(), bounds.bottom(), *paint);
 
   // Draw indicator line (additive blend mode to increase contrast when drawn on
   // top of graph).
-  flags->setColor(DebugColors::HUDIndicatorLineColor());
-  flags->setBlendMode(SkBlendMode::kPlus);
+  paint->setColor(DebugColors::HUDIndicatorLineColor());
+  paint->setBlendMode(SkBlendMode::kPlus);
   const double indicator_top =
       bounds.height() * (1.0 - graph.indicator / graph.current_upper_bound) -
       1.0;
-  canvas->drawLine(bounds.left(), bounds.top() + indicator_top, bounds.right(),
-                   bounds.top() + indicator_top, *flags);
-  flags->setBlendMode(SkBlendMode::kSrcOver);
+  canvas->drawLine(bounds.left(),
+                   bounds.top() + indicator_top,
+                   bounds.right(),
+                   bounds.top() + indicator_top,
+                   *paint);
+  paint->setBlendMode(SkBlendMode::kSrcOver);
 }
 
 SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay(
-    PaintCanvas* canvas,
+    SkCanvas* canvas,
     const FrameRateCounter* fps_counter,
     int right,
     int top) const {
@@ -682,8 +595,8 @@ SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay(
   int left = bounds().width() - width - right;
   SkRect area = SkRect::MakeXYWH(left, top, width, height);
 
-  PaintFlags flags = CreatePaintFlags();
-  DrawGraphBackground(canvas, &flags, area);
+  SkPaint paint = CreatePaint();
+  DrawGraphBackground(canvas, &paint, area);
 
   SkRect title_bounds = SkRect::MakeXYWH(
       left + kPadding, top + kPadding, kGraphWidth + kHistogramWidth + kGap + 2,
@@ -708,17 +621,17 @@ SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay(
 
   VLOG(1) << value_text;
 
-  flags.setColor(DebugColors::HUDTitleColor());
-  DrawText(canvas, &flags, title, TextAlign::kLeft, kTitleFontHeight,
+  paint.setColor(DebugColors::HUDTitleColor());
+  DrawText(canvas, &paint, title, TextAlign::kLeft, kTitleFontHeight,
            title_bounds.left(), title_bounds.bottom());
 
-  flags.setColor(DebugColors::FPSDisplayTextAndGraphColor());
-  DrawText(canvas, &flags, value_text, TextAlign::kLeft, kFontHeight,
+  paint.setColor(DebugColors::FPSDisplayTextAndGraphColor());
+  DrawText(canvas, &paint, value_text, TextAlign::kLeft, kFontHeight,
            text_bounds.left(), text_bounds.bottom());
-  DrawText(canvas, &flags, min_max_text, TextAlign::kRight, kFontHeight,
+  DrawText(canvas, &paint, min_max_text, TextAlign::kRight, kFontHeight,
            text_bounds.right(), text_bounds.bottom());
 
-  DrawGraphLines(canvas, &flags, graph_bounds, fps_graph_);
+  DrawGraphLines(canvas, &paint, graph_bounds, fps_graph_);
 
   // Collect graph and histogram data.
   SkPath path;
@@ -761,15 +674,19 @@ SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay(
   }
 
   // Draw FPS histogram.
-  flags.setColor(DebugColors::HUDSeparatorLineColor());
-  canvas->drawLine(histogram_bounds.left() - 1, histogram_bounds.top() - 1,
-                   histogram_bounds.left() - 1, histogram_bounds.bottom() + 1,
-                   flags);
-  canvas->drawLine(histogram_bounds.right() + 1, histogram_bounds.top() - 1,
-                   histogram_bounds.right() + 1, histogram_bounds.bottom() + 1,
-                   flags);
-
-  flags.setColor(DebugColors::FPSDisplayTextAndGraphColor());
+  paint.setColor(DebugColors::HUDSeparatorLineColor());
+  canvas->drawLine(histogram_bounds.left() - 1,
+                   histogram_bounds.top() - 1,
+                   histogram_bounds.left() - 1,
+                   histogram_bounds.bottom() + 1,
+                   paint);
+  canvas->drawLine(histogram_bounds.right() + 1,
+                   histogram_bounds.top() - 1,
+                   histogram_bounds.right() + 1,
+                   histogram_bounds.bottom() + 1,
+                   paint);
+
+  paint.setColor(DebugColors::FPSDisplayTextAndGraphColor());
   const double bar_height = histogram_bounds.height() / kHistogramSize;
 
   for (int i = kHistogramSize - 1; i >= 0; --i) {
@@ -779,21 +696,22 @@ SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay(
       canvas->drawRect(
           SkRect::MakeXYWH(histogram_bounds.left(),
                            histogram_bounds.bottom() - (i + 1) * bar_height,
-                           bar_width, 1),
-          flags);
+                           bar_width,
+                           1),
+          paint);
     }
   }
 
   // Draw FPS graph.
-  flags.setAntiAlias(true);
-  flags.setStyle(PaintFlags::kStroke_Style);
-  flags.setStrokeWidth(1);
-  canvas->drawPath(path, flags);
+  paint.setAntiAlias(true);
+  paint.setStyle(SkPaint::kStroke_Style);
+  paint.setStrokeWidth(1);
+  canvas->drawPath(path, paint);
 
   return area;
 }
 
-SkRect HeadsUpDisplayLayerImpl::DrawMemoryDisplay(PaintCanvas* canvas,
+SkRect HeadsUpDisplayLayerImpl::DrawMemoryDisplay(SkCanvas* canvas,
                                                   int right,
                                                   int top,
                                                   int width) const {
@@ -807,8 +725,8 @@ SkRect HeadsUpDisplayLayerImpl::DrawMemoryDisplay(PaintCanvas* canvas,
 
   const double kMegabyte = 1024.0 * 1024.0;
 
-  PaintFlags flags = CreatePaintFlags();
-  DrawGraphBackground(canvas, &flags, area);
+  SkPaint paint = CreatePaint();
+  DrawGraphBackground(canvas, &paint, area);
 
   SkPoint title_pos =
       SkPoint::Make(left + kPadding, top + kFontHeight + kPadding);
@@ -817,32 +735,31 @@ SkRect HeadsUpDisplayLayerImpl::DrawMemoryDisplay(PaintCanvas* canvas,
   SkPoint stat2_pos = SkPoint::Make(left + width - kPadding - 1,
                                     top + 2 * kPadding + 3 * kFontHeight);
 
-  flags.setColor(DebugColors::HUDTitleColor());
-  DrawText(canvas, &flags, "GPU Memory", TextAlign::kLeft, kTitleFontHeight,
+  paint.setColor(DebugColors::HUDTitleColor());
+  DrawText(canvas, &paint, "GPU Memory", TextAlign::kLeft, kTitleFontHeight,
            title_pos);
 
-  flags.setColor(DebugColors::MemoryDisplayTextColor());
+  paint.setColor(DebugColors::MemoryDisplayTextColor());
   std::string text = base::StringPrintf(
       "%6.1f MB used", memory_entry_.total_bytes_used / kMegabyte);
-  DrawText(canvas, &flags, text, TextAlign::kRight, kFontHeight, stat1_pos);
+  DrawText(canvas, &paint, text, TextAlign::kRight, kFontHeight, stat1_pos);
 
   if (!memory_entry_.had_enough_memory)
-    flags.setColor(SK_ColorRED);
+    paint.setColor(SK_ColorRED);
   text = base::StringPrintf("%6.1f MB max ",
                             memory_entry_.total_budget_in_bytes / kMegabyte);
-
-  DrawText(canvas, &flags, text, TextAlign::kRight, kFontHeight, stat2_pos);
+  DrawText(canvas, &paint, text, TextAlign::kRight, kFontHeight, stat2_pos);
 
   // Draw memory graph.
   int length = 2 * kFontHeight + kPadding + 12;
   SkRect oval =
       SkRect::MakeXYWH(left + kPadding * 6,
                        top + kTitleFontHeight + kPadding * 3, length, length);
-  flags.setAntiAlias(true);
-  flags.setStyle(PaintFlags::kFill_Style);
+  paint.setAntiAlias(true);
+  paint.setStyle(SkPaint::kFill_Style);
 
-  flags.setColor(SkColorSetARGB(64, 255, 255, 0));
-  DrawArc(canvas, oval, 180, 180, flags);
+  paint.setColor(SkColorSetARGB(64, 255, 255, 0));
+  canvas->drawArc(oval, 180, 180, true, paint);
 
   int radius = length / 2;
   int cx = oval.left() + radius;
@@ -856,25 +773,24 @@ SkRect HeadsUpDisplayLayerImpl::DrawMemoryDisplay(PaintCanvas* canvas,
   const SkScalar pos[] = {SkFloatToScalar(0.2f), SkFloatToScalar(0.4f),
                           SkFloatToScalar(0.6f), SkFloatToScalar(0.8f),
                           SkFloatToScalar(1.0f)};
-  flags.setShader(PaintShader::MakeSweepGradient(
-      cx, cy, colors, pos, 5, SkShader::kClamp_TileMode, 0, 360));
-  flags.setAntiAlias(true);
+  paint.setShader(SkGradientShader::MakeSweep(cx, cy, colors, pos, 5));
+  paint.setFlags(SkPaint::kAntiAlias_Flag);
 
   // Draw current status.
-  flags.setStyle(PaintFlags::kStroke_Style);
-  flags.setAlpha(32);
-  flags.setStrokeWidth(4);
-  DrawArc(canvas, oval, 180, angle, flags);
+  paint.setStyle(SkPaint::kStroke_Style);
+  paint.setAlpha(32);
+  paint.setStrokeWidth(4);
+  canvas->drawArc(oval, 180, angle, true, paint);
 
-  flags.setStyle(PaintFlags::kFill_Style);
-  flags.setColor(SkColorSetARGB(255, 0, 255, 0));
-  DrawArc(canvas, oval, 180, angle, flags);
-  flags.setShader(nullptr);
+  paint.setStyle(SkPaint::kFill_Style);
+  paint.setColor(SkColorSetARGB(255, 0, 255, 0));
+  canvas->drawArc(oval, 180, angle, true, paint);
+  paint.setShader(nullptr);
 
   return area;
 }
 
-SkRect HeadsUpDisplayLayerImpl::DrawGpuRasterizationStatus(PaintCanvas* canvas,
+SkRect HeadsUpDisplayLayerImpl::DrawGpuRasterizationStatus(SkCanvas* canvas,
                                                            int right,
                                                            int top,
                                                            int width) const {
@@ -914,24 +830,24 @@ SkRect HeadsUpDisplayLayerImpl::DrawGpuRasterizationStatus(PaintCanvas* canvas,
   const int left = bounds().width() - width - right;
   const SkRect area = SkRect::MakeXYWH(left, top, width, height);
 
-  PaintFlags flags = CreatePaintFlags();
-  DrawGraphBackground(canvas, &flags, area);
+  SkPaint paint = CreatePaint();
+  DrawGraphBackground(canvas, &paint, area);
 
   SkPoint gpu_status_pos = SkPoint::Make(left + width - kPadding,
                                          top + 2 * kFontHeight + 2 * kPadding);
-  flags.setColor(DebugColors::HUDTitleColor());
-  DrawText(canvas, &flags, "GPU Raster", TextAlign::kLeft, kTitleFontHeight,
+  paint.setColor(DebugColors::HUDTitleColor());
+  DrawText(canvas, &paint, "GPU Raster", TextAlign::kLeft, kTitleFontHeight,
            left + kPadding, top + kFontHeight + kPadding);
-  flags.setColor(color);
-  DrawText(canvas, &flags, status, TextAlign::kRight, kFontHeight,
+  paint.setColor(color);
+  DrawText(canvas, &paint, status, TextAlign::kRight, kFontHeight,
            gpu_status_pos);
 
   return area;
 }
 
 void HeadsUpDisplayLayerImpl::DrawDebugRect(
-    PaintCanvas* canvas,
-    PaintFlags* flags,
+    SkCanvas* canvas,
+    SkPaint* paint,
     const DebugRect& rect,
     SkColor stroke_color,
     SkColor fill_color,
@@ -942,14 +858,14 @@ void HeadsUpDisplayLayerImpl::DrawDebugRect(
       gfx::ScaleToEnclosingRect(rect.rect, 1.0 / internal_contents_scale_,
                                 1.0 / internal_contents_scale_);
   SkIRect sk_rect = RectToSkIRect(debug_layer_rect);
-  flags->setColor(fill_color);
-  flags->setStyle(PaintFlags::kFill_Style);
-  canvas->drawIRect(sk_rect, *flags);
+  paint->setColor(fill_color);
+  paint->setStyle(SkPaint::kFill_Style);
+  canvas->drawIRect(sk_rect, *paint);
 
-  flags->setColor(stroke_color);
-  flags->setStyle(PaintFlags::kStroke_Style);
-  flags->setStrokeWidth(SkFloatToScalar(stroke_width));
-  canvas->drawIRect(sk_rect, *flags);
+  paint->setColor(stroke_color);
+  paint->setStyle(SkPaint::kStroke_Style);
+  paint->setStrokeWidth(SkFloatToScalar(stroke_width));
+  canvas->drawIRect(sk_rect, *paint);
 
   if (label_text.length()) {
     const int kFontHeight = 12;
@@ -965,29 +881,33 @@ void HeadsUpDisplayLayerImpl::DrawDebugRect(
     canvas->clipRect(sk_clip_rect);
     canvas->translate(sk_clip_rect.x(), sk_clip_rect.y());
 
-    PaintFlags label_flags = CreatePaintFlags();
-    label_flags.setTextSize(kFontHeight);
-    label_flags.setTypeface(typeface_);
-    label_flags.setColor(stroke_color);
+    SkPaint label_paint = CreatePaint();
+    label_paint.setTextSize(kFontHeight);
+    label_paint.setTypeface(typeface_);
+    label_paint.setColor(stroke_color);
 
-    const SkScalar label_text_width = label_flags.ToSkPaint().measureText(
-        label_text.c_str(), label_text.length());
+    const SkScalar label_text_width =
+        label_paint.measureText(label_text.c_str(), label_text.length());
     canvas->drawRect(SkRect::MakeWH(label_text_width + 2 * kPadding,
                                     kFontHeight + 2 * kPadding),
-                     label_flags);
+                     label_paint);
+
+    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();
   }
 }
 
 void HeadsUpDisplayLayerImpl::DrawDebugRects(
-    PaintCanvas* canvas,
+    SkCanvas* canvas,
     DebugRectHistory* debug_rect_history) {
-  PaintFlags flags = CreatePaintFlags();
+  SkPaint paint = CreatePaint();
 
   const std::vector<DebugRect>& debug_rects = debug_rect_history->debug_rects();
   std::vector<DebugRect> new_paint_rects;
@@ -1050,8 +970,13 @@ void HeadsUpDisplayLayerImpl::DrawDebugRects(
         break;
     }
 
-    DrawDebugRect(canvas, &flags, debug_rects[i], stroke_color, fill_color,
-                  stroke_width, label_text);
+    DrawDebugRect(canvas,
+                  &paint,
+                  debug_rects[i],
+                  stroke_color,
+                  fill_color,
+                  stroke_width,
+                  label_text);
   }
 
   if (new_paint_rects.size()) {
@@ -1061,10 +986,13 @@ void HeadsUpDisplayLayerImpl::DrawDebugRects(
   if (fade_step_ > 0) {
     fade_step_--;
     for (size_t i = 0; i < paint_rects_.size(); ++i) {
-      DrawDebugRect(canvas, &flags, paint_rects_[i],
+      DrawDebugRect(canvas,
+                    &paint,
+                    paint_rects_[i],
                     DebugColors::PaintRectBorderColor(fade_step_),
                     DebugColors::PaintRectFillColor(fade_step_),
-                    DebugColors::PaintRectBorderWidth(), "");
+                    DebugColors::PaintRectBorderWidth(),
+                    "");
     }
   }
 }

cc/layers/heads_up_display_layer_impl.h

@@ -14,12 +14,13 @@
 #include "base/time/time.h"
 #include "cc/cc_export.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/resource_pool.h"
 #include "cc/trees/debug_rect_history.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 
+class SkCanvas;
+class SkPaint;
 class SkTypeface;
 struct SkRect;
 
@@ -30,8 +31,6 @@ class ClientResourceProvider;
 namespace cc {
 class FrameRateCounter;
 class LayerTreeFrameSink;
-class PaintCanvas;
-class PaintFlags;
 
 enum class TextAlign { kLeft, kCenter, kRight };
 
@@ -96,49 +95,50 @@ class CC_EXPORT HeadsUpDisplayLayerImpl : public LayerImpl {
   void AsValueInto(base::trace_event::TracedValue* dict) const override;
 
   void UpdateHudContents();
-  void DrawHudContents(PaintCanvas* canvas);
-  void DrawText(PaintCanvas* canvas,
-                PaintFlags* flags,
+  void DrawHudContents(SkCanvas* canvas);
+
+  int MeasureText(SkPaint* paint, const std::string& text, int size) const;
+  void DrawText(SkCanvas* canvas,
+                SkPaint* paint,
                 const std::string& text,
                 TextAlign align,
                 int size,
                 int x,
                 int y) const;
-  void DrawText(PaintCanvas* canvas,
-                PaintFlags* flags,
+  void DrawText(SkCanvas* canvas,
+                SkPaint* paint,
                 const std::string& text,
                 TextAlign align,
                 int size,
                 const SkPoint& pos) const;
-  void DrawGraphBackground(PaintCanvas* canvas,
-                           PaintFlags* flags,
+  void DrawGraphBackground(SkCanvas* canvas,
+                           SkPaint* paint,
                            const SkRect& bounds) const;
-  void DrawGraphLines(PaintCanvas* canvas,
-                      PaintFlags* flags,
+  void DrawGraphLines(SkCanvas* canvas,
+                      SkPaint* paint,
                       const SkRect& bounds,
                       const Graph& graph) const;
 
-  SkRect DrawFPSDisplay(PaintCanvas* canvas,
+  SkRect DrawFPSDisplay(SkCanvas* canvas,
                         const FrameRateCounter* fps_counter,
                         int right,
                         int top) const;
-  SkRect DrawMemoryDisplay(PaintCanvas* canvas,
+  SkRect DrawMemoryDisplay(SkCanvas* canvas,
                            int top,
                            int right,
                            int width) const;
-  SkRect DrawGpuRasterizationStatus(PaintCanvas* canvas,
+  SkRect DrawGpuRasterizationStatus(SkCanvas* canvas,
                                     int right,
                                     int top,
                                     int width) const;
-  void DrawDebugRect(PaintCanvas* canvas,
-                     PaintFlags* flags,
+  void DrawDebugRect(SkCanvas* canvas,
+                     SkPaint* paint,
                      const DebugRect& rect,
                      SkColor stroke_color,
                      SkColor fill_color,
                      float stroke_width,
                      const std::string& label_text) const;
-  void DrawDebugRects(PaintCanvas* canvas,
-                      DebugRectHistory* debug_rect_history);
+  void DrawDebugRects(SkCanvas* canvas, DebugRectHistory* debug_rect_history);
 
   ResourcePool::InUsePoolResource in_flight_resource_;
   std::unique_ptr<ResourcePool> pool_;
@@ -159,9 +159,6 @@ class CC_EXPORT HeadsUpDisplayLayerImpl : public LayerImpl {
 
   base::TimeTicks time_of_last_graph_update_;
 
-  // color space for OOPR
-  const RasterColorSpace raster_color_space_;
-
   DISALLOW_COPY_AND_ASSIGN(HeadsUpDisplayLayerImpl);
 };