1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
// Copyright 2010 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.
#include "cc/content_layer.h"
#include "base/auto_reset.h"
#include "base/metrics/histogram.h"
#include "base/time.h"
#include "cc/content_layer_client.h"
#include "cc/resources/bitmap_content_layer_updater.h"
#include "cc/resources/bitmap_skpicture_content_layer_updater.h"
#include "cc/resources/layer_painter.h"
#include "cc/trees/layer_tree_host.h"
namespace cc {
ContentLayerPainter::ContentLayerPainter(ContentLayerClient* client)
: client_(client) {}
scoped_ptr<ContentLayerPainter> ContentLayerPainter::Create(
ContentLayerClient* client) {
return make_scoped_ptr(new ContentLayerPainter(client));
}
void ContentLayerPainter::Paint(SkCanvas* canvas,
gfx::Rect content_rect,
gfx::RectF* opaque) {
base::TimeTicks paint_start = base::TimeTicks::HighResNow();
client_->PaintContents(canvas, content_rect, opaque);
base::TimeTicks paint_end = base::TimeTicks::HighResNow();
double pixels_per_sec = (content_rect.width() * content_rect.height()) /
(paint_end - paint_start).InSecondsF();
UMA_HISTOGRAM_CUSTOM_COUNTS("Renderer4.AccelContentPaintDurationMS",
(paint_end - paint_start).InMilliseconds(),
0,
120,
30);
UMA_HISTOGRAM_CUSTOM_COUNTS("Renderer4.AccelContentPaintMegapixPerSecond",
pixels_per_sec / 1000000,
10,
210,
30);
}
scoped_refptr<ContentLayer> ContentLayer::Create(ContentLayerClient* client) {
return make_scoped_refptr(new ContentLayer(client));
}
ContentLayer::ContentLayer(ContentLayerClient* client)
: TiledLayer(),
client_(client) {}
ContentLayer::~ContentLayer() {}
bool ContentLayer::DrawsContent() const {
return TiledLayer::DrawsContent() && client_;
}
void ContentLayer::SetTexturePriorities(
const PriorityCalculator& priority_calc) {
// Update the tile data before creating all the layer's tiles.
UpdateTileSizeAndTilingOption();
TiledLayer::SetTexturePriorities(priority_calc);
}
void ContentLayer::Update(ResourceUpdateQueue* queue,
const OcclusionTracker* occlusion,
RenderingStats* stats) {
{
base::AutoReset<bool> ignore_set_needs_commit(&ignore_set_needs_commit_,
true);
CreateUpdaterIfNeeded();
}
TiledLayer::Update(queue, occlusion, stats);
needs_display_ = false;
}
bool ContentLayer::NeedMoreUpdates() {
return NeedsIdlePaint();
}
LayerUpdater* ContentLayer::Updater() const {
return updater_.get();
}
void ContentLayer::CreateUpdaterIfNeeded() {
if (updater_)
return;
scoped_ptr<LayerPainter> painter =
ContentLayerPainter::Create(client_).PassAs<LayerPainter>();
if (layer_tree_host()->settings().acceleratePainting)
updater_ = SkPictureContentLayerUpdater::Create(painter.Pass());
else if (layer_tree_host()->settings().perTilePaintingEnabled)
updater_ = BitmapSkPictureContentLayerUpdater::Create(painter.Pass());
else
updater_ = BitmapContentLayerUpdater::Create(painter.Pass());
updater_->SetOpaque(contents_opaque());
unsigned texture_format =
layer_tree_host()->GetRendererCapabilities().best_texture_format;
SetTextureFormat(texture_format);
}
void ContentLayer::SetContentsOpaque(bool opaque) {
Layer::SetContentsOpaque(opaque);
if (updater_)
updater_->SetOpaque(opaque);
}
} // namespace cc
|
