cc: Use gpu raster in HUD.

cc/layers/heads_up_display_layer_impl.cc

 // Copyright 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 "cc/layers/heads_up_display_layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "base/numerics/safe_conversions.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/quads/texture_draw_quad.h"
+#include "cc/raster/scoped_gpu_raster.h"
 #include "cc/resources/memory_history.h"
 #include "cc/trees/frame_rate_counter.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
+#include "gpu/command_buffer/client/gles2_interface.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"
@@ skipping 53 matching lines @@
 void HeadsUpDisplayLayerImpl::AcquireResource(
     ResourceProvider* resource_provider) {
   for (auto& resource : resources_) {
     if (!resource_provider->InUseByConsumer(resource->id())) {
       resource.swap(resources_.back());
       return;
     }
   }
 
   auto resource = base::MakeUnique<ScopedResource>(resource_provider);
-  resource->Allocate(
-      internal_content_bounds_, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
-      resource_provider->best_texture_format(), gfx::ColorSpace());
+  resource->Allocate(internal_content_bounds_,
+                     ResourceProvider::TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER,
+                     resource_provider->best_render_buffer_format(),
+                     gfx::ColorSpace());
   resources_.push_back(std::move(resource));
 }
 
 void HeadsUpDisplayLayerImpl::ReleaseUnmatchedSizeResources(
     ResourceProvider* resource_provider) {
   base::EraseIf(resources_,
                 [this](const std::unique_ptr<ScopedResource>& resource) {
                   return internal_content_bounds_ != resource->size();
                 });
 }
@@ skipping 39 matching lines @@
       render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   quad->SetNew(shared_quad_state, quad_rect, opaque_rect, visible_quad_rect,
                resources_.back()->id(), premultiplied_alpha, uv_top_left,
                uv_bottom_right, SK_ColorTRANSPARENT, vertex_opacity, flipped,
                nearest_neighbor, false);
   ValidateQuadResources(quad);
 }
 
 void HeadsUpDisplayLayerImpl::UpdateHudTexture(
     DrawMode draw_mode,
-    ResourceProvider* resource_provider) {
+    ResourceProvider* resource_provider,
+    ContextProvider* context_provider) {
   if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE || !resources_.back()->id())
     return;
 
