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_RESOURCES_TILE_H_
6#define CC_RESOURCES_TILE_H_
7
8#include "base/memory/ref_counted.h"
9#include "base/memory/scoped_ptr.h"
10#include "base/memory/scoped_vector.h"
11#include "cc/base/ref_counted_managed.h"
12#include "cc/resources/managed_tile_state.h"
13#include "cc/resources/picture_pile_impl.h"
14#include "cc/resources/raster_mode.h"
15#include "cc/resources/tile_priority.h"
16#include "ui/gfx/rect.h"
17#include "ui/gfx/size.h"
18
19namespace cc {
20
21class CC_EXPORT Tile : public RefCountedManaged<Tile> {
22 public:
23  enum TileRasterFlags { USE_PICTURE_ANALYSIS = 1 << 0 };
24
25  typedef uint64 Id;
26
27  Id id() const {
28    return id_;
29  }
30
31  PicturePileImpl* picture_pile() {
32    return picture_pile_.get();
33  }
34
35  const PicturePileImpl* picture_pile() const {
36    return picture_pile_.get();
37  }
38
39  const TilePriority& priority(WhichTree tree) const {
40    return priority_[tree];
41  }
42
43  TilePriority priority_for_tree_priority(TreePriority tree_priority) const {
44    switch (tree_priority) {
45      case SMOOTHNESS_TAKES_PRIORITY:
46        return priority_[ACTIVE_TREE];
47      case NEW_CONTENT_TAKES_PRIORITY:
48        return priority_[PENDING_TREE];
49      case SAME_PRIORITY_FOR_BOTH_TREES:
50        return combined_priority();
51      default:
52        NOTREACHED();
53        return TilePriority();
54    }
55  }
56
57  TilePriority combined_priority() const {
58    return TilePriority(priority_[ACTIVE_TREE],
59                        priority_[PENDING_TREE]);
60  }
61
62  void SetPriority(WhichTree tree, const TilePriority& priority);
63
64  void set_is_occluded(WhichTree tree, bool is_occluded) {
65    is_occluded_[tree] = is_occluded;
66  }
67
68  bool is_occluded(WhichTree tree) const { return is_occluded_[tree]; }
69
70  void set_shared(bool is_shared) { is_shared_ = is_shared; }
71  bool is_shared() const { return is_shared_; }
72
73  bool is_occluded_for_tree_priority(TreePriority tree_priority) const {
74    switch (tree_priority) {
75      case SMOOTHNESS_TAKES_PRIORITY:
76        return is_occluded_[ACTIVE_TREE];
77      case NEW_CONTENT_TAKES_PRIORITY:
78        return is_occluded_[PENDING_TREE];
79      case SAME_PRIORITY_FOR_BOTH_TREES:
80        return is_occluded_[ACTIVE_TREE] && is_occluded_[PENDING_TREE];
81      default:
82        NOTREACHED();
83        return false;
84    }
85  }
86
87  void MarkRequiredForActivation();
88
89  bool required_for_activation() const {
90    return priority_[PENDING_TREE].required_for_activation;
91  }
92
93  bool use_picture_analysis() const {
94    return !!(flags_ & USE_PICTURE_ANALYSIS);
95  }
96
97  bool NeedsRasterForMode(RasterMode mode) const {
98    return !managed_state_.tile_versions[mode].IsReadyToDraw();
99  }
100
101  bool HasResources() const {
102    for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
103      if (managed_state_.tile_versions[mode].has_resource())
104        return true;
105    }
106    return false;
107  }
108
109  void AsValueInto(base::debug::TracedValue* dict) const;
110
111  inline bool IsReadyToDraw() const {
112    for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
113      if (managed_state_.tile_versions[mode].IsReadyToDraw())
114        return true;
115    }
116    return false;
117  }
118
119  const ManagedTileState::TileVersion& GetTileVersionForDrawing() const {
120    for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
121      if (managed_state_.tile_versions[mode].IsReadyToDraw())
122        return managed_state_.tile_versions[mode];
123    }
124    return managed_state_.tile_versions[HIGH_QUALITY_RASTER_MODE];
125  }
126
127  float contents_scale() const { return contents_scale_; }
128  gfx::Rect content_rect() const { return content_rect_; }
129
130  int layer_id() const { return layer_id_; }
131
132  int source_frame_number() const { return source_frame_number_; }
133
134  void set_picture_pile(scoped_refptr<PicturePileImpl> pile) {
135    DCHECK(pile->CanRaster(contents_scale_, content_rect_))
136        << "Recording rect: "
137        << gfx::ScaleToEnclosingRect(content_rect_, 1.f / contents_scale_)
138               .ToString();
139    picture_pile_ = pile;
140  }
141
142  size_t GPUMemoryUsageInBytes() const;
143
144  gfx::Size size() const { return size_; }
145
146  RasterMode DetermineRasterModeForTree(WhichTree tree) const;
147  RasterMode DetermineOverallRasterMode() const;
148
149  // Functionality used in tests.
150  RasterMode GetRasterModeForTesting() const {
151    return managed_state().raster_mode;
152  }
153  ManagedTileState::TileVersion& GetTileVersionForTesting(RasterMode mode) {
154    return managed_state_.tile_versions[mode];
155  }
156
157 private:
158  friend class TileManager;
159  friend class PrioritizedTileSet;
160  friend class FakeTileManager;
161  friend class BinComparator;
162  friend class FakePictureLayerImpl;
163
164  // Methods called by by tile manager.
165  Tile(TileManager* tile_manager,
166       PicturePileImpl* picture_pile,
167       const gfx::Size& tile_size,
168       const gfx::Rect& content_rect,
169       float contents_scale,
170       int layer_id,
171       int source_frame_number,
172       int flags);
173  ~Tile();
174
175  ManagedTileState& managed_state() { return managed_state_; }
176  const ManagedTileState& managed_state() const { return managed_state_; }
177  RasterMode DetermineRasterModeForResolution(TileResolution resolution) const;
178
179  bool HasRasterTask() const;
180
181  TileManager* tile_manager_;
182  scoped_refptr<PicturePileImpl> picture_pile_;
183  gfx::Size size_;
184  gfx::Rect content_rect_;
185  float contents_scale_;
186  bool is_occluded_[NUM_TREES];
187
188  TilePriority priority_[NUM_TREES];
189  ManagedTileState managed_state_;
190  int layer_id_;
191  int source_frame_number_;
192  int flags_;
193  bool is_shared_;
194
195  Id id_;
196  static Id s_next_id_;
197
198  DISALLOW_COPY_AND_ASSIGN(Tile);
199};
200
201}  // namespace cc
202
203#endif  // CC_RESOURCES_TILE_H_
204