cc/test/tiled_layer_test_common.h

   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().
  57   gfx::Rect last_update_rect() const { return last_update_rect_; }
  58
  59   // Number of times PrepareToUpdate has been invoked.
  60   int prepare_count() const { return prepare_count_; }
  61   void ClearPrepareCount() { prepare_count_ = 0; }
  62
  63   // Number of times Update() has been invoked on a texture.
  64   int update_count() const { return update_count_; }
  65   void ClearUpdateCount() { update_count_ = 0; }
  66   void Update() { update_count_++; }
  67
  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
  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;
 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;
 116   FakeLayerUpdater* fake_layer_updater() { return fake_updater_.get(); }
 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;
 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_