-  SkISize canvas_size;
-  if (hud_surface_)
-    canvas_size = hud_surface_->getCanvas()->getBaseLayerSize();
-  else
-    canvas_size.set(0, 0);
+  if (context_provider) {
+    gpu::gles2::GLES2Interface* gl = context_provider->ContextGL();
+    DCHECK(gl);
+    ScopedGpuRaster gpu_raster(context_provider);
+    bool using_worker_context = false;
+    ResourceProvider::ScopedWriteLockGL lock(
+        resource_provider, resources_.back()->id(), using_worker_context);
 
-  if (canvas_size.width() != internal_content_bounds_.width() ||
-      canvas_size.height() != internal_content_bounds_.height() ||
-      !hud_surface_) {
-    TRACE_EVENT0("cc", "ResizeHudCanvas");
+    TRACE_EVENT_BEGIN0("cc", "CreateHudCanvas");
+    bool use_distance_field_text = false;
+    bool can_use_lcd_text = false;
+    int msaa_sample_count = 0;
+    ResourceProvider::ScopedSkSurfaceProvider scoped_surface(
+        context_provider, &lock, using_worker_context, use_distance_field_text,
+        can_use_lcd_text, msaa_sample_count);
+    SkCanvas* gpu_raster_canvas = scoped_surface.sk_surface()->getCanvas();
+    TRACE_EVENT_END0("cc", "CreateHudCanvas");
 
-    hud_surface_ = SkSurface::MakeRasterN32Premul(
-        internal_content_bounds_.width(), internal_content_bounds_.height());
-  }
+    UpdateHudContents();
 
-  UpdateHudContents();
+    DrawHudContents(gpu_raster_canvas);
 
-  {
-    TRACE_EVENT0("cc", "DrawHudContents");
-    hud_surface_->getCanvas()->clear(SkColorSetARGB(0, 0, 0, 0));
-    hud_surface_->getCanvas()->save();
-    hud_surface_->getCanvas()->scale(internal_contents_scale_,
-                                     internal_contents_scale_);
+    TRACE_EVENT_BEGIN0("cc", "UploadHudTexture");
+    const uint64_t fence = gl->InsertFenceSyncCHROMIUM();
+    gl->OrderingBarrierCHROMIUM();
+    gpu::SyncToken sync_token;
+    gl->GenSyncTokenCHROMIUM(fence, sync_token.GetData());
+    lock.set_sync_token(sync_token);
+    lock.set_synchronized(true);

[ericrk, 2017/06/07 20:50:18]

Don't worry about it for this change, but I wonder if we could clean up some of
our code by moving this sync token generation logic into the ScopedWriteLockGL,
like have a bool needs_sync_token, which will run this on destruction?

Again, not for this change, just something that might clean things up later.

+    TRACE_EVENT_END0("cc", "UploadHudTexture");
+  } else {
+    SkISize canvas_size;
+    if (hud_surface_)
+      canvas_size = hud_surface_->getCanvas()->getBaseLayerSize();
+    else
+      canvas_size.set(0, 0);
+
+    if (canvas_size.width() != internal_content_bounds_.width() ||
+        canvas_size.height() != internal_content_bounds_.height() ||
+        !hud_surface_) {
+      TRACE_EVENT0("cc", "ResizeHudCanvas");
+
+      hud_surface_ = SkSurface::MakeRasterN32Premul(
+          internal_content_bounds_.width(), internal_content_bounds_.height());
+    }
+
+    UpdateHudContents();
 
     DrawHudContents(hud_surface_->getCanvas());
 
-    hud_surface_->getCanvas()->restore();
+    TRACE_EVENT0("cc", "UploadHudTexture");
+    SkPixmap pixmap;
+    hud_surface_->peekPixels(&pixmap);
+    DCHECK(pixmap.addr());
+    DCHECK(pixmap.info().colorType() == kN32_SkColorType);
+    resource_provider->CopyToResource(
+        resources_.back()->id(), static_cast<const uint8_t*>(pixmap.addr()),
+        internal_content_bounds_);
+    resource_provider->GenerateSyncTokenForResource(resources_.back()->id());
   }
-
-  TRACE_EVENT0("cc", "UploadHudTexture");
-  SkPixmap pixmap;
-  hud_surface_->peekPixels(&pixmap);
-  DCHECK(pixmap.addr());
-  DCHECK(pixmap.info().colorType() == kN32_SkColorType);
-  resource_provider->CopyToResource(resources_.back()->id(),
-                                    static_cast<const uint8_t*>(pixmap.addr()),
-                                    internal_content_bounds_);
-  resource_provider->GenerateSyncTokenForResource(resources_.back()->id());
 }
 
 void HeadsUpDisplayLayerImpl::ReleaseResources() {
   resources_.clear();
 }
 
 gfx::Rect HeadsUpDisplayLayerImpl::GetEnclosingRectInTargetSpace() const {
   DCHECK_GT(internal_contents_scale_, 0.f);
   return GetScaledEnclosingRectInTargetSpace(internal_contents_scale_);
 }
@@ skipping 39 matching lines @@
     }
   }
 
   fps_graph_.UpdateUpperBound();
   paint_time_graph_.UpdateUpperBound();
 }
 
 void HeadsUpDisplayLayerImpl::DrawHudContents(SkCanvas* canvas) {
   const LayerTreeDebugState& debug_state = layer_tree_impl()->debug_state();
 
+  TRACE_EVENT0("cc", "DrawHudContents");
+  canvas->clear(SkColorSetARGB(0, 0, 0, 0));
+  canvas->save();
+  canvas->scale(internal_contents_scale_, internal_contents_scale_);
+
   if (debug_state.ShowHudRects()) {
     DrawDebugRects(canvas, layer_tree_impl()->debug_rect_history());
     if (IsAnimatingHUDContents()) {
       layer_tree_impl()->SetNeedsRedraw();
     }
   }
 
-  if (!debug_state.show_fps_counter)
+  if (!debug_state.show_fps_counter) {
+    canvas->restore();
     return;
+  }
 
   SkRect area =
       DrawFPSDisplay(canvas, layer_tree_impl()->frame_rate_counter(), 0, 0);
   area = DrawGpuRasterizationStatus(canvas, 0, area.bottom(),
                                     SkMaxScalar(area.width(), 150));
 
   if (debug_state.ShowMemoryStats() && memory_entry_.total_bytes_used)
     DrawMemoryDisplay(canvas, 0, area.bottom(), SkMaxScalar(area.width(), 150));
+
+  canvas->restore();
 }
 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());
@@ skipping 502 matching lines @@
   return "cc::HeadsUpDisplayLayerImpl";
 }
 
 void HeadsUpDisplayLayerImpl::AsValueInto(
     base::trace_event::TracedValue* dict) const {
   LayerImpl::AsValueInto(dict);
   dict->SetString("layer_name", "Heads Up Display Layer");
 }
 
 }  // namespace cc