tiled_layer_impl.cc revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7 
1// Copyright 2011 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/layers/tiled_layer_impl.h"
6
7#include "base/basictypes.h"
8#include "base/strings/stringprintf.h"
9#include "cc/base/math_util.h"
10#include "cc/debug/debug_colors.h"
11#include "cc/layers/append_quads_data.h"
12#include "cc/layers/quad_sink.h"
13#include "cc/quads/checkerboard_draw_quad.h"
14#include "cc/quads/debug_border_draw_quad.h"
15#include "cc/quads/solid_color_draw_quad.h"
16#include "cc/quads/tile_draw_quad.h"
17#include "cc/resources/layer_tiling_data.h"
18#include "third_party/khronos/GLES2/gl2.h"
19#include "third_party/skia/include/core/SkColor.h"
20#include "ui/gfx/quad_f.h"
21
22namespace cc {
23
24class DrawableTile : public LayerTilingData::Tile {
25 public:
26  static scoped_ptr<DrawableTile> Create() {
27    return make_scoped_ptr(new DrawableTile());
28  }
29
30  ResourceProvider::ResourceId resource_id() const { return resource_id_; }
31  void set_resource_id(ResourceProvider::ResourceId resource_id) {
32    resource_id_ = resource_id;
33  }
34  bool contents_swizzled() { return contents_swizzled_; }
35  void set_contents_swizzled(bool contents_swizzled) {
36    contents_swizzled_ = contents_swizzled;
37  }
38
39 private:
40  DrawableTile() : resource_id_(0), contents_swizzled_(false) {}
41
42  ResourceProvider::ResourceId resource_id_;
43  bool contents_swizzled_;
44
45  DISALLOW_COPY_AND_ASSIGN(DrawableTile);
46};
47
48TiledLayerImpl::TiledLayerImpl(LayerTreeImpl* tree_impl, int id)
49    : LayerImpl(tree_impl, id), skips_draw_(true) {}
50
51TiledLayerImpl::~TiledLayerImpl() {
52}
53
54ResourceProvider::ResourceId TiledLayerImpl::ContentsResourceId() const {
55  // This function is only valid for single texture layers, e.g. masks.
56  DCHECK(tiler_);
57  // It's possible the mask layer is created but has no size or otherwise
58  // can't draw.
59  if (tiler_->num_tiles_x() == 0 || tiler_->num_tiles_y() == 0)
60    return 0;
61
62  // Any other number of tiles other than 0 or 1 is incorrect for masks.
63  DCHECK_EQ(tiler_->num_tiles_x(), 1);
64  DCHECK_EQ(tiler_->num_tiles_y(), 1);
65
66  DrawableTile* tile = TileAt(0, 0);
67  ResourceProvider::ResourceId resource_id = tile ? tile->resource_id() : 0;
68  return resource_id;
69}
70
71bool TiledLayerImpl::HasTileAt(int i, int j) const {
72  return !!tiler_->TileAt(i, j);
73}
74
75bool TiledLayerImpl::HasResourceIdForTileAt(int i, int j) const {
76  return HasTileAt(i, j) && TileAt(i, j)->resource_id();
77}
78
79DrawableTile* TiledLayerImpl::TileAt(int i, int j) const {
80  return static_cast<DrawableTile*>(tiler_->TileAt(i, j));
81}
82
83DrawableTile* TiledLayerImpl::CreateTile(int i, int j) {
84  scoped_ptr<DrawableTile> tile(DrawableTile::Create());
85  DrawableTile* added_tile = tile.get();
86  tiler_->AddTile(tile.PassAs<LayerTilingData::Tile>(), i, j);
87
88  return added_tile;
89}
90
91void TiledLayerImpl::GetDebugBorderProperties(SkColor* color,
92                                              float* width) const {
93  *color = DebugColors::TiledContentLayerBorderColor();
94  *width = DebugColors::TiledContentLayerBorderWidth(layer_tree_impl());
95}
96
97scoped_ptr<LayerImpl> TiledLayerImpl::CreateLayerImpl(
98    LayerTreeImpl* tree_impl) {
99  return TiledLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
100}
101
102void TiledLayerImpl::AsValueInto(base::DictionaryValue* state) const {
103  LayerImpl::AsValueInto(state);
104  state->Set("invalidation", MathUtil::AsValue(update_rect()).release());
105}
106
107size_t TiledLayerImpl::GPUMemoryUsageInBytes() const {
108  size_t amount = 0;
109  const size_t kMemoryUsagePerTileInBytes =
110      4 * tiler_->tile_size().width() * tiler_->tile_size().height();
111  for (LayerTilingData::TileMap::const_iterator iter = tiler_->tiles().begin();
112       iter != tiler_->tiles().end();
113       ++iter) {
114    const DrawableTile* tile = static_cast<DrawableTile*>(iter->second);
115    if (!tile || !tile->resource_id())
116      continue;
117    amount += kMemoryUsagePerTileInBytes;
118  }
119  return amount;
120}
121
122void TiledLayerImpl::PushPropertiesTo(LayerImpl* layer) {
123  LayerImpl::PushPropertiesTo(layer);
124
125  TiledLayerImpl* tiled_layer = static_cast<TiledLayerImpl*>(layer);
126
127  tiled_layer->set_skips_draw(skips_draw_);
128  tiled_layer->SetTilingData(*tiler_);
129
130  for (LayerTilingData::TileMap::const_iterator iter = tiler_->tiles().begin();
131       iter != tiler_->tiles().end();
132       ++iter) {
133    int i = iter->first.first;
134    int j = iter->first.second;
135    DrawableTile* tile = static_cast<DrawableTile*>(iter->second);
136
137    tiled_layer->PushTileProperties(i,
138                                    j,
139                                    tile->resource_id(),
140                                    tile->opaque_rect(),
141                                    tile->contents_swizzled());
142  }
143}
144
145bool TiledLayerImpl::WillDraw(DrawMode draw_mode,
146                              ResourceProvider* resource_provider) {
147  if (!tiler_ || tiler_->has_empty_bounds() ||
148      visible_content_rect().IsEmpty() ||
149      draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE)
150    return false;
151  return LayerImpl::WillDraw(draw_mode, resource_provider);
152}
153
154void TiledLayerImpl::AppendQuads(QuadSink* quad_sink,
155                                 AppendQuadsData* append_quads_data) {
156  DCHECK(tiler_);
157  DCHECK(!tiler_->has_empty_bounds());
158  DCHECK(!visible_content_rect().IsEmpty());
159
160  gfx::Rect content_rect = visible_content_rect();
161  SharedQuadState* shared_quad_state =
162      quad_sink->UseSharedQuadState(CreateSharedQuadState());
163  AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
164
165  int left, top, right, bottom;
166  tiler_->ContentRectToTileIndices(content_rect, &left, &top, &right, &bottom);
167
168  if (ShowDebugBorders()) {
169    for (int j = top; j <= bottom; ++j) {
170      for (int i = left; i <= right; ++i) {
171        DrawableTile* tile = TileAt(i, j);
172        gfx::Rect tile_rect = tiler_->tile_bounds(i, j);
173        SkColor border_color;
174        float border_width;
175
176        if (skips_draw_ || !tile || !tile->resource_id()) {
177          border_color = DebugColors::MissingTileBorderColor();
178          border_width = DebugColors::MissingTileBorderWidth(layer_tree_impl());
179        } else {
180          border_color = DebugColors::HighResTileBorderColor();
181          border_width = DebugColors::HighResTileBorderWidth(layer_tree_impl());
182        }
183        scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
184            DebugBorderDrawQuad::Create();
185        debug_border_quad->SetNew(
186            shared_quad_state, tile_rect, border_color, border_width);
187        quad_sink->Append(debug_border_quad.PassAs<DrawQuad>(),
188                          append_quads_data);
189      }
190    }
191  }
192
193  if (skips_draw_)
194    return;
195
196  for (int j = top; j <= bottom; ++j) {
197    for (int i = left; i <= right; ++i) {
198      DrawableTile* tile = TileAt(i, j);
199      gfx::Rect tile_rect = tiler_->tile_bounds(i, j);
200      gfx::Rect display_rect = tile_rect;
201      tile_rect.Intersect(content_rect);
202
203      // Skip empty tiles.
204      if (tile_rect.IsEmpty())
205        continue;
206
207      if (!tile || !tile->resource_id()) {
208        SkColor checker_color;
209        if (ShowDebugBorders()) {
210          checker_color =
211              tile ? DebugColors::InvalidatedTileCheckerboardColor()
212                   : DebugColors::EvictedTileCheckerboardColor();
213        } else {
214          checker_color = DebugColors::DefaultCheckerboardColor();
215        }
216
217        scoped_ptr<CheckerboardDrawQuad> checkerboard_quad =
218            CheckerboardDrawQuad::Create();
219        checkerboard_quad->SetNew(
220            shared_quad_state, tile_rect, checker_color);
221        if (quad_sink->Append(checkerboard_quad.PassAs<DrawQuad>(),
222                              append_quads_data))
223          append_quads_data->num_missing_tiles++;
224
225        continue;
226      }
227
228      gfx::Rect tile_opaque_rect =
229          contents_opaque() ? tile_rect : gfx::IntersectRects(
230                                              tile->opaque_rect(), tile_rect);
231
232      // Keep track of how the top left has moved, so the texture can be
233      // offset the same amount.
234      gfx::Vector2d display_offset = tile_rect.origin() - display_rect.origin();
235      gfx::Vector2d texture_offset =
236          tiler_->texture_offset(i, j) + display_offset;
237      gfx::RectF tex_coord_rect = gfx::RectF(tile_rect.size()) + texture_offset;
238
239      float tile_width = static_cast<float>(tiler_->tile_size().width());
240      float tile_height = static_cast<float>(tiler_->tile_size().height());
241      gfx::Size texture_size(tile_width, tile_height);
242
243      scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
244      quad->SetNew(shared_quad_state,
245                   tile_rect,
246                   tile_opaque_rect,
247                   tile->resource_id(),
248                   tex_coord_rect,
249                   texture_size,
250                   tile->contents_swizzled());
251      quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
252    }
253  }
254}
255
256void TiledLayerImpl::SetTilingData(const LayerTilingData& tiler) {
257  if (tiler_) {
258    tiler_->reset();
259  } else {
260    tiler_ = LayerTilingData::Create(tiler.tile_size(),
261                                     tiler.has_border_texels()
262                                         ? LayerTilingData::HAS_BORDER_TEXELS
263                                         : LayerTilingData::NO_BORDER_TEXELS);
264  }
265  *tiler_ = tiler;
266}
267
268void TiledLayerImpl::PushTileProperties(
269    int i,
270    int j,
271    ResourceProvider::ResourceId resource_id,
272    const gfx::Rect& opaque_rect,
273    bool contents_swizzled) {
274  DrawableTile* tile = TileAt(i, j);
275  if (!tile)
276    tile = CreateTile(i, j);
277  tile->set_resource_id(resource_id);
278  tile->set_opaque_rect(opaque_rect);
279  tile->set_contents_swizzled(contents_swizzled);
280}
281
282void TiledLayerImpl::PushInvalidTile(int i, int j) {
283  DrawableTile* tile = TileAt(i, j);
284  if (!tile)
285    tile = CreateTile(i, j);
286  tile->set_resource_id(0);
287  tile->set_opaque_rect(gfx::Rect());
288  tile->set_contents_swizzled(false);
289}
290
291Region TiledLayerImpl::VisibleContentOpaqueRegion() const {
292  if (skips_draw_)
293    return Region();
294  if (contents_opaque())
295    return visible_content_rect();
296  return tiler_->OpaqueRegionInContentRect(visible_content_rect());
297}
298
299void TiledLayerImpl::ReleaseResources() {
300  tiler_->reset();
301}
302
303const char* TiledLayerImpl::LayerTypeAsString() const {
304  return "cc::TiledLayerImpl";
305}
306
307}  // namespace cc
308