1 // Copyright 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CC_TEST_TILED_LAYER_TEST_COMMON_H_ 6 #define CC_TEST_TILED_LAYER_TEST_COMMON_H_ 7 8 #include "cc/base/region.h" 9 #include "cc/layers/tiled_layer.h" 10 #include "cc/layers/tiled_layer_impl.h" 11 #include "cc/resources/layer_updater.h" 12 #include "cc/resources/prioritized_resource.h" 13 #include "cc/resources/resource_provider.h" 14 #include "cc/resources/resource_update_queue.h" 15 #include "ui/gfx/rect.h" 16 #include "ui/gfx/size.h" 17 18 namespace cc { 19 20 class FakeTiledLayer; 21 22 class FakeLayerUpdater : public LayerUpdater { 23 public: 24 class Resource : public LayerUpdater::Resource { 25 public: 26 Resource(FakeLayerUpdater* updater, 27 scoped_ptr<PrioritizedResource> resource); 28 virtual ~Resource(); 29 30 virtual void Update(ResourceUpdateQueue* queue, 31 const gfx::Rect& source_rect, 32 const gfx::Vector2d& dest_offset, 33 bool partial_update) OVERRIDE; 34 35 private: 36 FakeLayerUpdater* layer_; 37 SkBitmap bitmap_; 38 39 DISALLOW_COPY_AND_ASSIGN(Resource); 40 }; 41 42 FakeLayerUpdater(); 43 44 virtual scoped_ptr<LayerUpdater::Resource> CreateResource( 45 PrioritizedResourceManager* resource) OVERRIDE; 46 47 virtual void PrepareToUpdate(const gfx::Size& content_size, 48 const gfx::Rect& paint_rect, 49 const gfx::Size& tile_size, 50 float contents_width_scale, 51 float contents_height_scale) OVERRIDE; 52 // Sets the rect to invalidate during the next call to PrepareToUpdate(). 53 // After the next call to PrepareToUpdate() the rect is reset. 54 void SetRectToInvalidate(const gfx::Rect& rect, FakeTiledLayer* layer); 55 // Last rect passed to PrepareToUpdate(). 56 gfx::Rect last_update_rect() const { return last_update_rect_; } 57 58 // Value of |contents_width_scale| last passed to PrepareToUpdate(). 59 float last_contents_width_scale() const { return last_contents_width_scale_; } 60 61 // Number of times PrepareToUpdate has been invoked. 62 int prepare_count() const { return prepare_count_; } 63 void ClearPrepareCount() { prepare_count_ = 0; } 64 65 // Number of times Update() has been invoked on a texture. 66 int update_count() const { return update_count_; } 67 void ClearUpdateCount() { update_count_ = 0; } 68 void Update() { update_count_++; } 69 70 protected: 71 virtual ~FakeLayerUpdater(); 72 73 private: 74 int prepare_count_; 75 int update_count_; 76 gfx::Rect rect_to_invalidate_; 77 gfx::Rect last_update_rect_; 78 float last_contents_width_scale_; 79 scoped_refptr<FakeTiledLayer> layer_; 80 81 DISALLOW_COPY_AND_ASSIGN(FakeLayerUpdater); 82 }; 83 84 class FakeTiledLayerImpl : public TiledLayerImpl { 85 public: 86 FakeTiledLayerImpl(LayerTreeImpl* tree_impl, int id); 87 virtual ~FakeTiledLayerImpl(); 88 89 using TiledLayerImpl::HasTileAt; 90 using TiledLayerImpl::HasResourceIdForTileAt; 91 }; 92 93 class FakeTiledLayer : public TiledLayer { 94 public: 95 explicit FakeTiledLayer(PrioritizedResourceManager* resource_manager); 96 97 static gfx::Size tile_size() { return gfx::Size(100, 100); } 98 99 using TiledLayer::InvalidateContentRect; 100 using TiledLayer::NeedsIdlePaint; 101 using TiledLayer::SkipsDraw; 102 using TiledLayer::NumPaintedTiles; 103 using TiledLayer::IdlePaintRect; 104 105 virtual void SetNeedsDisplayRect(const gfx::RectF& rect) OVERRIDE; 106 const gfx::RectF& last_needs_display_rect() const { 107 return last_needs_display_rect_; 108 } 109 110 virtual void SetTexturePriorities( 111 const PriorityCalculator& priority_calculator) OVERRIDE; 112 113 virtual PrioritizedResourceManager* ResourceManager() OVERRIDE; 114 FakeLayerUpdater* fake_layer_updater() { return fake_updater_.get(); } 115 gfx::RectF update_rect() { return update_rect_; } 116 117 // Simulate CalcDrawProperties. 118 void UpdateContentsScale(float ideal_contents_scale); 119 120 void ResetNumDependentsNeedPushProperties(); 121 122 protected: 123 virtual LayerUpdater* Updater() const OVERRIDE; 124 virtual void CreateUpdaterIfNeeded() OVERRIDE {} 125 virtual ~FakeTiledLayer(); 126 127 private: 128 scoped_refptr<FakeLayerUpdater> fake_updater_; 129 PrioritizedResourceManager* resource_manager_; 130 gfx::RectF last_needs_display_rect_; 131 132 DISALLOW_COPY_AND_ASSIGN(FakeTiledLayer); 133 }; 134 135 class FakeTiledLayerWithScaledBounds : public FakeTiledLayer { 136 public: 137 explicit FakeTiledLayerWithScaledBounds( 138 PrioritizedResourceManager* resource_manager); 139 140 void SetContentBounds(const gfx::Size& content_bounds); 141 virtual void CalculateContentsScale(float ideal_contents_scale, 142 float* contents_scale_x, 143 float* contents_scale_y, 144 gfx::Size* content_bounds) OVERRIDE; 145 146 protected: 147 virtual ~FakeTiledLayerWithScaledBounds(); 148 gfx::Size forced_content_bounds_; 149 150 private: 151 DISALLOW_COPY_AND_ASSIGN(FakeTiledLayerWithScaledBounds); 152 }; 153 154 } // namespace cc 155 156 #endif // CC_TEST_TILED_LAYER_TEST_COMMON_H_ 157