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) {
+    context_provider->DetachFromThread();
+    std::unique_ptr<ContextCacheController::ScopedBusy> busy =

[ericrk, 2017/06/06 20:22:25]

I wouldn't expect to need this DetachFromThread or ScopedBusy - I don't believe
we use these on the main context provider (just the worker context provider).

Given that the main context provider is not threadsafe, I'd be a bit worried if
we needed to detachfromthread. Can these lines just be removed?

[sohan, 2017/06/07 13:31:11]

Done.

Yes, this was a little over engineering in main context.

+        context_provider->CacheController()->ClientBecameBusy();
+    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();
+
+    TRACE_EVENT_BEGIN0("cc", "DrawHudContents");
+    gpu_raster_canvas->clear(SkColorSetARGB(0, 0, 0, 0));

[ericrk, 2017/06/06 20:22:25]

Can we just move the Trace, clear, save, scale, and following restore to within
DrawHudContents? this would avoid the duplication in both branch of the if
statement.

[sohan, 2017/06/07 13:31:11]

Done.

Thanks, this does make the code look better !

+    gpu_raster_canvas->save();
+    gpu_raster_canvas->scale(internal_contents_scale_,
+                             internal_contents_scale_);
+    DrawHudContents(gpu_raster_canvas);
+    gpu_raster_canvas->restore();
+    TRACE_EVENT_END0("cc", "DrawHudContents");
+
+    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);
+    TRACE_EVENT_END0("cc", "UploadHudTexture");
+
+    context_provider->CacheController()->ClientBecameNotBusy(std::move(busy));
+    context_provider->DetachFromThread();

[ericrk, 2017/06/06 20:22:25]

See comment above - Drop these lines if possible... 

[sohan, 2017/06/07 13:31:11]

Done.

+  } 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();
+
+    {
+      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_);
+
+      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());
   }
-
-  UpdateHudContents();
-
-  {
-    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_);
-
-    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());
 }
 
 void HeadsUpDisplayLayerImpl::ReleaseResources() {
   resources_.clear();
 }
 
 gfx::Rect HeadsUpDisplayLayerImpl::GetEnclosingRectInTargetSpace() const {
   DCHECK_GT(internal_contents_scale_, 0.f);
   return GetScaledEnclosingRectInTargetSpace(internal_contents_scale_);
 }
@@ skipping 578 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