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(
+ResourceId HeadsUpDisplayLayerImpl::UpdateHudTexture(
     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();
     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 24 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_);
   }
+
+  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 576 matching lines @@
                     &paint,
                     paint_rects_[i],
                     DebugColors::PaintRectBorderColor(fade_step_),
                     DebugColors::PaintRectFillColor(fade_step_),
                     DebugColors::PaintRectBorderWidth(),
                     "");
     }
   }
 }
 
+void HeadsUpDisplayLayerImpl::EvictHudQuad(const RenderPassList& list) {
+  ResourceId evict_resource_id = resources_.back()->id();
+  // This iterates over the render pass list of quads to evict the hud quad
+  // appended during render pass preparation. We need this eviction when we
+  // have a context loss during SkSurface creation in UpdateHudTexture, and
+  // we early out without updating the Hud contents.
+  for (const auto& render_pass : list) {
+    for (auto it = render_pass->quad_list.begin();
+         it != render_pass->quad_list.end(); ++it) {
+      for (ResourceId resource_id : it->resources) {
+        if (resource_id == evict_resource_id) {
+          render_pass->quad_list.EraseAndInvalidateAllPointers(it);
+          return;
+        }
+      }
+    }
+  }
+}
+
 const char* HeadsUpDisplayLayerImpl::LayerTypeAsString() const {
   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