cc: HUD handle context lost in Gpu raster.

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>
@@ skipping 59 matching lines @@
   current_upper_bound += (target_upper_bound - current_upper_bound) * 0.5;
   return current_upper_bound;
 }
 
 HeadsUpDisplayLayerImpl::HeadsUpDisplayLayerImpl(LayerTreeImpl* tree_impl,
                                                  int id)
     : LayerImpl(tree_impl, id),
       internal_contents_scale_(1.f),
       fps_graph_(60.0, 80.0),
       paint_time_graph_(16.0, 48.0),
-      fade_step_(0) {
-}
+      fade_step_(0) {}
 
 HeadsUpDisplayLayerImpl::~HeadsUpDisplayLayerImpl() {}
 
 std::unique_ptr<LayerImpl> HeadsUpDisplayLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return HeadsUpDisplayLayerImpl::Create(tree_impl, id());
 }
 
 void HeadsUpDisplayLayerImpl::AcquireResource(
     ResourceProvider* resource_provider) {
@@ skipping 59 matching lines @@
   bool nearest_neighbor = false;
   TextureDrawQuad* quad =
       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(
+uint32_t HeadsUpDisplayLayerImpl::UpdateHudTexture(

[vmpstr, 2017/06/30 23:16:51]

The actual return type is ResourceId (even though it's just a typedef). I think
we should still use that.

[sohan, 2017/07/04 16:51:13]

Done.

     DrawMode draw_mode,
     ResourceProvider* resource_provider,
     ContextProvider* context_provider) {
   if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE || !resources_.back()->id())
-    return;
+    return 0U;
 
   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);
 
     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);
+    if (!scoped_surface.sk_surface())
+      return resources_.back()->id();

[vmpstr, 2017/06/30 23:16:51]

Should we be somehow cleaning up resources_ if things are no longer valid?

[sohan, 2017/07/04 16:51:12]

Hmm. we are in ScopedWriteLockGL scope here, so if we delete the ScopedResource
from vector it will free itself and dcheck for lock for write in
ResourceProvider::DeleteResource.
Wouldnt scope take care of it implicitly ?

     SkCanvas* gpu_raster_canvas = scoped_surface.sk_surface()->getCanvas();
     TRACE_EVENT_END0("cc", "CreateHudCanvas");
 
     UpdateHudContents();
 
     DrawHudContents(gpu_raster_canvas);
 
     TRACE_EVENT_BEGIN0("cc", "UploadHudTexture");
     const uint64_t fence = gl->InsertFenceSyncCHROMIUM();
     gl->OrderingBarrierCHROMIUM();
@@ skipping 25 matching lines @@
     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());
   }
+
+  return 0U;
 }
 
 void HeadsUpDisplayLayerImpl::ReleaseResources() {
   resources_.clear();
 }
 
 gfx::Rect HeadsUpDisplayLayerImpl::GetEnclosingRectInTargetSpace() const {
   DCHECK_GT(internal_contents_scale_, 0.f);
   return GetScaledEnclosingRectInTargetSpace(internal_contents_scale_);
 }
@@ skipping 587 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