tiled_layer_test_common.cc revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7 
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
7namespace cc {
8
9FakeLayerUpdater::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
16FakeLayerUpdater::Resource::~Resource() {}
17
18void FakeLayerUpdater::Resource::Update(ResourceUpdateQueue* queue,
19                                        const gfx::Rect& source_rect,
20                                        const 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
33FakeLayerUpdater::FakeLayerUpdater() : prepare_count_(0), update_count_(0) {}
34
35FakeLayerUpdater::~FakeLayerUpdater() {}
36
37void FakeLayerUpdater::PrepareToUpdate(const gfx::Rect& content_rect,
38                                       const 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
52void FakeLayerUpdater::SetRectToInvalidate(const gfx::Rect& rect,
53                                           FakeTiledLayer* layer) {
54  rect_to_invalidate_ = rect;
55  layer_ = layer;
56}
57
58scoped_ptr<LayerUpdater::Resource> FakeLayerUpdater::CreateResource(
59    PrioritizedResourceManager* manager) {
60  return scoped_ptr<LayerUpdater::Resource>(
61      new Resource(this, PrioritizedResource::Create(manager)));
62}
63
64FakeTiledLayerImpl::FakeTiledLayerImpl(LayerTreeImpl* tree_impl, int id)
65    : TiledLayerImpl(tree_impl, id) {}
66
67FakeTiledLayerImpl::~FakeTiledLayerImpl() {}
68
69FakeTiledLayer::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(RGBA_8888);
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
81FakeTiledLayerWithScaledBounds::FakeTiledLayerWithScaledBounds(
82    PrioritizedResourceManager* resource_manager)
83    : FakeTiledLayer(resource_manager) {}
84
85FakeTiledLayerWithScaledBounds::~FakeTiledLayerWithScaledBounds() {}
86
87FakeTiledLayer::~FakeTiledLayer() {}
88
89void FakeTiledLayer::SetNeedsDisplayRect(const gfx::RectF& rect) {
90  last_needs_display_rect_ = rect;
91  TiledLayer::SetNeedsDisplayRect(rect);
92}
93
94void 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
112PrioritizedResourceManager* FakeTiledLayer::ResourceManager() {
113  return resource_manager_;
114}
115
116void 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
126void 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
146LayerUpdater* FakeTiledLayer::Updater() const {
147  return fake_updater_.get();
148}
149
150void FakeTiledLayerWithScaledBounds::SetContentBounds(
151    const gfx::Size& content_bounds) {
152  forced_content_bounds_ = content_bounds;
153  draw_properties().content_bounds = forced_content_bounds_;
154}
155
156void 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
172