cc/test/tiled_layer_test_common.cc

   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 #include "cc/test/tiled_layer_test_common.h"
   6
   7 namespace cc {
   8
   9 FakeLayerUpdater::Resource::Resource(FakeLayerUpdater* layer,
  10                                      scoped_ptr<PrioritizedResource> texture)
  11     : LayerUpdater::Resource(texture.Pass()), layer_(layer) {
  12   bitmap_.setConfig(SkBitmap::kARGB_8888_Config, 10, 10);
  13   bitmap_.allocPixels();
  14 }
  15
  16 FakeLayerUpdater::Resource::~Resource() {}
  17
  18 void FakeLayerUpdater::Resource::Update(ResourceUpdateQueue* queue,
  19                                         gfx::Rect source_rect,
  20                                         gfx::Vector2d dest_offset,
  21                                         bool partial_update) {
  22   const gfx::Rect kRect(0, 0, 10, 10);
  23   ResourceUpdate upload = ResourceUpdate::Create(
  24       texture(), &bitmap_, kRect, kRect, gfx::Vector2d());
  25   if (partial_update)
  26     queue->AppendPartialUpload(upload);
  27   else
  28     queue->AppendFullUpload(upload);
  29
  30   layer_->Update();
  31 }
  32
  33 FakeLayerUpdater::FakeLayerUpdater() : prepare_count_(0), update_count_(0) {}
  34
  35 FakeLayerUpdater::~FakeLayerUpdater() {}
  36
  37 void FakeLayerUpdater::PrepareToUpdate(gfx::Rect content_rect,
  38                                        gfx::Size tile_size,
  39                                        float contents_width_scale,
  40                                        float contents_height_scale,
  41                                        gfx::Rect* resulting_opaque_rect) {
  42   prepare_count_++;
  43   last_update_rect_ = content_rect;
  44   if (!rect_to_invalidate_.IsEmpty()) {
  45     layer_->InvalidateContentRect(rect_to_invalidate_);
  46     rect_to_invalidate_ = gfx::Rect();
  47     layer_ = NULL;
  48   }
  49   *resulting_opaque_rect = opaque_paint_rect_;
  50 }
  51
  52 void FakeLayerUpdater::SetRectToInvalidate(gfx::Rect rect,
  53                                            FakeTiledLayer* layer) {
  54   rect_to_invalidate_ = rect;
  55   layer_ = layer;
  56 }
  57
  58 scoped_ptr<LayerUpdater::Resource> FakeLayerUpdater::CreateResource(
  59     PrioritizedResourceManager* manager) {
  60   return scoped_ptr<LayerUpdater::Resource>(
  61       new Resource(this, PrioritizedResource::Create(manager)));
  62 }
  63
  64 FakeTiledLayerImpl::FakeTiledLayerImpl(LayerTreeImpl* tree_impl, int id)
  65     : TiledLayerImpl(tree_impl, id) {}
  66
  67 FakeTiledLayerImpl::~FakeTiledLayerImpl() {}
  68
  69 FakeTiledLayer::FakeTiledLayer(PrioritizedResourceManager* resource_manager)
  70     : TiledLayer(),
  71       fake_updater_(make_scoped_refptr(new FakeLayerUpdater)),
  72       resource_manager_(resource_manager) {
  73   SetTileSize(tile_size());
  74   SetTextureFormat(GL_RGBA);
  75   SetBorderTexelOption(LayerTilingData::NO_BORDER_TEXELS);
  76   // So that we don't get false positives if any of these
  77   // tests expect to return false from DrawsContent() for other reasons.
  78   SetIsDrawable(true);
  79 }
  80
  81 FakeTiledLayerWithScaledBounds::FakeTiledLayerWithScaledBounds(
  82     PrioritizedResourceManager* resource_manager)
  83     : FakeTiledLayer(resource_manager) {}
  84
  85 FakeTiledLayerWithScaledBounds::~FakeTiledLayerWithScaledBounds() {}
  86
  87 FakeTiledLayer::~FakeTiledLayer() {}
  88
  89 void FakeTiledLayer::SetNeedsDisplayRect(const gfx::RectF& rect) {
  90   last_needs_display_rect_ = rect;
  91   TiledLayer::SetNeedsDisplayRect(rect);
  92 }
  93
  94 void FakeTiledLayer::SetTexturePriorities(
  95     const PriorityCalculator& calculator) {
  96   // Ensure there is always a target render surface available. If none has been
  97   // set (the layer is an orphan for the test), then just set a surface on
  98   // itself.
  99   bool missing_target_render_surface = !render_target();
 100
 101   if (missing_target_render_surface)
 102     CreateRenderSurface();
 103
 104   TiledLayer::SetTexturePriorities(calculator);
 105
 106   if (missing_target_render_surface) {
 107     ClearRenderSurface();
 108     draw_properties().render_target = 0;
 109   }
 110 }
 111
 112 PrioritizedResourceManager* FakeTiledLayer::ResourceManager() {
 113   return resource_manager_;
 114 }
 115
 116 void FakeTiledLayer::UpdateContentsScale(float ideal_contents_scale) {
 117   CalculateContentsScale(ideal_contents_scale,
 118                          1.f,
 119                          1.f,
 120                          false,  // animating_transform_to_screen
 121                          &draw_properties().contents_scale_x,
 122                          &draw_properties().contents_scale_y,
 123                          &draw_properties().content_bounds);
 124 }
 125
 126 void FakeTiledLayer::ResetNumDependentsNeedPushProperties() {
 127   size_t num = 0;
 128   if (mask_layer()) {
 129     if (mask_layer()->needs_push_properties() ||
 130         mask_layer()->descendant_needs_push_properties())
 131       ++num;
 132   }
 133   if (replica_layer()) {
 134     if (replica_layer()->needs_push_properties() ||
 135         replica_layer()->descendant_needs_push_properties())
 136       ++num;
 137   }
 138   for (size_t i = 0; i < children().size(); ++i) {
 139     if (children()[i]->needs_push_properties() ||
 140         children()[i]->descendant_needs_push_properties())
 141       ++num;
 142   }
 143   num_dependents_need_push_properties_ = num;
 144 }
 145
 146 LayerUpdater* FakeTiledLayer::Updater() const {
 147   return fake_updater_.get();
 148 }
 149
 150 void FakeTiledLayerWithScaledBounds::SetContentBounds(
 151     gfx::Size content_bounds) {
 152   forced_content_bounds_ = content_bounds;
 153   draw_properties().content_bounds = forced_content_bounds_;
 154 }
 155
 156 void FakeTiledLayerWithScaledBounds::CalculateContentsScale(
 157     float ideal_contents_scale,
 158     float device_scale_factor,
 159     float page_scale_factor,
 160     bool animating_transform_to_screen,
 161     float* contents_scale_x,
 162     float* contents_scale_y,
 163     gfx::Size* content_bounds) {
 164   *contents_scale_x =
 165       static_cast<float>(forced_content_bounds_.width()) / bounds().width();
 166   *contents_scale_y =
 167       static_cast<float>(forced_content_bounds_.height()) / bounds().height();
 168   *content_bounds = forced_content_bounds_;
 169 }
 170
 171 }  // namespace cc