Skip drawing unsupported layers in forced software mode

cc/layers/layer_impl.h

 // 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.
 
 #ifndef CC_LAYERS_LAYER_IMPL_H_
 #define CC_LAYERS_LAYER_IMPL_H_
 
 #include <string>
 
 #include "base/logging.h"
@@ skipping 401 matching lines @@
   virtual bool CanClipSelf() const;
 
   virtual bool AreVisibleResourcesReady() const;
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl);
   virtual void PushPropertiesTo(LayerImpl* layer);
 
   scoped_ptr<base::Value> AsValue() const;
   virtual size_t GPUMemoryUsageInBytes() const;
 
+  virtual bool CanDrawInTilelessSoftwareMode() const;

[enne (OOO), 2013/05/30 17:04:37]

I am generally averse to yet more virtual boolean pseudo-RTTI functions on
LayerImpl, in part because it creates distance between the flag-checking code,
the code that's avoided, and this flag function itself.

I think I'd prefer making other layer types behave like PictureLayerImpl in that
you ask the layers and they make some decision to behave differently if needed.

What do you think about having WillDraw/AppendQuadsData take an explicit enum of
{ hardware, software, resourceless } and each layer type could do its best to
meet that request? WillDraw could even return a boolean to imply that the layer
can't support that mode.

That would also make testing easier.  You could have all layer types (there's a
test helper for this) crossed with all drawing modes so it'd be clear that all
layer types were safe in all modes.

+
  protected:
   LayerImpl(LayerTreeImpl* layer_impl, int id);
 
   // Get the color and size of the layer's debug border.
   virtual void GetDebugBorderProperties(SkColor* color, float* width) const;
 
   void AppendDebugBorderQuad(QuadSink* quad_sink,
                              const SharedQuadState* shared_quad_state,
                              AppendQuadsData* append_quads_data) const;
   void AppendDebugBorderQuad(QuadSink* quad_sink,
@@ skipping 123 matching lines @@
   // Group of properties that need to be computed based on the layer tree
   // hierarchy before layers can be drawn.
   DrawProperties<LayerImpl, RenderSurfaceImpl> draw_properties_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYERS_LAYER_IMPL_H_