Skip drawing unsupported layers in forced software mode

cc/layers/layer_impl.cc

 // Copyright 2011 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_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/stringprintf.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/scrollbar_animation_controller.h"
@@ skipping 37 matching lines @@
       contents_opaque_(false),
       opacity_(1.0),
       preserves_3d_(false),
       use_parent_backface_visibility_(false),
       draw_checkerboard_for_missing_tiles_(false),
       draws_content_(false),
       force_render_surface_(false),
       is_container_for_fixed_position_layers_(false),
       draw_depth_(0.f),
       compositing_reasons_(kCompositingReasonUnknown),
-#ifndef NDEBUG
-      between_will_draw_and_did_draw_(false),
-#endif
+      current_draw_mode_(DRAW_MODE_NONE),
       horizontal_scrollbar_layer_(NULL),
       vertical_scrollbar_layer_(NULL) {
   DCHECK_GT(layer_id_, 0);
   DCHECK(layer_tree_impl_);
   layer_tree_impl_->RegisterLayer(this);
   AnimationRegistrar* registrar = layer_tree_impl_->animationRegistrar();
   layer_animation_controller_ =
       registrar->GetAnimationControllerForId(layer_id_);
   layer_animation_controller_->AddValueObserver(this);
 }
 
 LayerImpl::~LayerImpl() {
-#ifndef NDEBUG
-  DCHECK(!between_will_draw_and_did_draw_);
-#endif
+  DCHECK_EQ(DRAW_MODE_NONE, current_draw_mode_);
 
   layer_tree_impl_->UnregisterLayer(this);
   layer_animation_controller_->RemoveValueObserver(this);
 }
 
 void LayerImpl::AddChild(scoped_ptr<LayerImpl> child) {
   child->set_parent(this);
   DCHECK_EQ(layer_tree_impl(), child->layer_tree_impl());
   children_.push_back(child.Pass());
   layer_tree_impl()->set_needs_update_draw_properties();
@@ skipping 54 matching lines @@
   scoped_ptr<SharedQuadState> state = SharedQuadState::Create();
   state->SetAll(draw_properties_.target_space_transform,
                 draw_properties_.content_bounds,
                 draw_properties_.visible_content_rect,
                 draw_properties_.clip_rect,
                 draw_properties_.is_clipped,
                 draw_properties_.opacity);
   return state.Pass();
 }
 
-void LayerImpl::WillDraw(ResourceProvider* resource_provider) {
-#ifndef NDEBUG
+bool LayerImpl::WillDraw(DrawMode draw_mode,
+                         ResourceProvider* resource_provider) {
   // WillDraw/DidDraw must be matched.
-  DCHECK(!between_will_draw_and_did_draw_);
-  between_will_draw_and_did_draw_ = true;
-#endif
+  DCHECK_NE(DRAW_MODE_NONE, draw_mode);
+  DCHECK_EQ(DRAW_MODE_NONE, current_draw_mode_);
+  current_draw_mode_ = draw_mode;
+  return true;
 }
 
 void LayerImpl::DidDraw(ResourceProvider* resource_provider) {
-#ifndef NDEBUG
-  DCHECK(between_will_draw_and_did_draw_);
-  between_will_draw_and_did_draw_ = false;
-#endif
+  DCHECK_NE(DRAW_MODE_NONE, current_draw_mode_);
+  current_draw_mode_ = DRAW_MODE_NONE;
 }
 
 bool LayerImpl::ShowDebugBorders() const {
   return layer_tree_impl()->debug_state().show_debug_borders;
 }
 
 void LayerImpl::GetDebugBorderProperties(SkColor* color, float* width) const {
   if (draws_content_) {
     *color = DebugColors::ContentLayerBorderColor();
     *width = DebugColors::ContentLayerBorderWidth(layer_tree_impl());
@@ skipping 979 matching lines @@
 
 size_t LayerImpl::GPUMemoryUsageInBytes() const { return 0; }
 
 scoped_ptr<base::Value> LayerImpl::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   AsValueInto(state.get());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc