blob: 5e1ce5a694af75130d6ad3ab15e5dda4480c2b6c [file] [log] [blame]
// Copyright 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CC_RESOURCES_TILE_H_
#define CC_RESOURCES_TILE_H_
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/scoped_vector.h"
#include "cc/base/ref_counted_managed.h"
#include "cc/resources/managed_tile_state.h"
#include "cc/resources/picture_pile_impl.h"
#include "cc/resources/raster_mode.h"
#include "cc/resources/tile_priority.h"
#include "ui/gfx/rect.h"
#include "ui/gfx/size.h"
namespace cc {
class CC_EXPORT Tile : public RefCountedManaged<Tile> {
public:
enum TileRasterFlags { USE_PICTURE_ANALYSIS = 1 << 0 };
typedef uint64 Id;
Id id() const {
return id_;
}
PicturePileImpl* picture_pile() {
return picture_pile_.get();
}
const PicturePileImpl* picture_pile() const {
return picture_pile_.get();
}
const TilePriority& priority(WhichTree tree) const {
return priority_[tree];
}
TilePriority priority_for_tree_priority(TreePriority tree_priority) const {
switch (tree_priority) {
case SMOOTHNESS_TAKES_PRIORITY:
return priority_[ACTIVE_TREE];
case NEW_CONTENT_TAKES_PRIORITY:
return priority_[PENDING_TREE];
case SAME_PRIORITY_FOR_BOTH_TREES:
return combined_priority();
default:
NOTREACHED();
return TilePriority();
}
}
TilePriority combined_priority() const {
return TilePriority(priority_[ACTIVE_TREE],
priority_[PENDING_TREE]);
}
void SetPriority(WhichTree tree, const TilePriority& priority);
void set_is_occluded(WhichTree tree, bool is_occluded) {
is_occluded_[tree] = is_occluded;
}
bool is_occluded(WhichTree tree) const { return is_occluded_[tree]; }
bool is_occluded_for_tree_priority(TreePriority tree_priority) const {
switch (tree_priority) {
case SMOOTHNESS_TAKES_PRIORITY:
return is_occluded_[ACTIVE_TREE];
case NEW_CONTENT_TAKES_PRIORITY:
return is_occluded_[PENDING_TREE];
case SAME_PRIORITY_FOR_BOTH_TREES:
return is_occluded_[ACTIVE_TREE] && is_occluded_[PENDING_TREE];
default:
NOTREACHED();
return false;
}
}
void MarkRequiredForActivation();
bool required_for_activation() const {
return priority_[PENDING_TREE].required_for_activation;
}
bool use_picture_analysis() const {
return !!(flags_ & USE_PICTURE_ANALYSIS);
}
bool NeedsRasterForMode(RasterMode mode) const {
return !managed_state_.tile_versions[mode].IsReadyToDraw();
}
bool HasResources() const {
for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
if (managed_state_.tile_versions[mode].has_resource())
return true;
}
return false;
}
void AsValueInto(base::debug::TracedValue* dict) const;
inline bool IsReadyToDraw() const {
for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
if (managed_state_.tile_versions[mode].IsReadyToDraw())
return true;
}
return false;
}
const ManagedTileState::TileVersion& GetTileVersionForDrawing() const {
for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
if (managed_state_.tile_versions[mode].IsReadyToDraw())
return managed_state_.tile_versions[mode];
}
return managed_state_.tile_versions[HIGH_QUALITY_RASTER_MODE];
}
gfx::Rect opaque_rect() const { return opaque_rect_; }
float contents_scale() const { return contents_scale_; }
gfx::Rect content_rect() const { return content_rect_; }
int layer_id() const { return layer_id_; }
int source_frame_number() const { return source_frame_number_; }
void set_picture_pile(scoped_refptr<PicturePileImpl> pile) {
DCHECK(pile->CanRaster(contents_scale_, content_rect_))
<< "Recording rect: "
<< gfx::ScaleToEnclosingRect(content_rect_, 1.f / contents_scale_)
.ToString();
picture_pile_ = pile;
}
size_t GPUMemoryUsageInBytes() const;
gfx::Size size() const { return size_; }
RasterMode DetermineRasterModeForTree(WhichTree tree) const;
RasterMode DetermineOverallRasterMode() const;
// Functionality used in tests.
RasterMode GetRasterModeForTesting() const {
return managed_state().raster_mode;
}
ManagedTileState::TileVersion& GetTileVersionForTesting(RasterMode mode) {
return managed_state_.tile_versions[mode];
}
private:
friend class TileManager;
friend class PrioritizedTileSet;
friend class FakeTileManager;
friend class BinComparator;
friend class FakePictureLayerImpl;
// Methods called by by tile manager.
Tile(TileManager* tile_manager,
PicturePileImpl* picture_pile,
const gfx::Size& tile_size,
const gfx::Rect& content_rect,
const gfx::Rect& opaque_rect,
float contents_scale,
int layer_id,
int source_frame_number,
int flags);
~Tile();
ManagedTileState& managed_state() { return managed_state_; }
const ManagedTileState& managed_state() const { return managed_state_; }
RasterMode DetermineRasterModeForResolution(TileResolution resolution) const;
bool HasRasterTask() const;
TileManager* tile_manager_;
scoped_refptr<PicturePileImpl> picture_pile_;
gfx::Size size_;
gfx::Rect content_rect_;
float contents_scale_;
gfx::Rect opaque_rect_;
bool is_occluded_[NUM_TREES];
TilePriority priority_[NUM_TREES];
ManagedTileState managed_state_;
int layer_id_;
int source_frame_number_;
int flags_;
Id id_;
static Id s_next_id_;
DISALLOW_COPY_AND_ASSIGN(Tile);
};
} // namespace cc
#endif // CC_RESOURCES_TILE_H_