HUD: Show first paint invalidation in red

cc/layers/layer.cc

 // Copyright 2010 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/layer.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/debug/trace_event.h"
@@ skipping 22 matching lines @@
 base::StaticAtomicSequenceNumber g_next_layer_id;
 
 scoped_refptr<Layer> Layer::Create() {
   return make_scoped_refptr(new Layer());
 }
 
 Layer::Layer()
     : needs_push_properties_(false),
       num_dependents_need_push_properties_(false),
       stacking_order_changed_(false),
+      includes_first_paint_invalidation_(false),
       // Layer IDs start from 1.
       layer_id_(g_next_layer_id.GetNext() + 1),
       ignore_set_needs_commit_(false),
       sorting_context_id_(0),
       parent_(NULL),
       layer_tree_host_(NULL),
       scroll_clip_layer_id_(INVALID_ID),
       num_descendants_that_draw_content_(0),
       should_scroll_on_main_thread_(false),
       have_wheel_event_handlers_(false),
@@ skipping 810 matching lines @@
                                         : bounds_);
   layer->SetContentBounds(content_bounds());
   layer->SetContentsScale(contents_scale_x(), contents_scale_y());
 
   bool is_tracing;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(
       TRACE_DISABLED_BY_DEFAULT("cc.debug") "," TRACE_DISABLED_BY_DEFAULT(
           "devtools.timeline.layers"),
       &is_tracing);
   if (is_tracing)
     layer->SetDebugInfo(TakeDebugInfo());

[chrishtr, 2014/08/20 04:28:56]

Let's extend the GraphicsLayerDebugInfo struct to include this information as
well, since it is used purely for debugging
purposes. That way there are no new API concepts that are outside of explicit
debugging.

 
   layer->SetDoubleSided(double_sided_);
   layer->SetDrawCheckerboardForMissingTiles(
       draw_checkerboard_for_missing_tiles_);
   layer->SetForceRenderSurface(force_render_surface_);
   layer->SetDrawsContent(DrawsContent());
   layer->SetHideLayerAndSubtree(hide_layer_and_subtree_);
   if (!layer->FilterIsAnimatingOnImplOnly() && !FilterIsAnimating())
     layer->SetFilters(filters_);
   DCHECK(!(FilterIsAnimating() && layer->FilterIsAnimatingOnImplOnly()));
@@ skipping 101 matching lines @@
   }
   copy_requests_.clear();
   layer->PassCopyRequests(&main_thread_copy_requests);
 
   // If the main thread commits multiple times before the impl thread actually
   // draws, then damage tracking will become incorrect if we simply clobber the
   // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
   // union) any update changes that have occurred on the main thread.
   update_rect_.Union(layer->update_rect());
   layer->SetUpdateRect(update_rect_);
+  layer->SetIncludesFirstPaintInvalidation(includes_first_paint_invalidation_);
+  includes_first_paint_invalidation_ = false;
 
   layer->SetStackingOrderChanged(stacking_order_changed_);
 
   layer_animation_controller_->PushAnimationUpdatesTo(
       layer->layer_animation_controller());
 
   // Reset any state that should be cleared for the next update.
   stacking_order_changed_ = false;
   update_rect_ = gfx::RectF();
 
@@ skipping 231 matching lines @@
 
 void Layer::RunMicroBenchmark(MicroBenchmark* benchmark) {
   benchmark->RunOnLayer(this);
 }
 
 bool Layer::HasDelegatedContent() const {
   return false;
 }
 
 }  // namespace cc