Use the solid color detection to create solid layers

cc/layers/picture_layer.h

 // 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.
 
 #ifndef CC_LAYERS_PICTURE_LAYER_H_
 #define CC_LAYERS_PICTURE_LAYER_H_
 
 #include "cc/base/invalidation_region.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/micro_benchmark_controller.h"
 #include "cc/layers/layer.h"
 #include "cc/resources/picture_pile.h"
 #include "cc/trees/occlusion_tracker.h"
 
 namespace cc {
 
 class ContentLayerClient;
 class ResourceUpdateQueue;
+class PictureLayerImpl;
 
 class CC_EXPORT PictureLayer : public Layer {
  public:
   static scoped_refptr<PictureLayer> Create(ContentLayerClient* client);
 
   void ClearClient();
 
   // Layer interface.
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(
       LayerTreeImpl* tree_impl) OVERRIDE;
@@ skipping 15 matching lines @@
 
   PicturePile* GetPicturePileForTesting() const { return pile_.get(); }
 
  protected:
   explicit PictureLayer(ContentLayerClient* client);
   virtual ~PictureLayer();
 
   virtual bool HasDrawableContent() const OVERRIDE;
   void UpdateCanUseLCDText();
 
+  virtual void SetSolidColorPropertiesTo(PictureLayerImpl* layer_impl) const;

[vmpstr, 2014/08/29 06:49:14]

Why virtual?

[hendrikw, 2014/08/29 14:03:21]

There are four tests in layer try host unit test which set
SetMaxTransferBufferUsageBytes, to some value, then tests against that value. 
Obviously now, when we play the layer, it gets detected as solid and doesn't
draw to any gles textures, so it never gets the chance to test the buffer usage
(it returns zero).  I'm using this as a way to override the solid color state
for the fake picture layer used in the test :/

[vmpstr, 2014/08/29 14:20:44]

Ah ok. Can you leave a "Virtual for testing." comment here?

[enne (OOO), 2014/08/29 16:53:43]

Virtual for testing.  :(

Can you make the fake picture layer not detected as solid in that test?

[hendrikw, 2014/09/02 14:19:17]

I found a way to do the same thing without the virtual

+
  private:
   ContentLayerClient* client_;
   scoped_refptr<PicturePile> pile_;
   devtools_instrumentation::
       ScopedLayerObjectTracker instrumentation_object_tracker_;
   // Invalidation to use the next time update is called.
   InvalidationRegion pending_invalidation_;
   // Invalidation from the last time update was called.
   Region pile_invalidation_;
   gfx::Rect last_updated_visible_content_rect_;
   bool is_mask_;
 
   int update_source_frame_number_;
   bool can_use_lcd_text_last_frame_;
 
   DISALLOW_COPY_AND_ASSIGN(PictureLayer);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYERS_PICTURE_LAYER_H_