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 "cc/scheduler/texture_uploader.h" 16 #include "ui/gfx/rect.h" 17 #include "ui/gfx/size.h" 18 19 namespace cc { 20 21 class FakeTiledLayer; 22 23 class FakeLayerUpdater : public LayerUpdater { 24 public: 25 class Resource : public LayerUpdater::Resource { 26 public: 27 Resource(FakeLayerUpdater* updater, 28 scoped_ptr<PrioritizedResource> resource); 29 virtual ~Resource(); 30 31 virtual void Update(ResourceUpdateQueue* queue, 32 gfx::Rect source_rect, 33 gfx::Vector2d dest_offset, 34 bool partial_update) OVERRIDE; 35 36 private: 37 FakeLayerUpdater* layer_; 38 SkBitmap bitmap_; 39 40 DISALLOW_COPY_AND_ASSIGN(Resource); 41 }; 42 43 FakeLayerUpdater(); 44 45 virtual scoped_ptr<LayerUpdater::Resource> CreateResource( 46 PrioritizedResourceManager* resource) OVERRIDE; 47 48 virtual void PrepareToUpdate(gfx::Rect content_rect, 49 gfx::Size tile_size, 50 float contents_width_scale, 51 float contents_height_scale, 52 gfx::Rect* resulting_opaque_rect) OVERRIDE; 53 // Sets the rect to invalidate during the next call to PrepareToUpdate(). 54 // After the next call to PrepareToUpdate() the rect is reset. 55 void SetRectToInvalidate(gfx::Rect rect, FakeTiledLayer* layer); 56 // Last rect passed to PrepareToUpdate(). last_update_rect()57 gfx::Rect last_update_rect() const { return last_update_rect_; } 58 59 // Number of times PrepareToUpdate has been invoked. prepare_count()60 int prepare_count() const { return prepare_count_; } ClearPrepareCount()61 void ClearPrepareCount() { prepare_count_ = 0; } 62 63 // Number of times Update() has been invoked on a texture. update_count()64 int update_count() const { return update_count_; } ClearUpdateCount()65 void ClearUpdateCount() { update_count_ = 0; } Update()66 void Update() { update_count_++; } 67 SetOpaquePaintRect(gfx::Rect opaque_paint_rect)68 void SetOpaquePaintRect(gfx::Rect opaque_paint_rect) { 69 opaque_paint_rect_ = opaque_paint_rect; 70 } 71 72 protected: 73 virtual ~FakeLayerUpdater(); 74 75 private: 76 int prepare_count_; 77 int update_count_; 78 gfx::Rect rect_to_invalidate_; 79 gfx::Rect last_update_rect_; 80 gfx::Rect opaque_paint_rect_; 81 scoped_refptr<FakeTiledLayer> layer_; 82 83 DISALLOW_COPY_AND_ASSIGN(FakeLayerUpdater); 84 }; 85 86 class FakeTiledLayerImpl : public TiledLayerImpl { 87 public: 88 FakeTiledLayerImpl(LayerTreeImpl* tree_impl, int id); 89 virtual ~FakeTiledLayerImpl(); 90 91 using TiledLayerImpl::HasTileAt; 92 using TiledLayerImpl::HasResourceIdForTileAt; 93 }; 94 95 class FakeTiledLayer : public TiledLayer { 96 public: 97 explicit FakeTiledLayer(PrioritizedResourceManager* resource_manager); 98 tile_size()99 static gfx::Size tile_size() { return gfx::Size(100, 100); } 100 101 using TiledLayer::InvalidateContentRect; 102 using TiledLayer::NeedsIdlePaint; 103 using TiledLayer::SkipsDraw; 104 using TiledLayer::NumPaintedTiles; 105 using TiledLayer::IdlePaintRect; 106 107 virtual void SetNeedsDisplayRect(const gfx::RectF& rect) OVERRIDE; last_needs_display_rect()108 const gfx::RectF& last_needs_display_rect() const { 109 return last_needs_display_rect_; 110 } 111 112 virtual void SetTexturePriorities( 113 const PriorityCalculator& priority_calculator) OVERRIDE; 114 115 virtual PrioritizedResourceManager* ResourceManager() OVERRIDE; fake_layer_updater()116 FakeLayerUpdater* fake_layer_updater() { return fake_updater_.get(); } update_rect()117 gfx::RectF update_rect() { return update_rect_; } 118 119 // Simulate CalcDrawProperties. 120 void UpdateContentsScale(float ideal_contents_scale); 121 122 void ResetNumDependentsNeedPushProperties(); 123 124 protected: 125 virtual LayerUpdater* Updater() const OVERRIDE; CreateUpdaterIfNeeded()126 virtual void CreateUpdaterIfNeeded() OVERRIDE {} 127 virtual ~FakeTiledLayer(); 128 129 private: 130 scoped_refptr<FakeLayerUpdater> fake_updater_; 131 PrioritizedResourceManager* resource_manager_; 132 gfx::RectF last_needs_display_rect_; 133 134 DISALLOW_COPY_AND_ASSIGN(FakeTiledLayer); 135 }; 136 137 class FakeTiledLayerWithScaledBounds : public FakeTiledLayer { 138 public: 139 explicit FakeTiledLayerWithScaledBounds( 140 PrioritizedResourceManager* resource_manager); 141 142 void SetContentBounds(gfx::Size content_bounds); 143 virtual void CalculateContentsScale(float ideal_contents_scale, 144 float device_scale_factor, 145 float page_scale_factor, 146 bool animating_transform_to_screen, 147 float* contents_scale_x, 148 float* contents_scale_y, 149 gfx::Size* content_bounds) OVERRIDE; 150 151 protected: 152 virtual ~FakeTiledLayerWithScaledBounds(); 153 gfx::Size forced_content_bounds_; 154 155 private: 156 DISALLOW_COPY_AND_ASSIGN(FakeTiledLayerWithScaledBounds); 157 }; 158 159 } // namespace cc 160 161 #endif // CC_TEST_TILED_LAYER_TEST_COMMON_H_ 162