Update from https://crrev.com/306655
Includes updates to ui/ and mojo/services for cc and gpu changes and
a minor update to a unit test in sky/ for skia interface changes.
Review URL: https://codereview.chromium.org/761903003
diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index 6d5fec4..7e66bd9 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -323,10 +323,24 @@
"resources/bitmap_raster_worker_pool.h",
"resources/bitmap_skpicture_content_layer_updater.cc",
"resources/bitmap_skpicture_content_layer_updater.h",
+ "resources/clip_display_item.cc",
+ "resources/clip_display_item.h",
"resources/content_layer_updater.cc",
"resources/content_layer_updater.h",
+ "resources/display_item.cc",
+ "resources/display_item.h",
+ "resources/display_item_list.cc",
+ "resources/display_item_list.h",
+ "resources/display_list_raster_source.cc",
+ "resources/display_list_raster_source.h",
+ "resources/display_list_recording_source.cc",
+ "resources/display_list_recording_source.h",
+ "resources/drawing_display_item.cc",
+ "resources/drawing_display_item.h",
"resources/eviction_tile_priority_queue.cc",
"resources/eviction_tile_priority_queue.h",
+ "resources/filter_display_item.cc",
+ "resources/filter_display_item.h",
"resources/gpu_raster_worker_pool.cc",
"resources/gpu_raster_worker_pool.h",
"resources/image_layer_updater.cc",
@@ -366,6 +380,8 @@
"resources/raster_buffer.cc",
"resources/raster_buffer.h",
"resources/raster_source.h",
+ "resources/raster_source_helper.cc",
+ "resources/raster_source_helper.h",
"resources/raster_tile_priority_queue.cc",
"resources/raster_tile_priority_queue.h",
"resources/raster_worker_pool.cc",
@@ -417,8 +433,14 @@
"resources/tile_manager.h",
"resources/tile_priority.cc",
"resources/tile_priority.h",
+ "resources/tiling_set_eviction_queue.cc",
+ "resources/tiling_set_eviction_queue.h",
"resources/transferable_resource.cc",
"resources/transferable_resource.h",
+ "resources/transform_display_item.cc",
+ "resources/transform_display_item.h",
+ "resources/transparency_display_item.cc",
+ "resources/transparency_display_item.h",
"resources/ui_resource_bitmap.cc",
"resources/ui_resource_bitmap.h",
"resources/ui_resource_client.h",
@@ -482,6 +504,7 @@
deps = [
"//base",
"//base/third_party/dynamic_annotations",
+ "//cc/surfaces:surface_id",
"//gpu",
"//gpu/command_buffer/client:gles2_interface",
"//gpu/command_buffer/client:gpu_memory_buffer_manager",
@@ -635,6 +658,7 @@
]
deps = [
"//base",
+ "//base/test:test_support",
"//base/third_party/dynamic_annotations",
"//gpu/command_buffer/client:gles2_c_lib",
"//gpu/command_buffer/client:gles2_implementation",
@@ -720,6 +744,7 @@
"quads/draw_quad_unittest.cc",
"quads/list_container_unittest.cc",
"quads/render_pass_unittest.cc",
+ "resources/display_item_list_unittest.cc",
"resources/layer_quad_unittest.cc",
"resources/picture_layer_tiling_set_unittest.cc",
"resources/picture_layer_tiling_unittest.cc",
@@ -786,6 +811,7 @@
":test_support",
"//base/test:test_support",
"//cc/surfaces",
+ "//cc/surfaces:surface_id",
"//gpu",
"//gpu:test_support",
"//gpu/command_buffer/client:gles2_interface",
@@ -795,6 +821,8 @@
"//ui/events:events_base",
"//ui/gfx",
"//ui/gfx/geometry",
+ "//ui/gfx:test_support",
+ "//ui/gl",
]
}
@@ -818,6 +846,7 @@
":cc",
":test_support",
"//base",
+ "//base/test:test_support",
"//gpu",
"//gpu:test_support",
"//gpu/command_buffer/common:gles2_utils",
@@ -827,5 +856,6 @@
"//testing/perf",
"//ui/gfx",
"//ui/gfx/geometry",
+ "//ui/gl",
]
}
diff --git a/cc/base/rolling_time_delta_history.cc b/cc/base/rolling_time_delta_history.cc
index 0f95cc5..db04f58 100644
--- a/cc/base/rolling_time_delta_history.cc
+++ b/cc/base/rolling_time_delta_history.cc
@@ -26,10 +26,6 @@
chronological_sample_deque_.push_back(it);
}
-size_t RollingTimeDeltaHistory::SampleCount() {
- return sample_set_.size();
-}
-
void RollingTimeDeltaHistory::Clear() {
chronological_sample_deque_.clear();
sample_set_.clear();
diff --git a/cc/base/rolling_time_delta_history.h b/cc/base/rolling_time_delta_history.h
index 603c813..e51fb86 100644
--- a/cc/base/rolling_time_delta_history.h
+++ b/cc/base/rolling_time_delta_history.h
@@ -23,8 +23,6 @@
void InsertSample(base::TimeDelta time);
- size_t SampleCount();
-
void Clear();
// Returns the smallest sample that is greater than or equal to the specified
diff --git a/cc/blink/BUILD.gn b/cc/blink/BUILD.gn
index fac991b..138be59 100644
--- a/cc/blink/BUILD.gn
+++ b/cc/blink/BUILD.gn
@@ -33,6 +33,8 @@
"web_compositor_support_impl.h",
"web_content_layer_impl.cc",
"web_content_layer_impl.h",
+ "web_display_item_list_impl.cc",
+ "web_display_item_list_impl.h",
"web_external_bitmap_impl.cc",
"web_external_bitmap_impl.h",
"web_external_texture_layer_impl.cc",
diff --git a/cc/blink/cc_blink.gyp b/cc/blink/cc_blink.gyp
index d9f19ea..892082c 100644
--- a/cc/blink/cc_blink.gyp
+++ b/cc/blink/cc_blink.gyp
@@ -36,6 +36,8 @@
'web_compositor_support_impl.h',
'web_content_layer_impl.cc',
'web_content_layer_impl.h',
+ 'web_display_item_list_impl.cc',
+ 'web_display_item_list_impl.h',
'web_external_bitmap_impl.cc',
'web_external_bitmap_impl.h',
'web_external_texture_layer_impl.cc',
diff --git a/cc/blink/web_compositor_support_impl.cc b/cc/blink/web_compositor_support_impl.cc
index ae098fc..042908c 100644
--- a/cc/blink/web_compositor_support_impl.cc
+++ b/cc/blink/web_compositor_support_impl.cc
@@ -9,6 +9,7 @@
#include "cc/animation/transform_operations.h"
#include "cc/blink/web_animation_impl.h"
#include "cc/blink/web_content_layer_impl.h"
+#include "cc/blink/web_display_item_list_impl.h"
#include "cc/blink/web_external_texture_layer_impl.h"
#include "cc/blink/web_filter_animation_curve_impl.h"
#include "cc/blink/web_filter_operations_impl.h"
@@ -27,6 +28,9 @@
using blink::WebCompositorAnimationCurve;
using blink::WebContentLayer;
using blink::WebContentLayerClient;
+#if WEB_DISPLAY_ITEM_LIST_IS_DEFINED
+using blink::WebDisplayItemList;
+#endif
using blink::WebExternalTextureLayer;
using blink::WebExternalTextureLayerClient;
using blink::WebFilterAnimationCurve;
@@ -91,6 +95,12 @@
is_left_side_vertical_scrollbar);
}
+#if WEB_DISPLAY_ITEM_LIST_IS_DEFINED
+WebDisplayItemList* WebCompositorSupportImpl::createDisplayItemList() {
+ return new WebDisplayItemListImpl();
+}
+#endif
+
WebCompositorAnimation* WebCompositorSupportImpl::createAnimation(
const blink::WebCompositorAnimationCurve& curve,
blink::WebCompositorAnimation::TargetProperty target,
diff --git a/cc/blink/web_compositor_support_impl.h b/cc/blink/web_compositor_support_impl.h
index 0f6371a..1c5198c 100644
--- a/cc/blink/web_compositor_support_impl.h
+++ b/cc/blink/web_compositor_support_impl.h
@@ -10,6 +10,7 @@
#include "cc/blink/cc_blink_export.h"
#include "third_party/WebKit/public/platform/WebCompositorAnimationCurve.h"
#include "third_party/WebKit/public/platform/WebCompositorSupport.h"
+#include "third_party/WebKit/public/platform/WebContentLayerClient.h"
#include "third_party/WebKit/public/platform/WebLayer.h"
#include "third_party/WebKit/public/platform/WebTransformOperations.h"
@@ -41,6 +42,9 @@
int thumb_thickness,
int track_start,
bool is_left_side_vertical_scrollbar);
+#if WEB_DISPLAY_ITEM_LIST_IS_DEFINED
+ virtual blink::WebDisplayItemList* createDisplayItemList();
+#endif
virtual blink::WebCompositorAnimation* createAnimation(
const blink::WebCompositorAnimationCurve& curve,
blink::WebCompositorAnimation::TargetProperty target,
diff --git a/cc/blink/web_content_layer_impl.cc b/cc/blink/web_content_layer_impl.cc
index d0a4cca..9757ff3 100644
--- a/cc/blink/web_content_layer_impl.cc
+++ b/cc/blink/web_content_layer_impl.cc
@@ -4,6 +4,7 @@
#include "cc/blink/web_content_layer_impl.h"
+#include "cc/blink/web_display_item_list_impl.h"
#include "cc/layers/content_layer.h"
#include "cc/layers/picture_layer.h"
#include "third_party/WebKit/public/platform/WebContentLayerClient.h"
@@ -63,6 +64,25 @@
: blink::WebContentLayerClient::GraphicsContextDisabled);
}
+scoped_refptr<cc::DisplayItemList>
+WebContentLayerImpl::PaintContentsToDisplayList(
+ const gfx::Rect& clip,
+ ContentLayerClient::GraphicsContextStatus graphics_context_status) {
+ if (!client_)
+ return cc::DisplayItemList::Create();
+
+ WebDisplayItemListImpl list;
+#if WEB_DISPLAY_ITEM_LIST_IS_DEFINED
+ bool can_use_lcd_text = true;
+ client_->paintContents(
+ &list, clip, can_use_lcd_text,
+ graphics_context_status == ContentLayerClient::GRAPHICS_CONTEXT_ENABLED
+ ? blink::WebContentLayerClient::GraphicsContextEnabled
+ : blink::WebContentLayerClient::GraphicsContextDisabled);
+#endif
+ return list.ToDisplayItemList();
+}
+
bool WebContentLayerImpl::FillsBoundsCompletely() const {
return false;
}
diff --git a/cc/blink/web_content_layer_impl.h b/cc/blink/web_content_layer_impl.h
index 2966bd4..148f4fc 100644
--- a/cc/blink/web_content_layer_impl.h
+++ b/cc/blink/web_content_layer_impl.h
@@ -40,6 +40,9 @@
const gfx::Rect& clip,
ContentLayerClient::GraphicsContextStatus
graphics_context_status) override;
+ scoped_refptr<cc::DisplayItemList> PaintContentsToDisplayList(
+ const gfx::Rect& clip,
+ GraphicsContextStatus graphics_context_status) override;
bool FillsBoundsCompletely() const override;
scoped_ptr<WebLayerImpl> layer_;
@@ -47,9 +50,6 @@
bool draws_content_;
private:
- bool can_use_lcd_text_;
- bool ignore_lcd_text_change_;
-
DISALLOW_COPY_AND_ASSIGN(WebContentLayerImpl);
};
diff --git a/cc/blink/web_display_item_list_impl.cc b/cc/blink/web_display_item_list_impl.cc
new file mode 100644
index 0000000..4ba3431
--- /dev/null
+++ b/cc/blink/web_display_item_list_impl.cc
@@ -0,0 +1,90 @@
+// Copyright 2014 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/blink/web_display_item_list_impl.h"
+
+#include <vector>
+
+#include "cc/blink/web_blend_mode.h"
+#include "cc/resources/clip_display_item.h"
+#include "cc/resources/drawing_display_item.h"
+#include "cc/resources/filter_display_item.h"
+#include "cc/resources/transform_display_item.h"
+#include "cc/resources/transparency_display_item.h"
+#include "skia/ext/refptr.h"
+#include "third_party/WebKit/public/platform/WebFloatRect.h"
+#include "third_party/WebKit/public/platform/WebRect.h"
+#include "third_party/skia/include/core/SkImageFilter.h"
+#include "third_party/skia/include/core/SkPicture.h"
+#include "third_party/skia/include/utils/SkMatrix44.h"
+#include "ui/gfx/transform.h"
+
+namespace cc_blink {
+
+WebDisplayItemListImpl::WebDisplayItemListImpl()
+ : display_item_list_(cc::DisplayItemList::Create()) {
+}
+
+scoped_refptr<cc::DisplayItemList> WebDisplayItemListImpl::ToDisplayItemList() {
+ return display_item_list_;
+}
+
+void WebDisplayItemListImpl::appendDrawingItem(
+ SkPicture* picture,
+ const blink::WebFloatPoint& location) {
+ display_item_list_->AppendItem(
+ cc::DrawingDisplayItem::Create(skia::SharePtr(picture), location));
+}
+
+void WebDisplayItemListImpl::appendClipItem(
+ const blink::WebRect& clip_rect,
+ const blink::WebVector<SkRRect>& rounded_clip_rects) {
+ std::vector<SkRRect> rounded_rects;
+ for (size_t i = 0; i < rounded_clip_rects.size(); ++i) {
+ rounded_rects.push_back(rounded_clip_rects[i]);
+ }
+ display_item_list_->AppendItem(
+ cc::ClipDisplayItem::Create(clip_rect, rounded_rects));
+}
+
+void WebDisplayItemListImpl::appendEndClipItem() {
+ display_item_list_->AppendItem(cc::EndClipDisplayItem::Create());
+}
+
+void WebDisplayItemListImpl::appendTransformItem(const SkMatrix44& matrix) {
+ gfx::Transform transform;
+ transform.matrix() = matrix;
+ display_item_list_->AppendItem(cc::TransformDisplayItem::Create(transform));
+}
+
+void WebDisplayItemListImpl::appendTransparencyItem(
+ float opacity,
+ blink::WebBlendMode blend_mode) {
+ display_item_list_->AppendItem(cc::TransparencyDisplayItem::Create(
+ opacity, BlendModeToSkia(blend_mode)));
+}
+
+void WebDisplayItemListImpl::appendEndTransformItem() {
+ display_item_list_->AppendItem(cc::EndTransformDisplayItem::Create());
+}
+
+void WebDisplayItemListImpl::appendEndTransparencyItem() {
+ display_item_list_->AppendItem(cc::EndTransparencyDisplayItem::Create());
+}
+
+void WebDisplayItemListImpl::appendFilterItem(
+ SkImageFilter* filter,
+ const blink::WebFloatRect& bounds) {
+ display_item_list_->AppendItem(
+ cc::FilterDisplayItem::Create(skia::SharePtr(filter), bounds));
+}
+
+void WebDisplayItemListImpl::appendEndFilterItem() {
+ display_item_list_->AppendItem(cc::EndFilterDisplayItem::Create());
+}
+
+WebDisplayItemListImpl::~WebDisplayItemListImpl() {
+}
+
+} // namespace cc_blink
diff --git a/cc/blink/web_display_item_list_impl.h b/cc/blink/web_display_item_list_impl.h
new file mode 100644
index 0000000..4725498
--- /dev/null
+++ b/cc/blink/web_display_item_list_impl.h
@@ -0,0 +1,63 @@
+// Copyright 2014 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_BLINK_WEB_DISPLAY_ITEM_LIST_IMPL_H_
+#define CC_BLINK_WEB_DISPLAY_ITEM_LIST_IMPL_H_
+
+#include "base/memory/ref_counted.h"
+#include "cc/blink/cc_blink_export.h"
+#include "cc/resources/display_item_list.h"
+#include "third_party/WebKit/public/platform/WebBlendMode.h"
+#include "third_party/WebKit/public/platform/WebContentLayerClient.h"
+#include "third_party/WebKit/public/platform/WebFloatPoint.h"
+#include "third_party/WebKit/public/platform/WebVector.h"
+
+#if WEB_DISPLAY_ITEM_LIST_IS_DEFINED
+#include "third_party/WebKit/public/platform/WebDisplayItemList.h"
+#endif
+
+class SkImageFilter;
+class SkMatrix44;
+class SkPicture;
+class SkRRect;
+
+namespace cc_blink {
+
+#if WEB_DISPLAY_ITEM_LIST_IS_DEFINED
+class WebDisplayItemListImpl : public blink::WebDisplayItemList {
+#else
+class WebDisplayItemListImpl {
+#endif
+
+ public:
+ CC_BLINK_EXPORT WebDisplayItemListImpl();
+ virtual ~WebDisplayItemListImpl();
+
+ scoped_refptr<cc::DisplayItemList> ToDisplayItemList();
+
+ // blink::WebDisplayItemList implementation.
+ virtual void appendDrawingItem(SkPicture* picture,
+ const blink::WebFloatPoint& location);
+ virtual void appendClipItem(
+ const blink::WebRect& clip_rect,
+ const blink::WebVector<SkRRect>& rounded_clip_rects);
+ virtual void appendEndClipItem();
+ virtual void appendTransformItem(const SkMatrix44& matrix);
+ virtual void appendEndTransformItem();
+ virtual void appendTransparencyItem(float opacity,
+ blink::WebBlendMode blend_mode);
+ virtual void appendEndTransparencyItem();
+ virtual void appendFilterItem(SkImageFilter* filter,
+ const blink::WebFloatRect& bounds);
+ virtual void appendEndFilterItem();
+
+ private:
+ scoped_refptr<cc::DisplayItemList> display_item_list_;
+
+ DISALLOW_COPY_AND_ASSIGN(WebDisplayItemListImpl);
+};
+
+} // namespace cc_blink
+
+#endif // CC_BLINK_WEB_DISPLAY_ITEM_LIST_IMPL_H_
diff --git a/cc/cc.gyp b/cc/cc.gyp
index 046d43c..3374251 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -358,10 +358,24 @@
'resources/bitmap_raster_worker_pool.h',
'resources/bitmap_skpicture_content_layer_updater.cc',
'resources/bitmap_skpicture_content_layer_updater.h',
+ 'resources/clip_display_item.cc',
+ 'resources/clip_display_item.h',
'resources/content_layer_updater.cc',
'resources/content_layer_updater.h',
+ 'resources/display_item.cc',
+ 'resources/display_item.h',
+ 'resources/display_item_list.cc',
+ 'resources/display_item_list.h',
+ 'resources/display_list_raster_source.cc',
+ 'resources/display_list_raster_source.h',
+ 'resources/display_list_recording_source.cc',
+ 'resources/display_list_recording_source.h',
+ 'resources/drawing_display_item.cc',
+ 'resources/drawing_display_item.h',
'resources/eviction_tile_priority_queue.cc',
'resources/eviction_tile_priority_queue.h',
+ 'resources/filter_display_item.cc',
+ 'resources/filter_display_item.h',
'resources/gpu_raster_worker_pool.cc',
'resources/gpu_raster_worker_pool.h',
'resources/image_layer_updater.cc',
@@ -401,6 +415,8 @@
'resources/raster_buffer.cc',
'resources/raster_buffer.h',
'resources/raster_source.h',
+ 'resources/raster_source_helper.cc',
+ 'resources/raster_source_helper.h',
'resources/raster_tile_priority_queue.cc',
'resources/raster_tile_priority_queue.h',
'resources/raster_worker_pool.cc',
@@ -453,8 +469,14 @@
'resources/tile_manager.h',
'resources/tile_priority.cc',
'resources/tile_priority.h',
+ 'resources/tiling_set_eviction_queue.cc',
+ 'resources/tiling_set_eviction_queue.h',
'resources/transferable_resource.cc',
'resources/transferable_resource.h',
+ 'resources/transform_display_item.cc',
+ 'resources/transform_display_item.h',
+ 'resources/transparency_display_item.cc',
+ 'resources/transparency_display_item.h',
'resources/ui_resource_bitmap.cc',
'resources/ui_resource_bitmap.h',
'resources/ui_resource_client.h',
diff --git a/cc/cc_tests.gyp b/cc/cc_tests.gyp
index d4a031f..d0b1000 100644
--- a/cc/cc_tests.gyp
+++ b/cc/cc_tests.gyp
@@ -74,6 +74,7 @@
'quads/draw_quad_unittest.cc',
'quads/list_container_unittest.cc',
'quads/render_pass_unittest.cc',
+ 'resources/display_item_list_unittest.cc',
'resources/layer_quad_unittest.cc',
'resources/picture_layer_tiling_set_unittest.cc',
'resources/picture_layer_tiling_unittest.cc',
diff --git a/cc/debug/rasterize_and_record_benchmark.cc b/cc/debug/rasterize_and_record_benchmark.cc
index a2052ab..41d6210 100644
--- a/cc/debug/rasterize_and_record_benchmark.cc
+++ b/cc/debug/rasterize_and_record_benchmark.cc
@@ -18,6 +18,7 @@
#include "cc/resources/picture_pile.h"
#include "cc/trees/layer_tree_host.h"
#include "cc/trees/layer_tree_host_common.h"
+#include "third_party/skia/include/utils/SkPictureUtils.h"
#include "ui/gfx/geometry/rect.h"
namespace cc {
@@ -64,6 +65,7 @@
DCHECK(!results_.get());
results_ = make_scoped_ptr(new base::DictionaryValue);
results_->SetInteger("pixels_recorded", record_results_.pixels_recorded);
+ results_->SetInteger("picture_memory_usage", record_results_.bytes_used);
for (int i = 0; i < Picture::RECORDING_MODE_COUNT; i++) {
std::string name = base::StringPrintf("record_time%s_ms", kModeSuffixes[i]);
@@ -119,6 +121,7 @@
Picture::RecordingMode mode =
static_cast<Picture::RecordingMode>(mode_index);
base::TimeDelta min_time = base::TimeDelta::Max();
+ size_t memory_used = 0;
// Parameters for LapTimer.
const int kTimeLimitMillis = 1;
@@ -131,18 +134,21 @@
LapTimer timer(kWarmupRuns,
base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
kTimeCheckInterval);
+ scoped_refptr<Picture> picture;
do {
- scoped_refptr<Picture> picture = Picture::Create(
- visible_content_rect, painter, tile_grid_info, false, mode);
+ picture = Picture::Create(visible_content_rect, painter, tile_grid_info,
+ false, mode);
timer.NextLap();
} while (!timer.HasTimeLimitExpired());
base::TimeDelta duration =
base::TimeDelta::FromMillisecondsD(timer.MsPerLap());
if (duration < min_time)
min_time = duration;
+ memory_used = picture->ApproximateMemoryUsage();
}
if (mode == Picture::RECORD_NORMALLY) {
+ record_results_.bytes_used += memory_used;
record_results_.pixels_recorded +=
visible_content_rect.width() * visible_content_rect.height();
}
@@ -151,7 +157,8 @@
}
RasterizeAndRecordBenchmark::RecordResults::RecordResults()
- : pixels_recorded(0) {}
+ : pixels_recorded(0), bytes_used(0) {
+}
RasterizeAndRecordBenchmark::RecordResults::~RecordResults() {}
diff --git a/cc/debug/rasterize_and_record_benchmark.h b/cc/debug/rasterize_and_record_benchmark.h
index 68d5d05..8a23292 100644
--- a/cc/debug/rasterize_and_record_benchmark.h
+++ b/cc/debug/rasterize_and_record_benchmark.h
@@ -46,6 +46,7 @@
~RecordResults();
int pixels_recorded;
+ size_t bytes_used;
base::TimeDelta total_best_time[Picture::RECORDING_MODE_COUNT];
};
diff --git a/cc/debug/rasterize_and_record_benchmark_impl.cc b/cc/debug/rasterize_and_record_benchmark_impl.cc
index e276a41..c1fc809 100644
--- a/cc/debug/rasterize_and_record_benchmark_impl.cc
+++ b/cc/debug/rasterize_and_record_benchmark_impl.cc
@@ -173,6 +173,8 @@
scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
result->SetDouble("rasterize_time_ms",
rasterize_results_.total_best_time.InMillisecondsF());
+ result->SetDouble("total_pictures_in_pile_size",
+ rasterize_results_.total_memory_usage);
result->SetInteger("pixels_rasterized", rasterize_results_.pixels_rasterized);
result->SetInteger("pixels_rasterized_with_non_solid_color",
rasterize_results_.pixels_rasterized_with_non_solid_color);
@@ -263,16 +265,22 @@
rasterize_results_.pixels_rasterized += tile_size;
rasterize_results_.total_best_time += min_time;
}
+
+ const RasterSource* layer_raster_source = layer->GetRasterSource();
+ rasterize_results_.total_memory_usage +=
+ layer_raster_source->GetPictureMemoryUsage();
}
RasterizeAndRecordBenchmarkImpl::RasterizeResults::RasterizeResults()
: pixels_rasterized(0),
pixels_rasterized_with_non_solid_color(0),
pixels_rasterized_as_opaque(0),
+ total_memory_usage(0),
total_layers(0),
total_picture_layers(0),
total_picture_layers_with_no_content(0),
- total_picture_layers_off_screen(0) {}
+ total_picture_layers_off_screen(0) {
+}
RasterizeAndRecordBenchmarkImpl::RasterizeResults::~RasterizeResults() {}
diff --git a/cc/debug/rasterize_and_record_benchmark_impl.h b/cc/debug/rasterize_and_record_benchmark_impl.h
index c0f26fd..7ca471a 100644
--- a/cc/debug/rasterize_and_record_benchmark_impl.h
+++ b/cc/debug/rasterize_and_record_benchmark_impl.h
@@ -41,6 +41,7 @@
int pixels_rasterized_with_non_solid_color;
int pixels_rasterized_as_opaque;
base::TimeDelta total_best_time;
+ int total_memory_usage;
int total_layers;
int total_picture_layers;
int total_picture_layers_with_no_content;
diff --git a/cc/layers/content_layer_client.h b/cc/layers/content_layer_client.h
index ea22e97..c8d3a7e 100644
--- a/cc/layers/content_layer_client.h
+++ b/cc/layers/content_layer_client.h
@@ -6,6 +6,7 @@
#define CC_LAYERS_CONTENT_LAYER_CLIENT_H_
#include "cc/base/cc_export.h"
+#include "cc/resources/display_item_list.h"
class SkCanvas;
@@ -27,6 +28,10 @@
const gfx::Rect& clip,
GraphicsContextStatus gc_status) = 0;
+ virtual scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
+ const gfx::Rect& clip,
+ GraphicsContextStatus gc_status) = 0;
+
// If true the layer may skip clearing the background before rasterizing,
// because it will cover any uncleared data with content.
virtual bool FillsBoundsCompletely() const = 0;
diff --git a/cc/layers/picture_image_layer.cc b/cc/layers/picture_image_layer.cc
index dba506e..5d76618 100644
--- a/cc/layers/picture_image_layer.cc
+++ b/cc/layers/picture_image_layer.cc
@@ -60,6 +60,13 @@
canvas->drawBitmap(bitmap_, 0, 0);
}
+scoped_refptr<DisplayItemList> PictureImageLayer::PaintContentsToDisplayList(
+ const gfx::Rect& clip,
+ GraphicsContextStatus gc_status) {
+ NOTIMPLEMENTED();
+ return DisplayItemList::Create();
+}
+
bool PictureImageLayer::FillsBoundsCompletely() const {
return false;
}
diff --git a/cc/layers/picture_image_layer.h b/cc/layers/picture_image_layer.h
index 3f8d68d..57c7de2 100644
--- a/cc/layers/picture_image_layer.h
+++ b/cc/layers/picture_image_layer.h
@@ -27,6 +27,9 @@
SkCanvas* canvas,
const gfx::Rect& clip,
ContentLayerClient::GraphicsContextStatus gc_status) override;
+ scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
+ const gfx::Rect& clip,
+ GraphicsContextStatus gc_status) override;
bool FillsBoundsCompletely() const override;
protected:
diff --git a/cc/layers/picture_layer.cc b/cc/layers/picture_layer.cc
index d734538..55241d0 100644
--- a/cc/layers/picture_layer.cc
+++ b/cc/layers/picture_layer.cc
@@ -7,6 +7,7 @@
#include "base/auto_reset.h"
#include "cc/layers/content_layer_client.h"
#include "cc/layers/picture_layer_impl.h"
+#include "cc/resources/display_list_recording_source.h"
#include "cc/resources/picture_pile.h"
#include "cc/trees/layer_tree_impl.h"
#include "third_party/skia/include/core/SkPictureRecorder.h"
@@ -20,7 +21,6 @@
PictureLayer::PictureLayer(ContentLayerClient* client)
: client_(client),
- recording_source_(new PicturePile),
instrumentation_object_tracker_(id()),
update_source_frame_number_(-1),
can_use_lcd_text_for_update_(true),
@@ -79,6 +79,13 @@
void PictureLayer::SetLayerTreeHost(LayerTreeHost* host) {
Layer::SetLayerTreeHost(host);
if (host) {
+ if (!recording_source_) {
+ if (host->settings().use_display_lists) {
+ recording_source_.reset(new DisplayListRecordingSource);
+ } else {
+ recording_source_.reset(new PicturePile);
+ }
+ }
recording_source_->SetMinContentsScale(
host->settings().minimum_contents_scale);
recording_source_->SetTileGridSize(host->settings().default_tile_grid_size);
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 0eb9621..1827bea 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -98,6 +98,14 @@
layer_tree_impl()->UnregisterPictureLayerImpl(this);
}
+scoped_ptr<TilingSetEvictionQueue> PictureLayerImpl::CreateEvictionQueue(
+ TreePriority tree_priority) {
+ if (!tilings_)
+ return make_scoped_ptr(new TilingSetEvictionQueue());
+ return make_scoped_ptr(
+ new TilingSetEvictionQueue(tilings_.get(), tree_priority));
+}
+
const char* PictureLayerImpl::LayerTypeAsString() const {
return "cc::PictureLayerImpl";
}
@@ -1475,158 +1483,4 @@
}
}
-PictureLayerImpl::LayerEvictionTileIterator::LayerEvictionTileIterator()
- : layer_(nullptr),
- tree_priority_(SAME_PRIORITY_FOR_BOTH_TREES),
- current_category_(PictureLayerTiling::EVENTUALLY),
- current_tiling_range_type_(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES),
- current_tiling_(0u) {
-}
-
-PictureLayerImpl::LayerEvictionTileIterator::LayerEvictionTileIterator(
- PictureLayerImpl* layer,
- TreePriority tree_priority)
- : layer_(layer),
- tree_priority_(tree_priority),
- current_category_(PictureLayerTiling::EVENTUALLY),
- current_tiling_range_type_(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES),
- current_tiling_(0u) {
- // Early out if the layer has no tilings.
- if (!layer_->tilings_ || !layer_->tilings_->num_tilings())
- return;
-
- current_tiling_ = CurrentTilingRange().start - 1u;
- do {
- if (!AdvanceToNextTiling())
- break;
-
- current_iterator_ = PictureLayerTiling::TilingEvictionTileIterator(
- layer_->tilings_->tiling_at(CurrentTilingIndex()),
- tree_priority,
- current_category_);
- } while (!current_iterator_);
-}
-
-PictureLayerImpl::LayerEvictionTileIterator::~LayerEvictionTileIterator() {
-}
-
-Tile* PictureLayerImpl::LayerEvictionTileIterator::operator*() {
- DCHECK(*this);
- return *current_iterator_;
-}
-
-const Tile* PictureLayerImpl::LayerEvictionTileIterator::operator*() const {
- DCHECK(*this);
- return *current_iterator_;
-}
-
-PictureLayerImpl::LayerEvictionTileIterator&
-PictureLayerImpl::LayerEvictionTileIterator::
-operator++() {
- DCHECK(*this);
- ++current_iterator_;
- while (!current_iterator_) {
- if (!AdvanceToNextTiling())
- break;
-
- current_iterator_ = PictureLayerTiling::TilingEvictionTileIterator(
- layer_->tilings_->tiling_at(CurrentTilingIndex()),
- tree_priority_,
- current_category_);
- }
- return *this;
-}
-
-PictureLayerImpl::LayerEvictionTileIterator::operator bool() const {
- return !!current_iterator_;
-}
-
-bool PictureLayerImpl::LayerEvictionTileIterator::AdvanceToNextCategory() {
- switch (current_category_) {
- case PictureLayerTiling::EVENTUALLY:
- current_category_ =
- PictureLayerTiling::EVENTUALLY_AND_REQUIRED_FOR_ACTIVATION;
- return true;
- case PictureLayerTiling::EVENTUALLY_AND_REQUIRED_FOR_ACTIVATION:
- current_category_ = PictureLayerTiling::SOON;
- return true;
- case PictureLayerTiling::SOON:
- current_category_ = PictureLayerTiling::SOON_AND_REQUIRED_FOR_ACTIVATION;
- return true;
- case PictureLayerTiling::SOON_AND_REQUIRED_FOR_ACTIVATION:
- current_category_ = PictureLayerTiling::NOW;
- return true;
- case PictureLayerTiling::NOW:
- current_category_ = PictureLayerTiling::NOW_AND_REQUIRED_FOR_ACTIVATION;
- return true;
- case PictureLayerTiling::NOW_AND_REQUIRED_FOR_ACTIVATION:
- return false;
- }
- NOTREACHED();
- return false;
-}
-
-bool
-PictureLayerImpl::LayerEvictionTileIterator::AdvanceToNextTilingRangeType() {
- switch (current_tiling_range_type_) {
- case PictureLayerTilingSet::HIGHER_THAN_HIGH_RES:
- current_tiling_range_type_ = PictureLayerTilingSet::LOWER_THAN_LOW_RES;
- return true;
- case PictureLayerTilingSet::LOWER_THAN_LOW_RES:
- current_tiling_range_type_ =
- PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES;
- return true;
- case PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES:
- current_tiling_range_type_ = PictureLayerTilingSet::LOW_RES;
- return true;
- case PictureLayerTilingSet::LOW_RES:
- current_tiling_range_type_ = PictureLayerTilingSet::HIGH_RES;
- return true;
- case PictureLayerTilingSet::HIGH_RES:
- if (!AdvanceToNextCategory())
- return false;
-
- current_tiling_range_type_ = PictureLayerTilingSet::HIGHER_THAN_HIGH_RES;
- return true;
- }
- NOTREACHED();
- return false;
-}
-
-bool PictureLayerImpl::LayerEvictionTileIterator::AdvanceToNextTiling() {
- DCHECK_NE(current_tiling_, CurrentTilingRange().end);
- ++current_tiling_;
- while (current_tiling_ == CurrentTilingRange().end) {
- if (!AdvanceToNextTilingRangeType())
- return false;
-
- current_tiling_ = CurrentTilingRange().start;
- }
- return true;
-}
-
-PictureLayerTilingSet::TilingRange
-PictureLayerImpl::LayerEvictionTileIterator::CurrentTilingRange() const {
- return layer_->tilings_->GetTilingRange(current_tiling_range_type_);
-}
-
-size_t PictureLayerImpl::LayerEvictionTileIterator::CurrentTilingIndex() const {
- DCHECK_NE(current_tiling_, CurrentTilingRange().end);
- switch (current_tiling_range_type_) {
- case PictureLayerTilingSet::HIGHER_THAN_HIGH_RES:
- case PictureLayerTilingSet::LOW_RES:
- case PictureLayerTilingSet::HIGH_RES:
- return current_tiling_;
- // Tilings in the following ranges are accessed in reverse order.
- case PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES:
- case PictureLayerTilingSet::LOWER_THAN_LOW_RES: {
- PictureLayerTilingSet::TilingRange tiling_range = CurrentTilingRange();
- size_t current_tiling_range_offset = current_tiling_ - tiling_range.start;
- return tiling_range.end - 1 - current_tiling_range_offset;
- }
- }
- NOTREACHED();
- return 0;
-}
-
} // namespace cc
diff --git a/cc/layers/picture_layer_impl.h b/cc/layers/picture_layer_impl.h
index 9a77546..52d8433 100644
--- a/cc/layers/picture_layer_impl.h
+++ b/cc/layers/picture_layer_impl.h
@@ -15,6 +15,7 @@
#include "cc/resources/picture_layer_tiling.h"
#include "cc/resources/picture_layer_tiling_set.h"
#include "cc/resources/picture_pile_impl.h"
+#include "cc/resources/tiling_set_eviction_queue.h"
#include "skia/ext/refptr.h"
#include "third_party/skia/include/core/SkPicture.h"
@@ -67,40 +68,14 @@
PictureLayerTiling::TilingRasterTileIterator iterators_[NUM_ITERATORS];
};
- class CC_EXPORT LayerEvictionTileIterator {
- public:
- LayerEvictionTileIterator();
- LayerEvictionTileIterator(PictureLayerImpl* layer,
- TreePriority tree_priority);
- ~LayerEvictionTileIterator();
-
- Tile* operator*();
- const Tile* operator*() const;
- LayerEvictionTileIterator& operator++();
- operator bool() const;
-
- private:
- bool AdvanceToNextCategory();
- bool AdvanceToNextTilingRangeType();
- bool AdvanceToNextTiling();
-
- PictureLayerTilingSet::TilingRange CurrentTilingRange() const;
- size_t CurrentTilingIndex() const;
-
- PictureLayerImpl* layer_;
- TreePriority tree_priority_;
-
- PictureLayerTiling::EvictionCategory current_category_;
- PictureLayerTilingSet::TilingRangeType current_tiling_range_type_;
- size_t current_tiling_;
- PictureLayerTiling::TilingEvictionTileIterator current_iterator_;
- };
-
static scoped_ptr<PictureLayerImpl> Create(LayerTreeImpl* tree_impl, int id) {
return make_scoped_ptr(new PictureLayerImpl(tree_impl, id));
}
~PictureLayerImpl() override;
+ scoped_ptr<TilingSetEvictionQueue> CreateEvictionQueue(
+ TreePriority tree_priority);
+
// LayerImpl overrides.
const char* LayerTypeAsString() const override;
scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl) override;
@@ -154,6 +129,9 @@
bool AllTilesRequiredForActivationAreReadyToDraw() const;
bool AllTilesRequiredForDrawAreReadyToDraw() const;
+ // Used for benchmarking
+ const RasterSource* GetRasterSource() const { return raster_source_.get(); }
+
protected:
friend class LayerRasterTileIterator;
using TileRequirementCheck = bool (PictureLayerTiling::*)(const Tile*) const;
diff --git a/cc/layers/picture_layer_impl_perftest.cc b/cc/layers/picture_layer_impl_perftest.cc
index 1f98a68..bfb5703 100644
--- a/cc/layers/picture_layer_impl_perftest.cc
+++ b/cc/layers/picture_layer_impl_perftest.cc
@@ -115,7 +115,7 @@
true);
}
- void RunEvictionIteratorConstructAndIterateTest(
+ void RunEvictionQueueConstructAndIterateTest(
const std::string& test_name,
int num_tiles,
const gfx::Size& viewport_size) {
@@ -129,12 +129,12 @@
timer_.Reset();
do {
int count = num_tiles;
- PictureLayerImpl::LayerEvictionTileIterator it(
- pending_layer_, priorities[priority_count]);
+ scoped_ptr<TilingSetEvictionQueue> queue =
+ pending_layer_->CreateEvictionQueue(priorities[priority_count]);
while (count--) {
- ASSERT_TRUE(it) << "count: " << count;
- ASSERT_TRUE(*it != nullptr) << "count: " << count;
- ++it;
+ ASSERT_TRUE(!queue->IsEmpty()) << "count: " << count;
+ ASSERT_TRUE(queue->Top() != nullptr) << "count: " << count;
+ queue->Pop();
}
priority_count = (priority_count + 1) % arraysize(priorities);
timer_.NextLap();
@@ -148,8 +148,8 @@
true);
}
- void RunEvictionIteratorConstructTest(const std::string& test_name,
- const gfx::Rect& viewport) {
+ void RunEvictionQueueConstructTest(const std::string& test_name,
+ const gfx::Rect& viewport) {
host_impl_.SetViewportSize(viewport.size());
pending_layer_->SetScrollOffset(
gfx::ScrollOffset(viewport.x(), viewport.y()));
@@ -161,8 +161,8 @@
int priority_count = 0;
timer_.Reset();
do {
- PictureLayerImpl::LayerEvictionTileIterator it(
- pending_layer_, priorities[priority_count]);
+ scoped_ptr<TilingSetEvictionQueue> queue =
+ pending_layer_->CreateEvictionQueue(priorities[priority_count]);
priority_count = (priority_count + 1) % arraysize(priorities);
timer_.NextLap();
} while (!timer_.HasTimeLimitExpired());
@@ -225,6 +225,7 @@
gfx::Rect(9999, 0, 100, 100));
}
+// TODO(e_hakkinen): Rename these tests once the perf numbers are in.
TEST_F(PictureLayerImplPerfTest, LayerEvictionTileIteratorConstructAndIterate) {
SetupPendingTree(gfx::Size(10000, 10000), gfx::Size(256, 256));
@@ -240,16 +241,17 @@
ASSERT_TRUE(host_impl_.tile_manager() != nullptr);
host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
- RunEvictionIteratorConstructAndIterateTest(
+ RunEvictionQueueConstructAndIterateTest(
"32_100x100", 32, gfx::Size(100, 100));
- RunEvictionIteratorConstructAndIterateTest(
+ RunEvictionQueueConstructAndIterateTest(
"32_500x500", 32, gfx::Size(500, 500));
- RunEvictionIteratorConstructAndIterateTest(
+ RunEvictionQueueConstructAndIterateTest(
"64_100x100", 64, gfx::Size(100, 100));
- RunEvictionIteratorConstructAndIterateTest(
+ RunEvictionQueueConstructAndIterateTest(
"64_500x500", 64, gfx::Size(500, 500));
}
+// TODO(e_hakkinen): Rename these tests once the perf numbers are in.
TEST_F(PictureLayerImplPerfTest, LayerEvictionTileIteratorConstruct) {
SetupPendingTree(gfx::Size(10000, 10000), gfx::Size(256, 256));
@@ -265,11 +267,9 @@
ASSERT_TRUE(host_impl_.tile_manager() != nullptr);
host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
- RunEvictionIteratorConstructTest("0_0_100x100", gfx::Rect(0, 0, 100, 100));
- RunEvictionIteratorConstructTest("5000_0_100x100",
- gfx::Rect(5000, 0, 100, 100));
- RunEvictionIteratorConstructTest("9999_0_100x100",
- gfx::Rect(9999, 0, 100, 100));
+ RunEvictionQueueConstructTest("0_0_100x100", gfx::Rect(0, 0, 100, 100));
+ RunEvictionQueueConstructTest("5000_0_100x100", gfx::Rect(5000, 0, 100, 100));
+ RunEvictionQueueConstructTest("9999_0_100x100", gfx::Rect(9999, 0, 100, 100));
}
} // namespace
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index 246e625..ce66675 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -330,7 +330,7 @@
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(400, 400);
@@ -347,7 +347,7 @@
time_ticks += base::TimeDelta::FromMilliseconds(200);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
// Update tiles with viewport for tile priority as (0, 0, 100, 100) and the
// identify transform for tile priority.
@@ -385,7 +385,7 @@
// should be (200, 200, 100, 100) applied with the said transform.
time_ticks += base::TimeDelta::FromMilliseconds(200);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
viewport_rect_for_tile_priority = gfx::Rect(200, 200, 100, 100);
transform_for_tile_priority.Translate(100, 100);
@@ -426,7 +426,7 @@
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(400, 400);
@@ -468,7 +468,7 @@
// Should update viewport and transform, but not update visible rect.
time_ticks += base::TimeDelta::FromMilliseconds(200);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
resourceless_software_draw = true;
viewport = gfx::ScaleToEnclosingRect(viewport, 2);
transform.Translate(1.f, 1.f);
@@ -492,7 +492,7 @@
// Keep expanded viewport but mark it valid. Should update tile viewport.
time_ticks += base::TimeDelta::FromMilliseconds(200);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
resourceless_software_draw = false;
host_impl_.SetExternalDrawConstraints(transform,
viewport,
@@ -1561,7 +1561,7 @@
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
pending_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
EXPECT_EQ(HIGH_RESOLUTION, tiling->resolution());
@@ -1589,7 +1589,7 @@
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(400, 400);
@@ -1625,7 +1625,7 @@
pending_layer_->draw_properties().visible_content_rect = visible_content_rect;
time_ticks += base::TimeDelta::FromMilliseconds(200);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
pending_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
// Intersect the two rects. Any tile outside should not be required for
@@ -1678,7 +1678,7 @@
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(200, 200);
@@ -1714,7 +1714,7 @@
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(200, 200);
@@ -1745,7 +1745,7 @@
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(200, 200);
@@ -1779,7 +1779,7 @@
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(200, 200);
@@ -1822,7 +1822,7 @@
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(200, 200);
@@ -1890,6 +1890,9 @@
TEST_F(PictureLayerImplTest, HighResRequiredWhenUnsharedActiveAllReady) {
gfx::Size layer_bounds(400, 400);
gfx::Size tile_size(100, 100);
+
+ host_impl_.SetViewportSize(layer_bounds);
+
SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
// No tiles shared.
@@ -1911,6 +1914,9 @@
TEST_F(PictureLayerImplTest, HighResRequiredWhenMissingHighResFlagOn) {
gfx::Size layer_bounds(400, 400);
gfx::Size tile_size(100, 100);
+
+ host_impl_.SetViewportSize(layer_bounds);
+
SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
// All tiles shared (no invalidation).
@@ -1935,6 +1941,9 @@
TEST_F(PictureLayerImplTest, AllHighResRequiredEvenIfShared) {
gfx::Size layer_bounds(400, 400);
gfx::Size tile_size(100, 100);
+
+ host_impl_.SetViewportSize(layer_bounds);
+
SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
CreateHighLowResAndSetAllTilesVisible();
@@ -2009,6 +2018,9 @@
TEST_F(PictureLayerImplTest, HighResRequiredIfActiveCantHaveTiles) {
gfx::Size layer_bounds(400, 400);
gfx::Size tile_size(100, 100);
+
+ host_impl_.SetViewportSize(layer_bounds);
+
scoped_refptr<FakePicturePileImpl> pending_pile =
FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
scoped_refptr<FakePicturePileImpl> active_pile =
@@ -2767,7 +2779,7 @@
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(1000, 1000);
@@ -2837,7 +2849,7 @@
// No NOW tiles.
time_ticks += base::TimeDelta::FromMilliseconds(200);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
pending_layer_->draw_properties().visible_content_rect =
gfx::Rect(1100, 1100, 500, 500);
@@ -2868,7 +2880,7 @@
time_ticks += base::TimeDelta::FromMilliseconds(200);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
pending_layer_->draw_properties().visible_content_rect =
gfx::Rect(0, 0, 500, 500);
@@ -2903,7 +2915,7 @@
EXPECT_EQ(0u, high_res_tile_count);
}
-TEST_F(PictureLayerImplTest, LayerEvictionTileIterator) {
+TEST_F(PictureLayerImplTest, TilingSetEvictionQueue) {
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(1000, 1000);
@@ -2964,14 +2976,10 @@
EXPECT_GT(number_of_marked_tiles, 1u);
EXPECT_GT(number_of_unmarked_tiles, 1u);
- // Empty iterator.
- PictureLayerImpl::LayerEvictionTileIterator it;
- EXPECT_FALSE(it);
-
// Tiles don't have resources yet.
- it = PictureLayerImpl::LayerEvictionTileIterator(
- pending_layer_, SAME_PRIORITY_FOR_BOTH_TREES);
- EXPECT_FALSE(it);
+ scoped_ptr<TilingSetEvictionQueue> queue =
+ pending_layer_->CreateEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES);
+ EXPECT_TRUE(queue->IsEmpty());
host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
@@ -2980,11 +2988,9 @@
size_t scale_index = 0;
bool reached_visible = false;
Tile* last_tile = nullptr;
- for (it = PictureLayerImpl::LayerEvictionTileIterator(
- pending_layer_, SAME_PRIORITY_FOR_BOTH_TREES);
- it;
- ++it) {
- Tile* tile = *it;
+ queue = pending_layer_->CreateEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES);
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
if (!last_tile)
last_tile = tile;
@@ -3022,6 +3028,7 @@
}
last_tile = tile;
+ queue->Pop();
}
EXPECT_TRUE(reached_visible);
@@ -3029,8 +3036,8 @@
scale_index = 0;
bool reached_required = false;
- for (; it; ++it) {
- Tile* tile = *it;
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile);
TilePriority priority = tile->priority(PENDING_TREE);
@@ -3051,6 +3058,7 @@
EXPECT_FLOAT_EQ(tile->contents_scale(), expected_scales[scale_index]);
unique_tiles.insert(tile);
+ queue->Pop();
}
EXPECT_TRUE(reached_required);
@@ -3155,6 +3163,8 @@
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(1000, 1000);
+ host_impl_.SetViewportSize(layer_bounds);
+
SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
// Make sure some tiles are not shared.
@@ -3182,6 +3192,8 @@
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(1000, 1000);
+ host_impl_.SetViewportSize(layer_bounds);
+
SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
// Make sure some tiles are not shared.
@@ -3205,6 +3217,8 @@
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(1000, 1000);
+ host_impl_.SetViewportSize(layer_bounds);
+
SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
// Make sure some tiles are not shared.
@@ -3229,6 +3243,8 @@
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(1000, 1000);
+ host_impl_.SetViewportSize(layer_bounds);
+
SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
// Make sure some tiles are not shared.
@@ -3316,6 +3332,9 @@
TEST_F(NoLowResPictureLayerImplTest, AllHighResRequiredEvenIfShared) {
gfx::Size layer_bounds(400, 400);
gfx::Size tile_size(100, 100);
+
+ host_impl_.SetViewportSize(layer_bounds);
+
SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
CreateHighLowResAndSetAllTilesVisible();
@@ -3374,7 +3393,7 @@
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(400, 400);
@@ -3416,7 +3435,7 @@
// Should update viewport and transform, but not update visible rect.
time_ticks += base::TimeDelta::FromMilliseconds(200);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
resourceless_software_draw = true;
viewport = gfx::ScaleToEnclosingRect(viewport, 2);
transform.Translate(1.f, 1.f);
@@ -3440,7 +3459,7 @@
// Keep expanded viewport but mark it valid. Should update tile viewport.
time_ticks += base::TimeDelta::FromMilliseconds(200);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
resourceless_software_draw = false;
host_impl_.SetExternalDrawConstraints(transform,
viewport,
@@ -3677,6 +3696,8 @@
gfx::Size tile_size(400, 400);
gfx::Size layer_bounds(1000, 2000);
+ host_impl_.SetViewportSize(layer_bounds);
+
scoped_refptr<FakePicturePileImpl> pending_pile =
FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
scoped_refptr<FakePicturePileImpl> active_pile =
@@ -3841,12 +3862,10 @@
size_t occluded_tile_count = 0u;
Tile* last_tile = nullptr;
- for (PictureLayerImpl::LayerEvictionTileIterator it =
- PictureLayerImpl::LayerEvictionTileIterator(layer,
- tree_priority);
- it;
- ++it) {
- Tile* tile = *it;
+ scoped_ptr<TilingSetEvictionQueue> queue =
+ layer->CreateEvictionQueue(tree_priority);
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
if (!last_tile)
last_tile = tile;
@@ -3874,6 +3893,7 @@
}
}
last_tile = tile;
+ queue->Pop();
}
EXPECT_EQ(expected_occluded_tile_count[priority_count],
occluded_tile_count);
@@ -3886,7 +3906,7 @@
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
gfx::Size tile_size(102, 102);
gfx::Size layer_bounds(1000, 1000);
@@ -3932,7 +3952,7 @@
time_ticks += base::TimeDelta::FromMilliseconds(200);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
host_impl_.pending_tree()->UpdateDrawProperties();
unoccluded_tile_count = 0;
@@ -3956,7 +3976,7 @@
time_ticks += base::TimeDelta::FromMilliseconds(200);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
host_impl_.pending_tree()->UpdateDrawProperties();
unoccluded_tile_count = 0;
@@ -3981,7 +4001,7 @@
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
gfx::Size tile_size(102, 102);
gfx::Size layer_bounds(1000, 1000);
@@ -4032,7 +4052,7 @@
time_ticks += base::TimeDelta::FromMilliseconds(200);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
host_impl_.pending_tree()->UpdateDrawProperties();
for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
@@ -4072,7 +4092,7 @@
time_ticks += base::TimeDelta::FromMilliseconds(200);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
host_impl_.pending_tree()->UpdateDrawProperties();
for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
@@ -4501,7 +4521,7 @@
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(200, 200);
@@ -4568,7 +4588,7 @@
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(200, 200);
@@ -4625,7 +4645,7 @@
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
- CreateBeginFrameArgsForTesting(time_ticks));
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(400, 4000);
diff --git a/cc/layers/picture_layer_unittest.cc b/cc/layers/picture_layer_unittest.cc
index 3f81ef8..ac20e4c 100644
--- a/cc/layers/picture_layer_unittest.cc
+++ b/cc/layers/picture_layer_unittest.cc
@@ -24,6 +24,12 @@
SkCanvas* canvas,
const gfx::Rect& clip,
ContentLayerClient::GraphicsContextStatus gc_status) override {}
+ scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
+ const gfx::Rect& clip,
+ GraphicsContextStatus gc_status) override {
+ NOTIMPLEMENTED();
+ return DisplayItemList::Create();
+ }
bool FillsBoundsCompletely() const override { return false; };
};
@@ -73,6 +79,9 @@
TEST(PictureLayerTest, SuitableForGpuRasterization) {
MockContentLayerClient client;
scoped_refptr<PictureLayer> layer = PictureLayer::Create(&client);
+ FakeLayerTreeHostClient host_client(FakeLayerTreeHostClient::DIRECT_3D);
+ scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(&host_client);
+ host->SetRootLayer(layer);
RecordingSource* recording_source = layer->GetRecordingSourceForTesting();
// Layer is suitable for gpu rasterization by default.
diff --git a/cc/layers/tiled_layer_unittest.cc b/cc/layers/tiled_layer_unittest.cc
index 908d428..512fa51 100644
--- a/cc/layers/tiled_layer_unittest.cc
+++ b/cc/layers/tiled_layer_unittest.cc
@@ -261,6 +261,8 @@
};
TEST_F(TiledLayerTest, PushDirtyTiles) {
+ layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
+
scoped_refptr<FakeTiledLayer> layer =
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
scoped_ptr<FakeTiledLayerImpl> layer_impl =
@@ -290,6 +292,8 @@
}
TEST_F(TiledLayerTest, Scale) {
+ layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
+
layer_tree_host_->SetDeviceScaleFactor(1.5);
scoped_refptr<FakeTiledLayer> layer =
@@ -352,6 +356,8 @@
}
TEST_F(TiledLayerTest, PushDeletedTiles) {
+ layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
+
scoped_refptr<FakeTiledLayer> layer =
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
scoped_ptr<FakeTiledLayerImpl> layer_impl =
@@ -1201,6 +1207,8 @@
}
TEST_F(TiledLayerTest, TilesPaintedWithoutOcclusion) {
+ layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
+
scoped_refptr<FakeTiledLayer> layer =
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
RenderSurfaceLayerList render_surface_layer_list;
diff --git a/cc/output/begin_frame_args.cc b/cc/output/begin_frame_args.cc
index 0be9318..5744d9d 100644
--- a/cc/output/begin_frame_args.cc
+++ b/cc/output/begin_frame_args.cc
@@ -41,12 +41,19 @@
type(type) {
}
-BeginFrameArgs BeginFrameArgs::Create(base::TimeTicks frame_time,
+BeginFrameArgs BeginFrameArgs::Create(BeginFrameArgs::CreationLocation location,
+ base::TimeTicks frame_time,
base::TimeTicks deadline,
base::TimeDelta interval,
BeginFrameArgs::BeginFrameArgsType type) {
DCHECK_NE(type, BeginFrameArgs::INVALID);
+#ifdef NDEBUG
return BeginFrameArgs(frame_time, deadline, interval, type);
+#else
+ BeginFrameArgs args = BeginFrameArgs(frame_time, deadline, interval, type);
+ args.created_from = location;
+ return args;
+#endif
}
scoped_refptr<base::debug::ConvertableToTraceFormat> BeginFrameArgs::AsValue()
@@ -63,6 +70,9 @@
state->SetDouble("frame_time_us", frame_time.ToInternalValue());
state->SetDouble("deadline_us", deadline.ToInternalValue());
state->SetDouble("interval_us", interval.InMicroseconds());
+#ifndef NDEBUG
+ state->SetString("created_from", created_from.ToString());
+#endif
}
// This is a hard-coded deadline adjustment that assumes 60Hz, to be used in
diff --git a/cc/output/begin_frame_args.h b/cc/output/begin_frame_args.h
index 0be5241..ba29523 100644
--- a/cc/output/begin_frame_args.h
+++ b/cc/output/begin_frame_args.h
@@ -5,6 +5,7 @@
#ifndef CC_OUTPUT_BEGIN_FRAME_ARGS_H_
#define CC_OUTPUT_BEGIN_FRAME_ARGS_H_
+#include "base/location.h"
#include "base/memory/ref_counted.h"
#include "base/time/time.h"
#include "base/values.h"
@@ -17,6 +18,22 @@
}
}
+/**
+ * In debug builds we trace the creation origin of BeginFrameArgs objects. We
+ * reuse the tracked_objects::Location system to do that.
+ *
+ * However, in release builds we don't want this as it doubles the size of the
+ * BeginFrameArgs object. As well it adds a number of largish strings to the
+ * binary. Despite the argument being unused, most compilers are unable to
+ * optimise it away even when unused. Instead we use the BEGINFRAME_FROM_HERE
+ * macro to prevent the data even getting referenced.
+ */
+#ifdef NDEBUG
+#define BEGINFRAME_FROM_HERE nullptr
+#else
+#define BEGINFRAME_FROM_HERE FROM_HERE
+#endif
+
namespace cc {
struct CC_EXPORT BeginFrameArgs {
@@ -31,9 +48,18 @@
// Creates an invalid set of values.
BeginFrameArgs();
+#ifdef NDEBUG
+ typedef const void* CreationLocation;
+#else
+ typedef const tracked_objects::Location& CreationLocation;
+ tracked_objects::Location created_from;
+#endif
+
// You should be able to find all instances where a BeginFrame has been
// created by searching for "BeginFrameArgs::Create".
- static BeginFrameArgs Create(base::TimeTicks frame_time,
+ // The location argument should **always** be BEGINFRAME_FROM_HERE macro.
+ static BeginFrameArgs Create(CreationLocation location,
+ base::TimeTicks frame_time,
base::TimeTicks deadline,
base::TimeDelta interval,
BeginFrameArgsType type);
diff --git a/cc/output/begin_frame_args_unittest.cc b/cc/output/begin_frame_args_unittest.cc
index 9d77a45..877a857 100644
--- a/cc/output/begin_frame_args_unittest.cc
+++ b/cc/output/begin_frame_args_unittest.cc
@@ -15,26 +15,29 @@
TEST(BeginFrameArgsTest, Helpers) {
// Quick create methods work
- BeginFrameArgs args0 = CreateBeginFrameArgsForTesting();
+ BeginFrameArgs args0 = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
EXPECT_TRUE(args0.IsValid()) << args0;
- BeginFrameArgs args1 = CreateBeginFrameArgsForTesting(0, 0, -1);
+ BeginFrameArgs args1 =
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 0, -1);
EXPECT_FALSE(args1.IsValid()) << args1;
- BeginFrameArgs args2 = CreateBeginFrameArgsForTesting(1, 2, 3);
+ BeginFrameArgs args2 =
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 1, 2, 3);
EXPECT_TRUE(args2.IsValid()) << args2;
EXPECT_EQ(1, args2.frame_time.ToInternalValue());
EXPECT_EQ(2, args2.deadline.ToInternalValue());
EXPECT_EQ(3, args2.interval.ToInternalValue());
EXPECT_EQ(BeginFrameArgs::NORMAL, args2.type);
- BeginFrameArgs args3 = CreateExpiredBeginFrameArgsForTesting();
+ BeginFrameArgs args3 =
+ CreateExpiredBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
EXPECT_TRUE(args3.IsValid()) << args3;
EXPECT_GT(gfx::FrameTime::Now(), args3.deadline);
EXPECT_EQ(BeginFrameArgs::NORMAL, args3.type);
- BeginFrameArgs args4 =
- CreateBeginFrameArgsForTesting(1, 2, 3, BeginFrameArgs::MISSED);
+ BeginFrameArgs args4 = CreateBeginFrameArgsForTesting(
+ BEGINFRAME_FROM_HERE, 1, 2, 3, BeginFrameArgs::MISSED);
EXPECT_TRUE(args4.IsValid()) << args4;
EXPECT_EQ(1, args4.frame_time.ToInternalValue());
EXPECT_EQ(2, args4.deadline.ToInternalValue());
@@ -42,16 +45,19 @@
EXPECT_EQ(BeginFrameArgs::MISSED, args4.type);
// operator==
- EXPECT_EQ(CreateBeginFrameArgsForTesting(4, 5, 6),
- CreateBeginFrameArgsForTesting(4, 5, 6));
+ EXPECT_EQ(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 4, 5, 6),
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 4, 5, 6));
EXPECT_NONFATAL_FAILURE(
- EXPECT_EQ(CreateBeginFrameArgsForTesting(7, 8, 9, BeginFrameArgs::MISSED),
- CreateBeginFrameArgsForTesting(7, 8, 9)),
+ EXPECT_EQ(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 7, 8, 9,
+ BeginFrameArgs::MISSED),
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 7, 8, 9)),
"");
- EXPECT_NONFATAL_FAILURE(EXPECT_EQ(CreateBeginFrameArgsForTesting(4, 5, 6),
- CreateBeginFrameArgsForTesting(7, 8, 9)),
- "");
+
+ EXPECT_NONFATAL_FAILURE(
+ EXPECT_EQ(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 4, 5, 6),
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 7, 8, 9)),
+ "");
// operator<<
std::stringstream out1;
@@ -74,7 +80,7 @@
EXPECT_FALSE(args1.IsValid()) << args1;
BeginFrameArgs args2 = BeginFrameArgs::Create(
- base::TimeTicks::FromInternalValue(1),
+ BEGINFRAME_FROM_HERE, base::TimeTicks::FromInternalValue(1),
base::TimeTicks::FromInternalValue(2),
base::TimeDelta::FromInternalValue(3), BeginFrameArgs::NORMAL);
EXPECT_TRUE(args2.IsValid()) << args2;
@@ -84,5 +90,14 @@
EXPECT_EQ(BeginFrameArgs::NORMAL, args2.type) << args2;
}
+#ifndef NDEBUG
+TEST(BeginFrameArgsTest, Location) {
+ tracked_objects::Location expected_location = BEGINFRAME_FROM_HERE;
+
+ BeginFrameArgs args = CreateBeginFrameArgsForTesting(expected_location);
+ EXPECT_EQ(expected_location.ToString(), args.created_from.ToString());
+}
+#endif
+
} // namespace
} // namespace cc
diff --git a/cc/output/renderer_settings.cc b/cc/output/renderer_settings.cc
index bacde5b..2277af3 100644
--- a/cc/output/renderer_settings.cc
+++ b/cc/output/renderer_settings.cc
@@ -15,6 +15,7 @@
force_antialiasing(false),
force_blending_with_shaders(false),
partial_swap_enabled(false),
+ finish_rendering_on_resize(false),
should_clear_root_render_pass(true),
refresh_rate(60.0),
highp_threshold_min(0),
diff --git a/cc/output/renderer_settings.h b/cc/output/renderer_settings.h
index 748d230..6da0238 100644
--- a/cc/output/renderer_settings.h
+++ b/cc/output/renderer_settings.h
@@ -19,6 +19,7 @@
bool force_antialiasing;
bool force_blending_with_shaders;
bool partial_swap_enabled;
+ bool finish_rendering_on_resize;
bool should_clear_root_render_pass;
double refresh_rate;
int highp_threshold_min;
diff --git a/cc/quads/largest_draw_quad.cc b/cc/quads/largest_draw_quad.cc
index 55fcb22..6445204 100644
--- a/cc/quads/largest_draw_quad.cc
+++ b/cc/quads/largest_draw_quad.cc
@@ -6,15 +6,62 @@
#include <algorithm>
+#include "cc/quads/checkerboard_draw_quad.h"
+#include "cc/quads/debug_border_draw_quad.h"
+#include "cc/quads/io_surface_draw_quad.h"
+#include "cc/quads/picture_draw_quad.h"
#include "cc/quads/render_pass_draw_quad.h"
+#include "cc/quads/solid_color_draw_quad.h"
#include "cc/quads/stream_video_draw_quad.h"
+#include "cc/quads/surface_draw_quad.h"
+#include "cc/quads/texture_draw_quad.h"
+#include "cc/quads/tile_draw_quad.h"
+#include "cc/quads/yuv_video_draw_quad.h"
+
+namespace {
+const size_t kLargestDrawQuadSize =
+ sizeof(cc::RenderPassDrawQuad) > sizeof(cc::StreamVideoDrawQuad)
+ ? sizeof(cc::RenderPassDrawQuad)
+ : sizeof(cc::StreamVideoDrawQuad);
+} // namespace
namespace cc {
size_t LargestDrawQuadSize() {
- // The largest quad is either a RenderPassDrawQuad or a StreamVideoDrawQuad
- // depends on hardware structure.
- return std::max(sizeof(RenderPassDrawQuad), sizeof(StreamVideoDrawQuad));
+ // Currently the largest quad is either a RenderPassDrawQuad or a
+ // StreamVideoDrawQuad depends on hardware structure.
+
+ // Use compile assert to make sure largest is actually larger than all other
+ // type of draw quads.
+ COMPILE_ASSERT(sizeof(CheckerboardDrawQuad) <= kLargestDrawQuadSize,
+ "Largest Draw Quad size needs update. CheckerboardDrawQuad is "
+ "currently largest.");
+ COMPILE_ASSERT(sizeof(DebugBorderDrawQuad) <= kLargestDrawQuadSize,
+ "Largest Draw Quad size needs update. DebugBorderDrawQuad is "
+ "currently largest.");
+ COMPILE_ASSERT(sizeof(IOSurfaceDrawQuad) <= kLargestDrawQuadSize,
+ "Largest Draw Quad size needs update. IOSurfaceDrawQuad is "
+ "currently largest.");
+ COMPILE_ASSERT(sizeof(PictureDrawQuad) <= kLargestDrawQuadSize,
+ "Largest Draw Quad size needs update. PictureDrawQuad is "
+ "currently largest.");
+ COMPILE_ASSERT(sizeof(TextureDrawQuad) <= kLargestDrawQuadSize,
+ "Largest Draw Quad size needs update. TextureDrawQuad is "
+ "currently largest.");
+ COMPILE_ASSERT(sizeof(SolidColorDrawQuad) <= kLargestDrawQuadSize,
+ "Largest Draw Quad size needs update. SolidColorDrawQuad is "
+ "currently largest.");
+ COMPILE_ASSERT(sizeof(SurfaceDrawQuad) <= kLargestDrawQuadSize,
+ "Largest Draw Quad size needs update. SurfaceDrawQuad is "
+ "currently largest.");
+ COMPILE_ASSERT(sizeof(TileDrawQuad) <= kLargestDrawQuadSize,
+ "Largest Draw Quad size needs update. TileDrawQuad is "
+ "currently largest.");
+ COMPILE_ASSERT(sizeof(YUVVideoDrawQuad) <= kLargestDrawQuadSize,
+ "Largest Draw Quad size needs update. YUVVideoDrawQuad is "
+ "currently largest.");
+
+ return kLargestDrawQuadSize;
}
} // namespace cc
diff --git a/cc/resources/clip_display_item.cc b/cc/resources/clip_display_item.cc
new file mode 100644
index 0000000..731c605
--- /dev/null
+++ b/cc/resources/clip_display_item.cc
@@ -0,0 +1,74 @@
+// Copyright 2014 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/resources/clip_display_item.h"
+
+#include "third_party/skia/include/core/SkCanvas.h"
+
+namespace cc {
+
+ClipDisplayItem::ClipDisplayItem(gfx::Rect clip_rect,
+ const std::vector<SkRRect>& rounded_clip_rects)
+ : clip_rect_(clip_rect), rounded_clip_rects_(rounded_clip_rects) {
+}
+
+ClipDisplayItem::~ClipDisplayItem() {
+}
+
+void ClipDisplayItem::Raster(SkCanvas* canvas,
+ SkDrawPictureCallback* callback) const {
+ canvas->save();
+ canvas->clipRect(SkRect::MakeXYWH(clip_rect_.x(), clip_rect_.y(),
+ clip_rect_.width(), clip_rect_.height()));
+ for (size_t i = 0; i < rounded_clip_rects_.size(); ++i) {
+ if (rounded_clip_rects_[i].isRect()) {
+ canvas->clipRect(rounded_clip_rects_[i].rect());
+ } else {
+ bool antialiased = true;
+ canvas->clipRRect(rounded_clip_rects_[i], SkRegion::kIntersect_Op,
+ antialiased);
+ }
+ }
+}
+
+bool ClipDisplayItem::IsSuitableForGpuRasterization() const {
+ return true;
+}
+
+int ClipDisplayItem::ApproximateOpCount() const {
+ return 1;
+}
+
+size_t ClipDisplayItem::PictureMemoryUsage() const {
+ size_t total_size = sizeof(gfx::Rect);
+ for (size_t i = 0; i < rounded_clip_rects_.size(); ++i) {
+ total_size += sizeof(rounded_clip_rects_[i]);
+ }
+ return total_size;
+}
+
+EndClipDisplayItem::EndClipDisplayItem() {
+}
+
+EndClipDisplayItem::~EndClipDisplayItem() {
+}
+
+void EndClipDisplayItem::Raster(SkCanvas* canvas,
+ SkDrawPictureCallback* callback) const {
+ canvas->restore();
+}
+
+bool EndClipDisplayItem::IsSuitableForGpuRasterization() const {
+ return true;
+}
+
+int EndClipDisplayItem::ApproximateOpCount() const {
+ return 0;
+}
+
+size_t EndClipDisplayItem::PictureMemoryUsage() const {
+ return 0;
+}
+
+} // namespace cc
diff --git a/cc/resources/clip_display_item.h b/cc/resources/clip_display_item.h
new file mode 100644
index 0000000..55c1ffd
--- /dev/null
+++ b/cc/resources/clip_display_item.h
@@ -0,0 +1,66 @@
+// Copyright 2014 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_CLIP_DISPLAY_ITEM_H_
+#define CC_RESOURCES_CLIP_DISPLAY_ITEM_H_
+
+#include <vector>
+
+#include "base/memory/scoped_ptr.h"
+#include "cc/base/cc_export.h"
+#include "cc/resources/display_item.h"
+#include "third_party/skia/include/core/SkRRect.h"
+#include "ui/gfx/geometry/rect.h"
+
+class SkCanvas;
+class SkDrawPictureCallback;
+
+namespace cc {
+
+class CC_EXPORT ClipDisplayItem : public DisplayItem {
+ public:
+ virtual ~ClipDisplayItem();
+
+ static scoped_ptr<ClipDisplayItem> Create(
+ gfx::Rect clip_rect,
+ const std::vector<SkRRect>& rounded_clip_rects) {
+ return make_scoped_ptr(new ClipDisplayItem(clip_rect, rounded_clip_rects));
+ }
+
+ void Raster(SkCanvas* canvas, SkDrawPictureCallback* callback) const override;
+
+ bool IsSuitableForGpuRasterization() const override;
+ int ApproximateOpCount() const override;
+ size_t PictureMemoryUsage() const override;
+
+ protected:
+ ClipDisplayItem(gfx::Rect clip_rect,
+ const std::vector<SkRRect>& rounded_clip_rects);
+
+ private:
+ gfx::Rect clip_rect_;
+ std::vector<SkRRect> rounded_clip_rects_;
+};
+
+class CC_EXPORT EndClipDisplayItem : public DisplayItem {
+ public:
+ virtual ~EndClipDisplayItem();
+
+ static scoped_ptr<EndClipDisplayItem> Create() {
+ return make_scoped_ptr(new EndClipDisplayItem());
+ }
+
+ void Raster(SkCanvas* canvas, SkDrawPictureCallback* callback) const override;
+
+ bool IsSuitableForGpuRasterization() const override;
+ int ApproximateOpCount() const override;
+ size_t PictureMemoryUsage() const override;
+
+ protected:
+ EndClipDisplayItem();
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_CLIP_DISPLAY_ITEM_H_
diff --git a/cc/resources/display_item.cc b/cc/resources/display_item.cc
new file mode 100644
index 0000000..33069a5
--- /dev/null
+++ b/cc/resources/display_item.cc
@@ -0,0 +1,12 @@
+// Copyright 2014 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/resources/display_item.h"
+
+namespace cc {
+
+DisplayItem::DisplayItem() {
+}
+
+} // namespace cc
diff --git a/cc/resources/display_item.h b/cc/resources/display_item.h
new file mode 100644
index 0000000..6f1b5f7
--- /dev/null
+++ b/cc/resources/display_item.h
@@ -0,0 +1,34 @@
+// Copyright 2014 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_DISPLAY_ITEM_H_
+#define CC_RESOURCES_DISPLAY_ITEM_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "cc/base/cc_export.h"
+#include "ui/gfx/rect.h"
+
+class SkCanvas;
+class SkDrawPictureCallback;
+
+namespace cc {
+
+class CC_EXPORT DisplayItem {
+ public:
+ virtual ~DisplayItem() {}
+
+ virtual void Raster(SkCanvas* canvas,
+ SkDrawPictureCallback* callback) const = 0;
+
+ virtual bool IsSuitableForGpuRasterization() const = 0;
+ virtual int ApproximateOpCount() const = 0;
+ virtual size_t PictureMemoryUsage() const = 0;
+
+ protected:
+ DisplayItem();
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_DISPLAY_ITEM_H_
diff --git a/cc/resources/display_item_list.cc b/cc/resources/display_item_list.cc
new file mode 100644
index 0000000..2ead28d
--- /dev/null
+++ b/cc/resources/display_item_list.cc
@@ -0,0 +1,79 @@
+// Copyright 2014 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/resources/display_item_list.h"
+
+#include "base/debug/trace_event.h"
+#include "base/debug/trace_event_argument.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+
+namespace cc {
+
+DisplayItemList::DisplayItemList()
+ : is_suitable_for_gpu_rasterization_(true), approximate_op_count_(0) {
+}
+
+scoped_refptr<DisplayItemList> DisplayItemList::Create() {
+ return make_scoped_refptr(new DisplayItemList());
+}
+
+DisplayItemList::~DisplayItemList() {
+}
+
+void DisplayItemList::Raster(SkCanvas* canvas,
+ SkDrawPictureCallback* callback,
+ float contents_scale) const {
+ canvas->save();
+ canvas->scale(contents_scale, contents_scale);
+ for (size_t i = 0; i < items_.size(); ++i) {
+ items_[i]->Raster(canvas, callback);
+ }
+ canvas->restore();
+}
+
+void DisplayItemList::AppendItem(scoped_ptr<DisplayItem> item) {
+ is_suitable_for_gpu_rasterization_ &= item->IsSuitableForGpuRasterization();
+ approximate_op_count_ += item->ApproximateOpCount();
+ items_.push_back(item.Pass());
+}
+
+bool DisplayItemList::IsSuitableForGpuRasterization() const {
+ // This is more permissive than Picture's implementation, since none of the
+ // items might individually trigger a veto even though they collectively have
+ // enough "bad" operations that a corresponding Picture would get vetoed.
+ return is_suitable_for_gpu_rasterization_;
+}
+
+int DisplayItemList::ApproximateOpCount() const {
+ return approximate_op_count_;
+}
+
+size_t DisplayItemList::PictureMemoryUsage() const {
+ size_t total_size = 0;
+
+ for (const auto& item : items_) {
+ total_size += item->PictureMemoryUsage();
+ }
+
+ return total_size;
+}
+
+scoped_refptr<base::debug::ConvertableToTraceFormat> DisplayItemList::AsValue()
+ const {
+ scoped_refptr<base::debug::TracedValue> state =
+ new base::debug::TracedValue();
+
+ // TODO(ajuma): Include the value of each item.
+ state->SetInteger("length", items_.size());
+ return state;
+}
+
+void DisplayItemList::EmitTraceSnapshot() const {
+ TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
+ TRACE_DISABLED_BY_DEFAULT("cc.debug") "," TRACE_DISABLED_BY_DEFAULT(
+ "devtools.timeline.picture"),
+ "cc::DisplayItemList", this, AsValue());
+}
+
+} // namespace cc
diff --git a/cc/resources/display_item_list.h b/cc/resources/display_item_list.h
new file mode 100644
index 0000000..10d052f
--- /dev/null
+++ b/cc/resources/display_item_list.h
@@ -0,0 +1,53 @@
+// Copyright 2014 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_DISPLAY_ITEM_LIST_H_
+#define CC_RESOURCES_DISPLAY_ITEM_LIST_H_
+
+#include "base/debug/trace_event.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "cc/base/cc_export.h"
+#include "cc/base/scoped_ptr_vector.h"
+#include "cc/resources/display_item.h"
+#include "ui/gfx/rect.h"
+
+class SkCanvas;
+class SkDrawPictureCallback;
+
+namespace cc {
+
+class CC_EXPORT DisplayItemList
+ : public base::RefCountedThreadSafe<DisplayItemList> {
+ public:
+ static scoped_refptr<DisplayItemList> Create();
+
+ void Raster(SkCanvas* canvas,
+ SkDrawPictureCallback* callback,
+ float contents_scale) const;
+
+ void AppendItem(scoped_ptr<DisplayItem> item);
+
+ bool IsSuitableForGpuRasterization() const;
+ int ApproximateOpCount() const;
+ size_t PictureMemoryUsage() const;
+
+ scoped_refptr<base::debug::ConvertableToTraceFormat> AsValue() const;
+
+ void EmitTraceSnapshot() const;
+
+ private:
+ DisplayItemList();
+ ~DisplayItemList();
+ ScopedPtrVector<DisplayItem> items_;
+ bool is_suitable_for_gpu_rasterization_;
+ int approximate_op_count_;
+
+ friend class base::RefCountedThreadSafe<DisplayItemList>;
+ DISALLOW_COPY_AND_ASSIGN(DisplayItemList);
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_DISPLAY_ITEM_LIST_H_
diff --git a/cc/resources/display_item_list_unittest.cc b/cc/resources/display_item_list_unittest.cc
new file mode 100644
index 0000000..d6455a2
--- /dev/null
+++ b/cc/resources/display_item_list_unittest.cc
@@ -0,0 +1,166 @@
+// Copyright 2014 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/resources/display_item_list.h"
+
+#include <vector>
+
+#include "cc/resources/clip_display_item.h"
+#include "cc/resources/drawing_display_item.h"
+#include "cc/resources/transform_display_item.h"
+#include "cc/test/skia_common.h"
+#include "skia/ext/refptr.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "third_party/skia/include/core/SkPictureRecorder.h"
+#include "ui/gfx/skia_util.h"
+
+namespace cc {
+namespace {
+
+TEST(DisplayItemListTest, SingleDrawingItem) {
+ gfx::Rect layer_rect(100, 100);
+ SkPictureRecorder recorder;
+ skia::RefPtr<SkCanvas> canvas;
+ skia::RefPtr<SkPicture> picture;
+ SkPaint blue_paint;
+ blue_paint.setColor(SK_ColorBLUE);
+ SkPaint red_paint;
+ red_paint.setColor(SK_ColorRED);
+ unsigned char pixels[4 * 100 * 100] = {0};
+ scoped_refptr<DisplayItemList> list = DisplayItemList::Create();
+
+ canvas = skia::SharePtr(
+ recorder.beginRecording(layer_rect.width(), layer_rect.height()));
+ canvas->drawRectCoords(0.f, 0.f, 60.f, 60.f, red_paint);
+ canvas->drawRectCoords(50.f, 50.f, 75.f, 75.f, blue_paint);
+ picture = skia::AdoptRef(recorder.endRecording());
+ gfx::PointF offset(8.f, 9.f);
+ list->AppendItem(DrawingDisplayItem::Create(picture, offset));
+ DrawDisplayList(pixels, layer_rect, list);
+
+ SkBitmap expected_bitmap;
+ unsigned char expected_pixels[4 * 100 * 100] = {0};
+ SkImageInfo info =
+ SkImageInfo::MakeN32Premul(layer_rect.width(), layer_rect.height());
+ expected_bitmap.installPixels(info, expected_pixels, info.minRowBytes());
+ SkCanvas expected_canvas(expected_bitmap);
+ expected_canvas.clipRect(gfx::RectToSkRect(layer_rect));
+ expected_canvas.drawRectCoords(0.f + offset.x(), 0.f + offset.y(),
+ 60.f + offset.x(), 60.f + offset.y(),
+ red_paint);
+ expected_canvas.drawRectCoords(50.f + offset.x(), 50.f + offset.y(),
+ 75.f + offset.x(), 75.f + offset.y(),
+ blue_paint);
+
+ EXPECT_EQ(0, memcmp(pixels, expected_pixels, 4 * 100 * 100));
+}
+
+TEST(DisplayItemListTest, ClipItem) {
+ gfx::Rect layer_rect(100, 100);
+ SkPictureRecorder recorder;
+ skia::RefPtr<SkCanvas> canvas;
+ skia::RefPtr<SkPicture> picture;
+ SkPaint blue_paint;
+ blue_paint.setColor(SK_ColorBLUE);
+ SkPaint red_paint;
+ red_paint.setColor(SK_ColorRED);
+ unsigned char pixels[4 * 100 * 100] = {0};
+ scoped_refptr<DisplayItemList> list = DisplayItemList::Create();
+
+ canvas = skia::SharePtr(
+ recorder.beginRecording(layer_rect.width(), layer_rect.height()));
+ canvas->drawRectCoords(0.f, 0.f, 60.f, 60.f, red_paint);
+ picture = skia::AdoptRef(recorder.endRecording());
+ gfx::PointF first_offset(8.f, 9.f);
+ list->AppendItem(DrawingDisplayItem::Create(picture, first_offset));
+
+ gfx::Rect clip_rect(60, 60, 10, 10);
+ list->AppendItem(ClipDisplayItem::Create(clip_rect, std::vector<SkRRect>()));
+
+ canvas = skia::SharePtr(
+ recorder.beginRecording(layer_rect.width(), layer_rect.height()));
+ canvas->drawRectCoords(50.f, 50.f, 75.f, 75.f, blue_paint);
+ picture = skia::AdoptRef(recorder.endRecording());
+ gfx::PointF second_offset(2.f, 3.f);
+ list->AppendItem(DrawingDisplayItem::Create(picture, second_offset));
+
+ list->AppendItem(EndClipDisplayItem::Create());
+
+ DrawDisplayList(pixels, layer_rect, list);
+
+ SkBitmap expected_bitmap;
+ unsigned char expected_pixels[4 * 100 * 100] = {0};
+ SkImageInfo info =
+ SkImageInfo::MakeN32Premul(layer_rect.width(), layer_rect.height());
+ expected_bitmap.installPixels(info, expected_pixels, info.minRowBytes());
+ SkCanvas expected_canvas(expected_bitmap);
+ expected_canvas.clipRect(gfx::RectToSkRect(layer_rect));
+ expected_canvas.drawRectCoords(0.f + first_offset.x(), 0.f + first_offset.y(),
+ 60.f + first_offset.x(),
+ 60.f + first_offset.y(), red_paint);
+ expected_canvas.clipRect(gfx::RectToSkRect(clip_rect));
+ expected_canvas.drawRectCoords(
+ 50.f + second_offset.x(), 50.f + second_offset.y(),
+ 75.f + second_offset.x(), 75.f + second_offset.y(), blue_paint);
+
+ EXPECT_EQ(0, memcmp(pixels, expected_pixels, 4 * 100 * 100));
+}
+
+TEST(DisplayItemListTest, TransformItem) {
+ gfx::Rect layer_rect(100, 100);
+ SkPictureRecorder recorder;
+ skia::RefPtr<SkCanvas> canvas;
+ skia::RefPtr<SkPicture> picture;
+ SkPaint blue_paint;
+ blue_paint.setColor(SK_ColorBLUE);
+ SkPaint red_paint;
+ red_paint.setColor(SK_ColorRED);
+ unsigned char pixels[4 * 100 * 100] = {0};
+ scoped_refptr<DisplayItemList> list = DisplayItemList::Create();
+
+ canvas = skia::SharePtr(
+ recorder.beginRecording(layer_rect.width(), layer_rect.height()));
+ canvas->drawRectCoords(0.f, 0.f, 60.f, 60.f, red_paint);
+ picture = skia::AdoptRef(recorder.endRecording());
+ gfx::PointF first_offset(8.f, 9.f);
+ list->AppendItem(DrawingDisplayItem::Create(picture, first_offset));
+
+ gfx::Transform transform;
+ transform.Rotate(45.0);
+ list->AppendItem(TransformDisplayItem::Create(transform));
+
+ canvas = skia::SharePtr(
+ recorder.beginRecording(layer_rect.width(), layer_rect.height()));
+ canvas->drawRectCoords(50.f, 50.f, 75.f, 75.f, blue_paint);
+ picture = skia::AdoptRef(recorder.endRecording());
+ gfx::PointF second_offset(2.f, 3.f);
+ list->AppendItem(DrawingDisplayItem::Create(picture, second_offset));
+
+ list->AppendItem(EndTransformDisplayItem::Create());
+
+ DrawDisplayList(pixels, layer_rect, list);
+
+ SkBitmap expected_bitmap;
+ unsigned char expected_pixels[4 * 100 * 100] = {0};
+ SkImageInfo info =
+ SkImageInfo::MakeN32Premul(layer_rect.width(), layer_rect.height());
+ expected_bitmap.installPixels(info, expected_pixels, info.minRowBytes());
+ SkCanvas expected_canvas(expected_bitmap);
+ expected_canvas.clipRect(gfx::RectToSkRect(layer_rect));
+ expected_canvas.drawRectCoords(0.f + first_offset.x(), 0.f + first_offset.y(),
+ 60.f + first_offset.x(),
+ 60.f + first_offset.y(), red_paint);
+ expected_canvas.setMatrix(transform.matrix());
+ expected_canvas.drawRectCoords(
+ 50.f + second_offset.x(), 50.f + second_offset.y(),
+ 75.f + second_offset.x(), 75.f + second_offset.y(), blue_paint);
+
+ EXPECT_EQ(0, memcmp(pixels, expected_pixels, 4 * 100 * 100));
+}
+
+} // namespace
+} // namespace cc
diff --git a/cc/resources/display_list_raster_source.cc b/cc/resources/display_list_raster_source.cc
new file mode 100644
index 0000000..f3ff816
--- /dev/null
+++ b/cc/resources/display_list_raster_source.cc
@@ -0,0 +1,208 @@
+// Copyright 2014 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/resources/display_list_raster_source.h"
+
+#include "base/debug/trace_event.h"
+#include "cc/base/region.h"
+#include "cc/debug/debug_colors.h"
+#include "cc/resources/display_item_list.h"
+#include "cc/resources/raster_source_helper.h"
+#include "skia/ext/analysis_canvas.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkPictureRecorder.h"
+#include "ui/gfx/geometry/rect_conversions.h"
+
+namespace {
+
+#ifdef NDEBUG
+const bool kDefaultClearCanvasSetting = false;
+#else
+const bool kDefaultClearCanvasSetting = true;
+#endif
+
+} // namespace
+
+namespace cc {
+
+scoped_refptr<DisplayListRasterSource> DisplayListRasterSource::Create() {
+ return make_scoped_refptr(new DisplayListRasterSource);
+}
+
+scoped_refptr<DisplayListRasterSource>
+DisplayListRasterSource::CreateFromDisplayListRecordingSource(
+ const DisplayListRecordingSource* other) {
+ return make_scoped_refptr(new DisplayListRasterSource(other));
+}
+
+DisplayListRasterSource::DisplayListRasterSource()
+ : background_color_(SK_ColorTRANSPARENT),
+ requires_clear_(true),
+ can_use_lcd_text_(true),
+ is_solid_color_(false),
+ solid_color_(SK_ColorTRANSPARENT),
+ clear_canvas_with_debug_color_(kDefaultClearCanvasSetting),
+ slow_down_raster_scale_factor_for_debug_(0),
+ should_attempt_to_use_distance_field_text_(false) {
+}
+
+DisplayListRasterSource::DisplayListRasterSource(
+ const DisplayListRecordingSource* other)
+ : display_list_(other->display_list_),
+ background_color_(SK_ColorTRANSPARENT),
+ requires_clear_(true),
+ can_use_lcd_text_(other->can_use_lcd_text_),
+ is_solid_color_(other->is_solid_color_),
+ solid_color_(other->solid_color_),
+ recorded_viewport_(other->recorded_viewport_),
+ size_(other->size_),
+ clear_canvas_with_debug_color_(kDefaultClearCanvasSetting),
+ slow_down_raster_scale_factor_for_debug_(
+ other->slow_down_raster_scale_factor_for_debug_),
+ should_attempt_to_use_distance_field_text_(false) {
+}
+
+DisplayListRasterSource::~DisplayListRasterSource() {
+}
+
+void DisplayListRasterSource::PlaybackToSharedCanvas(
+ SkCanvas* canvas,
+ const gfx::Rect& canvas_rect,
+ float contents_scale) const {
+ RasterCommon(canvas, NULL, canvas_rect, contents_scale, false);
+}
+
+void DisplayListRasterSource::RasterForAnalysis(skia::AnalysisCanvas* canvas,
+ const gfx::Rect& canvas_rect,
+ float contents_scale) const {
+ RasterCommon(canvas, canvas, canvas_rect, contents_scale, true);
+}
+
+void DisplayListRasterSource::PlaybackToCanvas(SkCanvas* canvas,
+ const gfx::Rect& canvas_rect,
+ float contents_scale) const {
+ RasterSourceHelper::PrepareForPlaybackToCanvas(
+ canvas, canvas_rect, gfx::Rect(size_), contents_scale, background_color_,
+ clear_canvas_with_debug_color_, requires_clear_);
+
+ RasterCommon(canvas, NULL, canvas_rect, contents_scale, false);
+}
+
+void DisplayListRasterSource::RasterCommon(SkCanvas* canvas,
+ SkDrawPictureCallback* callback,
+ const gfx::Rect& canvas_rect,
+ float contents_scale,
+ bool is_analysis) const {
+ canvas->translate(-canvas_rect.x(), -canvas_rect.y());
+ gfx::Rect content_rect =
+ gfx::ToEnclosingRect(gfx::ScaleRect(gfx::Rect(size_), contents_scale));
+ content_rect.Intersect(canvas_rect);
+
+ canvas->clipRect(gfx::RectToSkRect(content_rect), SkRegion::kIntersect_Op);
+
+ DCHECK(display_list_.get());
+ display_list_->Raster(canvas, callback, contents_scale);
+}
+
+skia::RefPtr<SkPicture> DisplayListRasterSource::GetFlattenedPicture() {
+ TRACE_EVENT0("cc", "DisplayListRasterSource::GetFlattenedPicture");
+
+ gfx::Rect display_list_rect(size_);
+ SkPictureRecorder recorder;
+ SkCanvas* canvas = recorder.beginRecording(display_list_rect.width(),
+ display_list_rect.height());
+ if (!display_list_rect.IsEmpty())
+ PlaybackToCanvas(canvas, display_list_rect, 1.0);
+ skia::RefPtr<SkPicture> picture = skia::AdoptRef(recorder.endRecording());
+
+ return picture;
+}
+
+size_t DisplayListRasterSource::GetPictureMemoryUsage() const {
+ return display_list_->PictureMemoryUsage();
+}
+
+void DisplayListRasterSource::PerformSolidColorAnalysis(
+ const gfx::Rect& content_rect,
+ float contents_scale,
+ RasterSource::SolidColorAnalysis* analysis) const {
+ DCHECK(analysis);
+ TRACE_EVENT0("cc", "DisplayListRasterSource::PerformSolidColorAnalysis");
+
+ gfx::Rect layer_rect =
+ gfx::ScaleToEnclosingRect(content_rect, 1.0f / contents_scale);
+
+ layer_rect.Intersect(gfx::Rect(size_));
+ skia::AnalysisCanvas canvas(layer_rect.width(), layer_rect.height());
+ RasterForAnalysis(&canvas, layer_rect, 1.0f);
+ analysis->is_solid_color = canvas.GetColorIfSolid(&analysis->solid_color);
+}
+
+void DisplayListRasterSource::GatherPixelRefs(
+ const gfx::Rect& content_rect,
+ float contents_scale,
+ std::vector<SkPixelRef*>* pixel_refs) const {
+ // TODO(ajuma): Implement this.
+}
+
+bool DisplayListRasterSource::CoversRect(const gfx::Rect& content_rect,
+ float contents_scale) const {
+ if (size_.IsEmpty())
+ return false;
+ gfx::Rect layer_rect =
+ gfx::ScaleToEnclosingRect(content_rect, 1.f / contents_scale);
+ layer_rect.Intersect(gfx::Rect(size_));
+
+ return recorded_viewport_.Contains(layer_rect);
+}
+
+gfx::Size DisplayListRasterSource::GetSize() const {
+ return size_;
+}
+
+bool DisplayListRasterSource::IsSolidColor() const {
+ return is_solid_color_;
+}
+
+SkColor DisplayListRasterSource::GetSolidColor() const {
+ DCHECK(IsSolidColor());
+ return solid_color_;
+}
+
+bool DisplayListRasterSource::HasRecordings() const {
+ return !!display_list_.get();
+}
+
+void DisplayListRasterSource::SetShouldAttemptToUseDistanceFieldText() {
+ should_attempt_to_use_distance_field_text_ = true;
+}
+
+void DisplayListRasterSource::SetBackgoundColor(SkColor background_color) {
+ background_color_ = background_color;
+}
+
+void DisplayListRasterSource::SetRequiresClear(bool requires_clear) {
+ requires_clear_ = requires_clear;
+}
+
+bool DisplayListRasterSource::ShouldAttemptToUseDistanceFieldText() const {
+ return should_attempt_to_use_distance_field_text_;
+}
+
+void DisplayListRasterSource::AsValueInto(
+ base::debug::TracedValue* array) const {
+ if (display_list_.get())
+ TracedValue::AppendIDRef(display_list_.get(), array);
+}
+
+void DisplayListRasterSource::DidBeginTracing() {
+ if (display_list_.get())
+ display_list_->EmitTraceSnapshot();
+}
+
+bool DisplayListRasterSource::CanUseLCDText() const {
+ return can_use_lcd_text_;
+}
+
+} // namespace cc
diff --git a/cc/resources/display_list_raster_source.h b/cc/resources/display_list_raster_source.h
new file mode 100644
index 0000000..8f1fd12
--- /dev/null
+++ b/cc/resources/display_list_raster_source.h
@@ -0,0 +1,94 @@
+// Copyright 2014 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_DISPLAY_LIST_RASTER_SOURCE_H_
+#define CC_RESOURCES_DISPLAY_LIST_RASTER_SOURCE_H_
+
+#include <vector>
+
+#include "base/memory/scoped_ptr.h"
+#include "cc/base/cc_export.h"
+#include "cc/debug/rendering_stats_instrumentation.h"
+#include "cc/resources/display_list_recording_source.h"
+#include "cc/resources/raster_source.h"
+#include "skia/ext/analysis_canvas.h"
+#include "skia/ext/refptr.h"
+#include "third_party/skia/include/core/SkPicture.h"
+
+namespace cc {
+class DisplayItemList;
+
+class CC_EXPORT DisplayListRasterSource : public RasterSource {
+ public:
+ static scoped_refptr<DisplayListRasterSource> Create();
+ static scoped_refptr<DisplayListRasterSource>
+ CreateFromDisplayListRecordingSource(const DisplayListRecordingSource* other);
+
+ // RasterSource overrides.
+ void PlaybackToCanvas(SkCanvas* canvas,
+ const gfx::Rect& canvas_rect,
+ float contents_scale) const override;
+ void PlaybackToSharedCanvas(SkCanvas* canvas,
+ const gfx::Rect& canvas_rect,
+ float contents_scale) const override;
+ void PerformSolidColorAnalysis(
+ const gfx::Rect& content_rect,
+ float contents_scale,
+ RasterSource::SolidColorAnalysis* analysis) const override;
+ bool IsSolidColor() const override;
+ SkColor GetSolidColor() const override;
+ gfx::Size GetSize() const override;
+ void GatherPixelRefs(const gfx::Rect& content_rect,
+ float contents_scale,
+ std::vector<SkPixelRef*>* pixel_refs) const override;
+ bool CoversRect(const gfx::Rect& content_rect,
+ float contents_scale) const override;
+ bool HasRecordings() const override;
+ void SetShouldAttemptToUseDistanceFieldText() override;
+ void SetBackgoundColor(SkColor background_color) override;
+ void SetRequiresClear(bool requires_clear) override;
+ bool ShouldAttemptToUseDistanceFieldText() const override;
+ void DidBeginTracing() override;
+ void AsValueInto(base::debug::TracedValue* array) const override;
+ skia::RefPtr<SkPicture> GetFlattenedPicture() override;
+ size_t GetPictureMemoryUsage() const override;
+ bool CanUseLCDText() const override;
+
+ protected:
+ DisplayListRasterSource();
+ explicit DisplayListRasterSource(const DisplayListRecordingSource* other);
+ ~DisplayListRasterSource() override;
+
+ scoped_refptr<DisplayItemList> display_list_;
+ SkColor background_color_;
+ bool requires_clear_;
+ bool can_use_lcd_text_;
+ bool is_solid_color_;
+ SkColor solid_color_;
+ gfx::Rect recorded_viewport_;
+ gfx::Size size_;
+ bool clear_canvas_with_debug_color_;
+ int slow_down_raster_scale_factor_for_debug_;
+
+ private:
+ // Called when analyzing a tile. We can use AnalysisCanvas as
+ // SkDrawPictureCallback, which allows us to early out from analysis.
+ void RasterForAnalysis(skia::AnalysisCanvas* canvas,
+ const gfx::Rect& canvas_rect,
+ float contents_scale) const;
+
+ void RasterCommon(SkCanvas* canvas,
+ SkDrawPictureCallback* callback,
+ const gfx::Rect& canvas_rect,
+ float contents_scale,
+ bool is_analysis) const;
+
+ bool should_attempt_to_use_distance_field_text_;
+
+ DISALLOW_COPY_AND_ASSIGN(DisplayListRasterSource);
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_DISPLAY_LIST_RASTER_SOURCE_H_
diff --git a/cc/resources/display_list_recording_source.cc b/cc/resources/display_list_recording_source.cc
new file mode 100644
index 0000000..3c0e0e4
--- /dev/null
+++ b/cc/resources/display_list_recording_source.cc
@@ -0,0 +1,158 @@
+// Copyright 2014 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/resources/display_list_recording_source.h"
+
+#include <algorithm>
+
+#include "cc/base/region.h"
+#include "cc/layers/content_layer_client.h"
+#include "cc/resources/display_item_list.h"
+#include "cc/resources/display_list_raster_source.h"
+#include "skia/ext/analysis_canvas.h"
+
+namespace {
+
+// Layout pixel buffer around the visible layer rect to record. Any base
+// picture that intersects the visible layer rect expanded by this distance
+// will be recorded.
+const int kPixelDistanceToRecord = 8000;
+// We don't perform solid color analysis on images that have more than 10 skia
+// operations.
+const int kOpCountThatIsOkToAnalyze = 10;
+
+} // namespace
+
+namespace cc {
+
+DisplayListRecordingSource::DisplayListRecordingSource()
+ : slow_down_raster_scale_factor_for_debug_(0),
+ can_use_lcd_text_(true),
+ is_solid_color_(false),
+ solid_color_(SK_ColorTRANSPARENT),
+ pixel_record_distance_(kPixelDistanceToRecord),
+ is_suitable_for_gpu_rasterization_(true) {
+}
+
+DisplayListRecordingSource::~DisplayListRecordingSource() {
+}
+
+bool DisplayListRecordingSource::UpdateAndExpandInvalidation(
+ ContentLayerClient* painter,
+ Region* invalidation,
+ bool can_use_lcd_text,
+ const gfx::Size& layer_size,
+ const gfx::Rect& visible_layer_rect,
+ int frame_number,
+ Picture::RecordingMode recording_mode) {
+ bool updated = false;
+
+ if (size_ != layer_size) {
+ size_ = layer_size;
+ updated = true;
+ }
+
+ if (can_use_lcd_text_ != can_use_lcd_text) {
+ can_use_lcd_text_ = can_use_lcd_text;
+ invalidation->Union(gfx::Rect(GetSize()));
+ updated = true;
+ }
+
+ gfx::Rect old_recorded_viewport = recorded_viewport_;
+ recorded_viewport_ = visible_layer_rect;
+ recorded_viewport_.Inset(-pixel_record_distance_, -pixel_record_distance_);
+ recorded_viewport_.Intersect(gfx::Rect(GetSize()));
+
+ if (recorded_viewport_ != old_recorded_viewport) {
+ // Invalidate newly-exposed and no-longer-exposed areas.
+ Region newly_exposed_region(recorded_viewport_);
+ newly_exposed_region.Subtract(old_recorded_viewport);
+ invalidation->Union(newly_exposed_region);
+
+ Region no_longer_exposed_region(old_recorded_viewport);
+ no_longer_exposed_region.Subtract(recorded_viewport_);
+ invalidation->Union(no_longer_exposed_region);
+
+ updated = true;
+ }
+
+ if (!updated && !invalidation->Intersects(recorded_viewport_))
+ return false;
+
+ // TODO(ajuma): Does repeating this way really makes sense with display lists?
+ // With Blink caching recordings, repeated calls will not cause re-recording.
+ int repeat_count = std::max(1, slow_down_raster_scale_factor_for_debug_);
+ for (int i = 0; i < repeat_count; ++i) {
+ display_list_ = painter->PaintContentsToDisplayList(
+ recorded_viewport_, ContentLayerClient::GRAPHICS_CONTEXT_ENABLED);
+ }
+ is_suitable_for_gpu_rasterization_ =
+ display_list_->IsSuitableForGpuRasterization();
+
+ DetermineIfSolidColor();
+ display_list_->EmitTraceSnapshot();
+ return true;
+}
+
+gfx::Size DisplayListRecordingSource::GetSize() const {
+ return size_;
+}
+
+void DisplayListRecordingSource::SetEmptyBounds() {
+ size_ = gfx::Size();
+ Clear();
+}
+
+void DisplayListRecordingSource::SetMinContentsScale(float min_contents_scale) {
+}
+
+void DisplayListRecordingSource::SetTileGridSize(
+ const gfx::Size& tile_grid_size) {
+}
+
+void DisplayListRecordingSource::SetSlowdownRasterScaleFactor(int factor) {
+ slow_down_raster_scale_factor_for_debug_ = factor;
+}
+
+void DisplayListRecordingSource::SetUnsuitableForGpuRasterizationForTesting() {
+ is_suitable_for_gpu_rasterization_ = false;
+}
+
+bool DisplayListRecordingSource::IsSuitableForGpuRasterization() const {
+ return is_suitable_for_gpu_rasterization_;
+}
+
+scoped_refptr<RasterSource> DisplayListRecordingSource::CreateRasterSource()
+ const {
+ return scoped_refptr<RasterSource>(
+ DisplayListRasterSource::CreateFromDisplayListRecordingSource(this));
+}
+
+SkTileGridFactory::TileGridInfo
+DisplayListRecordingSource::GetTileGridInfoForTesting() const {
+ return SkTileGridFactory::TileGridInfo();
+}
+
+void DisplayListRecordingSource::DetermineIfSolidColor() {
+ DCHECK(display_list_.get());
+ is_solid_color_ = false;
+ solid_color_ = SK_ColorTRANSPARENT;
+
+ if (display_list_->ApproximateOpCount() > kOpCountThatIsOkToAnalyze)
+ return;
+
+ skia::AnalysisCanvas canvas(recorded_viewport_.width(),
+ recorded_viewport_.height());
+ canvas.translate(-recorded_viewport_.x(), -recorded_viewport_.y());
+ display_list_->Raster(&canvas, nullptr, 1.f);
+ is_solid_color_ = canvas.GetColorIfSolid(&solid_color_);
+}
+
+void DisplayListRecordingSource::Clear() {
+ recorded_viewport_ = gfx::Rect();
+ display_list_ = NULL;
+ is_solid_color_ = false;
+}
+
+} // namespace cc
diff --git a/cc/resources/display_list_recording_source.h b/cc/resources/display_list_recording_source.h
new file mode 100644
index 0000000..6bc8208
--- /dev/null
+++ b/cc/resources/display_list_recording_source.h
@@ -0,0 +1,64 @@
+// Copyright 2014 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_DISPLAY_LIST_RECORDING_SOURCE_H_
+#define CC_RESOURCES_DISPLAY_LIST_RECORDING_SOURCE_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "cc/resources/recording_source.h"
+
+namespace cc {
+class DisplayItemList;
+class DisplayListRasterSource;
+
+class CC_EXPORT DisplayListRecordingSource : public RecordingSource {
+ public:
+ DisplayListRecordingSource();
+ ~DisplayListRecordingSource() override;
+
+ // RecordingSource overrides.
+ bool UpdateAndExpandInvalidation(
+ ContentLayerClient* painter,
+ Region* invalidation,
+ bool can_use_lcd_text,
+ const gfx::Size& layer_size,
+ const gfx::Rect& visible_layer_rect,
+ int frame_number,
+ Picture::RecordingMode recording_mode) override;
+ scoped_refptr<RasterSource> CreateRasterSource() const override;
+ gfx::Size GetSize() const final;
+ void SetEmptyBounds() override;
+ void SetMinContentsScale(float min_contents_scale) override;
+ void SetSlowdownRasterScaleFactor(int factor) override;
+ bool IsSuitableForGpuRasterization() const override;
+ void SetTileGridSize(const gfx::Size& tile_grid_size) override;
+ void SetUnsuitableForGpuRasterizationForTesting() override;
+ SkTileGridFactory::TileGridInfo GetTileGridInfoForTesting() const override;
+
+ protected:
+ void Clear();
+
+ gfx::Rect recorded_viewport_;
+ gfx::Size size_;
+ int slow_down_raster_scale_factor_for_debug_;
+ bool can_use_lcd_text_;
+ bool is_solid_color_;
+ SkColor solid_color_;
+ int pixel_record_distance_;
+
+ scoped_refptr<DisplayItemList> display_list_;
+
+ private:
+ friend class DisplayListRasterSource;
+
+ void DetermineIfSolidColor();
+
+ bool is_suitable_for_gpu_rasterization_;
+
+ DISALLOW_COPY_AND_ASSIGN(DisplayListRecordingSource);
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_DISPLAY_LIST_RECORDING_SOURCE_H_
diff --git a/cc/resources/drawing_display_item.cc b/cc/resources/drawing_display_item.cc
new file mode 100644
index 0000000..9466d5c
--- /dev/null
+++ b/cc/resources/drawing_display_item.cc
@@ -0,0 +1,47 @@
+// Copyright 2014 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/resources/drawing_display_item.h"
+
+#include "base/logging.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkMatrix.h"
+#include "third_party/skia/include/core/SkPicture.h"
+#include "third_party/skia/include/utils/SkPictureUtils.h"
+
+namespace cc {
+
+DrawingDisplayItem::DrawingDisplayItem(skia::RefPtr<SkPicture> picture,
+ gfx::PointF location)
+ : picture_(picture), location_(location) {
+}
+
+DrawingDisplayItem::~DrawingDisplayItem() {
+}
+
+void DrawingDisplayItem::Raster(SkCanvas* canvas,
+ SkDrawPictureCallback* callback) const {
+ canvas->save();
+ canvas->translate(location_.x(), location_.y());
+ if (callback)
+ picture_->draw(canvas, callback);
+ else
+ canvas->drawPicture(picture_.get());
+ canvas->restore();
+}
+
+bool DrawingDisplayItem::IsSuitableForGpuRasterization() const {
+ return picture_->suitableForGpuRasterization(NULL);
+}
+
+int DrawingDisplayItem::ApproximateOpCount() const {
+ return picture_->approximateOpCount() + sizeof(gfx::PointF);
+}
+
+size_t DrawingDisplayItem::PictureMemoryUsage() const {
+ DCHECK(picture_);
+ return SkPictureUtils::ApproximateBytesUsed(picture_.get());
+}
+
+} // namespace cc
diff --git a/cc/resources/drawing_display_item.h b/cc/resources/drawing_display_item.h
new file mode 100644
index 0000000..544e4eb
--- /dev/null
+++ b/cc/resources/drawing_display_item.h
@@ -0,0 +1,45 @@
+// Copyright 2014 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_DRAWING_DISPLAY_ITEM_H_
+#define CC_RESOURCES_DRAWING_DISPLAY_ITEM_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "cc/base/cc_export.h"
+#include "cc/resources/display_item.h"
+#include "skia/ext/refptr.h"
+#include "ui/gfx/geometry/point_f.h"
+
+class SkCanvas;
+class SkDrawPictureCallback;
+class SkPicture;
+
+namespace cc {
+
+class CC_EXPORT DrawingDisplayItem : public DisplayItem {
+ public:
+ virtual ~DrawingDisplayItem();
+
+ static scoped_ptr<DrawingDisplayItem> Create(skia::RefPtr<SkPicture> picture,
+ gfx::PointF location) {
+ return make_scoped_ptr(new DrawingDisplayItem(picture, location));
+ }
+
+ void Raster(SkCanvas* canvas, SkDrawPictureCallback* callback) const override;
+
+ bool IsSuitableForGpuRasterization() const override;
+ int ApproximateOpCount() const override;
+ size_t PictureMemoryUsage() const override;
+
+ protected:
+ DrawingDisplayItem(skia::RefPtr<SkPicture> picture, gfx::PointF location);
+
+ private:
+ skia::RefPtr<SkPicture> picture_;
+ gfx::PointF location_;
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_DRAWING_DISPLAY_ITEM_H_
diff --git a/cc/resources/eviction_tile_priority_queue.cc b/cc/resources/eviction_tile_priority_queue.cc
index 9f05e81..4d66987 100644
--- a/cc/resources/eviction_tile_priority_queue.cc
+++ b/cc/resources/eviction_tile_priority_queue.cc
@@ -14,8 +14,8 @@
: tree_priority_(tree_priority) {}
bool operator()(
- const EvictionTilePriorityQueue::PairedPictureLayerQueue* a,
- const EvictionTilePriorityQueue::PairedPictureLayerQueue* b) const {
+ const EvictionTilePriorityQueue::PairedTilingSetQueue* a,
+ const EvictionTilePriorityQueue::PairedTilingSetQueue* b) const {
// Note that in this function, we have to return true if and only if
// b is strictly lower priority than a. Note that for the sake of
// completeness, empty queue is considered to have lowest priority.
@@ -23,15 +23,15 @@
return b->IsEmpty() < a->IsEmpty();
WhichTree a_tree = a->NextTileIteratorTree(tree_priority_);
- const PictureLayerImpl::LayerEvictionTileIterator* a_iterator =
- a_tree == ACTIVE_TREE ? &a->active_iterator : &a->pending_iterator;
+ const TilingSetEvictionQueue* a_queue =
+ a_tree == ACTIVE_TREE ? a->active_queue.get() : a->pending_queue.get();
WhichTree b_tree = b->NextTileIteratorTree(tree_priority_);
- const PictureLayerImpl::LayerEvictionTileIterator* b_iterator =
- b_tree == ACTIVE_TREE ? &b->active_iterator : &b->pending_iterator;
+ const TilingSetEvictionQueue* b_queue =
+ b_tree == ACTIVE_TREE ? b->active_queue.get() : b->pending_queue.get();
- const Tile* a_tile = **a_iterator;
- const Tile* b_tile = **b_iterator;
+ const Tile* a_tile = a_queue->Top();
+ const Tile* b_tile = b_queue->Top();
const TilePriority& a_priority =
a_tile->priority_for_tree_priority(tree_priority_);
@@ -94,7 +94,7 @@
it != paired_layers.end();
++it) {
paired_queues_.push_back(
- make_scoped_ptr(new PairedPictureLayerQueue(*it, tree_priority_)));
+ make_scoped_ptr(new PairedTilingSetQueue(*it, tree_priority_)));
}
paired_queues_.make_heap(EvictionOrderComparator(tree_priority_));
@@ -117,94 +117,89 @@
DCHECK(!IsEmpty());
paired_queues_.pop_heap(EvictionOrderComparator(tree_priority_));
- PairedPictureLayerQueue* paired_queue = paired_queues_.back();
+ PairedTilingSetQueue* paired_queue = paired_queues_.back();
paired_queue->Pop(tree_priority_);
paired_queues_.push_heap(EvictionOrderComparator(tree_priority_));
}
-EvictionTilePriorityQueue::PairedPictureLayerQueue::PairedPictureLayerQueue() {
+EvictionTilePriorityQueue::PairedTilingSetQueue::PairedTilingSetQueue() {
}
-EvictionTilePriorityQueue::PairedPictureLayerQueue::PairedPictureLayerQueue(
+EvictionTilePriorityQueue::PairedTilingSetQueue::PairedTilingSetQueue(
const PictureLayerImpl::Pair& layer_pair,
- TreePriority tree_priority)
- : active_iterator(
- layer_pair.active
- ? PictureLayerImpl::LayerEvictionTileIterator(layer_pair.active,
- tree_priority)
- : PictureLayerImpl::LayerEvictionTileIterator()),
- pending_iterator(
- layer_pair.pending
- ? PictureLayerImpl::LayerEvictionTileIterator(layer_pair.pending,
- tree_priority)
- : PictureLayerImpl::LayerEvictionTileIterator()) {
+ TreePriority tree_priority) {
+ if (layer_pair.active)
+ active_queue = layer_pair.active->CreateEvictionQueue(tree_priority);
+ if (layer_pair.pending)
+ pending_queue = layer_pair.pending->CreateEvictionQueue(tree_priority);
}
-EvictionTilePriorityQueue::PairedPictureLayerQueue::~PairedPictureLayerQueue() {
+EvictionTilePriorityQueue::PairedTilingSetQueue::~PairedTilingSetQueue() {
}
-bool EvictionTilePriorityQueue::PairedPictureLayerQueue::IsEmpty() const {
- return !active_iterator && !pending_iterator;
+bool EvictionTilePriorityQueue::PairedTilingSetQueue::IsEmpty() const {
+ return (!active_queue || active_queue->IsEmpty()) &&
+ (!pending_queue || pending_queue->IsEmpty());
}
-Tile* EvictionTilePriorityQueue::PairedPictureLayerQueue::Top(
+Tile* EvictionTilePriorityQueue::PairedTilingSetQueue::Top(
TreePriority tree_priority) {
DCHECK(!IsEmpty());
WhichTree next_tree = NextTileIteratorTree(tree_priority);
- PictureLayerImpl::LayerEvictionTileIterator* next_iterator =
- next_tree == ACTIVE_TREE ? &active_iterator : &pending_iterator;
- DCHECK(*next_iterator);
+ TilingSetEvictionQueue* next_queue =
+ next_tree == ACTIVE_TREE ? active_queue.get() : pending_queue.get();
+ DCHECK(next_queue && !next_queue->IsEmpty());
- Tile* tile = **next_iterator;
+ Tile* tile = next_queue->Top();
DCHECK(std::find(returned_shared_tiles.begin(),
returned_shared_tiles.end(),
tile) == returned_shared_tiles.end());
return tile;
}
-void EvictionTilePriorityQueue::PairedPictureLayerQueue::Pop(
+void EvictionTilePriorityQueue::PairedTilingSetQueue::Pop(
TreePriority tree_priority) {
DCHECK(!IsEmpty());
WhichTree next_tree = NextTileIteratorTree(tree_priority);
- PictureLayerImpl::LayerEvictionTileIterator* next_iterator =
- next_tree == ACTIVE_TREE ? &active_iterator : &pending_iterator;
- DCHECK(*next_iterator);
- returned_shared_tiles.push_back(**next_iterator);
- ++(*next_iterator);
+ TilingSetEvictionQueue* next_queue =
+ next_tree == ACTIVE_TREE ? active_queue.get() : pending_queue.get();
+ DCHECK(next_queue && !next_queue->IsEmpty());
+ returned_shared_tiles.push_back(next_queue->Top());
+ next_queue->Pop();
if (IsEmpty())
return;
next_tree = NextTileIteratorTree(tree_priority);
- next_iterator =
- next_tree == ACTIVE_TREE ? &active_iterator : &pending_iterator;
+ next_queue =
+ next_tree == ACTIVE_TREE ? active_queue.get() : pending_queue.get();
while (std::find(returned_shared_tiles.begin(),
returned_shared_tiles.end(),
- **next_iterator) != returned_shared_tiles.end()) {
- ++(*next_iterator);
+ next_queue->Top()) != returned_shared_tiles.end()) {
+ next_queue->Pop();
if (IsEmpty())
break;
next_tree = NextTileIteratorTree(tree_priority);
- next_iterator =
- next_tree == ACTIVE_TREE ? &active_iterator : &pending_iterator;
+ next_queue =
+ next_tree == ACTIVE_TREE ? active_queue.get() : pending_queue.get();
}
}
WhichTree
-EvictionTilePriorityQueue::PairedPictureLayerQueue::NextTileIteratorTree(
+EvictionTilePriorityQueue::PairedTilingSetQueue::NextTileIteratorTree(
TreePriority tree_priority) const {
DCHECK(!IsEmpty());
// If we only have one iterator with tiles, return it.
- if (!active_iterator)
+ if (!active_queue || active_queue->IsEmpty())
return PENDING_TREE;
- if (!pending_iterator)
+ if (!pending_queue || pending_queue->IsEmpty())
return ACTIVE_TREE;
- const Tile* active_tile = *active_iterator;
- const Tile* pending_tile = *pending_iterator;
+ const Tile* active_tile = active_queue->Top();
+ const Tile* pending_tile = pending_queue->Top();
if (active_tile == pending_tile)
return ACTIVE_TREE;
diff --git a/cc/resources/eviction_tile_priority_queue.h b/cc/resources/eviction_tile_priority_queue.h
index e91f0d2..6f5d964 100644
--- a/cc/resources/eviction_tile_priority_queue.h
+++ b/cc/resources/eviction_tile_priority_queue.h
@@ -11,16 +11,17 @@
#include "cc/base/cc_export.h"
#include "cc/layers/picture_layer_impl.h"
#include "cc/resources/tile_priority.h"
+#include "cc/resources/tiling_set_eviction_queue.h"
namespace cc {
class CC_EXPORT EvictionTilePriorityQueue {
public:
- struct PairedPictureLayerQueue {
- PairedPictureLayerQueue();
- PairedPictureLayerQueue(const PictureLayerImpl::Pair& layer_pair,
- TreePriority tree_priority);
- ~PairedPictureLayerQueue();
+ struct PairedTilingSetQueue {
+ PairedTilingSetQueue();
+ PairedTilingSetQueue(const PictureLayerImpl::Pair& layer_pair,
+ TreePriority tree_priority);
+ ~PairedTilingSetQueue();
bool IsEmpty() const;
Tile* Top(TreePriority tree_priority);
@@ -28,8 +29,8 @@
WhichTree NextTileIteratorTree(TreePriority tree_priority) const;
- PictureLayerImpl::LayerEvictionTileIterator active_iterator;
- PictureLayerImpl::LayerEvictionTileIterator pending_iterator;
+ scoped_ptr<TilingSetEvictionQueue> active_queue;
+ scoped_ptr<TilingSetEvictionQueue> pending_queue;
// TODO(vmpstr): Investigate removing this.
std::vector<Tile*> returned_shared_tiles;
@@ -48,9 +49,9 @@
private:
// TODO(vmpstr): This is potentially unnecessary if it becomes the case that
- // PairedPictureLayerQueue is fast enough to copy. In that case, we can use
- // objects directly (ie std::vector<PairedPictureLayerQueue>).
- ScopedPtrVector<PairedPictureLayerQueue> paired_queues_;
+ // PairedTilingSetQueue is fast enough to copy. In that case, we can use
+ // objects directly (ie std::vector<PairedTilingSetQueue>).
+ ScopedPtrVector<PairedTilingSetQueue> paired_queues_;
TreePriority tree_priority_;
DISALLOW_COPY_AND_ASSIGN(EvictionTilePriorityQueue);
diff --git a/cc/resources/filter_display_item.cc b/cc/resources/filter_display_item.cc
new file mode 100644
index 0000000..63bfeee
--- /dev/null
+++ b/cc/resources/filter_display_item.cc
@@ -0,0 +1,75 @@
+// Copyright 2014 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/resources/filter_display_item.h"
+
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkImageFilter.h"
+#include "third_party/skia/include/core/SkPaint.h"
+#include "third_party/skia/include/core/SkXfermode.h"
+#include "ui/gfx/skia_util.h"
+
+namespace cc {
+
+FilterDisplayItem::FilterDisplayItem(skia::RefPtr<SkImageFilter> filter,
+ gfx::RectF bounds)
+ : filter_(filter), bounds_(bounds) {
+}
+
+FilterDisplayItem::~FilterDisplayItem() {
+}
+
+void FilterDisplayItem::Raster(SkCanvas* canvas,
+ SkDrawPictureCallback* callback) const {
+ canvas->save();
+ SkRect boundaries;
+ filter_->computeFastBounds(gfx::RectFToSkRect(bounds_), &boundaries);
+ canvas->translate(bounds_.x(), bounds_.y());
+ boundaries.offset(-bounds_.x(), -bounds_.y());
+
+ SkPaint paint;
+ paint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
+ paint.setImageFilter(filter_.get());
+ canvas->saveLayer(&boundaries, &paint);
+
+ canvas->translate(-bounds_.x(), -bounds_.y());
+}
+
+bool FilterDisplayItem::IsSuitableForGpuRasterization() const {
+ return true;
+}
+
+int FilterDisplayItem::ApproximateOpCount() const {
+ return 1;
+}
+
+size_t FilterDisplayItem::PictureMemoryUsage() const {
+ return sizeof(skia::RefPtr<SkImageFilter>) + sizeof(gfx::RectF);
+}
+
+EndFilterDisplayItem::EndFilterDisplayItem() {
+}
+
+EndFilterDisplayItem::~EndFilterDisplayItem() {
+}
+
+void EndFilterDisplayItem::Raster(SkCanvas* canvas,
+ SkDrawPictureCallback* callback) const {
+ canvas->restore();
+ canvas->restore();
+}
+
+bool EndFilterDisplayItem::IsSuitableForGpuRasterization() const {
+ return true;
+}
+
+int EndFilterDisplayItem::ApproximateOpCount() const {
+ return 0;
+}
+
+size_t EndFilterDisplayItem::PictureMemoryUsage() const {
+ return 0;
+}
+
+} // namespace cc
diff --git a/cc/resources/filter_display_item.h b/cc/resources/filter_display_item.h
new file mode 100644
index 0000000..4c1b265
--- /dev/null
+++ b/cc/resources/filter_display_item.h
@@ -0,0 +1,64 @@
+// Copyright 2014 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_FILTER_DISPLAY_ITEM_H_
+#define CC_RESOURCES_FILTER_DISPLAY_ITEM_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "cc/base/cc_export.h"
+#include "cc/resources/display_item.h"
+#include "skia/ext/refptr.h"
+#include "ui/gfx/geometry/rect_f.h"
+
+class SkCanvas;
+class SkDrawPictureCallback;
+class SkImageFilter;
+
+namespace cc {
+
+class CC_EXPORT FilterDisplayItem : public DisplayItem {
+ public:
+ virtual ~FilterDisplayItem();
+
+ static scoped_ptr<FilterDisplayItem> Create(
+ skia::RefPtr<SkImageFilter> filter,
+ gfx::RectF bounds) {
+ return make_scoped_ptr(new FilterDisplayItem(filter, bounds));
+ }
+
+ void Raster(SkCanvas* canvas, SkDrawPictureCallback* callback) const override;
+
+ bool IsSuitableForGpuRasterization() const override;
+ int ApproximateOpCount() const override;
+ size_t PictureMemoryUsage() const override;
+
+ protected:
+ FilterDisplayItem(skia::RefPtr<SkImageFilter> filter, gfx::RectF bounds);
+
+ private:
+ skia::RefPtr<SkImageFilter> filter_;
+ gfx::RectF bounds_;
+};
+
+class CC_EXPORT EndFilterDisplayItem : public DisplayItem {
+ public:
+ virtual ~EndFilterDisplayItem();
+
+ static scoped_ptr<EndFilterDisplayItem> Create() {
+ return make_scoped_ptr(new EndFilterDisplayItem());
+ }
+
+ void Raster(SkCanvas* canvas, SkDrawPictureCallback* callback) const override;
+
+ bool IsSuitableForGpuRasterization() const override;
+ int ApproximateOpCount() const override;
+ size_t PictureMemoryUsage() const override;
+
+ protected:
+ EndFilterDisplayItem();
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_FILTER_DISPLAY_ITEM_H_
diff --git a/cc/resources/managed_tile_state.cc b/cc/resources/managed_tile_state.cc
index 2841711..a60c28af 100644
--- a/cc/resources/managed_tile_state.cc
+++ b/cc/resources/managed_tile_state.cc
@@ -12,38 +12,9 @@
namespace cc {
-std::string ManagedTileBinToString(ManagedTileBin bin) {
- switch (bin) {
- case NOW_AND_READY_TO_DRAW_BIN:
- return "NOW_AND_READY_TO_DRAW_BIN";
- case NOW_BIN:
- return "NOW_BIN";
- case SOON_BIN:
- return "SOON_BIN";
- case EVENTUALLY_AND_ACTIVE_BIN:
- return "EVENTUALLY_AND_ACTIVE_BIN";
- case EVENTUALLY_BIN:
- return "EVENTUALLY_BIN";
- case AT_LAST_AND_ACTIVE_BIN:
- return "AT_LAST_AND_ACTIVE_BIN";
- case AT_LAST_BIN:
- return "AT_LAST_BIN";
- case NEVER_BIN:
- return "NEVER_BIN";
- case NUM_BINS:
- NOTREACHED();
- return "Invalid Bin (NUM_BINS)";
- }
- return "Invalid Bin (UNKNOWN)";
-}
-
ManagedTileState::ManagedTileState()
- : bin(NEVER_BIN),
- resolution(NON_IDEAL_RESOLUTION),
- required_for_activation(false),
+ : resolution(NON_IDEAL_RESOLUTION),
priority_bin(TilePriority::EVENTUALLY),
- distance_to_visible(std::numeric_limits<float>::infinity()),
- visible_and_ready_to_draw(false),
scheduled_priority(0) {
}
@@ -77,12 +48,8 @@
state->SetBoolean("has_resource", has_resource);
state->SetBoolean("is_using_gpu_memory", is_using_gpu_memory);
- state->SetString("bin", ManagedTileBinToString(bin));
state->SetString("resolution", TileResolutionToString(resolution));
state->SetString("priority_bin", TilePriorityBinToString(priority_bin));
- state->SetDouble("distance_to_visible",
- MathUtil::AsFloatSafely(distance_to_visible));
- state->SetBoolean("required_for_activation", required_for_activation);
state->SetBoolean("is_solid_color",
draw_info.mode_ == DrawInfo::SOLID_COLOR_MODE);
state->SetBoolean("is_transparent",
diff --git a/cc/resources/managed_tile_state.h b/cc/resources/managed_tile_state.h
index 58b77c6..a0905c7 100644
--- a/cc/resources/managed_tile_state.h
+++ b/cc/resources/managed_tile_state.h
@@ -15,24 +15,6 @@
namespace cc {
-class TileManager;
-
-// Tile manager classifying tiles into a few basic bins:
-enum ManagedTileBin {
- NOW_AND_READY_TO_DRAW_BIN = 0, // Ready to draw and within viewport.
- NOW_BIN = 1, // Needed ASAP.
- SOON_BIN = 2, // Impl-side version of prepainting.
- EVENTUALLY_AND_ACTIVE_BIN = 3, // Nice to have, and has a task or resource.
- EVENTUALLY_BIN = 4, // Nice to have, if we've got memory and time.
- AT_LAST_AND_ACTIVE_BIN = 5, // Only do this after all other bins.
- AT_LAST_BIN = 6, // Only do this after all other bins.
- NEVER_BIN = 7, // Dont bother.
- NUM_BINS = 8
- // NOTE: Be sure to update ManagedTileBinAsValue and kBinPolicyMap when adding
- // or reordering fields.
-};
-scoped_ptr<base::Value> ManagedTileBinAsValue(ManagedTileBin bin);
-
// This is state that is specific to a tile that is
// managed by the TileManager.
class CC_EXPORT ManagedTileState {
@@ -107,13 +89,8 @@
DrawInfo draw_info;
scoped_refptr<RasterTask> raster_task;
- ManagedTileBin bin;
-
TileResolution resolution;
- bool required_for_activation;
TilePriority::PriorityBin priority_bin;
- float distance_to_visible;
- bool visible_and_ready_to_draw;
// Priority for this state from the last time we assigned memory.
unsigned scheduled_priority;
diff --git a/cc/resources/picture.cc b/cc/resources/picture.cc
index 9a45ad1..5b90571 100644
--- a/cc/resources/picture.cc
+++ b/cc/resources/picture.cc
@@ -25,6 +25,7 @@
#include "third_party/skia/include/core/SkPictureRecorder.h"
#include "third_party/skia/include/core/SkStream.h"
#include "third_party/skia/include/utils/SkNullCanvas.h"
+#include "third_party/skia/include/utils/SkPictureUtils.h"
#include "ui/gfx/codec/jpeg_codec.h"
#include "ui/gfx/codec/png_codec.h"
#include "ui/gfx/geometry/rect_conversions.h"
@@ -192,6 +193,11 @@
return picture_->approximateOpCount();
}
+size_t Picture::ApproximateMemoryUsage() const {
+ DCHECK(picture_);
+ return SkPictureUtils::ApproximateBytesUsed(picture_.get());
+}
+
bool Picture::HasText() const {
DCHECK(picture_);
return picture_->hasText();
diff --git a/cc/resources/picture.h b/cc/resources/picture.h
index 1677309..771d715 100644
--- a/cc/resources/picture.h
+++ b/cc/resources/picture.h
@@ -67,6 +67,7 @@
bool IsSuitableForGpuRasterization() const;
int ApproximateOpCount() const;
+ size_t ApproximateMemoryUsage() const;
bool HasText() const;
diff --git a/cc/resources/picture_layer_tiling.cc b/cc/resources/picture_layer_tiling.cc
index 9d8ea84..e9e3b86 100644
--- a/cc/resources/picture_layer_tiling.cc
+++ b/cc/resources/picture_layer_tiling.cc
@@ -1216,50 +1216,4 @@
return *this;
}
-PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator()
- : eviction_tiles_(NULL), current_eviction_tiles_index_(0u) {
-}
-
-PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator(
- PictureLayerTiling* tiling,
- TreePriority tree_priority,
- EvictionCategory category)
- : eviction_tiles_(tiling->GetEvictionTiles(tree_priority, category)),
- // Note: initializing to "0 - 1" works as overflow is well defined for
- // unsigned integers.
- current_eviction_tiles_index_(static_cast<size_t>(0) - 1) {
- DCHECK(eviction_tiles_);
- ++(*this);
-}
-
-PictureLayerTiling::TilingEvictionTileIterator::~TilingEvictionTileIterator() {
-}
-
-PictureLayerTiling::TilingEvictionTileIterator::operator bool() const {
- return eviction_tiles_ &&
- current_eviction_tiles_index_ != eviction_tiles_->size();
-}
-
-Tile* PictureLayerTiling::TilingEvictionTileIterator::operator*() {
- DCHECK(*this);
- return (*eviction_tiles_)[current_eviction_tiles_index_];
-}
-
-const Tile* PictureLayerTiling::TilingEvictionTileIterator::operator*() const {
- DCHECK(*this);
- return (*eviction_tiles_)[current_eviction_tiles_index_];
-}
-
-PictureLayerTiling::TilingEvictionTileIterator&
-PictureLayerTiling::TilingEvictionTileIterator::
-operator++() {
- DCHECK(*this);
- do {
- ++current_eviction_tiles_index_;
- } while (current_eviction_tiles_index_ != eviction_tiles_->size() &&
- !(*eviction_tiles_)[current_eviction_tiles_index_]->HasResources());
-
- return *this;
-}
-
} // namespace cc
diff --git a/cc/resources/picture_layer_tiling.h b/cc/resources/picture_layer_tiling.h
index e1ccde4..daa0485 100644
--- a/cc/resources/picture_layer_tiling.h
+++ b/cc/resources/picture_layer_tiling.h
@@ -118,24 +118,6 @@
TilingData::SpiralDifferenceIterator spiral_iterator_;
};
- class CC_EXPORT TilingEvictionTileIterator {
- public:
- TilingEvictionTileIterator();
- TilingEvictionTileIterator(PictureLayerTiling* tiling,
- TreePriority tree_priority,
- EvictionCategory category);
- ~TilingEvictionTileIterator();
-
- operator bool() const;
- const Tile* operator*() const;
- Tile* operator*();
- TilingEvictionTileIterator& operator++();
-
- private:
- const std::vector<Tile*>* eviction_tiles_;
- size_t current_eviction_tiles_index_;
- };
-
~PictureLayerTiling();
// Create a tiling with no tiles. CreateTiles must be called to add some.
@@ -299,7 +281,7 @@
protected:
friend class CoverageIterator;
friend class TilingRasterTileIterator;
- friend class TilingEvictionTileIterator;
+ friend class TilingSetEvictionQueue;
typedef std::pair<int, int> TileMapKey;
typedef base::hash_map<TileMapKey, scoped_refptr<Tile>> TileMap;
diff --git a/cc/resources/picture_layer_tiling_perftest.cc b/cc/resources/picture_layer_tiling_perftest.cc
index 55d495b..3944e46 100644
--- a/cc/resources/picture_layer_tiling_perftest.cc
+++ b/cc/resources/picture_layer_tiling_perftest.cc
@@ -178,98 +178,6 @@
true);
}
- void RunEvictionIteratorConstructTest(const std::string& test_name,
- const gfx::Rect& viewport) {
- gfx::Size bounds(viewport.size());
- picture_layer_tiling_ =
- PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
- picture_layer_tiling_client_.set_tree(ACTIVE_TREE);
- picture_layer_tiling_->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
- Occlusion());
-
- timer_.Reset();
- TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
- SMOOTHNESS_TAKES_PRIORITY,
- NEW_CONTENT_TAKES_PRIORITY};
- int priority_count = 0;
- do {
- PictureLayerTiling::TilingEvictionTileIterator it(
- picture_layer_tiling_.get(),
- priorities[priority_count],
- PictureLayerTiling::NOW);
- priority_count = (priority_count + 1) % arraysize(priorities);
- timer_.NextLap();
- } while (!timer_.HasTimeLimitExpired());
-
- perf_test::PrintResult("tiling_eviction_tile_iterator_construct",
- "",
- test_name,
- timer_.LapsPerSecond(),
- "runs/s",
- true);
- }
-
- void RunEvictionIteratorConstructAndIterateTest(const std::string& test_name,
- int num_tiles,
- const gfx::Rect& viewport) {
- gfx::Size bounds(10000, 10000);
- picture_layer_tiling_ =
- PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
- picture_layer_tiling_client_.set_tree(ACTIVE_TREE);
- picture_layer_tiling_->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
- Occlusion());
-
- TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
- SMOOTHNESS_TAKES_PRIORITY,
- NEW_CONTENT_TAKES_PRIORITY};
-
- // Ensure all tiles have resources.
- std::vector<Tile*> all_tiles = picture_layer_tiling_->AllTilesForTesting();
- for (std::vector<Tile*>::iterator tile_it = all_tiles.begin();
- tile_it != all_tiles.end();
- ++tile_it) {
- Tile* tile = *tile_it;
- ManagedTileState::DrawInfo& draw_info = tile->draw_info();
- draw_info.SetResourceForTesting(
- ScopedResource::Create(resource_provider_.get()).Pass());
- }
-
- int priority_count = 0;
- timer_.Reset();
- do {
- int count = num_tiles;
- PictureLayerTiling::TilingEvictionTileIterator it(
- picture_layer_tiling_.get(),
- priorities[priority_count],
- PictureLayerTiling::EVENTUALLY);
- while (count--) {
- ASSERT_TRUE(it) << "count: " << count;
- ASSERT_TRUE(*it != NULL) << "count: " << count;
- ++it;
- }
- priority_count = (priority_count + 1) % arraysize(priorities);
- timer_.NextLap();
- } while (!timer_.HasTimeLimitExpired());
-
- // Remove all resources from tiles to make sure the tile version destructor
- // doesn't complain.
- for (std::vector<Tile*>::iterator tile_it = all_tiles.begin();
- tile_it != all_tiles.end();
- ++tile_it) {
- Tile* tile = *tile_it;
- ManagedTileState::DrawInfo& draw_info = tile->draw_info();
- draw_info.SetResourceForTesting(nullptr);
- }
-
- perf_test::PrintResult(
- "tiling_eviction_tile_iterator_construct_and_iterate",
- "",
- test_name,
- timer_.LapsPerSecond(),
- "runs/s",
- true);
- }
-
private:
FakePictureLayerTilingClient picture_layer_tiling_client_;
scoped_ptr<PictureLayerTiling> picture_layer_tiling_;
@@ -333,27 +241,6 @@
"64_500x500", 64, gfx::Rect(0, 0, 500, 500));
}
-TEST_F(PictureLayerTilingPerfTest, TilingEvictionTileIteratorConstruct) {
- RunEvictionIteratorConstructTest("0_0_100x100", gfx::Rect(0, 0, 100, 100));
- RunEvictionIteratorConstructTest("50_0_100x100", gfx::Rect(50, 0, 100, 100));
- RunEvictionIteratorConstructTest("100_0_100x100",
- gfx::Rect(100, 0, 100, 100));
- RunEvictionIteratorConstructTest("150_0_100x100",
- gfx::Rect(150, 0, 100, 100));
-}
-
-TEST_F(PictureLayerTilingPerfTest,
- TilingEvictionTileIteratorConstructAndIterate) {
- RunEvictionIteratorConstructAndIterateTest(
- "32_100x100", 32, gfx::Rect(0, 0, 100, 100));
- RunEvictionIteratorConstructAndIterateTest(
- "32_500x500", 32, gfx::Rect(0, 0, 500, 500));
- RunEvictionIteratorConstructAndIterateTest(
- "64_100x100", 64, gfx::Rect(0, 0, 100, 100));
- RunEvictionIteratorConstructAndIterateTest(
- "64_500x500", 64, gfx::Rect(0, 0, 500, 500));
-}
-
} // namespace
} // namespace cc
diff --git a/cc/resources/picture_layer_tiling_unittest.cc b/cc/resources/picture_layer_tiling_unittest.cc
index b982dc1..9190b98 100644
--- a/cc/resources/picture_layer_tiling_unittest.cc
+++ b/cc/resources/picture_layer_tiling_unittest.cc
@@ -1247,102 +1247,6 @@
EXPECT_EQ(exists, tile != NULL) << geometry_rect.ToString();
}
-TEST(PictureLayerTilingTest, TilingEvictionTileIteratorStaticViewport) {
- FakeOutputSurfaceClient output_surface_client;
- scoped_ptr<FakeOutputSurface> output_surface = FakeOutputSurface::Create3d();
- CHECK(output_surface->BindToClient(&output_surface_client));
- TestSharedBitmapManager shared_bitmap_manager;
- scoped_ptr<ResourceProvider> resource_provider = ResourceProvider::Create(
- output_surface.get(), &shared_bitmap_manager, NULL, NULL, 0, false, 1);
-
- FakePictureLayerTilingClient client(resource_provider.get());
- scoped_ptr<TestablePictureLayerTiling> tiling;
-
- gfx::Rect viewport(50, 50, 100, 100);
- gfx::Size layer_bounds(2000, 2000);
-
- client.SetTileSize(gfx::Size(30, 30));
- client.set_tree(ACTIVE_TREE);
-
- tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
- tiling->ComputeTilePriorityRects(viewport, 1.0f, 1.0, Occlusion());
- tiling->UpdateAllTilePrioritiesForTesting();
-
- PictureLayerTiling::TilingRasterTileIterator empty_iterator;
- EXPECT_FALSE(empty_iterator);
-
- std::vector<Tile*> all_tiles = tiling->AllTilesForTesting();
-
- PictureLayerTiling::TilingEvictionTileIterator it(
- tiling.get(), SMOOTHNESS_TAKES_PRIORITY, PictureLayerTiling::NOW);
-
- // Tiles don't have resources to evict.
- EXPECT_FALSE(it);
-
- // Sanity check.
- EXPECT_EQ(5184u, all_tiles.size());
-
- client.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
-
- std::set<Tile*> all_tiles_set(all_tiles.begin(), all_tiles.end());
-
- std::set<Tile*> eviction_tiles;
-
- it = PictureLayerTiling::TilingEvictionTileIterator(
- tiling.get(), SMOOTHNESS_TAKES_PRIORITY, PictureLayerTiling::EVENTUALLY);
- EXPECT_TRUE(it);
- for (; it; ++it) {
- Tile* tile = *it;
- EXPECT_TRUE(tile);
- EXPECT_EQ(TilePriority::EVENTUALLY,
- tile->priority(ACTIVE_TREE).priority_bin);
- EXPECT_FALSE(tile->required_for_activation());
- eviction_tiles.insert(tile);
- }
-
- it = PictureLayerTiling::TilingEvictionTileIterator(
- tiling.get(), SMOOTHNESS_TAKES_PRIORITY, PictureLayerTiling::SOON);
- EXPECT_TRUE(it);
- for (; it; ++it) {
- Tile* tile = *it;
- EXPECT_TRUE(tile);
- EXPECT_EQ(TilePriority::SOON, tile->priority(ACTIVE_TREE).priority_bin);
- EXPECT_FALSE(tile->required_for_activation());
- eviction_tiles.insert(tile);
- }
-
- it = PictureLayerTiling::TilingEvictionTileIterator(
- tiling.get(), SMOOTHNESS_TAKES_PRIORITY, PictureLayerTiling::NOW);
- EXPECT_TRUE(it);
- for (; it; ++it) {
- Tile* tile = *it;
- EXPECT_TRUE(tile);
- EXPECT_EQ(TilePriority::NOW, tile->priority(ACTIVE_TREE).priority_bin);
- EXPECT_FALSE(tile->required_for_activation());
- eviction_tiles.insert(tile);
- }
-
- it = PictureLayerTiling::TilingEvictionTileIterator(
- tiling.get(),
- SMOOTHNESS_TAKES_PRIORITY,
- PictureLayerTiling::NOW_AND_REQUIRED_FOR_ACTIVATION);
- EXPECT_FALSE(it);
-
- EXPECT_GT(all_tiles_set.size(), 0u);
- EXPECT_EQ(all_tiles_set, eviction_tiles);
-
- EXPECT_TRUE(tiling->eviction_tiles_cache_valid());
- tiling->RemoveTileAt(0, 0, nullptr);
- EXPECT_FALSE(tiling->eviction_tiles_cache_valid());
-
- it = PictureLayerTiling::TilingEvictionTileIterator(
- tiling.get(), SMOOTHNESS_TAKES_PRIORITY,
- PictureLayerTiling::NOW_AND_REQUIRED_FOR_ACTIVATION);
- EXPECT_TRUE(tiling->eviction_tiles_cache_valid());
- tiling->Reset();
- EXPECT_FALSE(tiling->eviction_tiles_cache_valid());
-}
-
TEST_F(PictureLayerTilingIteratorTest, TilesExist) {
gfx::Size layer_bounds(1099, 801);
Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
diff --git a/cc/resources/picture_pile_impl.cc b/cc/resources/picture_pile_impl.cc
index 2655d24..5cd7bd6 100644
--- a/cc/resources/picture_pile_impl.cc
+++ b/cc/resources/picture_pile_impl.cc
@@ -4,11 +4,13 @@
#include <algorithm>
#include <limits>
+#include <set>
#include "base/debug/trace_event.h"
#include "cc/base/region.h"
#include "cc/debug/debug_colors.h"
#include "cc/resources/picture_pile_impl.h"
+#include "cc/resources/raster_source_helper.h"
#include "skia/ext/analysis_canvas.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkPictureRecorder.h"
@@ -87,62 +89,9 @@
void PicturePileImpl::PlaybackToCanvas(SkCanvas* canvas,
const gfx::Rect& canvas_rect,
float contents_scale) const {
- canvas->discard();
- if (clear_canvas_with_debug_color_) {
- // Any non-painted areas in the content bounds will be left in this color.
- canvas->clear(DebugColors::NonPaintedFillColor());
- }
-
- // If this picture has opaque contents, it is guaranteeing that it will
- // draw an opaque rect the size of the layer. If it is not, then we must
- // clear this canvas ourselves.
- if (requires_clear_) {
- TRACE_EVENT_INSTANT0("cc", "SkCanvas::clear", TRACE_EVENT_SCOPE_THREAD);
- // Clearing is about ~4x faster than drawing a rect even if the content
- // isn't covering a majority of the canvas.
- canvas->clear(SK_ColorTRANSPARENT);
- } else {
- // Even if completely covered, for rasterizations that touch the edge of the
- // layer, we also need to raster the background color underneath the last
- // texel (since the recording won't cover it) and outside the last texel
- // (due to linear filtering when using this texture).
- gfx::Rect content_tiling_rect = gfx::ToEnclosingRect(
- gfx::ScaleRect(gfx::Rect(tiling_.tiling_size()), contents_scale));
-
- // The final texel of content may only be partially covered by a
- // rasterization; this rect represents the content rect that is fully
- // covered by content.
- gfx::Rect deflated_content_tiling_rect = content_tiling_rect;
- deflated_content_tiling_rect.Inset(0, 0, 1, 1);
- if (!deflated_content_tiling_rect.Contains(canvas_rect)) {
- if (clear_canvas_with_debug_color_) {
- // Any non-painted areas outside of the content bounds are left in
- // this color. If this is seen then it means that cc neglected to
- // rerasterize a tile that used to intersect with the content rect
- // after the content bounds grew.
- canvas->save();
- canvas->translate(-canvas_rect.x(), -canvas_rect.y());
- canvas->clipRect(gfx::RectToSkRect(content_tiling_rect),
- SkRegion::kDifference_Op);
- canvas->drawColor(DebugColors::MissingResizeInvalidations(),
- SkXfermode::kSrc_Mode);
- canvas->restore();
- }
-
- // Drawing at most 2 x 2 x (canvas width + canvas height) texels is 2-3X
- // faster than clearing, so special case this.
- canvas->save();
- canvas->translate(-canvas_rect.x(), -canvas_rect.y());
- gfx::Rect inflated_content_tiling_rect = content_tiling_rect;
- inflated_content_tiling_rect.Inset(0, 0, -1, -1);
- canvas->clipRect(gfx::RectToSkRect(inflated_content_tiling_rect),
- SkRegion::kReplace_Op);
- canvas->clipRect(gfx::RectToSkRect(deflated_content_tiling_rect),
- SkRegion::kDifference_Op);
- canvas->drawColor(background_color_, SkXfermode::kSrc_Mode);
- canvas->restore();
- }
- }
+ RasterSourceHelper::PrepareForPlaybackToCanvas(
+ canvas, canvas_rect, gfx::Rect(tiling_.tiling_size()), contents_scale,
+ background_color_, clear_canvas_with_debug_color_, requires_clear_);
RasterCommon(canvas,
NULL,
@@ -319,6 +268,19 @@
return picture;
}
+size_t PicturePileImpl::GetPictureMemoryUsage() const {
+ // Place all pictures in a set to de-dupe.
+ size_t total_size = 0;
+ std::set<const Picture*> pictures_seen;
+ for (const auto& map_value : picture_map_) {
+ const Picture* picture = map_value.second.GetPicture();
+ if (picture && pictures_seen.insert(picture).second)
+ total_size += picture->ApproximateMemoryUsage();
+ }
+
+ return total_size;
+}
+
void PicturePileImpl::PerformSolidColorAnalysis(
const gfx::Rect& content_rect,
float contents_scale,
diff --git a/cc/resources/picture_pile_impl.h b/cc/resources/picture_pile_impl.h
index d7d0399..3e0dd78 100644
--- a/cc/resources/picture_pile_impl.h
+++ b/cc/resources/picture_pile_impl.h
@@ -67,6 +67,7 @@
void DidBeginTracing() override;
void AsValueInto(base::debug::TracedValue* array) const override;
skia::RefPtr<SkPicture> GetFlattenedPicture() override;
+ size_t GetPictureMemoryUsage() const override;
// Iterator used to return SkPixelRefs from this picture pile.
// Public for testing.
diff --git a/cc/resources/raster_source.h b/cc/resources/raster_source.h
index 3584436..88c9962 100644
--- a/cc/resources/raster_source.h
+++ b/cc/resources/raster_source.h
@@ -18,6 +18,8 @@
namespace cc {
+class Picture;
+
class CC_EXPORT RasterSource : public base::RefCountedThreadSafe<RasterSource> {
public:
struct CC_EXPORT SolidColorAnalysis {
@@ -92,6 +94,7 @@
virtual void DidBeginTracing() = 0;
virtual void AsValueInto(base::debug::TracedValue* array) const = 0;
virtual skia::RefPtr<SkPicture> GetFlattenedPicture() = 0;
+ virtual size_t GetPictureMemoryUsage() const = 0;
// Return true if LCD anti-aliasing may be used when rastering text.
virtual bool CanUseLCDText() const = 0;
diff --git a/cc/resources/raster_source_helper.cc b/cc/resources/raster_source_helper.cc
new file mode 100644
index 0000000..f7ef305
--- /dev/null
+++ b/cc/resources/raster_source_helper.cc
@@ -0,0 +1,81 @@
+// Copyright 2014 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/resources/raster_source_helper.h"
+
+#include "base/debug/trace_event.h"
+#include "cc/debug/debug_colors.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/gfx/skia_util.h"
+
+namespace cc {
+
+void RasterSourceHelper::PrepareForPlaybackToCanvas(
+ SkCanvas* canvas,
+ const gfx::Rect& canvas_rect,
+ const gfx::Rect& source_rect,
+ float contents_scale,
+ SkColor background_color,
+ bool clear_canvas_with_debug_color,
+ bool requires_clear) {
+ canvas->discard();
+ if (clear_canvas_with_debug_color) {
+ // Any non-painted areas in the content bounds will be left in this color.
+ canvas->clear(DebugColors::NonPaintedFillColor());
+ }
+
+ // If this raster source has opaque contents, it is guaranteeing that it will
+ // draw an opaque rect the size of the layer. If it is not, then we must
+ // clear this canvas ourselves.
+ if (requires_clear) {
+ TRACE_EVENT_INSTANT0("cc", "SkCanvas::clear", TRACE_EVENT_SCOPE_THREAD);
+ // Clearing is about ~4x faster than drawing a rect even if the content
+ // isn't covering a majority of the canvas.
+ canvas->clear(SK_ColorTRANSPARENT);
+ } else {
+ // Even if completely covered, for rasterizations that touch the edge of the
+ // layer, we also need to raster the background color underneath the last
+ // texel (since the recording won't cover it) and outside the last texel
+ // (due to linear filtering when using this texture).
+ gfx::Rect content_rect =
+ gfx::ToEnclosingRect(gfx::ScaleRect(source_rect, contents_scale));
+
+ // The final texel of content may only be partially covered by a
+ // rasterization; this rect represents the content rect that is fully
+ // covered by content.
+ gfx::Rect deflated_content_rect = content_rect;
+ deflated_content_rect.Inset(0, 0, 1, 1);
+ if (!deflated_content_rect.Contains(canvas_rect)) {
+ if (clear_canvas_with_debug_color) {
+ // Any non-painted areas outside of the content bounds are left in
+ // this color. If this is seen then it means that cc neglected to
+ // rerasterize a tile that used to intersect with the content rect
+ // after the content bounds grew.
+ canvas->save();
+ canvas->translate(-canvas_rect.x(), -canvas_rect.y());
+ canvas->clipRect(gfx::RectToSkRect(content_rect),
+ SkRegion::kDifference_Op);
+ canvas->drawColor(DebugColors::MissingResizeInvalidations(),
+ SkXfermode::kSrc_Mode);
+ canvas->restore();
+ }
+
+ // Drawing at most 2 x 2 x (canvas width + canvas height) texels is 2-3X
+ // faster than clearing, so special case this.
+ canvas->save();
+ canvas->translate(-canvas_rect.x(), -canvas_rect.y());
+ gfx::Rect inflated_content_rect = content_rect;
+ inflated_content_rect.Inset(0, 0, -1, -1);
+ canvas->clipRect(gfx::RectToSkRect(inflated_content_rect),
+ SkRegion::kReplace_Op);
+ canvas->clipRect(gfx::RectToSkRect(deflated_content_rect),
+ SkRegion::kDifference_Op);
+ canvas->drawColor(background_color, SkXfermode::kSrc_Mode);
+ canvas->restore();
+ }
+ }
+}
+
+} // namespace cc
diff --git a/cc/resources/raster_source_helper.h b/cc/resources/raster_source_helper.h
new file mode 100644
index 0000000..abdea3e
--- /dev/null
+++ b/cc/resources/raster_source_helper.h
@@ -0,0 +1,29 @@
+// Copyright 2014 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_RASTER_SOURCE_HELPER_H_
+#define CC_RESOURCES_RASTER_SOURCE_HELPER_H_
+
+#include "cc/base/cc_export.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "ui/gfx/geometry/rect.h"
+
+class SkCanvas;
+
+namespace cc {
+
+class CC_EXPORT RasterSourceHelper {
+ public:
+ static void PrepareForPlaybackToCanvas(SkCanvas* canvas,
+ const gfx::Rect& canvas_rect,
+ const gfx::Rect& source_rect,
+ float contents_scale,
+ SkColor background_color,
+ bool clear_canvas_with_debug_color,
+ bool requires_clear);
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_RASTER_SOURCE_HELPER_H_
diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc
index 4511f9d..ca951f6 100644
--- a/cc/resources/raster_worker_pool.cc
+++ b/cc/resources/raster_worker_pool.cc
@@ -206,6 +206,7 @@
case LUMINANCE_8:
case RGB_565:
case ETC1:
+ case RED_8:
return false;
}
NOTREACHED();
diff --git a/cc/resources/resource_format.cc b/cc/resources/resource_format.cc
index 6cd0a93..45581b8 100644
--- a/cc/resources/resource_format.cc
+++ b/cc/resources/resource_format.cc
@@ -17,6 +17,7 @@
case ALPHA_8:
case LUMINANCE_8:
case RGB_565:
+ case RED_8:
NOTREACHED();
break;
}
diff --git a/cc/resources/resource_format.h b/cc/resources/resource_format.h
index b51ac7c..d785ab7 100644
--- a/cc/resources/resource_format.h
+++ b/cc/resources/resource_format.h
@@ -19,7 +19,8 @@
LUMINANCE_8,
RGB_565,
ETC1,
- RESOURCE_FORMAT_MAX = ETC1,
+ RED_8,
+ RESOURCE_FORMAT_MAX = RED_8,
};
SkColorType ResourceFormatToSkColorType(ResourceFormat format);
diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc
index 636e797..fe7cc00 100644
--- a/cc/resources/resource_provider.cc
+++ b/cc/resources/resource_provider.cc
@@ -76,6 +76,7 @@
case LUMINANCE_8:
case RGB_565:
case ETC1:
+ case RED_8:
NOTREACHED();
break;
}
@@ -94,6 +95,7 @@
case LUMINANCE_8:
case RGB_565:
case ETC1:
+ case RED_8:
return false;
}
return false;
@@ -125,6 +127,7 @@
case LUMINANCE_8:
case RGB_565:
case ETC1:
+ case RED_8:
break;
}
NOTREACHED();
@@ -1216,6 +1219,7 @@
use_texture_format_bgra_(false),
use_texture_usage_hint_(false),
use_compressed_texture_etc1_(false),
+ yuv_resource_format_(LUMINANCE_8),
max_texture_size_(0),
best_texture_format_(RGBA_8888),
use_rgba_4444_texture_format_(use_rgba_4444_texture_format),
@@ -1254,6 +1258,7 @@
use_texture_format_bgra_ = caps.gpu.texture_format_bgra8888;
use_texture_usage_hint_ = caps.gpu.texture_usage;
use_compressed_texture_etc1_ = caps.gpu.texture_format_etc1;
+ yuv_resource_format_ = caps.gpu.texture_rg ? RED_8 : LUMINANCE_8;
use_sync_query_ = caps.gpu.sync_query;
GLES2Interface* gl = ContextGL();
diff --git a/cc/resources/resource_provider.h b/cc/resources/resource_provider.h
index bfd3ebb..3a8d2e0 100644
--- a/cc/resources/resource_provider.h
+++ b/cc/resources/resource_provider.h
@@ -99,6 +99,7 @@
return use_rgba_4444_texture_format_ ? RGBA_4444 : best_texture_format_;
}
ResourceFormat best_texture_format() const { return best_texture_format_; }
+ ResourceFormat yuv_resource_format() const { return yuv_resource_format_; }
bool use_sync_query() const { return use_sync_query_; }
size_t num_resources() const { return resources_.size(); }
@@ -578,6 +579,7 @@
bool use_texture_format_bgra_;
bool use_texture_usage_hint_;
bool use_compressed_texture_etc1_;
+ ResourceFormat yuv_resource_format_;
scoped_ptr<TextureUploader> texture_uploader_;
int max_texture_size_;
ResourceFormat best_texture_format_;
@@ -610,6 +612,7 @@
return 16;
case ALPHA_8:
case LUMINANCE_8:
+ case RED_8:
return 8;
case ETC1:
return 4;
@@ -621,13 +624,14 @@
inline GLenum GLDataType(ResourceFormat format) {
DCHECK_LE(format, RESOURCE_FORMAT_MAX);
static const unsigned format_gl_data_type[RESOURCE_FORMAT_MAX + 1] = {
- GL_UNSIGNED_BYTE, // RGBA_8888
- GL_UNSIGNED_SHORT_4_4_4_4, // RGBA_4444
- GL_UNSIGNED_BYTE, // BGRA_8888
- GL_UNSIGNED_BYTE, // ALPHA_8
- GL_UNSIGNED_BYTE, // LUMINANCE_8
- GL_UNSIGNED_SHORT_5_6_5, // RGB_565,
- GL_UNSIGNED_BYTE // ETC1
+ GL_UNSIGNED_BYTE, // RGBA_8888
+ GL_UNSIGNED_SHORT_4_4_4_4, // RGBA_4444
+ GL_UNSIGNED_BYTE, // BGRA_8888
+ GL_UNSIGNED_BYTE, // ALPHA_8
+ GL_UNSIGNED_BYTE, // LUMINANCE_8
+ GL_UNSIGNED_SHORT_5_6_5, // RGB_565,
+ GL_UNSIGNED_BYTE, // ETC1
+ GL_UNSIGNED_BYTE // RED_8
};
return format_gl_data_type[format];
}
@@ -635,13 +639,14 @@
inline GLenum GLDataFormat(ResourceFormat format) {
DCHECK_LE(format, RESOURCE_FORMAT_MAX);
static const unsigned format_gl_data_format[RESOURCE_FORMAT_MAX + 1] = {
- GL_RGBA, // RGBA_8888
- GL_RGBA, // RGBA_4444
- GL_BGRA_EXT, // BGRA_8888
- GL_ALPHA, // ALPHA_8
- GL_LUMINANCE, // LUMINANCE_8
- GL_RGB, // RGB_565
- GL_ETC1_RGB8_OES // ETC1
+ GL_RGBA, // RGBA_8888
+ GL_RGBA, // RGBA_4444
+ GL_BGRA_EXT, // BGRA_8888
+ GL_ALPHA, // ALPHA_8
+ GL_LUMINANCE, // LUMINANCE_8
+ GL_RGB, // RGB_565
+ GL_ETC1_RGB8_OES, // ETC1
+ GL_RED_EXT // RED_8
};
return format_gl_data_format[format];
}
diff --git a/cc/resources/shared_bitmap.cc b/cc/resources/shared_bitmap.cc
index 31cf245..1ac0323 100644
--- a/cc/resources/shared_bitmap.cc
+++ b/cc/resources/shared_bitmap.cc
@@ -10,25 +10,13 @@
namespace cc {
-SharedBitmap::SharedBitmap(
- base::SharedMemory* memory,
- const SharedBitmapId& id,
- const base::Callback<void(SharedBitmap* bitmap)>& free_callback)
- : memory_(memory),
- pixels_(static_cast<uint8*>(memory_->memory())),
- id_(id),
- free_callback_(free_callback) {
+SharedBitmap::SharedBitmap(uint8* pixels, const SharedBitmapId& id)
+ : pixels_(pixels), id_(id) {
}
-SharedBitmap::SharedBitmap(
- uint8* pixels,
- const SharedBitmapId& id,
- const base::Callback<void(SharedBitmap* bitmap)>& free_callback)
- : memory_(NULL), pixels_(pixels), id_(id), free_callback_(free_callback) {
+SharedBitmap::~SharedBitmap() {
}
-SharedBitmap::~SharedBitmap() { free_callback_.Run(this); }
-
// static
bool SharedBitmap::SizeInBytes(const gfx::Size& size, size_t* size_in_bytes) {
if (size.IsEmpty())
diff --git a/cc/resources/shared_bitmap.h b/cc/resources/shared_bitmap.h
index ca12710..bbf0823 100644
--- a/cc/resources/shared_bitmap.h
+++ b/cc/resources/shared_bitmap.h
@@ -6,8 +6,7 @@
#define CC_RESOURCES_SHARED_BITMAP_H_
#include "base/basictypes.h"
-#include "base/callback.h"
-#include "base/memory/shared_memory.h"
+#include "base/memory/scoped_ptr.h"
#include "cc/base/cc_export.h"
#include "gpu/command_buffer/common/mailbox.h"
#include "ui/gfx/geometry/size.h"
@@ -19,29 +18,15 @@
class CC_EXPORT SharedBitmap {
public:
- SharedBitmap(base::SharedMemory* memory,
- const SharedBitmapId& id,
- const base::Callback<void(SharedBitmap* bitmap)>& free_callback);
+ SharedBitmap(uint8* pixels, const SharedBitmapId& id);
- SharedBitmap(uint8* pixels,
- const SharedBitmapId& id,
- const base::Callback<void(SharedBitmap* bitmap)>& free_callback);
-
- ~SharedBitmap();
-
- bool operator<(const SharedBitmap& right) const {
- if (memory_ < right.memory_)
- return true;
- if (memory_ > right.memory_)
- return false;
- return id_ < right.id_;
- }
+ virtual ~SharedBitmap();
uint8* pixels() { return pixels_; }
- base::SharedMemory* memory() { return memory_; }
+ virtual base::SharedMemory* memory() = 0;
- SharedBitmapId id() { return id_; }
+ const SharedBitmapId& id() { return id_; }
// Returns true if the size is valid and false otherwise.
static bool SizeInBytes(const gfx::Size& size, size_t* size_in_bytes);
@@ -57,10 +42,8 @@
static SharedBitmapId GenerateId();
private:
- base::SharedMemory* memory_;
uint8* pixels_;
SharedBitmapId id_;
- base::Callback<void(SharedBitmap* bitmap)> free_callback_;
DISALLOW_COPY_AND_ASSIGN(SharedBitmap);
};
diff --git a/cc/resources/texture_uploader_unittest.cc b/cc/resources/texture_uploader_unittest.cc
index 7249172..b168962 100644
--- a/cc/resources/texture_uploader_unittest.cc
+++ b/cc/resources/texture_uploader_unittest.cc
@@ -111,6 +111,14 @@
EXPECT_EQ(static_cast<unsigned>(GL_UNSIGNED_BYTE), type);
bytes_per_pixel = 2;
break;
+ case GL_RED_EXT:
+ EXPECT_EQ(static_cast<unsigned>(GL_UNSIGNED_BYTE), type);
+ bytes_per_pixel = 1;
+ break;
+ case GL_RG_EXT:
+ EXPECT_EQ(static_cast<unsigned>(GL_UNSIGNED_BYTE), type);
+ bytes_per_pixel = 2;
+ break;
}
// If NULL, we aren't checking texture contents.
@@ -232,6 +240,15 @@
buffer[(i + 1) * 82 - 1] = 0x2;
}
UploadTexture(uploader.get(), LUMINANCE_8, gfx::Size(82, 86), buffer);
+
+ // Upload a tightly packed 82x86 RED texture.
+ memset(buffer, 0, sizeof(buffer));
+ for (int i = 0; i < 86; ++i) {
+ // Mark the beginning and end of each row, for the test.
+ buffer[i * 1 * 82] = 0x1;
+ buffer[(i + 1) * 82 - 1] = 0x2;
+ }
+ UploadTexture(uploader.get(), RED_8, gfx::Size(82, 86), buffer);
}
} // namespace
diff --git a/cc/resources/tile.h b/cc/resources/tile.h
index 042d5ae..a35cffe 100644
--- a/cc/resources/tile.h
+++ b/cc/resources/tile.h
@@ -15,6 +15,8 @@
namespace cc {
+class TileManager;
+
class CC_EXPORT Tile : public RefCountedManaged<Tile> {
public:
enum TileRasterFlags { USE_PICTURE_ANALYSIS = 1 << 0 };
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index d83b824..66f95da 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -239,9 +239,11 @@
task_runner_.get(),
base::Bind(&TileManager::CheckIfReadyToActivate,
base::Unretained(this))),
- ready_to_draw_check_notifier_(task_runner_.get(),
- base::Bind(&TileManager::CheckIfReadyToDraw,
- base::Unretained(this))) {
+ ready_to_draw_check_notifier_(
+ task_runner_.get(),
+ base::Bind(&TileManager::CheckIfReadyToDraw, base::Unretained(this))),
+ did_notify_ready_to_activate_(false),
+ did_notify_ready_to_draw_(false) {
rasterizer_->SetClient(this);
}
@@ -416,9 +418,12 @@
TileVector tiles_that_need_to_be_rasterized;
AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized);
- // Finally, schedule rasterizer tasks.
+ // Schedule rasterizer tasks.
ScheduleTasks(tiles_that_need_to_be_rasterized);
+ did_notify_ready_to_activate_ = false;
+ did_notify_ready_to_draw_ = false;
+
TRACE_EVENT_INSTANT1("cc",
"DidManage",
TRACE_EVENT_SCOPE_THREAD,
@@ -882,8 +887,13 @@
rasterizer_->CheckForCompletedTasks();
did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
- if (IsReadyToActivate())
- client_->NotifyReadyToActivate();
+ if (did_notify_ready_to_activate_)
+ return;
+ if (!IsReadyToActivate())
+ return;
+
+ client_->NotifyReadyToActivate();
+ did_notify_ready_to_activate_ = true;
}
void TileManager::CheckIfReadyToDraw() {
@@ -892,8 +902,13 @@
rasterizer_->CheckForCompletedTasks();
did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
- if (IsReadyToDraw())
- client_->NotifyReadyToDraw();
+ if (did_notify_ready_to_draw_)
+ return;
+ if (!IsReadyToDraw())
+ return;
+
+ client_->NotifyReadyToDraw();
+ did_notify_ready_to_draw_ = true;
}
TileManager::MemoryUsage::MemoryUsage() : memory_bytes_(0), resource_count_(0) {
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index e94fb7c..8d19520 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -162,6 +162,10 @@
return tiles;
}
+ void SetScheduledRasterTaskLimitForTesting(size_t limit) {
+ scheduled_raster_task_limit_ = limit;
+ }
+
protected:
TileManager(TileManagerClient* client,
const scoped_refptr<base::SequencedTaskRunner>& task_runner,
@@ -243,7 +247,7 @@
ResourcePool* resource_pool_;
Rasterizer* rasterizer_;
GlobalStateThatImpactsTilePriority global_state_;
- const size_t scheduled_raster_task_limit_;
+ size_t scheduled_raster_task_limit_;
typedef base::hash_map<Tile::Id, Tile*> TileMap;
TileMap tiles_;
@@ -282,6 +286,9 @@
EvictionTilePriorityQueue eviction_priority_queue_;
bool eviction_priority_queue_is_up_to_date_;
+ bool did_notify_ready_to_activate_;
+ bool did_notify_ready_to_draw_;
+
DISALLOW_COPY_AND_ASSIGN(TileManager);
};
diff --git a/cc/resources/tile_manager_perftest.cc b/cc/resources/tile_manager_perftest.cc
index 7b096bd..2204ab8 100644
--- a/cc/resources/tile_manager_perftest.cc
+++ b/cc/resources/tile_manager_perftest.cc
@@ -400,7 +400,8 @@
timer_.Reset();
bool resourceless_software_draw = false;
do {
- BeginFrameArgs args = CreateBeginFrameArgsForTesting();
+ BeginFrameArgs args =
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
host_impl_.UpdateCurrentBeginFrameArgs(args);
for (unsigned i = 0; i < layers.size(); ++i) {
layers[i]->UpdateTiles(Occlusion(), resourceless_software_draw);
diff --git a/cc/resources/tile_manager_unittest.cc b/cc/resources/tile_manager_unittest.cc
index 49a93d3..fdd876e 100644
--- a/cc/resources/tile_manager_unittest.cc
+++ b/cc/resources/tile_manager_unittest.cc
@@ -149,7 +149,9 @@
};
TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueue) {
- SetupDefaultTrees(gfx::Size(1000, 1000));
+ const gfx::Size layer_bounds(1000, 1000);
+ host_impl_.SetViewportSize(layer_bounds);
+ SetupDefaultTrees(layer_bounds);
active_layer_->CreateDefaultTilingsAndTiles();
pending_layer_->CreateDefaultTilingsAndTiles();
@@ -391,7 +393,9 @@
}
TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueue) {
- SetupDefaultTrees(gfx::Size(1000, 1000));
+ const gfx::Size layer_bounds(1000, 1000);
+ host_impl_.SetViewportSize(layer_bounds);
+ SetupDefaultTrees(layer_bounds);
active_layer_->CreateDefaultTilingsAndTiles();
pending_layer_->CreateDefaultTilingsAndTiles();
@@ -560,6 +564,8 @@
gfx::Size tile_size(102, 102);
gfx::Size layer_bounds(1000, 1000);
+ host_impl_.SetViewportSize(layer_bounds);
+
scoped_refptr<FakePicturePileImpl> pending_pile =
FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
SetupPendingTree(pending_pile);
@@ -768,7 +774,9 @@
}
TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueEmptyLayers) {
- SetupDefaultTrees(gfx::Size(1000, 1000));
+ const gfx::Size layer_bounds(1000, 1000);
+ host_impl_.SetViewportSize(layer_bounds);
+ SetupDefaultTrees(layer_bounds);
active_layer_->CreateDefaultTilingsAndTiles();
pending_layer_->CreateDefaultTilingsAndTiles();
@@ -815,7 +823,9 @@
}
TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueueEmptyLayers) {
- SetupDefaultTrees(gfx::Size(1000, 1000));
+ const gfx::Size layer_bounds(1000, 1000);
+ host_impl_.SetViewportSize(layer_bounds);
+ SetupDefaultTrees(layer_bounds);
active_layer_->CreateDefaultTilingsAndTiles();
pending_layer_->CreateDefaultTilingsAndTiles();
diff --git a/cc/resources/tiling_set_eviction_queue.cc b/cc/resources/tiling_set_eviction_queue.cc
new file mode 100644
index 0000000..8c5ff52
--- /dev/null
+++ b/cc/resources/tiling_set_eviction_queue.cc
@@ -0,0 +1,197 @@
+// Copyright 2014 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/resources/tiling_set_eviction_queue.h"
+
+namespace cc {
+
+TilingSetEvictionQueue::TilingSetEvictionQueue()
+ : tiling_set_(nullptr),
+ tree_priority_(SAME_PRIORITY_FOR_BOTH_TREES),
+ current_category_(PictureLayerTiling::EVENTUALLY),
+ current_tiling_index_(0u),
+ current_tiling_range_type_(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES),
+ current_eviction_tile_(nullptr),
+ eviction_tiles_(nullptr),
+ next_eviction_tile_index_(0u) {
+}
+
+TilingSetEvictionQueue::TilingSetEvictionQueue(
+ PictureLayerTilingSet* tiling_set,
+ TreePriority tree_priority)
+ : tiling_set_(tiling_set),
+ tree_priority_(tree_priority),
+ current_category_(PictureLayerTiling::EVENTUALLY),
+ current_tiling_index_(0u),
+ current_tiling_range_type_(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES),
+ current_eviction_tile_(nullptr),
+ eviction_tiles_(nullptr),
+ next_eviction_tile_index_(0u) {
+ DCHECK(tiling_set_);
+
+ // Early out if the layer has no tilings.
+ if (!tiling_set_->num_tilings())
+ return;
+
+ current_tiling_index_ = CurrentTilingRange().start - 1u;
+ AdvanceToNextValidTiling();
+}
+
+TilingSetEvictionQueue::~TilingSetEvictionQueue() {
+}
+
+bool TilingSetEvictionQueue::IsEmpty() const {
+ return !current_eviction_tile_;
+}
+
+void TilingSetEvictionQueue::Pop() {
+ DCHECK(!IsEmpty());
+
+ if (!AdvanceToNextEvictionTile())
+ AdvanceToNextValidTiling();
+}
+
+Tile* TilingSetEvictionQueue::Top() {
+ DCHECK(!IsEmpty());
+ return current_eviction_tile_;
+}
+
+const Tile* TilingSetEvictionQueue::Top() const {
+ DCHECK(!IsEmpty());
+ return current_eviction_tile_;
+}
+
+bool TilingSetEvictionQueue::AdvanceToNextCategory() {
+ // Advance to the next category. This is done only after all tiling range
+ // types within the previous category have been gone through.
+ DCHECK_EQ(current_tiling_range_type_, PictureLayerTilingSet::HIGH_RES);
+
+ switch (current_category_) {
+ case PictureLayerTiling::EVENTUALLY:
+ current_category_ =
+ PictureLayerTiling::EVENTUALLY_AND_REQUIRED_FOR_ACTIVATION;
+ return true;
+ case PictureLayerTiling::EVENTUALLY_AND_REQUIRED_FOR_ACTIVATION:
+ current_category_ = PictureLayerTiling::SOON;
+ return true;
+ case PictureLayerTiling::SOON:
+ current_category_ = PictureLayerTiling::SOON_AND_REQUIRED_FOR_ACTIVATION;
+ return true;
+ case PictureLayerTiling::SOON_AND_REQUIRED_FOR_ACTIVATION:
+ current_category_ = PictureLayerTiling::NOW;
+ return true;
+ case PictureLayerTiling::NOW:
+ current_category_ = PictureLayerTiling::NOW_AND_REQUIRED_FOR_ACTIVATION;
+ return true;
+ case PictureLayerTiling::NOW_AND_REQUIRED_FOR_ACTIVATION:
+ return false;
+ }
+ NOTREACHED();
+ return false;
+}
+
+bool TilingSetEvictionQueue::AdvanceToNextEvictionTile() {
+ // Advance to the next eviction tile within the current category and tiling.
+ // This is done while advancing to a new tiling (in which case the next
+ // eviction tile index is 0) and while popping the current tile (in which
+ // case the next eviction tile index is greater than 0).
+ DCHECK_EQ(next_eviction_tile_index_ > 0, current_eviction_tile_ != nullptr);
+
+ while (next_eviction_tile_index_ < eviction_tiles_->size()) {
+ Tile* tile = (*eviction_tiles_)[next_eviction_tile_index_];
+ ++next_eviction_tile_index_;
+ if (tile->HasResources()) {
+ current_eviction_tile_ = tile;
+ return true;
+ }
+ }
+
+ current_eviction_tile_ = nullptr;
+ return false;
+}
+
+bool TilingSetEvictionQueue::AdvanceToNextTilingRangeType() {
+ // Advance to the next tiling range type within the current category or to
+ // the first tiling range type within the next category. This is done only
+ // after all tilings within the previous tiling range type have been gone
+ // through.
+ DCHECK_EQ(current_tiling_index_, CurrentTilingRange().end);
+
+ switch (current_tiling_range_type_) {
+ case PictureLayerTilingSet::HIGHER_THAN_HIGH_RES:
+ current_tiling_range_type_ = PictureLayerTilingSet::LOWER_THAN_LOW_RES;
+ return true;
+ case PictureLayerTilingSet::LOWER_THAN_LOW_RES:
+ current_tiling_range_type_ =
+ PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES;
+ return true;
+ case PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES:
+ current_tiling_range_type_ = PictureLayerTilingSet::LOW_RES;
+ return true;
+ case PictureLayerTilingSet::LOW_RES:
+ current_tiling_range_type_ = PictureLayerTilingSet::HIGH_RES;
+ return true;
+ case PictureLayerTilingSet::HIGH_RES:
+ if (!AdvanceToNextCategory())
+ return false;
+
+ current_tiling_range_type_ = PictureLayerTilingSet::HIGHER_THAN_HIGH_RES;
+ return true;
+ }
+ NOTREACHED();
+ return false;
+}
+
+bool TilingSetEvictionQueue::AdvanceToNextValidTiling() {
+ // Advance to the next tiling within current tiling range type or to
+ // the first tiling within the next tiling range type or category until
+ // the next eviction tile is found. This is done only after all eviction
+ // tiles within the previous tiling within the current category and tiling
+ // range type have been gone through.
+ DCHECK(!current_eviction_tile_);
+ DCHECK_NE(current_tiling_index_, CurrentTilingRange().end);
+
+ for (;;) {
+ ++current_tiling_index_;
+ while (current_tiling_index_ == CurrentTilingRange().end) {
+ if (!AdvanceToNextTilingRangeType())
+ return false;
+ current_tiling_index_ = CurrentTilingRange().start;
+ }
+
+ PictureLayerTiling* tiling = tiling_set_->tiling_at(CurrentTilingIndex());
+ eviction_tiles_ =
+ tiling->GetEvictionTiles(tree_priority_, current_category_);
+ next_eviction_tile_index_ = 0u;
+ if (AdvanceToNextEvictionTile())
+ return true;
+ }
+}
+
+PictureLayerTilingSet::TilingRange
+TilingSetEvictionQueue::CurrentTilingRange() const {
+ return tiling_set_->GetTilingRange(current_tiling_range_type_);
+}
+
+size_t TilingSetEvictionQueue::CurrentTilingIndex() const {
+ DCHECK_NE(current_tiling_index_, CurrentTilingRange().end);
+ switch (current_tiling_range_type_) {
+ case PictureLayerTilingSet::HIGHER_THAN_HIGH_RES:
+ case PictureLayerTilingSet::LOW_RES:
+ case PictureLayerTilingSet::HIGH_RES:
+ return current_tiling_index_;
+ // Tilings in the following ranges are accessed in reverse order.
+ case PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES:
+ case PictureLayerTilingSet::LOWER_THAN_LOW_RES: {
+ PictureLayerTilingSet::TilingRange tiling_range = CurrentTilingRange();
+ size_t current_tiling_range_offset =
+ current_tiling_index_ - tiling_range.start;
+ return tiling_range.end - 1 - current_tiling_range_offset;
+ }
+ }
+ NOTREACHED();
+ return 0;
+}
+
+}
diff --git a/cc/resources/tiling_set_eviction_queue.h b/cc/resources/tiling_set_eviction_queue.h
new file mode 100644
index 0000000..f88ce3b
--- /dev/null
+++ b/cc/resources/tiling_set_eviction_queue.h
@@ -0,0 +1,48 @@
+// Copyright 2014 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_TILING_SET_EVICTION_QUEUE_H_
+#define CC_RESOURCES_TILING_SET_EVICTION_QUEUE_H_
+
+#include "cc/base/cc_export.h"
+#include "cc/resources/picture_layer_tiling_set.h"
+
+namespace cc {
+
+class CC_EXPORT TilingSetEvictionQueue {
+ public:
+ TilingSetEvictionQueue();
+ TilingSetEvictionQueue(PictureLayerTilingSet* tiling_set,
+ TreePriority tree_priority);
+ ~TilingSetEvictionQueue();
+
+ Tile* Top();
+ const Tile* Top() const;
+ void Pop();
+ bool IsEmpty() const;
+
+ private:
+ bool AdvanceToNextCategory();
+ bool AdvanceToNextEvictionTile();
+ bool AdvanceToNextTilingRangeType();
+ bool AdvanceToNextValidTiling();
+
+ PictureLayerTilingSet::TilingRange CurrentTilingRange() const;
+ size_t CurrentTilingIndex() const;
+
+ PictureLayerTilingSet* tiling_set_;
+ TreePriority tree_priority_;
+
+ PictureLayerTiling::EvictionCategory current_category_;
+ size_t current_tiling_index_;
+ PictureLayerTilingSet::TilingRangeType current_tiling_range_type_;
+ Tile* current_eviction_tile_;
+
+ const std::vector<Tile*>* eviction_tiles_;
+ size_t next_eviction_tile_index_;
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_TILING_SET_RASTER_QUEUE_H_
diff --git a/cc/resources/transform_display_item.cc b/cc/resources/transform_display_item.cc
new file mode 100644
index 0000000..c7f4d60
--- /dev/null
+++ b/cc/resources/transform_display_item.cc
@@ -0,0 +1,60 @@
+// Copyright 2014 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/resources/transform_display_item.h"
+
+#include "third_party/skia/include/core/SkCanvas.h"
+
+namespace cc {
+
+TransformDisplayItem::TransformDisplayItem(const gfx::Transform& transform)
+ : transform_(transform) {
+}
+
+TransformDisplayItem::~TransformDisplayItem() {
+}
+
+void TransformDisplayItem::Raster(SkCanvas* canvas,
+ SkDrawPictureCallback* callback) const {
+ canvas->save();
+ if (!transform_.IsIdentity())
+ canvas->concat(transform_.matrix());
+}
+
+bool TransformDisplayItem::IsSuitableForGpuRasterization() const {
+ return true;
+}
+
+int TransformDisplayItem::ApproximateOpCount() const {
+ return 1;
+}
+
+size_t TransformDisplayItem::PictureMemoryUsage() const {
+ return sizeof(gfx::Transform);
+}
+
+EndTransformDisplayItem::EndTransformDisplayItem() {
+}
+
+EndTransformDisplayItem::~EndTransformDisplayItem() {
+}
+
+void EndTransformDisplayItem::Raster(SkCanvas* canvas,
+ SkDrawPictureCallback* callback) const {
+ canvas->restore();
+}
+
+bool EndTransformDisplayItem::IsSuitableForGpuRasterization() const {
+ return true;
+}
+
+int EndTransformDisplayItem::ApproximateOpCount() const {
+ return 0;
+}
+
+size_t EndTransformDisplayItem::PictureMemoryUsage() const {
+ return 0;
+}
+
+} // namespace cc
diff --git a/cc/resources/transform_display_item.h b/cc/resources/transform_display_item.h
new file mode 100644
index 0000000..1671f49
--- /dev/null
+++ b/cc/resources/transform_display_item.h
@@ -0,0 +1,60 @@
+// Copyright 2014 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_TRANSFORM_DISPLAY_ITEM_H_
+#define CC_RESOURCES_TRANSFORM_DISPLAY_ITEM_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "cc/base/cc_export.h"
+#include "cc/resources/display_item.h"
+#include "ui/gfx/transform.h"
+
+class SkCanvas;
+class SkDrawPictureCallback;
+
+namespace cc {
+
+class CC_EXPORT TransformDisplayItem : public DisplayItem {
+ public:
+ virtual ~TransformDisplayItem();
+
+ static scoped_ptr<TransformDisplayItem> Create(
+ const gfx::Transform& transform) {
+ return make_scoped_ptr(new TransformDisplayItem(transform));
+ }
+
+ void Raster(SkCanvas* canvas, SkDrawPictureCallback* callback) const override;
+
+ bool IsSuitableForGpuRasterization() const override;
+ int ApproximateOpCount() const override;
+ size_t PictureMemoryUsage() const override;
+
+ protected:
+ explicit TransformDisplayItem(const gfx::Transform& transform);
+
+ private:
+ gfx::Transform transform_;
+};
+
+class CC_EXPORT EndTransformDisplayItem : public DisplayItem {
+ public:
+ virtual ~EndTransformDisplayItem();
+
+ static scoped_ptr<EndTransformDisplayItem> Create() {
+ return make_scoped_ptr(new EndTransformDisplayItem());
+ }
+
+ void Raster(SkCanvas* canvas, SkDrawPictureCallback* callback) const override;
+
+ bool IsSuitableForGpuRasterization() const override;
+ int ApproximateOpCount() const override;
+ size_t PictureMemoryUsage() const override;
+
+ protected:
+ EndTransformDisplayItem();
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_TRANSFORM_DISPLAY_ITEM_H_
diff --git a/cc/resources/transparency_display_item.cc b/cc/resources/transparency_display_item.cc
new file mode 100644
index 0000000..0401d90
--- /dev/null
+++ b/cc/resources/transparency_display_item.cc
@@ -0,0 +1,65 @@
+// Copyright 2014 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/resources/transparency_display_item.h"
+
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkPaint.h"
+#include "third_party/skia/include/core/SkXfermode.h"
+#include "ui/gfx/skia_util.h"
+
+namespace cc {
+
+TransparencyDisplayItem::TransparencyDisplayItem(float opacity,
+ SkXfermode::Mode blend_mode)
+ : opacity_(opacity), blend_mode_(blend_mode) {
+}
+
+TransparencyDisplayItem::~TransparencyDisplayItem() {
+}
+
+void TransparencyDisplayItem::Raster(SkCanvas* canvas,
+ SkDrawPictureCallback* callback) const {
+ SkPaint paint;
+ paint.setXfermodeMode(blend_mode_);
+ paint.setAlpha(opacity_ * 255);
+ canvas->saveLayer(NULL, &paint);
+}
+
+bool TransparencyDisplayItem::IsSuitableForGpuRasterization() const {
+ return true;
+}
+
+int TransparencyDisplayItem::ApproximateOpCount() const {
+ return 1;
+}
+
+size_t TransparencyDisplayItem::PictureMemoryUsage() const {
+ return sizeof(float) + sizeof(SkXfermode::Mode);
+}
+
+EndTransparencyDisplayItem::EndTransparencyDisplayItem() {
+}
+
+EndTransparencyDisplayItem::~EndTransparencyDisplayItem() {
+}
+
+void EndTransparencyDisplayItem::Raster(SkCanvas* canvas,
+ SkDrawPictureCallback* callback) const {
+ canvas->restore();
+}
+
+bool EndTransparencyDisplayItem::IsSuitableForGpuRasterization() const {
+ return true;
+}
+
+int EndTransparencyDisplayItem::ApproximateOpCount() const {
+ return 0;
+}
+
+size_t EndTransparencyDisplayItem::PictureMemoryUsage() const {
+ return 0;
+}
+
+} // namespace cc
diff --git a/cc/resources/transparency_display_item.h b/cc/resources/transparency_display_item.h
new file mode 100644
index 0000000..6766d91
--- /dev/null
+++ b/cc/resources/transparency_display_item.h
@@ -0,0 +1,64 @@
+// Copyright 2014 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_TRANSPARENCY_DISPLAY_ITEM_H_
+#define CC_RESOURCES_TRANSPARENCY_DISPLAY_ITEM_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "cc/base/cc_export.h"
+#include "cc/resources/display_item.h"
+#include "skia/ext/refptr.h"
+#include "third_party/skia/include/core/SkXfermode.h"
+#include "ui/gfx/geometry/rect_f.h"
+
+class SkCanvas;
+class SkDrawPictureCallback;
+
+namespace cc {
+
+class CC_EXPORT TransparencyDisplayItem : public DisplayItem {
+ public:
+ virtual ~TransparencyDisplayItem();
+
+ static scoped_ptr<TransparencyDisplayItem> Create(
+ float opacity,
+ SkXfermode::Mode blend_mode) {
+ return make_scoped_ptr(new TransparencyDisplayItem(opacity, blend_mode));
+ }
+
+ void Raster(SkCanvas* canvas, SkDrawPictureCallback* callback) const override;
+
+ bool IsSuitableForGpuRasterization() const override;
+ int ApproximateOpCount() const override;
+ size_t PictureMemoryUsage() const override;
+
+ protected:
+ TransparencyDisplayItem(float opacity, SkXfermode::Mode blend_mode);
+
+ private:
+ float opacity_;
+ SkXfermode::Mode blend_mode_;
+};
+
+class CC_EXPORT EndTransparencyDisplayItem : public DisplayItem {
+ public:
+ virtual ~EndTransparencyDisplayItem();
+
+ static scoped_ptr<EndTransparencyDisplayItem> Create() {
+ return make_scoped_ptr(new EndTransparencyDisplayItem());
+ }
+
+ void Raster(SkCanvas* canvas, SkDrawPictureCallback* callback) const override;
+
+ bool IsSuitableForGpuRasterization() const override;
+ int ApproximateOpCount() const override;
+ size_t PictureMemoryUsage() const override;
+
+ protected:
+ EndTransparencyDisplayItem();
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_TRANSPARENCY_DISPLAY_ITEM_H_
diff --git a/cc/resources/video_resource_updater.cc b/cc/resources/video_resource_updater.cc
index 7a775d9..2c9a688 100644
--- a/cc/resources/video_resource_updater.cc
+++ b/cc/resources/video_resource_updater.cc
@@ -20,7 +20,6 @@
namespace {
-const ResourceFormat kYUVResourceFormat = LUMINANCE_8;
const ResourceFormat kRGBResourceFormat = RGBA_8888;
class SyncPointClientImpl : public media::VideoFrame::SyncPointClient {
@@ -40,6 +39,37 @@
} // namespace
+VideoResourceUpdater::PlaneResource::PlaneResource(
+ unsigned int resource_id,
+ const gfx::Size& resource_size,
+ ResourceFormat resource_format,
+ gpu::Mailbox mailbox)
+ : resource_id(resource_id),
+ resource_size(resource_size),
+ resource_format(resource_format),
+ mailbox(mailbox),
+ frame_ptr(nullptr),
+ plane_index(0) {
+}
+
+bool VideoResourceUpdater::PlaneResourceMatchesUniqueID(
+ const PlaneResource& plane_resource,
+ const media::VideoFrame* video_frame,
+ int plane_index) {
+ return plane_resource.frame_ptr == video_frame &&
+ plane_resource.plane_index == plane_index &&
+ plane_resource.timestamp == video_frame->timestamp();
+}
+
+void VideoResourceUpdater::SetPlaneResourceUniqueId(
+ const media::VideoFrame* video_frame,
+ int plane_index,
+ PlaneResource* plane_resource) {
+ plane_resource->frame_ptr = video_frame;
+ plane_resource->plane_index = plane_index;
+ plane_resource->timestamp = video_frame->timestamp();
+}
+
VideoFrameExternalResources::VideoFrameExternalResources() : type(NONE) {}
VideoFrameExternalResources::~VideoFrameExternalResources() {}
@@ -104,14 +134,12 @@
// each plane in the frame.
static gfx::Size SoftwarePlaneDimension(
const scoped_refptr<media::VideoFrame>& input_frame,
- ResourceFormat output_resource_format,
+ bool software_compositor,
size_t plane_index) {
- if (output_resource_format == kYUVResourceFormat) {
+ if (!software_compositor) {
return media::VideoFrame::PlaneSize(
input_frame->format(), plane_index, input_frame->coded_size());
}
-
- DCHECK_EQ(output_resource_format, kRGBResourceFormat);
return input_frame->coded_size();
}
@@ -145,7 +173,8 @@
bool software_compositor = context_provider_ == NULL;
- ResourceFormat output_resource_format = kYUVResourceFormat;
+ ResourceFormat output_resource_format =
+ resource_provider_->yuv_resource_format();
size_t output_plane_count = media::VideoFrame::NumPlanes(input_frame_format);
// TODO(skaslev): If we're in software compositing mode, we do the YUV -> RGB
@@ -163,7 +192,7 @@
for (size_t i = 0; i < output_plane_count; ++i) {
gfx::Size output_plane_resource_size =
- SoftwarePlaneDimension(video_frame, output_resource_format, i);
+ SoftwarePlaneDimension(video_frame, software_compositor, i);
if (output_plane_resource_size.IsEmpty() ||
output_plane_resource_size.width() > max_resource_size ||
output_plane_resource_size.height() > max_resource_size) {
@@ -171,57 +200,56 @@
break;
}
- ResourceProvider::ResourceId resource_id = 0;
- gpu::Mailbox mailbox;
-
// Try recycle a previously-allocated resource.
- for (size_t i = 0; i < recycled_resources_.size(); ++i) {
- bool resource_matches =
- recycled_resources_[i].resource_format == output_resource_format &&
- recycled_resources_[i].resource_size == output_plane_resource_size;
- bool not_in_use =
- !software_compositor || !resource_provider_->InUseByConsumer(
- recycled_resources_[i].resource_id);
- if (resource_matches && not_in_use) {
- resource_id = recycled_resources_[i].resource_id;
- mailbox = recycled_resources_[i].mailbox;
- recycled_resources_.erase(recycled_resources_.begin() + i);
- break;
+ auto recycled_it = recycled_resources_.end();
+ for (auto it = recycled_resources_.begin(); it != recycled_resources_.end();
+ ++it) {
+ const bool resource_matches =
+ it->resource_format == output_resource_format &&
+ it->resource_size == output_plane_resource_size;
+ const bool in_use = software_compositor &&
+ resource_provider_->InUseByConsumer(it->resource_id);
+ if (resource_matches && !in_use) {
+ // We found a recycled resource with the allocation size and format we
+ // are looking for.
+ recycled_it = it;
+ // Keep looking for a recycled resource that also contains the data we
+ // are planning to put in it.
+ if (PlaneResourceMatchesUniqueID(*it, video_frame.get(), i))
+ break;
}
}
- if (resource_id == 0) {
- // TODO(danakj): Abstract out hw/sw resource create/delete from
- // ResourceProvider and stop using ResourceProvider in this class.
- resource_id = resource_provider_->CreateResource(
- output_plane_resource_size,
- GL_CLAMP_TO_EDGE,
- ResourceProvider::TextureHintImmutable,
- output_resource_format);
-
- DCHECK(mailbox.IsZero());
-
- if (!software_compositor) {
- DCHECK(context_provider_);
-
- gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
-
- GLC(gl, gl->GenMailboxCHROMIUM(mailbox.name));
- ResourceProvider::ScopedWriteLockGL lock(resource_provider_,
- resource_id);
- GLC(gl,
- gl->ProduceTextureDirectCHROMIUM(
- lock.texture_id(), GL_TEXTURE_2D, mailbox.name));
- }
-
- if (resource_id)
- all_resources_.push_back(resource_id);
+ // Check if we can avoid allocating a new resource.
+ if (recycled_it != recycled_resources_.end()) {
+ plane_resources.push_back(*recycled_it);
+ recycled_resources_.erase(recycled_it);
+ continue;
}
+ // TODO(danakj): Abstract out hw/sw resource create/delete from
+ // ResourceProvider and stop using ResourceProvider in this class.
+ const ResourceProvider::ResourceId resource_id =
+ resource_provider_->CreateResource(
+ output_plane_resource_size, GL_CLAMP_TO_EDGE,
+ ResourceProvider::TextureHintImmutable, output_resource_format);
if (resource_id == 0) {
allocation_success = false;
break;
}
+ all_resources_.push_back(resource_id);
+
+ gpu::Mailbox mailbox;
+ if (!software_compositor) {
+ DCHECK(context_provider_);
+
+ gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
+
+ GLC(gl, gl->GenMailboxCHROMIUM(mailbox.name));
+ ResourceProvider::ScopedWriteLockGL lock(resource_provider_, resource_id);
+ GLC(gl, gl->ProduceTextureDirectCHROMIUM(lock.texture_id(), GL_TEXTURE_2D,
+ mailbox.name));
+ }
DCHECK(software_compositor || !mailbox.IsZero());
plane_resources.push_back(PlaneResource(resource_id,
@@ -243,26 +271,23 @@
DCHECK_EQ(plane_resources[0].resource_format, kRGBResourceFormat);
DCHECK(plane_resources[0].mailbox.IsZero());
- if (!video_renderer_)
- video_renderer_.reset(new media::SkCanvasVideoRenderer);
+ if (!PlaneResourceMatchesUniqueID(plane_resources[0], video_frame.get(),
+ 0)) {
+ // We need to transfer data from |video_frame| to the plane resource.
+ if (!video_renderer_)
+ video_renderer_.reset(new media::SkCanvasVideoRenderer);
- {
ResourceProvider::ScopedWriteLockSoftware lock(
resource_provider_, plane_resources[0].resource_id);
SkCanvas canvas(lock.sk_bitmap());
video_renderer_->Copy(video_frame, &canvas);
+ SetPlaneResourceUniqueId(video_frame.get(), 0, &plane_resources[0]);
}
- RecycleResourceData recycle_data = {
- plane_resources[0].resource_id,
- plane_resources[0].resource_size,
- plane_resources[0].resource_format,
- gpu::Mailbox()
- };
external_resources.software_resources.push_back(
plane_resources[0].resource_id);
external_resources.software_release_callback =
- base::Bind(&RecycleResource, AsWeakPtr(), recycle_data);
+ base::Bind(&RecycleResource, AsWeakPtr(), plane_resources[0]);
external_resources.type = VideoFrameExternalResources::SOFTWARE_RESOURCE;
return external_resources;
@@ -270,32 +295,27 @@
for (size_t i = 0; i < plane_resources.size(); ++i) {
// Update each plane's resource id with its content.
- DCHECK_EQ(plane_resources[i].resource_format, kYUVResourceFormat);
+ DCHECK_EQ(plane_resources[i].resource_format,
+ resource_provider_->yuv_resource_format());
- const uint8_t* input_plane_pixels = video_frame->data(i);
+ if (!PlaneResourceMatchesUniqueID(plane_resources[i], video_frame.get(),
+ i)) {
+ // We need to transfer data from |video_frame| to the plane resource.
+ const uint8_t* input_plane_pixels = video_frame->data(i);
- gfx::Rect image_rect(0,
- 0,
- video_frame->stride(i),
- plane_resources[i].resource_size.height());
- gfx::Rect source_rect(plane_resources[i].resource_size);
- resource_provider_->SetPixels(plane_resources[i].resource_id,
- input_plane_pixels,
- image_rect,
- source_rect,
- gfx::Vector2d());
-
- RecycleResourceData recycle_data = {
- plane_resources[i].resource_id,
- plane_resources[i].resource_size,
- plane_resources[i].resource_format,
- plane_resources[i].mailbox
- };
+ gfx::Rect image_rect(0, 0, video_frame->stride(i),
+ plane_resources[i].resource_size.height());
+ gfx::Rect source_rect(plane_resources[i].resource_size);
+ resource_provider_->SetPixels(plane_resources[i].resource_id,
+ input_plane_pixels, image_rect, source_rect,
+ gfx::Vector2d());
+ SetPlaneResourceUniqueId(video_frame.get(), i, &plane_resources[i]);
+ }
external_resources.mailboxes.push_back(
TextureMailbox(plane_resources[i].mailbox, GL_TEXTURE_2D, 0));
external_resources.release_callbacks.push_back(
- base::Bind(&RecycleResource, AsWeakPtr(), recycle_data));
+ base::Bind(&RecycleResource, AsWeakPtr(), plane_resources[i]));
}
external_resources.type = VideoFrameExternalResources::YUV_RESOURCE;
@@ -362,7 +382,7 @@
// static
void VideoResourceUpdater::RecycleResource(
base::WeakPtr<VideoResourceUpdater> updater,
- RecycleResourceData data,
+ PlaneResource data,
uint32 sync_point,
bool lost_resource,
BlockingTaskRunner* main_thread_task_runner) {
@@ -385,16 +405,12 @@
// Drop recycled resources that are the wrong format.
while (!updater->recycled_resources_.empty() &&
updater->recycled_resources_.back().resource_format !=
- data.resource_format) {
+ data.resource_format) {
updater->DeleteResource(updater->recycled_resources_.back().resource_id);
updater->recycled_resources_.pop_back();
}
- PlaneResource recycled_resource(data.resource_id,
- data.resource_size,
- data.resource_format,
- data.mailbox);
- updater->recycled_resources_.push_back(recycled_resource);
+ updater->recycled_resources_.push_back(data);
}
} // namespace cc
diff --git a/cc/resources/video_resource_updater.h b/cc/resources/video_resource_updater.h
index 99800b4..38f6033 100644
--- a/cc/resources/video_resource_updater.h
+++ b/cc/resources/video_resource_updater.h
@@ -10,6 +10,7 @@
#include "base/basictypes.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
+#include "base/time/time.h"
#include "cc/base/cc_export.h"
#include "cc/resources/release_callback_impl.h"
#include "cc/resources/resource_format.h"
@@ -77,17 +78,28 @@
gfx::Size resource_size;
ResourceFormat resource_format;
gpu::Mailbox mailbox;
+ // These last three members will be used for identifying the data stored in
+ // this resource, and uniquely identifies a media::VideoFrame plane. The
+ // frame pointer will only be used for pointer comparison, i.e. the
+ // underlying data will not be accessed.
+ const void* frame_ptr;
+ int plane_index;
+ base::TimeDelta timestamp;
PlaneResource(unsigned resource_id,
const gfx::Size& resource_size,
ResourceFormat resource_format,
- gpu::Mailbox mailbox)
- : resource_id(resource_id),
- resource_size(resource_size),
- resource_format(resource_format),
- mailbox(mailbox) {}
+ gpu::Mailbox mailbox);
};
+ static bool PlaneResourceMatchesUniqueID(const PlaneResource& plane_resource,
+ const media::VideoFrame* video_frame,
+ int plane_index);
+
+ static void SetPlaneResourceUniqueId(const media::VideoFrame* video_frame,
+ int plane_index,
+ PlaneResource* plane_resource);
+
void DeleteResource(unsigned resource_id);
bool VerifyFrame(const scoped_refptr<media::VideoFrame>& video_frame);
VideoFrameExternalResources CreateForHardwarePlanes(
@@ -95,14 +107,8 @@
VideoFrameExternalResources CreateForSoftwarePlanes(
const scoped_refptr<media::VideoFrame>& video_frame);
- struct RecycleResourceData {
- unsigned resource_id;
- gfx::Size resource_size;
- ResourceFormat resource_format;
- gpu::Mailbox mailbox;
- };
static void RecycleResource(base::WeakPtr<VideoResourceUpdater> updater,
- RecycleResourceData data,
+ PlaneResource data,
uint32 sync_point,
bool lost_resource,
BlockingTaskRunner* main_thread_task_runner);
@@ -117,6 +123,8 @@
scoped_ptr<media::SkCanvasVideoRenderer> video_renderer_;
std::vector<unsigned> all_resources_;
+ // Recycle resources so that we can reduce the number of allocations and
+ // data transfers.
std::vector<PlaneResource> recycled_resources_;
DISALLOW_COPY_AND_ASSIGN(VideoResourceUpdater);
diff --git a/cc/resources/video_resource_updater_unittest.cc b/cc/resources/video_resource_updater_unittest.cc
index c0a4af4..1e3481b 100644
--- a/cc/resources/video_resource_updater_unittest.cc
+++ b/cc/resources/video_resource_updater_unittest.cc
@@ -17,11 +17,33 @@
namespace cc {
namespace {
+class WebGraphicsContext3DUploadCounter : public TestWebGraphicsContext3D {
+ public:
+ void texSubImage2D(GLenum target,
+ GLint level,
+ GLint xoffset,
+ GLint yoffset,
+ GLsizei width,
+ GLsizei height,
+ GLenum format,
+ GLenum type,
+ const void* pixels) override {
+ ++upload_count_;
+ }
+
+ int UploadCount() { return upload_count_; }
+ void ResetUploadCount() { upload_count_ = 0; }
+
+ private:
+ int upload_count_;
+};
+
class VideoResourceUpdaterTest : public testing::Test {
protected:
VideoResourceUpdaterTest() {
- scoped_ptr<TestWebGraphicsContext3D> context3d =
- TestWebGraphicsContext3D::Create();
+ scoped_ptr<WebGraphicsContext3DUploadCounter> context3d(
+ new WebGraphicsContext3DUploadCounter());
+
context3d_ = context3d.get();
output_surface3d_ =
@@ -60,7 +82,7 @@
base::Closure()); // no_longer_needed_cb
}
- TestWebGraphicsContext3D* context3d_;
+ WebGraphicsContext3DUploadCounter* context3d_;
FakeOutputSurfaceClient client_;
scoped_ptr<FakeOutputSurface> output_surface3d_;
scoped_ptr<TestSharedBitmapManager> shared_bitmap_manager_;
@@ -77,5 +99,52 @@
EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
}
+TEST_F(VideoResourceUpdaterTest, ReuseResource) {
+ VideoResourceUpdater updater(output_surface3d_->context_provider(),
+ resource_provider3d_.get());
+ scoped_refptr<media::VideoFrame> video_frame = CreateTestYUVVideoFrame();
+ video_frame->set_timestamp(base::TimeDelta::FromSeconds(1234));
+
+ // Allocate the resources for a YUV video frame.
+ context3d_->ResetUploadCount();
+ VideoFrameExternalResources resources =
+ updater.CreateExternalResourcesFromVideoFrame(video_frame);
+ EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
+ EXPECT_EQ(size_t(3), resources.mailboxes.size());
+ EXPECT_EQ(size_t(3), resources.release_callbacks.size());
+ // Expect exactly three texture uploads, one for each plane.
+ EXPECT_EQ(3, context3d_->UploadCount());
+
+ const ResourceProvider::ResourceId y_resource =
+ resource_provider3d_->CreateResourceFromTextureMailbox(
+ resources.mailboxes[media::VideoFrame::kYPlane],
+ SingleReleaseCallbackImpl::Create(
+ resources.release_callbacks[media::VideoFrame::kYPlane]));
+ const ResourceProvider::ResourceId u_resource =
+ resource_provider3d_->CreateResourceFromTextureMailbox(
+ resources.mailboxes[media::VideoFrame::kUPlane],
+ SingleReleaseCallbackImpl::Create(
+ resources.release_callbacks[media::VideoFrame::kUPlane]));
+ const ResourceProvider::ResourceId v_resource =
+ resource_provider3d_->CreateResourceFromTextureMailbox(
+ resources.mailboxes[media::VideoFrame::kVPlane],
+ SingleReleaseCallbackImpl::Create(
+ resources.release_callbacks[media::VideoFrame::kVPlane]));
+
+ // Delete the resources.
+ resource_provider3d_->DeleteResource(y_resource);
+ resource_provider3d_->DeleteResource(u_resource);
+ resource_provider3d_->DeleteResource(v_resource);
+
+ // Allocate resources for the same frame.
+ context3d_->ResetUploadCount();
+ resources = updater.CreateExternalResourcesFromVideoFrame(video_frame);
+ EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
+ EXPECT_EQ(size_t(3), resources.mailboxes.size());
+ EXPECT_EQ(size_t(3), resources.release_callbacks.size());
+ // The data should be reused so expect no texture uploads.
+ EXPECT_EQ(0, context3d_->UploadCount());
+}
+
} // namespace
} // namespace cc
diff --git a/cc/scheduler/begin_frame_source.cc b/cc/scheduler/begin_frame_source.cc
index 5252dcc..89b794e 100644
--- a/cc/scheduler/begin_frame_source.cc
+++ b/cc/scheduler/begin_frame_source.cc
@@ -7,6 +7,7 @@
#include "base/auto_reset.h"
#include "base/debug/trace_event.h"
#include "base/debug/trace_event_argument.h"
+#include "base/location.h"
#include "base/logging.h"
#include "base/strings/string_number_conversions.h"
#include "cc/scheduler/delay_based_time_source.h"
@@ -182,7 +183,7 @@
base::TimeTicks now = Now();
BeginFrameArgs args = BeginFrameArgs::Create(
- now, now + BeginFrameArgs::DefaultInterval(),
+ BEGINFRAME_FROM_HERE, now, now + BeginFrameArgs::DefaultInterval(),
BeginFrameArgs::DefaultInterval(), BeginFrameArgs::NORMAL);
CallOnBeginFrame(args);
}
@@ -242,8 +243,8 @@
base::TimeTicks frame_time,
BeginFrameArgs::BeginFrameArgsType type) {
base::TimeTicks deadline = time_source_->NextTickTime();
- return BeginFrameArgs::Create(frame_time, deadline, time_source_->Interval(),
- type);
+ return BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, deadline,
+ time_source_->Interval(), type);
}
// TimeSourceClient support
diff --git a/cc/scheduler/begin_frame_source_unittest.cc b/cc/scheduler/begin_frame_source_unittest.cc
index 498d10b..0972762 100644
--- a/cc/scheduler/begin_frame_source_unittest.cc
+++ b/cc/scheduler/begin_frame_source_unittest.cc
@@ -15,19 +15,18 @@
#include "testing/gtest/include/gtest/gtest.h"
// Macros to help set up expected calls on the MockBeginFrameObserver.
-#define EXPECT_BEGIN_FRAME_DROP(obs, frame_time, deadline, interval) \
- { \
- ::testing::Expectation exp = \
- EXPECT_CALL((obs), \
- OnBeginFrame(CreateBeginFrameArgsForTesting( \
- frame_time, deadline, interval))) \
- .InSequence((obs).sequence); \
+#define EXPECT_BEGIN_FRAME_DROP(obs, frame_time, deadline, interval) \
+ { \
+ ::testing::Expectation exp = \
+ EXPECT_CALL((obs), OnBeginFrame(CreateBeginFrameArgsForTesting( \
+ BEGINFRAME_FROM_HERE, frame_time, deadline, \
+ interval))).InSequence((obs).sequence); \
}
#define EXPECT_BEGIN_FRAME_USED(obs, frame_time, deadline, interval) \
{ \
- BeginFrameArgs args = \
- CreateBeginFrameArgsForTesting(frame_time, deadline, interval); \
+ BeginFrameArgs args = CreateBeginFrameArgsForTesting( \
+ BEGINFRAME_FROM_HERE, frame_time, deadline, interval); \
::testing::Expectation exp = \
EXPECT_CALL((obs), OnBeginFrame(args)).InSequence((obs).sequence); \
EXPECT_CALL((obs), LastUsedBeginFrameArgs()) \
@@ -38,15 +37,15 @@
// Macros to send BeginFrameArgs on a FakeBeginFrameSink (and verify resulting
// observer behaviour).
-#define SEND_BEGIN_FRAME(args_equal_to, source, frame_time, deadline, \
- interval) \
- { \
- BeginFrameArgs old_args = (source).TestLastUsedBeginFrameArgs(); \
- BeginFrameArgs new_args = \
- CreateBeginFrameArgsForTesting(frame_time, deadline, interval); \
- ASSERT_FALSE(old_args == new_args); \
- (source).TestOnBeginFrame(new_args); \
- EXPECT_EQ(args_equal_to, (source).TestLastUsedBeginFrameArgs()); \
+#define SEND_BEGIN_FRAME(args_equal_to, source, frame_time, deadline, \
+ interval) \
+ { \
+ BeginFrameArgs old_args = (source).TestLastUsedBeginFrameArgs(); \
+ BeginFrameArgs new_args = CreateBeginFrameArgsForTesting( \
+ BEGINFRAME_FROM_HERE, frame_time, deadline, interval); \
+ ASSERT_FALSE(old_args == new_args); \
+ (source).TestOnBeginFrame(new_args); \
+ EXPECT_EQ(args_equal_to, (source).TestLastUsedBeginFrameArgs()); \
}
// When dropping LastUsedBeginFrameArgs **shouldn't** change.
@@ -99,19 +98,25 @@
MockBeginFrameObserver::kDefaultBeginFrameArgs);
obs.OnBeginFrame(CreateBeginFrameArgsForTesting(
- 100, 200, 300)); // One call to LastUsedBeginFrameArgs
- EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
- CreateBeginFrameArgsForTesting(100, 200, 300));
+ BEGINFRAME_FROM_HERE, 100, 200,
+ 300)); // One call to LastUsedBeginFrameArgs
+ EXPECT_EQ(
+ obs.LastUsedBeginFrameArgs(),
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
obs.OnBeginFrame(CreateBeginFrameArgsForTesting(
- 400, 600, 300)); // Multiple calls to LastUsedBeginFrameArgs
- EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
- CreateBeginFrameArgsForTesting(400, 600, 300));
- EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
- CreateBeginFrameArgsForTesting(400, 600, 300));
+ BEGINFRAME_FROM_HERE, 400, 600,
+ 300)); // Multiple calls to LastUsedBeginFrameArgs
+ EXPECT_EQ(
+ obs.LastUsedBeginFrameArgs(),
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 400, 600, 300));
+ EXPECT_EQ(
+ obs.LastUsedBeginFrameArgs(),
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 400, 600, 300));
obs.OnBeginFrame(CreateBeginFrameArgsForTesting(
- 700, 900, 300)); // No calls to LastUsedBeginFrameArgs
+ BEGINFRAME_FROM_HERE, 700, 900,
+ 300)); // No calls to LastUsedBeginFrameArgs
}
TEST(MockBeginFrameObserverTest, ExpectOnBeginFrameStatus) {
@@ -125,28 +130,45 @@
MockBeginFrameObserver::kDefaultBeginFrameArgs);
// Used
- obs.OnBeginFrame(CreateBeginFrameArgsForTesting(100, 200, 300));
- EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
- CreateBeginFrameArgsForTesting(100, 200, 300));
+ obs.OnBeginFrame(
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
+ EXPECT_EQ(
+ obs.LastUsedBeginFrameArgs(),
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
// Dropped
- obs.OnBeginFrame(CreateBeginFrameArgsForTesting(400, 600, 300));
- EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
- CreateBeginFrameArgsForTesting(100, 200, 300));
+ obs.OnBeginFrame(
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 400, 600, 300));
+ EXPECT_EQ(
+ obs.LastUsedBeginFrameArgs(),
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
// Dropped
- obs.OnBeginFrame(CreateBeginFrameArgsForTesting(450, 650, 300));
- EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
- CreateBeginFrameArgsForTesting(100, 200, 300));
+ obs.OnBeginFrame(
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 450, 650, 300));
+ EXPECT_EQ(
+ obs.LastUsedBeginFrameArgs(),
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
// Used
- obs.OnBeginFrame(CreateBeginFrameArgsForTesting(700, 900, 300));
- EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
- CreateBeginFrameArgsForTesting(700, 900, 300));
+ obs.OnBeginFrame(
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 700, 900, 300));
+ EXPECT_EQ(
+ obs.LastUsedBeginFrameArgs(),
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 700, 900, 300));
}
const BeginFrameArgs MockBeginFrameObserver::kDefaultBeginFrameArgs =
- CreateBeginFrameArgsForTesting(-1, -1, -1);
+ CreateBeginFrameArgsForTesting(
+#ifdef NDEBUG
+ nullptr,
+#else
+ FROM_HERE_WITH_EXPLICIT_FUNCTION(
+ "MockBeginFrameObserver::kDefaultBeginFrameArgs"),
+#endif
+ -1,
+ -1,
+ -1);
// BeginFrameObserverMixIn testing ---------------------------------------
class MockMinimalBeginFrameObserverMixIn : public BeginFrameObserverMixIn {
@@ -168,25 +190,31 @@
EXPECT_DEATH({ obs.OnBeginFrame(BeginFrameArgs()); }, "");
#endif
- BeginFrameArgs args1 = CreateBeginFrameArgsForTesting(100, 200, 300);
+ BeginFrameArgs args1 =
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300);
EXPECT_CALL(obs, OnBeginFrameMixInDelegate(args1)).WillOnce(Return(true));
obs.OnBeginFrame(args1);
EXPECT_EQ(args1, obs.LastUsedBeginFrameArgs());
EXPECT_EQ(0, obs.dropped_begin_frame_args());
#ifndef NDEBUG
- EXPECT_DEATH(
- { obs.OnBeginFrame(CreateBeginFrameArgsForTesting(50, 200, 300)); }, "");
+ EXPECT_DEATH({
+ obs.OnBeginFrame(CreateBeginFrameArgsForTesting(
+ BEGINFRAME_FROM_HERE, 50, 200, 300));
+ },
+ "");
#endif
// Returning false shouldn't update the LastUsedBeginFrameArgs value.
- BeginFrameArgs args2 = CreateBeginFrameArgsForTesting(200, 300, 400);
+ BeginFrameArgs args2 =
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 200, 300, 400);
EXPECT_CALL(obs, OnBeginFrameMixInDelegate(args2)).WillOnce(Return(false));
obs.OnBeginFrame(args2);
EXPECT_EQ(args1, obs.LastUsedBeginFrameArgs());
EXPECT_EQ(1, obs.dropped_begin_frame_args());
- BeginFrameArgs args3 = CreateBeginFrameArgsForTesting(150, 300, 400);
+ BeginFrameArgs args3 =
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 150, 300, 400);
EXPECT_CALL(obs, OnBeginFrameMixInDelegate(args3)).WillOnce(Return(true));
obs.OnBeginFrame(args3);
EXPECT_EQ(args3, obs.LastUsedBeginFrameArgs());
@@ -495,7 +523,8 @@
SetNeedsBeginFramesCallsOnBeginFrameWithMissedTick) {
now_src_->SetNowMicroseconds(10010);
EXPECT_CALL((*obs_), OnBeginFrame(CreateBeginFrameArgsForTesting(
- 10000, 20000, 10000, BeginFrameArgs::MISSED)));
+ BEGINFRAME_FROM_HERE, 10000, 20000, 10000,
+ BeginFrameArgs::MISSED)));
source_->SetNeedsBeginFrames(true); // Should cause the last tick to be sent
// No tasks should need to be run for this to occur.
}
diff --git a/cc/scheduler/scheduler.cc b/cc/scheduler/scheduler.cc
index 3e6f6c6..0cce5dc 100644
--- a/cc/scheduler/scheduler.cc
+++ b/cc/scheduler/scheduler.cc
@@ -470,20 +470,16 @@
// draining the queue if we don't catch up. If we consistently can't catch
// up, our fallback should be to lower our frame rate.
base::TimeTicks now = Now();
- base::TimeDelta draw_duration_estimate = client_->DrawDurationEstimate();
- while (!begin_retro_frame_args_.empty()) {
- base::TimeTicks adjusted_deadline = AdjustedBeginImplFrameDeadline(
- begin_retro_frame_args_.front(), draw_duration_estimate);
- if (now <= adjusted_deadline)
- break;
- TRACE_EVENT_INSTANT2("cc",
- "Scheduler::BeginRetroFrame discarding",
- TRACE_EVENT_SCOPE_THREAD,
- "deadline - now",
- (adjusted_deadline - now).InMicroseconds(),
- "BeginFrameArgs",
- begin_retro_frame_args_.front().AsValue());
+ while (!begin_retro_frame_args_.empty()) {
+ const BeginFrameArgs& args = begin_retro_frame_args_.front();
+ base::TimeTicks expiration_time = args.frame_time + args.interval;
+ if (now <= expiration_time)
+ break;
+ TRACE_EVENT_INSTANT2(
+ "cc", "Scheduler::BeginRetroFrame discarding", TRACE_EVENT_SCOPE_THREAD,
+ "expiration_time - now", (expiration_time - now).InMillisecondsF(),
+ "BeginFrameArgs", begin_retro_frame_args_.front().AsValue());
begin_retro_frame_args_.pop_front();
frame_source_->DidFinishFrame(begin_retro_frame_args_.size());
}
@@ -564,19 +560,38 @@
ProcessScheduledActions();
state_machine_.OnBeginImplFrameDeadlinePending();
- ScheduleBeginImplFrameDeadline(
- AdjustedBeginImplFrameDeadline(args, draw_duration_estimate));
+
+ if (settings_.using_synchronous_renderer_compositor) {
+ // The synchronous renderer compositor has to make its GL calls
+ // within this call.
+ // TODO(brianderson): Have the OutputSurface initiate the deadline tasks
+ // so the synchronous renderer compositor can take advantage of splitting
+ // up the BeginImplFrame and deadline as well.
+ OnBeginImplFrameDeadline();
+ } else {
+ ScheduleBeginImplFrameDeadline(
+ AdjustedBeginImplFrameDeadline(args, draw_duration_estimate));
+ }
}
base::TimeTicks Scheduler::AdjustedBeginImplFrameDeadline(
const BeginFrameArgs& args,
base::TimeDelta draw_duration_estimate) const {
- if (settings_.using_synchronous_renderer_compositor) {
- // The synchronous compositor needs to draw right away.
+ // The synchronous compositor does not post a deadline task.
+ DCHECK(!settings_.using_synchronous_renderer_compositor);
+ if (settings_.main_thread_should_always_be_low_latency) {
+ // In main thread low latency mode, always start deadline early.
return base::TimeTicks();
} else if (state_machine_.ShouldTriggerBeginImplFrameDeadlineEarly()) {
// We are ready to draw a new active tree immediately.
+ // We don't use Now() here because it's somewhat expensive to call.
return base::TimeTicks();
+ } else if (settings_.main_thread_should_always_be_low_latency) {
+ // Post long deadline to keep advancing during idle period. After activation
+ // we will be able to trigger deadline early.
+ // TODO(weiliangc): Don't post deadline once input is deferred with
+ // BeginRetroFrames.
+ return args.frame_time + args.interval;
} else if (state_machine_.needs_redraw()) {
// We have an animation or fast input path on the impl thread that wants
// to draw, so don't wait too long for a new active tree.
@@ -596,15 +611,6 @@
void Scheduler::ScheduleBeginImplFrameDeadline(base::TimeTicks deadline) {
TRACE_EVENT1(
"cc", "Scheduler::ScheduleBeginImplFrameDeadline", "deadline", deadline);
- if (settings_.using_synchronous_renderer_compositor) {
- // The synchronous renderer compositor has to make its GL calls
- // within this call.
- // TODO(brianderson): Have the OutputSurface initiate the deadline tasks
- // so the sychronous renderer compositor can take advantage of splitting
- // up the BeginImplFrame and deadline as well.
- OnBeginImplFrameDeadline();
- return;
- }
begin_impl_frame_deadline_task_.Cancel();
begin_impl_frame_deadline_task_.Reset(begin_impl_frame_deadline_closure_);
@@ -618,7 +624,6 @@
void Scheduler::OnBeginImplFrameDeadline() {
TRACE_EVENT0("cc", "Scheduler::OnBeginImplFrameDeadline");
begin_impl_frame_deadline_task_.Cancel();
-
// We split the deadline actions up into two phases so the state machine
// has a chance to trigger actions that should occur durring and after
// the deadline separately. For example:
diff --git a/cc/scheduler/scheduler_settings.cc b/cc/scheduler/scheduler_settings.cc
index 84f0fcd..53abe7b 100644
--- a/cc/scheduler/scheduler_settings.cc
+++ b/cc/scheduler/scheduler_settings.cc
@@ -19,6 +19,7 @@
using_synchronous_renderer_compositor(false),
throttle_frame_production(true),
disable_hi_res_timer_tasks_on_battery(false),
+ main_thread_should_always_be_low_latency(false),
background_frame_interval(base::TimeDelta::FromSeconds(1)) {
}
@@ -38,6 +39,8 @@
throttle_frame_production(settings.throttle_frame_production),
disable_hi_res_timer_tasks_on_battery(
settings.disable_hi_res_timer_tasks_on_battery),
+ main_thread_should_always_be_low_latency(
+ settings.main_thread_should_always_be_low_latency),
background_frame_interval(base::TimeDelta::FromSecondsD(
1.0 / settings.background_animation_rate)) {
}
@@ -64,6 +67,8 @@
state->SetBoolean("throttle_frame_production", throttle_frame_production);
state->SetBoolean("disable_hi_res_timer_tasks_on_battery",
disable_hi_res_timer_tasks_on_battery);
+ state->SetBoolean("main_thread_should_always_be_low_latency",
+ main_thread_should_always_be_low_latency);
state->SetInteger("background_frame_interval",
background_frame_interval.InMicroseconds());
return state;
diff --git a/cc/scheduler/scheduler_settings.h b/cc/scheduler/scheduler_settings.h
index e3fd425..4ff3c7e 100644
--- a/cc/scheduler/scheduler_settings.h
+++ b/cc/scheduler/scheduler_settings.h
@@ -35,6 +35,12 @@
bool throttle_frame_production;
bool disable_hi_res_timer_tasks_on_battery;
+ // In main thread low latency mode the entire
+ // BeginMainFrame->Commit->Activation->Draw cycle should complete before
+ // starting the next cycle. Additionally, BeginMainFrame and Commit are
+ // completed atomically with no other tasks or actions occuring between them.
+ bool main_thread_should_always_be_low_latency;
+
base::TimeDelta background_frame_interval;
scoped_refptr<base::debug::ConvertableToTraceFormat> AsValue() const;
diff --git a/cc/scheduler/scheduler_state_machine.cc b/cc/scheduler/scheduler_state_machine.cc
index 5f56255..2946a2c 100644
--- a/cc/scheduler/scheduler_state_machine.cc
+++ b/cc/scheduler/scheduler_state_machine.cc
@@ -97,6 +97,8 @@
return "COMMIT_STATE_READY_TO_COMMIT";
case COMMIT_STATE_WAITING_FOR_ACTIVATION:
return "COMMIT_STATE_WAITING_FOR_ACTIVATION";
+ case COMMIT_STATE_WAITING_FOR_DRAW:
+ return "COMMIT_STATE_WAITING_FOR_DRAW";
}
NOTREACHED();
return "???";
@@ -592,9 +594,11 @@
if (commit_was_aborted || settings_.main_frame_before_activation_enabled) {
commit_state_ = COMMIT_STATE_IDLE;
+ } else if (settings_.impl_side_painting) {
+ commit_state_ = COMMIT_STATE_WAITING_FOR_ACTIVATION;
} else {
- commit_state_ = settings_.impl_side_painting
- ? COMMIT_STATE_WAITING_FOR_ACTIVATION
+ commit_state_ = settings_.main_thread_should_always_be_low_latency
+ ? COMMIT_STATE_WAITING_FOR_DRAW
: COMMIT_STATE_IDLE;
}
@@ -637,8 +641,11 @@
}
void SchedulerStateMachine::UpdateStateOnActivation() {
- if (commit_state_ == COMMIT_STATE_WAITING_FOR_ACTIVATION)
- commit_state_ = COMMIT_STATE_IDLE;
+ if (commit_state_ == COMMIT_STATE_WAITING_FOR_ACTIVATION) {
+ commit_state_ = settings_.main_thread_should_always_be_low_latency
+ ? COMMIT_STATE_WAITING_FOR_DRAW
+ : COMMIT_STATE_IDLE;
+ }
if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION)
output_surface_state_ = OUTPUT_SURFACE_ACTIVE;
@@ -656,6 +663,9 @@
if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)
forced_redraw_state_ = FORCED_REDRAW_STATE_IDLE;
+ if (commit_state_ == COMMIT_STATE_WAITING_FOR_DRAW)
+ commit_state_ = COMMIT_STATE_IDLE;
+
needs_redraw_ = false;
active_tree_needs_first_draw_ = false;
@@ -991,6 +1001,11 @@
DCHECK(commit_state_ == COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED)
<< AsValue()->ToString();
commit_state_ = COMMIT_STATE_READY_TO_COMMIT;
+ // In main thread low latency mode, commit should happen right after
+ // BeginFrame, meaning when this function is called, next action should be
+ // commit.
+ if (settings_.main_thread_should_always_be_low_latency)
+ DCHECK(ShouldCommit());
}
void SchedulerStateMachine::BeginMainFrameAborted(bool did_handle) {
diff --git a/cc/scheduler/scheduler_state_machine.h b/cc/scheduler/scheduler_state_machine.h
index c69c959..12f8635 100644
--- a/cc/scheduler/scheduler_state_machine.h
+++ b/cc/scheduler/scheduler_state_machine.h
@@ -68,6 +68,7 @@
COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED,
COMMIT_STATE_READY_TO_COMMIT,
COMMIT_STATE_WAITING_FOR_ACTIVATION,
+ COMMIT_STATE_WAITING_FOR_DRAW,
};
static const char* CommitStateToString(CommitState state);
diff --git a/cc/scheduler/scheduler_state_machine_unittest.cc b/cc/scheduler/scheduler_state_machine_unittest.cc
index af6d83a..f46389b 100644
--- a/cc/scheduler/scheduler_state_machine_unittest.cc
+++ b/cc/scheduler/scheduler_state_machine_unittest.cc
@@ -44,7 +44,8 @@
SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT,
SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED,
SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT,
- SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_ACTIVATION};
+ SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_ACTIVATION,
+ SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_DRAW};
// Exposes the protected state fields of the SchedulerStateMachine for testing
class StateMachine : public SchedulerStateMachine {
@@ -122,7 +123,8 @@
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
EXPECT_FALSE(state.BeginFrameNeeded());
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
state.OnBeginImplFrameDeadline();
@@ -140,7 +142,8 @@
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
EXPECT_FALSE(state.BeginFrameNeeded());
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
state.OnBeginImplFrameDeadline();
}
@@ -158,7 +161,8 @@
EXPECT_TRUE(state.BeginFrameNeeded());
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
}
@@ -195,7 +199,7 @@
EXPECT_TRUE(state.BeginFrameNeeded());
// Commit to the pending tree.
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -211,7 +215,7 @@
// Verify that the next commit starts while there is still a pending tree.
state.SetNeedsCommit();
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -252,7 +256,7 @@
state.SetNeedsRedraw(true);
EXPECT_TRUE(state.RedrawPending());
EXPECT_TRUE(state.BeginFrameNeeded());
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
state.OnBeginImplFrameDeadline();
@@ -269,7 +273,7 @@
// Failing the draw makes us require a commit.
state.DidDrawIfPossibleCompleted(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS);
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
@@ -289,7 +293,7 @@
EXPECT_TRUE(state.RedrawPending());
EXPECT_TRUE(state.BeginFrameNeeded());
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
state.OnBeginImplFrameDeadline();
@@ -303,7 +307,7 @@
// Missing high res content requires a commit (but not a redraw)
state.DidDrawIfPossibleCompleted(DRAW_ABORTED_MISSING_HIGH_RES_CONTENT);
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
EXPECT_FALSE(state.RedrawPending());
@@ -323,7 +327,7 @@
state.SetNeedsRedraw(true);
EXPECT_TRUE(state.RedrawPending());
EXPECT_TRUE(state.BeginFrameNeeded());
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
state.OnBeginImplFrameDeadline();
@@ -344,7 +348,7 @@
// Failing the draw for animation checkerboards makes us require a commit.
state.DidDrawIfPossibleCompleted(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS);
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
@@ -365,7 +369,7 @@
// Start a commit.
state.SetNeedsCommit();
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -395,7 +399,7 @@
EXPECT_TRUE(state.RedrawPending());
// The redraw should be forced at the end of the next BeginImplFrame.
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
@@ -423,7 +427,7 @@
// Start a commit.
state.SetNeedsCommit();
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -480,7 +484,7 @@
// Start a draw.
state.SetNeedsRedraw(true);
EXPECT_TRUE(state.BeginFrameNeeded());
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
state.OnBeginImplFrameDeadline();
@@ -497,7 +501,7 @@
// We should not be trying to draw again now, but we have a commit pending.
EXPECT_TRUE(state.BeginFrameNeeded());
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -523,7 +527,7 @@
// Draw the first frame.
EXPECT_TRUE(state.BeginFrameNeeded());
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -542,7 +546,7 @@
// Move to another frame. This should now draw.
EXPECT_TRUE(state.BeginFrameNeeded());
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -680,7 +684,8 @@
state.SetVisible(false);
state.SetNeedsRedraw(true);
if (j == 1)
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
state.SetCanDraw(false);
EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE,
@@ -702,7 +707,7 @@
state.SetNeedsRedraw(true);
state.SetVisible(true);
state.SetCanDraw(false);
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT);
EXPECT_ACTION_UPDATE_STATE(
@@ -730,7 +735,7 @@
EXPECT_TRUE(state.BeginFrameNeeded());
// Begin the frame.
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT,
@@ -766,7 +771,7 @@
state.begin_impl_frame_state());
EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.NextAction());
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_EQ(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING,
state.begin_impl_frame_state());
EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.NextAction());
@@ -803,7 +808,7 @@
state.SetNeedsCommit();
// Begin the frame.
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT,
@@ -840,6 +845,160 @@
EXPECT_FALSE(state.needs_redraw());
}
+TEST(SchedulerStateMachineTest, TestFullCycleWithMainThreadLowLatencyMode) {
+ SchedulerSettings scheduler_settings;
+ scheduler_settings.main_thread_should_always_be_low_latency = true;
+ StateMachine state(scheduler_settings);
+ state.SetCanStart();
+ state.UpdateState(state.NextAction());
+ state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
+ state.SetVisible(true);
+ state.SetCanDraw(true);
+
+ // Start clean and set commit.
+ state.SetNeedsCommit();
+
+ // Begin the frame.
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
+ EXPECT_ACTION_UPDATE_STATE(
+ SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT,
+ state.CommitState());
+ EXPECT_FALSE(state.NeedsCommit());
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+
+ // Tell the scheduler the frame finished.
+ state.NotifyBeginMainFrameStarted();
+ state.NotifyReadyToCommit();
+ EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT,
+ state.CommitState());
+
+ // Commit.
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
+ EXPECT_TRUE(state.active_tree_needs_first_draw());
+ EXPECT_TRUE(state.needs_redraw());
+
+ // Now commit should wait for draw.
+ EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_DRAW,
+ state.CommitState());
+
+ // Swap throttled. Do not draw.
+ state.DidSwapBuffers();
+ state.OnBeginImplFrameDeadline();
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ state.DidSwapBuffersComplete();
+
+ // Haven't draw since last commit, do not begin new main frame.
+ state.SetNeedsCommit();
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+
+ // At BeginImplFrame deadline, draw.
+ state.OnBeginImplFrameDeadline();
+ EXPECT_ACTION_UPDATE_STATE(
+ SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ state.DidSwapBuffers();
+ state.DidDrawIfPossibleCompleted(DRAW_SUCCESS);
+ state.DidSwapBuffersComplete();
+
+ // Now will be able to start main frame.
+ EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_IDLE, state.CommitState());
+ EXPECT_FALSE(state.needs_redraw());
+ EXPECT_ACTION_UPDATE_STATE(
+ SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+}
+
+TEST(SchedulerStateMachineTest,
+ TestFullCycleWithMainThreadLowLatencyMode_ImplSidePaint) {
+ SchedulerSettings scheduler_settings;
+ scheduler_settings.main_thread_should_always_be_low_latency = true;
+ scheduler_settings.impl_side_painting = true;
+ StateMachine state(scheduler_settings);
+ state.SetCanStart();
+ state.UpdateState(state.NextAction());
+ state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
+ state.SetVisible(true);
+ state.SetCanDraw(true);
+
+ // Start clean and set commit.
+ state.SetNeedsCommit();
+
+ // Begin the frame.
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
+ EXPECT_ACTION_UPDATE_STATE(
+ SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT,
+ state.CommitState());
+ EXPECT_FALSE(state.NeedsCommit());
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+
+ // Tell the scheduler the frame finished.
+ state.NotifyBeginMainFrameStarted();
+ state.NotifyReadyToCommit();
+ EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT,
+ state.CommitState());
+
+ // Commit.
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
+
+ // Now commit should wait for activation.
+ EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_ACTIVATION,
+ state.CommitState());
+
+ // No activation yet, so this commit is not drawn yet. Force to draw this
+ // frame, and still block BeginMainFrame.
+ state.SetNeedsRedraw(true);
+ state.SetNeedsCommit();
+ state.OnBeginImplFrameDeadline();
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(
+ SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+
+ // Cannot BeginMainFrame yet since last commit is not yet activated and drawn.
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
+ EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_ACTIVATION,
+ state.CommitState());
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+
+ // Now activate sync tree.
+ state.NotifyReadyToActivate();
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_TRUE(state.active_tree_needs_first_draw());
+ EXPECT_TRUE(state.needs_redraw());
+ EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_DRAW,
+ state.CommitState());
+
+ // Swap throttled. Do not draw.
+ state.DidSwapBuffers();
+ state.OnBeginImplFrameDeadline();
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ state.DidSwapBuffersComplete();
+
+ // Haven't draw since last commit, do not begin new main frame.
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+
+ // At BeginImplFrame deadline, draw. This draws unblocks BeginMainFrame.
+ state.OnBeginImplFrameDeadline();
+ EXPECT_ACTION_UPDATE_STATE(
+ SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ state.DidSwapBuffers();
+ state.DidDrawIfPossibleCompleted(DRAW_SUCCESS);
+ state.DidSwapBuffersComplete();
+
+ // Now will be able to start main frame.
+ EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_IDLE, state.CommitState());
+ EXPECT_FALSE(state.needs_redraw());
+ EXPECT_ACTION_UPDATE_STATE(
+ SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+}
+
TEST(SchedulerStateMachineTest, TestFullCycleWithCommitRequestInbetween) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
@@ -853,7 +1012,7 @@
state.SetNeedsCommit();
// Begin the frame.
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT,
@@ -894,7 +1053,7 @@
EXPECT_FALSE(state.needs_redraw());
// Next BeginImplFrame should initiate second commit.
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
}
@@ -922,7 +1081,7 @@
state.SetNeedsCommit();
// Begin the frame while visible.
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT,
@@ -952,7 +1111,7 @@
EXPECT_TRUE(state.NeedsCommit());
// Start a new frame.
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
@@ -991,7 +1150,7 @@
// Start a new frame; draw because this is the first frame since output
// surface init'd.
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
state.OnBeginImplFrameDeadline();
@@ -1043,7 +1202,7 @@
// Become visible and start a new frame.
state.SetVisible(true);
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -1108,7 +1267,7 @@
EXPECT_TRUE(state.NeedsCommit());
// We should get that commit when we begin the next frame.
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
@@ -1145,7 +1304,7 @@
EXPECT_TRUE(state.NeedsCommit());
// Begin a frame when not visible, the scheduler animates but does not commit.
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_IDLE, state.CommitState());
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
@@ -1171,14 +1330,14 @@
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
// Check that the first init does not SetNeedsCommit.
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
// Check that a needs commit initiates a BeginMainFrame.
state.SetNeedsCommit();
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
}
@@ -1208,7 +1367,7 @@
state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
// When the context is recreated, we should begin a commit.
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
}
@@ -1232,14 +1391,14 @@
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
// Once context recreation begins, nothing should happen.
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
// While context is recreating, commits shouldn't begin.
state.SetNeedsCommit();
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -1265,7 +1424,7 @@
// Once the context is recreated, whether we draw should be based on
// SetCanDraw.
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
state.OnBeginImplFrameDeadline();
@@ -1293,7 +1452,7 @@
// Set damage and expect a draw.
state.SetNeedsRedraw(true);
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
@@ -1328,7 +1487,7 @@
EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
state.NextAction());
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_EQ(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING,
state.begin_impl_frame_state());
EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
@@ -1360,7 +1519,7 @@
// Set damage and expect a draw.
state.SetNeedsRedraw(true);
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
@@ -1395,7 +1554,7 @@
EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
state.NextAction());
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_EQ(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING,
state.begin_impl_frame_state());
EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
@@ -1416,7 +1575,7 @@
// After we get a new output surface, the commit flow should start.
state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -1452,7 +1611,7 @@
state.DidCreateAndInitializeOutputSurface();
EXPECT_FALSE(state.RedrawPending());
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_EQ(SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME,
state.NextAction());
}
@@ -1584,7 +1743,7 @@
// This test mirrors what happens during the first frame of a scroll gesture.
// First we get the input event and a BeginFrame.
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
// As a response the compositor requests a redraw and a commit to tell the
// main thread about the new scroll offset.
@@ -1619,7 +1778,7 @@
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -1644,7 +1803,7 @@
// in prefer impl latency mode.
state.SetNeedsRedraw(true);
state.SetNeedsCommit();
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
@@ -1681,7 +1840,7 @@
// and did not just swap.
state.SetNeedsCommit();
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
EXPECT_FALSE(state.ShouldTriggerBeginImplFrameDeadlineEarly());
state.OnBeginImplFrameDeadline();
@@ -1699,7 +1858,7 @@
state.SetNeedsCommit();
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -1726,7 +1885,7 @@
EXPECT_TRUE(state.BeginFrameNeeded());
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
state.OnBeginImplFrameDeadlinePending();
@@ -1752,7 +1911,7 @@
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
EXPECT_TRUE(state.BeginFrameNeeded());
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
@@ -1780,7 +1939,7 @@
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
EXPECT_TRUE(state.BeginFrameNeeded());
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
@@ -1812,7 +1971,7 @@
EXPECT_TRUE(state.BeginFrameNeeded());
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- state.OnBeginImplFrame(CreateBeginFrameArgsForTesting());
+ state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
state.SetNeedsAnimate();
diff --git a/cc/scheduler/scheduler_unittest.cc b/cc/scheduler/scheduler_unittest.cc
index 636beb0..2992dbc 100644
--- a/cc/scheduler/scheduler_unittest.cc
+++ b/cc/scheduler/scheduler_unittest.cc
@@ -168,19 +168,32 @@
void AdvanceFrame() {
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"),
"FakeSchedulerClient::AdvanceFrame");
+ bool previous_deadline_pending =
+ scheduler_->BeginImplFrameDeadlinePending();
if (ExternalBeginFrame()) {
- // Creep the time forward so that any BeginFrameArgs is not equal to the
- // last one otherwise we violate the BeginFrameSource contract.
- now_src_->AdvanceNowMicroseconds(1);
- fake_external_begin_frame_source_->TestOnBeginFrame(
- CreateBeginFrameArgsForTesting(now_src_));
+ SendNextBeginFrame();
+ // This could be the previous deadline or a new one.
EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
}
-
+ // Consume previous deadline first. It is important that we check for the
+ // existence of a previous deadline so that we do not consume the new one.
+ if (previous_deadline_pending) {
+ EXPECT_TRUE(task_runner().RunTasksWhile(ImplFrameDeadlinePending(true)));
+ }
+ // Then run tasks until new deadline is scheduled.
EXPECT_TRUE(task_runner().RunTasksWhile(ImplFrameDeadlinePending(false)));
EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
}
+ void SendNextBeginFrame() {
+ DCHECK(ExternalBeginFrame());
+ // Creep the time forward so that any BeginFrameArgs is not equal to the
+ // last one otherwise we violate the BeginFrameSource contract.
+ now_src_->AdvanceNow(BeginFrameArgs::DefaultInterval());
+ fake_external_begin_frame_source_->TestOnBeginFrame(
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now_src_));
+ }
+
OrderedSimpleTaskRunner& task_runner() { return *task_runner_; }
TestNowSource* now_src() { return now_src_.get(); }
@@ -1167,7 +1180,8 @@
scheduler->NotifyReadyToCommit();
scheduler->SetNeedsRedraw();
- BeginFrameArgs frame_args = CreateBeginFrameArgsForTesting(client.now_src());
+ BeginFrameArgs frame_args =
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, client.now_src());
frame_args.interval = base::TimeDelta::FromMilliseconds(1000);
client.fake_external_begin_frame_source()->TestOnBeginFrame(frame_args);
@@ -1240,7 +1254,8 @@
// Create a BeginFrame with a long deadline to avoid race conditions.
// This is the first BeginFrame, which will be handled immediately.
- BeginFrameArgs args = CreateBeginFrameArgsForTesting(client.now_src());
+ BeginFrameArgs args =
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, client.now_src());
args.deadline += base::TimeDelta::FromHours(1);
client.fake_external_begin_frame_source()->TestOnBeginFrame(args);
EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
@@ -1318,7 +1333,8 @@
// Create a BeginFrame with a long deadline to avoid race conditions.
// This is the first BeginFrame, which will be handled immediately.
- BeginFrameArgs args = CreateBeginFrameArgsForTesting(client.now_src());
+ BeginFrameArgs args =
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, client.now_src());
args.deadline += base::TimeDelta::FromHours(1);
client.fake_external_begin_frame_source()->TestOnBeginFrame(args);
EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
@@ -1387,6 +1403,131 @@
client.Reset();
}
+TEST(SchedulerTest, RetroFrameDoesNotExpireTooEarly) {
+ FakeSchedulerClient client;
+ SchedulerSettings scheduler_settings;
+ scheduler_settings.use_external_begin_frame_source = true;
+ TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
+ scheduler->SetCanStart();
+ scheduler->SetVisible(true);
+ scheduler->SetCanDraw(true);
+ InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
+
+ client.Reset();
+ scheduler->SetNeedsCommit();
+ EXPECT_TRUE(client.needs_begin_frames());
+ EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(true)", client);
+
+ client.Reset();
+ client.AdvanceFrame();
+ EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
+ EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
+ EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+
+ client.Reset();
+ scheduler->NotifyBeginMainFrameStarted();
+
+ client.Reset();
+ client.SendNextBeginFrame();
+ // This BeginFrame is queued up as a retro frame.
+ EXPECT_NO_ACTION(client);
+ // The previous deadline is still pending.
+ EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+
+ client.Reset();
+ // This commit should schedule the (previous) deadline to trigger immediately.
+ scheduler->NotifyReadyToCommit();
+ EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
+
+ client.Reset();
+ // The deadline task should trigger causing a draw.
+ EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+ client.task_runner().RunTasksWhile(client.ImplFrameDeadlinePending(true));
+ EXPECT_ACTION("ScheduledActionAnimate", client, 0, 2);
+ EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 1, 2);
+
+ // Keep animating.
+ client.Reset();
+ scheduler->SetNeedsAnimate();
+ scheduler->SetNeedsRedraw();
+ EXPECT_NO_ACTION(client);
+
+ // Let's advance sufficiently past the next frame's deadline.
+ client.now_src()->AdvanceNow(
+ BeginFrameArgs::DefaultInterval() -
+ BeginFrameArgs::DefaultEstimatedParentDrawTime() +
+ base::TimeDelta::FromMicroseconds(1));
+
+ // The retro frame hasn't expired yet.
+ client.task_runner().RunTasksWhile(client.ImplFrameDeadlinePending(false));
+ EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
+ EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
+ EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+
+ // This is an immediate deadline case.
+ client.Reset();
+ client.task_runner().RunPendingTasks();
+ EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
+ EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client);
+}
+
+TEST(SchedulerTest, RetroFrameDoesNotExpireTooLate) {
+ FakeSchedulerClient client;
+ SchedulerSettings scheduler_settings;
+ scheduler_settings.use_external_begin_frame_source = true;
+ TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
+ scheduler->SetCanStart();
+ scheduler->SetVisible(true);
+ scheduler->SetCanDraw(true);
+ InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
+
+ client.Reset();
+ scheduler->SetNeedsCommit();
+ EXPECT_TRUE(client.needs_begin_frames());
+ EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(true)", client);
+
+ client.Reset();
+ client.AdvanceFrame();
+ EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
+ EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
+ EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+
+ client.Reset();
+ scheduler->NotifyBeginMainFrameStarted();
+
+ client.Reset();
+ client.SendNextBeginFrame();
+ // This BeginFrame is queued up as a retro frame.
+ EXPECT_NO_ACTION(client);
+ // The previous deadline is still pending.
+ EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+
+ client.Reset();
+ // This commit should schedule the (previous) deadline to trigger immediately.
+ scheduler->NotifyReadyToCommit();
+ EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
+
+ client.Reset();
+ // The deadline task should trigger causing a draw.
+ EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+ client.task_runner().RunTasksWhile(client.ImplFrameDeadlinePending(true));
+ EXPECT_ACTION("ScheduledActionAnimate", client, 0, 2);
+ EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 1, 2);
+
+ // Keep animating.
+ client.Reset();
+ scheduler->SetNeedsAnimate();
+ scheduler->SetNeedsRedraw();
+ EXPECT_NO_ACTION(client);
+
+ // Let's advance sufficiently past the next frame's deadline.
+ client.now_src()->AdvanceNow(BeginFrameArgs::DefaultInterval() +
+ base::TimeDelta::FromMicroseconds(1));
+
+ // The retro frame should've expired.
+ EXPECT_NO_ACTION(client);
+}
+
void BeginFramesNotFromClient(bool use_external_begin_frame_source,
bool throttle_frame_production) {
FakeSchedulerClient client;
@@ -1793,7 +1934,8 @@
// Create a BeginFrame with a long deadline to avoid race conditions.
// This is the first BeginFrame, which will be handled immediately.
client.Reset();
- BeginFrameArgs args = CreateBeginFrameArgsForTesting(client.now_src());
+ BeginFrameArgs args =
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, client.now_src());
args.deadline += base::TimeDelta::FromHours(1);
client.fake_external_begin_frame_source()->TestOnBeginFrame(args);
EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
@@ -1852,7 +1994,8 @@
// Create a BeginFrame with a long deadline to avoid race conditions.
// This is the first BeginFrame, which will be handled immediately.
client.Reset();
- BeginFrameArgs args = CreateBeginFrameArgsForTesting(client.now_src());
+ BeginFrameArgs args =
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, client.now_src());
args.deadline += base::TimeDelta::FromHours(1);
client.fake_external_begin_frame_source()->TestOnBeginFrame(args);
EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
diff --git a/cc/surfaces/BUILD.gn b/cc/surfaces/BUILD.gn
index a45e786..ea44068 100644
--- a/cc/surfaces/BUILD.gn
+++ b/cc/surfaces/BUILD.gn
@@ -2,6 +2,14 @@
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
+source_set("surface_id") {
+ sources = [
+ "surface_id.h",
+ ]
+
+ deps = [ "//base" ]
+}
+
component("surfaces") {
output_name = "cc_surfaces"
sources = [
@@ -15,7 +23,6 @@
"surface_factory.cc",
"surface_factory.h",
"surface_factory_client.h",
- "surface_id.h",
"surface_id_allocator.cc",
"surface_id_allocator.h",
"surface_manager.cc",
@@ -28,6 +35,7 @@
defines = [ "CC_SURFACES_IMPLEMENTATION=1" ]
deps = [
+ ":surface_id",
"//base",
"//base/third_party/dynamic_annotations",
"//cc",
diff --git a/cc/surfaces/display.cc b/cc/surfaces/display.cc
index a8ae27a..9257446 100644
--- a/cc/surfaces/display.cc
+++ b/cc/surfaces/display.cc
@@ -49,15 +49,23 @@
return output_surface_->BindToClient(this);
}
-void Display::Resize(SurfaceId id,
- const gfx::Size& size,
- float device_scale_factor) {
+void Display::SetSurfaceId(SurfaceId id, float device_scale_factor) {
current_surface_id_ = id;
- current_surface_size_ = size;
device_scale_factor_ = device_scale_factor;
client_->DisplayDamaged();
}
+void Display::Resize(const gfx::Size& size) {
+ if (size == current_surface_size_)
+ return;
+ // Need to ensure all pending swaps have executed before the window is
+ // resized, or D3D11 will scale the swap output.
+ if (renderer_ && settings_.finish_rendering_on_resize)
+ renderer_->Finish();
+ current_surface_size_ = size;
+ client_->DisplayDamaged();
+}
+
void Display::InitializeRenderer() {
if (resource_provider_)
return;
@@ -112,6 +120,9 @@
benchmark_instrumentation::IssueDisplayRenderingStatsEvent();
DelegatedFrameData* frame_data = frame->delegated_frame_data.get();
+ gfx::Size surface_size =
+ frame_data->render_pass_list.back()->output_rect.size();
+
gfx::Rect device_viewport_rect = gfx::Rect(current_surface_size_);
gfx::Rect device_clip_rect = device_viewport_rect;
bool disable_picture_quad_image_filtering = false;
@@ -122,7 +133,14 @@
device_viewport_rect,
device_clip_rect,
disable_picture_quad_image_filtering);
- renderer_->SwapBuffers(frame->metadata);
+
+ bool disable_swap = surface_size != current_surface_size_;
+ if (disable_swap) {
+ DidSwapBuffers();
+ } else {
+ renderer_->SwapBuffers(frame->metadata);
+ }
+
for (SurfaceAggregator::SurfaceIndexMap::iterator it =
aggregator_->previous_contained_surfaces().begin();
it != aggregator_->previous_contained_surfaces().end();
@@ -131,6 +149,8 @@
if (surface)
surface->RunDrawCallbacks();
}
+ if (disable_swap)
+ DidSwapBuffersComplete();
return true;
}
diff --git a/cc/surfaces/display.h b/cc/surfaces/display.h
index a0bb62a..47c55bb 100644
--- a/cc/surfaces/display.h
+++ b/cc/surfaces/display.h
@@ -51,9 +51,8 @@
// device_scale_factor is used to communicate to the external window system
// what scale this was rendered at.
- void Resize(SurfaceId id,
- const gfx::Size& new_size,
- float device_scale_factor);
+ void SetSurfaceId(SurfaceId id, float device_scale_factor);
+ void Resize(const gfx::Size& new_size);
bool Draw();
SurfaceId CurrentSurfaceId();
diff --git a/cc/surfaces/surface.cc b/cc/surfaces/surface.cc
index 600455f..c7b1145 100644
--- a/cc/surfaces/surface.cc
+++ b/cc/surfaces/surface.cc
@@ -18,9 +18,8 @@
// completely damaged the first time they're drawn from.
static const int kFrameIndexStart = 2;
-Surface::Surface(SurfaceId id, const gfx::Size& size, SurfaceFactory* factory)
+Surface::Surface(SurfaceId id, SurfaceFactory* factory)
: surface_id_(id),
- size_(size),
factory_(factory->AsWeakPtr()),
frame_index_(kFrameIndexStart) {
}
diff --git a/cc/surfaces/surface.h b/cc/surfaces/surface.h
index 7b3fbc1..ed0061d 100644
--- a/cc/surfaces/surface.h
+++ b/cc/surfaces/surface.h
@@ -34,10 +34,9 @@
class CC_SURFACES_EXPORT Surface {
public:
- Surface(SurfaceId id, const gfx::Size& size, SurfaceFactory* factory);
+ Surface(SurfaceId id, SurfaceFactory* factory);
~Surface();
- const gfx::Size& size() const { return size_; }
SurfaceId surface_id() const { return surface_id_; }
void QueueFrame(scoped_ptr<CompositorFrame> frame,
@@ -74,7 +73,6 @@
void ClearCopyRequests();
SurfaceId surface_id_;
- gfx::Size size_;
base::WeakPtr<SurfaceFactory> factory_;
// TODO(jamesr): Support multiple frames in flight.
scoped_ptr<CompositorFrame> current_frame_;
diff --git a/cc/surfaces/surface_aggregator.cc b/cc/surfaces/surface_aggregator.cc
index f5689c5..2334d14 100644
--- a/cc/surfaces/surface_aggregator.cc
+++ b/cc/surfaces/surface_aggregator.cc
@@ -153,13 +153,14 @@
}
gfx::Rect SurfaceAggregator::DamageRectForSurface(const Surface* surface,
- const RenderPass& source) {
+ const RenderPass& source,
+ const gfx::Rect& full_rect) {
int previous_index = previous_contained_surfaces_[surface->surface_id()];
if (previous_index == surface->frame_index())
return gfx::Rect();
else if (previous_index == surface->frame_index() - 1)
return source.damage_rect;
- return gfx::Rect(surface->size());
+ return full_rect;
}
void SurfaceAggregator::HandleSurfaceQuad(const SurfaceDrawQuad* surface_quad,
@@ -267,7 +268,8 @@
gfx::UnionRects(dest_pass->damage_rect,
MathUtil::MapEnclosingClippedRect(
surface_quad->quadTransform(),
- DamageRectForSurface(surface, last_pass)));
+ DamageRectForSurface(surface, last_pass,
+ surface_quad->visible_rect)));
referenced_surfaces_.erase(it);
}
@@ -364,9 +366,8 @@
RenderPassId remapped_pass_id =
RemapPassId(source.id, surface->surface_id());
- copy_pass->SetAll(remapped_pass_id,
- source.output_rect,
- DamageRectForSurface(surface, source),
+ copy_pass->SetAll(remapped_pass_id, source.output_rect,
+ DamageRectForSurface(surface, source, source.output_rect),
source.transform_to_root_target,
source.has_transparent_background);
@@ -415,6 +416,9 @@
referenced_surfaces_.erase(it);
DCHECK(referenced_surfaces_.empty());
+ if (dest_pass_list_->empty())
+ return nullptr;
+
dest_pass_list_ = NULL;
RemoveUnreferencedChildren();
contained_surfaces_.swap(previous_contained_surfaces_);
diff --git a/cc/surfaces/surface_aggregator.h b/cc/surfaces/surface_aggregator.h
index 6965041..1e68643 100644
--- a/cc/surfaces/surface_aggregator.h
+++ b/cc/surfaces/surface_aggregator.h
@@ -63,7 +63,8 @@
RenderPassList* render_pass_list);
int ChildIdForSurface(Surface* surface);
gfx::Rect DamageRectForSurface(const Surface* surface,
- const RenderPass& source);
+ const RenderPass& source,
+ const gfx::Rect& full_rect);
SurfaceManager* manager_;
ResourceProvider* provider_;
diff --git a/cc/surfaces/surface_aggregator_unittest.cc b/cc/surfaces/surface_aggregator_unittest.cc
index 2e47708..1daff52 100644
--- a/cc/surfaces/surface_aggregator_unittest.cc
+++ b/cc/surfaces/surface_aggregator_unittest.cc
@@ -59,7 +59,7 @@
TEST_F(SurfaceAggregatorTest, ValidSurfaceNoFrame) {
SurfaceId one_id(7);
- factory_.Create(one_id, SurfaceSize());
+ factory_.Create(one_id);
scoped_ptr<CompositorFrame> frame = aggregator_.Aggregate(one_id);
EXPECT_FALSE(frame);
factory_.Destroy(one_id);
@@ -72,7 +72,7 @@
virtual void SetUp() {
SurfaceAggregatorTest::SetUp();
root_surface_id_ = allocator_.GenerateId();
- factory_.Create(root_surface_id_, SurfaceSize());
+ factory_.Create(root_surface_id_);
}
virtual void TearDown() {
@@ -157,7 +157,7 @@
TEST_F(SurfaceAggregatorValidSurfaceTest, OpacityCopied) {
SurfaceId embedded_surface_id = allocator_.GenerateId();
- factory_.Create(embedded_surface_id, SurfaceSize());
+ factory_.Create(embedded_surface_id);
test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)};
test::Pass embedded_passes[] = {
@@ -190,9 +190,9 @@
TEST_F(SurfaceAggregatorValidSurfaceTest, OpacityCombinedWithNesting) {
SurfaceId surface_id1 = allocator_.GenerateId();
- factory_.Create(surface_id1, SurfaceSize());
+ factory_.Create(surface_id1);
SurfaceId surface_id2 = allocator_.GenerateId();
- factory_.Create(surface_id2, SurfaceSize());
+ factory_.Create(surface_id2);
// |surface_id1| is color quad.
{
@@ -258,7 +258,7 @@
// color quad should be aggregated into the final frame.
TEST_F(SurfaceAggregatorValidSurfaceTest, SimpleSurfaceReference) {
SurfaceId embedded_surface_id = allocator_.GenerateId();
- factory_.Create(embedded_surface_id, SurfaceSize());
+ factory_.Create(embedded_surface_id);
test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)};
test::Pass embedded_passes[] = {
@@ -287,7 +287,7 @@
TEST_F(SurfaceAggregatorValidSurfaceTest, CopyRequest) {
SurfaceId embedded_surface_id = allocator_.GenerateId();
- factory_.Create(embedded_surface_id, SurfaceSize());
+ factory_.Create(embedded_surface_id);
test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)};
test::Pass embedded_passes[] = {
@@ -344,7 +344,7 @@
// Root surface may contain copy requests.
TEST_F(SurfaceAggregatorValidSurfaceTest, RootCopyRequest) {
SurfaceId embedded_surface_id = allocator_.GenerateId();
- factory_.Create(embedded_surface_id, SurfaceSize());
+ factory_.Create(embedded_surface_id);
test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)};
test::Pass embedded_passes[] = {
@@ -432,7 +432,7 @@
// This tests referencing a surface that has multiple render passes.
TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassSurfaceReference) {
SurfaceId embedded_surface_id = child_allocator_.GenerateId();
- factory_.Create(embedded_surface_id, SurfaceSize());
+ factory_.Create(embedded_surface_id);
RenderPassId pass_ids[] = {RenderPassId(1, 1), RenderPassId(1, 2),
RenderPassId(1, 3)};
@@ -590,7 +590,7 @@
// should also just be dropped.
TEST_F(SurfaceAggregatorValidSurfaceTest, ValidSurfaceReferenceWithNoFrame) {
SurfaceId surface_with_no_frame_id = allocator_.GenerateId();
- factory_.Create(surface_with_no_frame_id, gfx::Size(5, 5));
+ factory_.Create(surface_with_no_frame_id);
test::Quad quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN),
test::Quad::SurfaceQuad(surface_with_no_frame_id, 1.f),
test::Quad::SolidColorQuad(SK_ColorBLUE)};
@@ -628,7 +628,7 @@
// Tests a more complex cycle with one intermediate surface.
TEST_F(SurfaceAggregatorValidSurfaceTest, TwoSurfaceCyclicalReference) {
SurfaceId child_surface_id = allocator_.GenerateId();
- factory_.Create(child_surface_id, SurfaceSize());
+ factory_.Create(child_surface_id);
test::Quad parent_quads[] = {test::Quad::SolidColorQuad(SK_ColorBLUE),
test::Quad::SurfaceQuad(child_surface_id, 1.f),
@@ -667,7 +667,7 @@
// namespace and update RenderPassDrawQuad's id references to match.
TEST_F(SurfaceAggregatorValidSurfaceTest, RenderPassIdMapping) {
SurfaceId child_surface_id = allocator_.GenerateId();
- factory_.Create(child_surface_id, SurfaceSize());
+ factory_.Create(child_surface_id);
RenderPassId child_pass_id[] = {RenderPassId(1, 1), RenderPassId(1, 2)};
test::Quad child_quad[][1] = {{test::Quad::SolidColorQuad(SK_ColorGREEN)},
@@ -795,7 +795,7 @@
RenderPassId pass_id(1, 1);
SurfaceId grandchild_surface_id = allocator_.GenerateId();
- factory_.Create(grandchild_surface_id, SurfaceSize());
+ factory_.Create(grandchild_surface_id);
scoped_ptr<RenderPass> grandchild_pass = RenderPass::Create();
gfx::Rect output_rect(SurfaceSize());
gfx::Rect damage_rect(SurfaceSize());
@@ -807,7 +807,7 @@
QueuePassAsFrame(grandchild_pass.Pass(), grandchild_surface_id);
SurfaceId child_one_surface_id = allocator_.GenerateId();
- factory_.Create(child_one_surface_id, SurfaceSize());
+ factory_.Create(child_one_surface_id);
scoped_ptr<RenderPass> child_one_pass = RenderPass::Create();
child_one_pass->SetNew(
@@ -825,7 +825,7 @@
QueuePassAsFrame(child_one_pass.Pass(), child_one_surface_id);
SurfaceId child_two_surface_id = allocator_.GenerateId();
- factory_.Create(child_two_surface_id, SurfaceSize());
+ factory_.Create(child_two_surface_id);
scoped_ptr<RenderPass> child_two_pass = RenderPass::Create();
child_two_pass->SetNew(
@@ -903,7 +903,7 @@
// affected.
TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) {
SurfaceId child_surface_id = allocator_.GenerateId();
- factory_.Create(child_surface_id, SurfaceSize());
+ factory_.Create(child_surface_id);
RenderPassId child_pass_id[] = {RenderPassId(1, 1), RenderPassId(1, 2)};
test::Quad child_quads[][1] = {
{test::Quad::SolidColorQuad(SK_ColorGREEN)},
@@ -1038,7 +1038,7 @@
// Tests that damage rects are aggregated correctly when surfaces change.
TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {
SurfaceId child_surface_id = allocator_.GenerateId();
- factory_.Create(child_surface_id, SurfaceSize());
+ factory_.Create(child_surface_id);
RenderPassId child_pass_id = RenderPassId(1, 1);
test::Quad child_quads[] = {test::Quad::RenderPassQuad(child_pass_id)};
test::Pass child_passes[] = {
@@ -1300,7 +1300,7 @@
ResourceTrackingSurfaceFactoryClient client;
SurfaceFactory factory(&manager_, &client);
SurfaceId surface_id(7u);
- factory.Create(surface_id, SurfaceSize());
+ factory.Create(surface_id);
ResourceProvider::ResourceId ids[] = {11, 12, 13};
SubmitFrameWithResources(ids, arraysize(ids), &factory, surface_id);
@@ -1328,9 +1328,9 @@
ResourceTrackingSurfaceFactoryClient client;
SurfaceFactory factory(&manager_, &client);
SurfaceId surface_id(7u);
- factory.Create(surface_id, SurfaceSize());
+ factory.Create(surface_id);
SurfaceId surface_id2(8u);
- factory.Create(surface_id2, SurfaceSize());
+ factory.Create(surface_id2);
ResourceProvider::ResourceId ids[] = {11, 12, 13};
SubmitFrameWithResources(ids, arraysize(ids), &factory, surface_id);
diff --git a/cc/surfaces/surface_factory.cc b/cc/surfaces/surface_factory.cc
index 574f5d1..fd5a6d4 100644
--- a/cc/surfaces/surface_factory.cc
+++ b/cc/surfaces/surface_factory.cc
@@ -30,8 +30,8 @@
surface_map_.clear();
}
-void SurfaceFactory::Create(SurfaceId surface_id, const gfx::Size& size) {
- scoped_ptr<Surface> surface(new Surface(surface_id, size, this));
+void SurfaceFactory::Create(SurfaceId surface_id) {
+ scoped_ptr<Surface> surface(new Surface(surface_id, this));
manager_->RegisterSurface(surface.get());
DCHECK(!surface_map_.count(surface_id));
surface_map_.add(surface_id, surface.Pass());
diff --git a/cc/surfaces/surface_factory.h b/cc/surfaces/surface_factory.h
index 8e9211c..eba32d2 100644
--- a/cc/surfaces/surface_factory.h
+++ b/cc/surfaces/surface_factory.h
@@ -38,7 +38,7 @@
SurfaceFactory(SurfaceManager* manager, SurfaceFactoryClient* client);
~SurfaceFactory();
- void Create(SurfaceId surface_id, const gfx::Size& size);
+ void Create(SurfaceId surface_id);
void Destroy(SurfaceId surface_id);
void DestroyAll();
// A frame can only be submitted to a surface created by this factory,
diff --git a/cc/surfaces/surface_factory_unittest.cc b/cc/surfaces/surface_factory_unittest.cc
index 14a25fd..84dcc5e 100644
--- a/cc/surfaces/surface_factory_unittest.cc
+++ b/cc/surfaces/surface_factory_unittest.cc
@@ -39,7 +39,7 @@
class SurfaceFactoryTest : public testing::Test {
public:
SurfaceFactoryTest() : factory_(&manager_, &client_), surface_id_(3) {
- factory_.Create(surface_id_, gfx::Size(5, 5));
+ factory_.Create(surface_id_);
}
virtual ~SurfaceFactoryTest() {
@@ -361,7 +361,7 @@
// Tests doing a DestroyAll before shutting down the factory;
TEST_F(SurfaceFactoryTest, DestroyAll) {
SurfaceId id(7);
- factory_.Create(id, gfx::Size(1, 1));
+ factory_.Create(id);
scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
TransferableResource resource;
@@ -378,7 +378,7 @@
TEST_F(SurfaceFactoryTest, DestroySequence) {
SurfaceId id2(5);
- factory_.Create(id2, gfx::Size(5, 5));
+ factory_.Create(id2);
// Check that waiting before the sequence is satisfied works.
manager_.GetSurfaceForId(id2)
@@ -395,7 +395,7 @@
DCHECK(!manager_.GetSurfaceForId(id2));
// Check that waiting after the sequence is satisfied works.
- factory_.Create(id2, gfx::Size(5, 5));
+ factory_.Create(id2);
DCHECK(manager_.GetSurfaceForId(id2));
manager_.GetSurfaceForId(id2)
->AddDestructionDependency(SurfaceSequence(0, 6));
diff --git a/cc/surfaces/surface_unittest.cc b/cc/surfaces/surface_unittest.cc
index b8990c5..7f2de36 100644
--- a/cc/surfaces/surface_unittest.cc
+++ b/cc/surfaces/surface_unittest.cc
@@ -17,7 +17,7 @@
SurfaceId surface_id(6);
{
- factory.Create(surface_id, gfx::Size(5, 5));
+ factory.Create(surface_id);
EXPECT_TRUE(!!manager.GetSurfaceForId(surface_id));
factory.Destroy(surface_id);
}
diff --git a/cc/surfaces/surfaces_pixeltest.cc b/cc/surfaces/surfaces_pixeltest.cc
index c70028b..bf9d483 100644
--- a/cc/surfaces/surfaces_pixeltest.cc
+++ b/cc/surfaces/surfaces_pixeltest.cc
@@ -85,7 +85,7 @@
root_frame->delegated_frame_data = delegated_frame_data.Pass();
SurfaceId root_surface_id = allocator_.GenerateId();
- factory_.Create(root_surface_id, device_viewport_size_);
+ factory_.Create(root_surface_id);
factory_.SubmitFrame(root_surface_id, root_frame.Pass(), base::Closure());
SurfaceAggregator aggregator(&manager_, resource_provider_.get());
@@ -107,8 +107,8 @@
gfx::Size child_size(200, 100);
SurfaceId child_surface_id = allocator_.GenerateId();
SurfaceId root_surface_id = allocator_.GenerateId();
- factory_.Create(child_surface_id, child_size);
- factory_.Create(root_surface_id, device_viewport_size_);
+ factory_.Create(child_surface_id);
+ factory_.Create(root_surface_id);
{
gfx::Rect rect(device_viewport_size_);
RenderPassId id(1, 1);
@@ -199,9 +199,9 @@
SurfaceId left_child_id = allocator_.GenerateId();
SurfaceId right_child_id = allocator_.GenerateId();
SurfaceId root_surface_id = allocator_.GenerateId();
- factory_.Create(left_child_id, child_size);
- factory_.Create(right_child_id, child_size);
- factory_.Create(root_surface_id, device_viewport_size_);
+ factory_.Create(left_child_id);
+ factory_.Create(right_child_id);
+ factory_.Create(root_surface_id);
{
gfx::Rect rect(device_viewport_size_);
diff --git a/cc/test/begin_frame_args_test.cc b/cc/test/begin_frame_args_test.cc
index f70d0c5..7b29748 100644
--- a/cc/test/begin_frame_args_test.cc
+++ b/cc/test/begin_frame_args_test.cc
@@ -10,57 +10,67 @@
namespace cc {
-BeginFrameArgs CreateBeginFrameArgsForTesting() {
- return CreateBeginFrameArgsForTesting(gfx::FrameTime::Now());
-}
-
-BeginFrameArgs CreateBeginFrameArgsForTesting(base::TimeTicks frame_time) {
- return BeginFrameArgs::Create(
- frame_time, frame_time + (BeginFrameArgs::DefaultInterval() / 2),
- BeginFrameArgs::DefaultInterval(), BeginFrameArgs::NORMAL);
-}
-
-BeginFrameArgs CreateBeginFrameArgsForTesting(int64 frame_time,
- int64 deadline,
- int64 interval) {
- return BeginFrameArgs::Create(base::TimeTicks::FromInternalValue(frame_time),
- base::TimeTicks::FromInternalValue(deadline),
- base::TimeDelta::FromInternalValue(interval),
- BeginFrameArgs::NORMAL);
+BeginFrameArgs CreateBeginFrameArgsForTesting(
+ BeginFrameArgs::CreationLocation location) {
+ return CreateBeginFrameArgsForTesting(location, gfx::FrameTime::Now());
}
BeginFrameArgs CreateBeginFrameArgsForTesting(
+ BeginFrameArgs::CreationLocation location,
+ base::TimeTicks frame_time) {
+ return BeginFrameArgs::Create(
+ location, frame_time,
+ frame_time + (BeginFrameArgs::DefaultInterval() / 2),
+ BeginFrameArgs::DefaultInterval(), BeginFrameArgs::NORMAL);
+}
+
+BeginFrameArgs CreateBeginFrameArgsForTesting(
+ BeginFrameArgs::CreationLocation location,
+ int64 frame_time,
+ int64 deadline,
+ int64 interval) {
+ return BeginFrameArgs::Create(
+ location, base::TimeTicks::FromInternalValue(frame_time),
+ base::TimeTicks::FromInternalValue(deadline),
+ base::TimeDelta::FromInternalValue(interval), BeginFrameArgs::NORMAL);
+}
+
+BeginFrameArgs CreateBeginFrameArgsForTesting(
+ BeginFrameArgs::CreationLocation location,
int64 frame_time,
int64 deadline,
int64 interval,
BeginFrameArgs::BeginFrameArgsType type) {
- return BeginFrameArgs::Create(base::TimeTicks::FromInternalValue(frame_time),
- base::TimeTicks::FromInternalValue(deadline),
- base::TimeDelta::FromInternalValue(interval),
- type);
+ return BeginFrameArgs::Create(
+ location, base::TimeTicks::FromInternalValue(frame_time),
+ base::TimeTicks::FromInternalValue(deadline),
+ base::TimeDelta::FromInternalValue(interval), type);
}
-BeginFrameArgs CreateExpiredBeginFrameArgsForTesting() {
+BeginFrameArgs CreateExpiredBeginFrameArgsForTesting(
+ BeginFrameArgs::CreationLocation location) {
base::TimeTicks now = gfx::FrameTime::Now();
- return BeginFrameArgs::Create(now, now - BeginFrameArgs::DefaultInterval(),
- BeginFrameArgs::DefaultInterval(),
- BeginFrameArgs::NORMAL);
+ return BeginFrameArgs::Create(
+ location, now, now - BeginFrameArgs::DefaultInterval(),
+ BeginFrameArgs::DefaultInterval(), BeginFrameArgs::NORMAL);
}
BeginFrameArgs CreateBeginFrameArgsForTesting(
+ BeginFrameArgs::CreationLocation location,
scoped_refptr<TestNowSource> now_src) {
base::TimeTicks now = now_src->Now();
return BeginFrameArgs::Create(
- now, now + (BeginFrameArgs::DefaultInterval() / 2),
+ location, now, now + (BeginFrameArgs::DefaultInterval() / 2),
BeginFrameArgs::DefaultInterval(), BeginFrameArgs::NORMAL);
}
BeginFrameArgs CreateExpiredBeginFrameArgsForTesting(
+ BeginFrameArgs::CreationLocation location,
scoped_refptr<TestNowSource> now_src) {
base::TimeTicks now = now_src->Now();
- return BeginFrameArgs::Create(now, now - BeginFrameArgs::DefaultInterval(),
- BeginFrameArgs::DefaultInterval(),
- BeginFrameArgs::NORMAL);
+ return BeginFrameArgs::Create(
+ location, now, now - BeginFrameArgs::DefaultInterval(),
+ BeginFrameArgs::DefaultInterval(), BeginFrameArgs::NORMAL);
}
bool operator==(const BeginFrameArgs& lhs, const BeginFrameArgs& rhs) {
diff --git a/cc/test/begin_frame_args_test.h b/cc/test/begin_frame_args_test.h
index ca4aa45..73aaf02 100644
--- a/cc/test/begin_frame_args_test.h
+++ b/cc/test/begin_frame_args_test.h
@@ -15,23 +15,32 @@
namespace cc {
// Functions for quickly creating BeginFrameArgs
-BeginFrameArgs CreateBeginFrameArgsForTesting();
-BeginFrameArgs CreateBeginFrameArgsForTesting(base::TimeTicks frame_time);
-BeginFrameArgs CreateBeginFrameArgsForTesting(int64 frame_time,
- int64 deadline,
- int64 interval);
BeginFrameArgs CreateBeginFrameArgsForTesting(
+ BeginFrameArgs::CreationLocation location);
+BeginFrameArgs CreateBeginFrameArgsForTesting(
+ BeginFrameArgs::CreationLocation location,
+ base::TimeTicks frame_time);
+BeginFrameArgs CreateBeginFrameArgsForTesting(
+ BeginFrameArgs::CreationLocation location,
+ int64 frame_time,
+ int64 deadline,
+ int64 interval);
+BeginFrameArgs CreateBeginFrameArgsForTesting(
+ BeginFrameArgs::CreationLocation location,
int64 frame_time,
int64 deadline,
int64 interval,
BeginFrameArgs::BeginFrameArgsType type);
-BeginFrameArgs CreateExpiredBeginFrameArgsForTesting();
+BeginFrameArgs CreateExpiredBeginFrameArgsForTesting(
+ BeginFrameArgs::CreationLocation location);
// Creates a BeginFrameArgs using the fake Now value stored on the
// OrderSimpleTaskRunner.
BeginFrameArgs CreateBeginFrameArgsForTesting(
+ BeginFrameArgs::CreationLocation location,
scoped_refptr<TestNowSource> now_src);
BeginFrameArgs CreateExpiredBeginFrameArgsForTesting(
+ BeginFrameArgs::CreationLocation location,
scoped_refptr<TestNowSource> now_src);
// gtest helpers -- these *must* be in the same namespace as the types they
diff --git a/cc/test/fake_content_layer_client.cc b/cc/test/fake_content_layer_client.cc
index 5463aed..46d1baa 100644
--- a/cc/test/fake_content_layer_client.cc
+++ b/cc/test/fake_content_layer_client.cc
@@ -4,7 +4,10 @@
#include "cc/test/fake_content_layer_client.h"
+#include "cc/resources/clip_display_item.h"
+#include "cc/resources/drawing_display_item.h"
#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkPictureRecorder.h"
#include "ui/gfx/skia_util.h"
namespace cc {
@@ -52,6 +55,58 @@
}
}
+scoped_refptr<DisplayItemList>
+FakeContentLayerClient::PaintContentsToDisplayList(
+ const gfx::Rect& clip,
+ GraphicsContextStatus gc_status) {
+ SkPictureRecorder recorder;
+ skia::RefPtr<SkCanvas> canvas;
+ skia::RefPtr<SkPicture> picture;
+ scoped_refptr<DisplayItemList> list = DisplayItemList::Create();
+ list->AppendItem(ClipDisplayItem::Create(clip, std::vector<SkRRect>()));
+
+ for (RectPaintVector::const_iterator it = draw_rects_.begin();
+ it != draw_rects_.end(); ++it) {
+ const gfx::RectF& draw_rect = it->first;
+ const SkPaint& paint = it->second;
+ canvas = skia::SharePtr(
+ recorder.beginRecording(draw_rect.width(), draw_rect.height()));
+ canvas->drawRectCoords(0.f, 0.f, draw_rect.width(), draw_rect.height(),
+ paint);
+ picture = skia::AdoptRef(recorder.endRecording());
+ list->AppendItem(DrawingDisplayItem::Create(
+ picture, gfx::PointF(draw_rect.x(), draw_rect.y())));
+ }
+
+ for (BitmapVector::const_iterator it = draw_bitmaps_.begin();
+ it != draw_bitmaps_.end(); ++it) {
+ canvas = skia::SharePtr(
+ recorder.beginRecording(it->bitmap.width(), it->bitmap.height()));
+ canvas->drawBitmap(it->bitmap, 0.f, 0.f, &it->paint);
+ picture = skia::AdoptRef(recorder.endRecording());
+ list->AppendItem(DrawingDisplayItem::Create(
+ picture, gfx::PointF(it->point.x(), it->point.y())));
+ }
+
+ if (fill_with_nonsolid_color_) {
+ gfx::RectF draw_rect = clip;
+ bool red = true;
+ while (!draw_rect.IsEmpty()) {
+ SkPaint paint;
+ paint.setColor(red ? SK_ColorRED : SK_ColorBLUE);
+ canvas =
+ skia::SharePtr(recorder.beginRecording(clip.width(), clip.height()));
+ canvas->drawRect(gfx::RectFToSkRect(draw_rect), paint);
+ picture = skia::AdoptRef(recorder.endRecording());
+ list->AppendItem(DrawingDisplayItem::Create(picture, gfx::PointF()));
+ draw_rect.Inset(1, 1);
+ }
+ }
+
+ list->AppendItem(EndClipDisplayItem::Create());
+ return list;
+}
+
bool FakeContentLayerClient::FillsBoundsCompletely() const { return false; }
} // namespace cc
diff --git a/cc/test/fake_content_layer_client.h b/cc/test/fake_content_layer_client.h
index 141bc97..1060d08 100644
--- a/cc/test/fake_content_layer_client.h
+++ b/cc/test/fake_content_layer_client.h
@@ -31,6 +31,9 @@
SkCanvas* canvas,
const gfx::Rect& rect,
ContentLayerClient::GraphicsContextStatus gc_status) override;
+ scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
+ const gfx::Rect& clip,
+ GraphicsContextStatus gc_status) override;
bool FillsBoundsCompletely() const override;
void set_fill_with_nonsolid_color(bool nonsolid) {
diff --git a/cc/test/fake_layer_tree_host_impl.cc b/cc/test/fake_layer_tree_host_impl.cc
index ea19e14..305b856 100644
--- a/cc/test/fake_layer_tree_host_impl.cc
+++ b/cc/test/fake_layer_tree_host_impl.cc
@@ -24,7 +24,8 @@
// Avoid using Now() as the frame time in unit tests.
base::TimeTicks time_ticks = base::TimeTicks::FromInternalValue(1);
- SetCurrentBeginFrameArgs(CreateBeginFrameArgsForTesting(time_ticks));
+ SetCurrentBeginFrameArgs(
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
}
FakeLayerTreeHostImpl::FakeLayerTreeHostImpl(const LayerTreeSettings& settings,
@@ -42,7 +43,8 @@
// Avoid using Now() as the frame time in unit tests.
base::TimeTicks time_ticks = base::TimeTicks::FromInternalValue(1);
- SetCurrentBeginFrameArgs(CreateBeginFrameArgsForTesting(time_ticks));
+ SetCurrentBeginFrameArgs(
+ CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
}
FakeLayerTreeHostImpl::~FakeLayerTreeHostImpl() {}
diff --git a/cc/test/layer_tree_pixel_resource_test.cc b/cc/test/layer_tree_pixel_resource_test.cc
index 9bd75ac..1839643 100644
--- a/cc/test/layer_tree_pixel_resource_test.cc
+++ b/cc/test/layer_tree_pixel_resource_test.cc
@@ -159,7 +159,7 @@
case ZERO_COPY_RASTER_WORKER_POOL:
EXPECT_TRUE(context_provider);
EXPECT_EQ(PIXEL_TEST_GL, test_type_);
- EXPECT_TRUE(host_impl->CanUseZeroCopyRasterizer());
+ EXPECT_TRUE(host_impl->GetRendererCapabilities().using_image);
*resource_pool =
ResourcePool::Create(resource_provider,
draw_texture_target_,
@@ -173,7 +173,7 @@
case ONE_COPY_RASTER_WORKER_POOL:
EXPECT_TRUE(context_provider);
EXPECT_EQ(PIXEL_TEST_GL, test_type_);
- EXPECT_TRUE(host_impl->CanUseOneCopyRasterizer());
+ EXPECT_TRUE(host_impl->GetRendererCapabilities().using_image);
// We need to create a staging resource pool when using copy rasterizer.
*staging_resource_pool =
ResourcePool::Create(resource_provider,
diff --git a/cc/test/layer_tree_test.cc b/cc/test/layer_tree_test.cc
index 80e9f11..9f08677 100644
--- a/cc/test/layer_tree_test.cc
+++ b/cc/test/layer_tree_test.cc
@@ -91,7 +91,7 @@
void TestOnBeginFrame() {
DCHECK(CalledOnValidThread());
- CallOnBeginFrame(CreateBeginFrameArgsForTesting());
+ CallOnBeginFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
}
private:
@@ -153,6 +153,11 @@
test_hooks_->ScheduledActionBeginOutputSurfaceCreation();
}
+ void ScheduledActionManageTiles() override {
+ ThreadProxy::ScheduledActionManageTiles();
+ test_hooks_->ScheduledActionManageTiles();
+ }
+
ThreadProxyForTest(
TestHooks* test_hooks,
LayerTreeHost* host,
@@ -780,6 +785,11 @@
RunTest(true, false, true);
}
+void LayerTreeTest::RunTestWithMainThreadLowLatency() {
+ settings_.main_thread_should_always_be_low_latency = true;
+ RunTest(false, false, false);
+}
+
void LayerTreeTest::RequestNewOutputSurface(bool fallback) {
layer_tree_host_->SetOutputSurface(CreateOutputSurface(fallback));
}
diff --git a/cc/test/layer_tree_test.h b/cc/test/layer_tree_test.h
index 2914cfc..ba2ef69 100644
--- a/cc/test/layer_tree_test.h
+++ b/cc/test/layer_tree_test.h
@@ -98,6 +98,7 @@
virtual void ScheduledActionAnimate() {}
virtual void ScheduledActionCommit() {}
virtual void ScheduledActionBeginOutputSurfaceCreation() {}
+ virtual void ScheduledActionManageTiles() {}
// Implementation of AnimationDelegate:
void NotifyAnimationStarted(base::TimeTicks monotonic_time,
@@ -175,6 +176,7 @@
bool delegating_renderer,
bool impl_side_painting);
virtual void RunTestWithImplSidePainting();
+ virtual void RunTestWithMainThreadLowLatency();
bool HasImplThread() { return proxy() ? proxy()->HasImplThread() : false; }
base::SingleThreadTaskRunner* ImplThreadTaskRunner() {
@@ -235,7 +237,18 @@
} // namespace cc
+#define SINGLE_THREAD_DIRECT_RENDERER_NOIMPL_MAIN_THREAD_LOW_LATENCY_TEST_F( \
+ TEST_FIXTURE_NAME) \
+ TEST_F( \
+ TEST_FIXTURE_NAME, \
+ RunSingleThread_DirectRenderer_MainThreadPaint_MainThreadLowLatency) { \
+ RunTestWithMainThreadLowLatency(); \
+ } \
+ class SingleThreadDirectNoImplLowLatencyNeedsSemicolon##TEST_FIXTURE_NAME {}
+
#define SINGLE_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME) \
+ SINGLE_THREAD_DIRECT_RENDERER_NOIMPL_MAIN_THREAD_LOW_LATENCY_TEST_F( \
+ TEST_FIXTURE_NAME); \
TEST_F(TEST_FIXTURE_NAME, RunSingleThread_DirectRenderer_MainThreadPaint) { \
RunTest(false, false, false); \
} \
diff --git a/cc/test/skia_common.cc b/cc/test/skia_common.cc
index 1ccb2d1..ef61e21 100644
--- a/cc/test/skia_common.cc
+++ b/cc/test/skia_common.cc
@@ -4,6 +4,7 @@
#include "cc/test/skia_common.h"
+#include "cc/resources/display_item_list.h"
#include "cc/resources/picture.h"
#include "skia/ext/refptr.h"
#include "third_party/skia/include/core/SkCanvas.h"
@@ -26,6 +27,18 @@
picture->Raster(&canvas, NULL, negated_content_region, 1.0f);
}
+void DrawDisplayList(unsigned char* buffer,
+ const gfx::Rect& layer_rect,
+ scoped_refptr<DisplayItemList> list) {
+ SkImageInfo info =
+ SkImageInfo::MakeN32Premul(layer_rect.width(), layer_rect.height());
+ SkBitmap bitmap;
+ bitmap.installPixels(info, buffer, info.minRowBytes());
+ SkCanvas canvas(bitmap);
+ canvas.clipRect(gfx::RectToSkRect(layer_rect));
+ list->Raster(&canvas, NULL, 1.0f);
+}
+
void CreateBitmap(const gfx::Size& size, const char* uri, SkBitmap* bitmap) {
SkImageInfo info = SkImageInfo::MakeN32Premul(size.width(), size.height());
diff --git a/cc/test/skia_common.h b/cc/test/skia_common.h
index 3bafa0b..51ebcc5 100644
--- a/cc/test/skia_common.h
+++ b/cc/test/skia_common.h
@@ -18,11 +18,16 @@
namespace cc {
class Picture;
+class DisplayItemList;
void DrawPicture(unsigned char* buffer,
const gfx::Rect& layer_rect,
scoped_refptr<Picture> picture);
+void DrawDisplayList(unsigned char* buffer,
+ const gfx::Rect& layer_rect,
+ scoped_refptr<DisplayItemList> list);
+
void CreateBitmap(const gfx::Size& size, const char* uri, SkBitmap* bitmap);
} // namespace cc
diff --git a/cc/test/solid_color_content_layer_client.cc b/cc/test/solid_color_content_layer_client.cc
index 237dbb6..701f004 100644
--- a/cc/test/solid_color_content_layer_client.cc
+++ b/cc/test/solid_color_content_layer_client.cc
@@ -25,6 +25,14 @@
paint);
}
+scoped_refptr<DisplayItemList>
+SolidColorContentLayerClient::PaintContentsToDisplayList(
+ const gfx::Rect& clip,
+ GraphicsContextStatus gc_status) {
+ NOTIMPLEMENTED();
+ return DisplayItemList::Create();
+}
+
bool SolidColorContentLayerClient::FillsBoundsCompletely() const {
return false;
}
diff --git a/cc/test/solid_color_content_layer_client.h b/cc/test/solid_color_content_layer_client.h
index 7a962cf..93fca84 100644
--- a/cc/test/solid_color_content_layer_client.h
+++ b/cc/test/solid_color_content_layer_client.h
@@ -20,6 +20,9 @@
SkCanvas* canvas,
const gfx::Rect& rect,
ContentLayerClient::GraphicsContextStatus gc_status) override;
+ scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
+ const gfx::Rect& clip,
+ GraphicsContextStatus gc_status) override;
bool FillsBoundsCompletely() const override;
private:
diff --git a/cc/test/test_shared_bitmap_manager.cc b/cc/test/test_shared_bitmap_manager.cc
index d7716dd..933dcd2 100644
--- a/cc/test/test_shared_bitmap_manager.cc
+++ b/cc/test/test_shared_bitmap_manager.cc
@@ -4,15 +4,41 @@
#include "cc/test/test_shared_bitmap_manager.h"
-#include "base/bind.h"
+#include "base/memory/shared_memory.h"
namespace cc {
-void FreeSharedBitmap(SharedBitmap* shared_bitmap) {
- delete shared_bitmap->memory();
-}
+namespace {
+class OwnedSharedBitmap : public SharedBitmap {
+ public:
+ OwnedSharedBitmap(scoped_ptr<base::SharedMemory> shared_memory,
+ const SharedBitmapId& id)
+ : SharedBitmap(static_cast<uint8*>(shared_memory->memory()), id),
+ shared_memory_(shared_memory.Pass()) {}
-void IgnoreSharedBitmap(SharedBitmap* shared_bitmap) {}
+ ~OwnedSharedBitmap() override {}
+
+ base::SharedMemory* memory() override { return shared_memory_.get(); }
+
+ private:
+ scoped_ptr<base::SharedMemory> shared_memory_;
+};
+
+class UnownedSharedBitmap : public SharedBitmap {
+ public:
+ UnownedSharedBitmap(base::SharedMemory* shared_memory,
+ const SharedBitmapId& id)
+ : SharedBitmap(static_cast<uint8*>(shared_memory->memory()), id),
+ shared_memory_(shared_memory) {}
+
+ ~UnownedSharedBitmap() override {}
+
+ base::SharedMemory* memory() override { return shared_memory_; }
+
+ private:
+ base::SharedMemory* shared_memory_;
+};
+} // namespace
TestSharedBitmapManager::TestSharedBitmapManager() {}
@@ -25,8 +51,7 @@
memory->CreateAndMapAnonymous(size.GetArea() * 4);
SharedBitmapId id = SharedBitmap::GenerateId();
bitmap_map_[id] = memory.get();
- return make_scoped_ptr(
- new SharedBitmap(memory.release(), id, base::Bind(&FreeSharedBitmap)));
+ return make_scoped_ptr(new OwnedSharedBitmap(memory.Pass(), id));
}
scoped_ptr<SharedBitmap> TestSharedBitmapManager::GetSharedBitmapFromId(
@@ -35,8 +60,7 @@
base::AutoLock lock(lock_);
if (bitmap_map_.find(id) == bitmap_map_.end())
return nullptr;
- return make_scoped_ptr(
- new SharedBitmap(bitmap_map_[id], id, base::Bind(&IgnoreSharedBitmap)));
+ return make_scoped_ptr(new UnownedSharedBitmap(bitmap_map_[id], id));
}
scoped_ptr<SharedBitmap> TestSharedBitmapManager::GetBitmapForSharedMemory(
@@ -44,8 +68,7 @@
base::AutoLock lock(lock_);
SharedBitmapId id = SharedBitmap::GenerateId();
bitmap_map_[id] = memory;
- return make_scoped_ptr(
- new SharedBitmap(memory, id, base::Bind(&IgnoreSharedBitmap)));
+ return make_scoped_ptr(new UnownedSharedBitmap(memory, id));
}
} // namespace cc
diff --git a/cc/test/test_web_graphics_context_3d.h b/cc/test/test_web_graphics_context_3d.h
index ff2c704..56c17c0 100644
--- a/cc/test/test_web_graphics_context_3d.h
+++ b/cc/test/test_web_graphics_context_3d.h
@@ -330,6 +330,9 @@
void set_support_image(bool support) {
test_capabilities_.gpu.image = support;
}
+ void set_support_texture_rectangle(bool support) {
+ test_capabilities_.gpu.texture_rectangle = support;
+ }
// When this context is lost, all contexts in its share group are also lost.
void add_share_group_context(TestWebGraphicsContext3D* context3d) {
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index 6863850..6d75687 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -392,7 +392,7 @@
gfx::Rect visible_rect_in_target_surface_space =
layer->drawable_content_rect();
- if (!layer->render_target()->render_surface()->clip_rect().IsEmpty()) {
+ if (layer->render_target()->render_surface()->is_clipped()) {
// The |layer| L has a target T which owns a surface Ts. The surface Ts
// has a target TsT.
//
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index 7a282c1..8c02bd3 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -59,6 +59,12 @@
SkCanvas* canvas,
const gfx::Rect& clip,
ContentLayerClient::GraphicsContextStatus gc_status) override {}
+ scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
+ const gfx::Rect& clip,
+ GraphicsContextStatus gc_status) override {
+ NOTIMPLEMENTED();
+ return DisplayItemList::Create();
+ }
bool FillsBoundsCompletely() const override { return false; }
};
@@ -2820,6 +2826,56 @@
}
TEST_F(LayerTreeHostCommonTest,
+ VisibleContentRectsForClippedSurfaceWithEmptyClip) {
+ scoped_refptr<Layer> root = Layer::Create();
+ scoped_refptr<LayerWithForcedDrawsContent> child1 =
+ make_scoped_refptr(new LayerWithForcedDrawsContent());
+ scoped_refptr<LayerWithForcedDrawsContent> child2 =
+ make_scoped_refptr(new LayerWithForcedDrawsContent());
+ scoped_refptr<LayerWithForcedDrawsContent> child3 =
+ make_scoped_refptr(new LayerWithForcedDrawsContent());
+ root->AddChild(child1);
+ root->AddChild(child2);
+ root->AddChild(child3);
+
+ scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
+ host->SetRootLayer(root);
+
+ gfx::Transform identity_matrix;
+ SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
+ gfx::PointF(), gfx::Size(100, 100), true, false);
+ SetLayerPropertiesForTesting(child1.get(), identity_matrix, gfx::Point3F(),
+ gfx::PointF(5.f, 5.f), gfx::Size(50, 50), true,
+ false);
+ SetLayerPropertiesForTesting(child2.get(), identity_matrix, gfx::Point3F(),
+ gfx::PointF(75.f, 75.f), gfx::Size(50, 50), true,
+ false);
+ SetLayerPropertiesForTesting(child3.get(), identity_matrix, gfx::Point3F(),
+ gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
+ true, false);
+
+ RenderSurfaceLayerList render_surface_layer_list;
+ // Now set the root render surface an empty clip.
+ LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
+ root.get(), gfx::Size(), &render_surface_layer_list);
+
+ LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+ ASSERT_TRUE(root->render_surface());
+ EXPECT_FALSE(root->is_clipped());
+
+ gfx::Rect empty;
+ EXPECT_EQ(empty, root->render_surface()->clip_rect());
+ EXPECT_TRUE(root->render_surface()->is_clipped());
+
+ // Visible content rect calculation will check if the target surface is
+ // clipped or not. An empty clip rect does not indicate the render surface
+ // is unclipped.
+ EXPECT_EQ(empty, child1->visible_content_rect());
+ EXPECT_EQ(empty, child2->visible_content_rect());
+ EXPECT_EQ(empty, child3->visible_content_rect());
+}
+
+TEST_F(LayerTreeHostCommonTest,
DrawableAndVisibleContentRectsForLayersWithUninvertibleTransform) {
scoped_refptr<Layer> root = Layer::Create();
scoped_refptr<LayerWithForcedDrawsContent> child =
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index e49dcfe..10b0685 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -151,22 +151,6 @@
max_transfer_buffer_usage_bytes);
}
-unsigned GetMapImageTextureTarget(
- const ContextProvider::Capabilities& context_capabilities) {
-// TODO(reveman): This should be a setting passed to the compositor instead
-// of hard-coded here. The target that need to be used depends on our choice
-// of GpuMemoryBuffer type. Note: SURFACE_TEXTURE needs EXTERNAL_OES,
-// IO_SURFACE needs RECTANGLE_ARB. crbug.com/431059
-#if defined(OS_ANDROID)
- if (context_capabilities.gpu.egl_image_external)
- return GL_TEXTURE_EXTERNAL_OES;
-#endif
- if (context_capabilities.gpu.texture_rectangle)
- return GL_TEXTURE_RECTANGLE_ARB;
-
- return GL_TEXTURE_2D;
-}
-
size_t GetMaxStagingResourceCount() {
// Upper bound for number of staging resource to allow.
return 32;
@@ -2005,9 +1989,6 @@
DCHECK(task_runner);
ContextProvider* context_provider = output_surface_->context_provider();
- bool should_use_zero_copy_rasterizer =
- settings_.use_zero_copy || IsSynchronousSingleThreaded();
-
if (!context_provider) {
*resource_pool =
ResourcePool::Create(resource_provider_.get(),
@@ -2018,7 +1999,10 @@
BitmapRasterWorkerPool::Create(task_runner,
RasterWorkerPool::GetTaskGraphRunner(),
resource_provider_.get());
- } else if (use_gpu_rasterization_) {
+ return;
+ }
+
+ if (use_gpu_rasterization_) {
*resource_pool =
ResourcePool::Create(resource_provider_.get(),
GL_TEXTURE_2D,
@@ -2029,53 +2013,65 @@
context_provider,
resource_provider_.get(),
settings_.use_distance_field_text);
- } else if (should_use_zero_copy_rasterizer && CanUseZeroCopyRasterizer()) {
- *resource_pool = ResourcePool::Create(
- resource_provider_.get(),
- GetMapImageTextureTarget(context_provider->ContextCapabilities()),
- resource_provider_->best_texture_format());
+ return;
+ }
- TaskGraphRunner* task_graph_runner;
- if (IsSynchronousSingleThreaded()) {
- DCHECK(!single_thread_synchronous_task_graph_runner_);
- single_thread_synchronous_task_graph_runner_.reset(new TaskGraphRunner);
- task_graph_runner = single_thread_synchronous_task_graph_runner_.get();
- } else {
- task_graph_runner = RasterWorkerPool::GetTaskGraphRunner();
+ if (GetRendererCapabilities().using_image) {
+ unsigned image_target = GL_TEXTURE_2D;
+#if defined(OS_MACOSX)
+ // GL_TEXTURE_RECTANGLE_ARB target is required by IOSurface backed images.
+ DCHECK(context_provider->ContextCapabilities().gpu.texture_rectangle);
+ image_target = GL_TEXTURE_RECTANGLE_ARB;
+#endif
+ if (settings_.use_image_external) {
+ DCHECK(context_provider->ContextCapabilities().gpu.egl_image_external);
+ image_target = GL_TEXTURE_EXTERNAL_OES;
}
- *raster_worker_pool = ZeroCopyRasterWorkerPool::Create(
- task_runner, task_graph_runner, resource_provider_.get());
- } else if (settings_.use_one_copy && CanUseOneCopyRasterizer()) {
- // We need to create a staging resource pool when using copy rasterizer.
- *staging_resource_pool = ResourcePool::Create(
- resource_provider_.get(),
- GetMapImageTextureTarget(context_provider->ContextCapabilities()),
- resource_provider_->best_texture_format());
- *resource_pool =
- ResourcePool::Create(resource_provider_.get(),
- GL_TEXTURE_2D,
- resource_provider_->best_texture_format());
+ if (settings_.use_zero_copy || IsSynchronousSingleThreaded()) {
+ *resource_pool =
+ ResourcePool::Create(resource_provider_.get(), image_target,
+ resource_provider_->best_texture_format());
- *raster_worker_pool =
- OneCopyRasterWorkerPool::Create(task_runner,
- RasterWorkerPool::GetTaskGraphRunner(),
- context_provider,
- resource_provider_.get(),
- staging_resource_pool_.get());
- } else {
- *resource_pool = ResourcePool::Create(
- resource_provider_.get(),
- GL_TEXTURE_2D,
- resource_provider_->memory_efficient_texture_format());
+ TaskGraphRunner* task_graph_runner;
+ if (IsSynchronousSingleThreaded()) {
+ DCHECK(!single_thread_synchronous_task_graph_runner_);
+ single_thread_synchronous_task_graph_runner_.reset(new TaskGraphRunner);
+ task_graph_runner = single_thread_synchronous_task_graph_runner_.get();
+ } else {
+ task_graph_runner = RasterWorkerPool::GetTaskGraphRunner();
+ }
- *raster_worker_pool = PixelBufferRasterWorkerPool::Create(
- task_runner, RasterWorkerPool::GetTaskGraphRunner(), context_provider,
- resource_provider_.get(),
- GetMaxTransferBufferUsageBytes(
- context_provider->ContextCapabilities(),
- settings_.renderer_settings.refresh_rate));
+ *raster_worker_pool = ZeroCopyRasterWorkerPool::Create(
+ task_runner, task_graph_runner, resource_provider_.get());
+ return;
+ }
+
+ if (settings_.use_one_copy) {
+ // We need to create a staging resource pool when using copy rasterizer.
+ *staging_resource_pool =
+ ResourcePool::Create(resource_provider_.get(), image_target,
+ resource_provider_->best_texture_format());
+ *resource_pool =
+ ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D,
+ resource_provider_->best_texture_format());
+
+ *raster_worker_pool = OneCopyRasterWorkerPool::Create(
+ task_runner, RasterWorkerPool::GetTaskGraphRunner(), context_provider,
+ resource_provider_.get(), staging_resource_pool_.get());
+ return;
+ }
}
+
+ *resource_pool = ResourcePool::Create(
+ resource_provider_.get(), GL_TEXTURE_2D,
+ resource_provider_->memory_efficient_texture_format());
+
+ *raster_worker_pool = PixelBufferRasterWorkerPool::Create(
+ task_runner, RasterWorkerPool::GetTaskGraphRunner(), context_provider,
+ resource_provider_.get(),
+ GetMaxTransferBufferUsageBytes(context_provider->ContextCapabilities(),
+ settings_.renderer_settings.refresh_rate));
}
void LayerTreeHostImpl::DestroyTileManager() {
@@ -2096,14 +2092,6 @@
return !proxy_->HasImplThread() && !settings_.single_thread_proxy_scheduler;
}
-bool LayerTreeHostImpl::CanUseZeroCopyRasterizer() const {
- return GetRendererCapabilities().using_image;
-}
-
-bool LayerTreeHostImpl::CanUseOneCopyRasterizer() const {
- return GetRendererCapabilities().using_image;
-}
-
void LayerTreeHostImpl::EnforceZeroBudget(bool zero_budget) {
SetManagedMemoryPolicy(cached_managed_memory_policy_, zero_budget);
}
@@ -2563,10 +2551,14 @@
return actual_viewport_end_point - viewport_point;
}
-static gfx::Vector2dF ScrollLayerWithLocalDelta(LayerImpl* layer_impl,
- const gfx::Vector2dF& local_delta) {
+static gfx::Vector2dF ScrollLayerWithLocalDelta(
+ LayerImpl* layer_impl,
+ const gfx::Vector2dF& local_delta,
+ float page_scale_factor) {
gfx::Vector2dF previous_delta(layer_impl->ScrollDelta());
- layer_impl->ScrollBy(local_delta);
+ gfx::Vector2dF delta = local_delta;
+ delta.Scale(1.f / page_scale_factor);
+ layer_impl->ScrollBy(delta);
return layer_impl->ScrollDelta() - previous_delta;
}
@@ -2644,7 +2636,8 @@
// Gesture events need to be transformed from viewport coordinates to local
// layer coordinates so that the scrolling contents exactly follow the
// user's finger. In contrast, wheel events represent a fixed amount of
- // scrolling so we can just apply them directly.
+ // scrolling so we can just apply them directly, but the page scale factor
+ // is applied to the scroll delta.
if (!wheel_scrolling_) {
float scale_from_viewport_to_screen_space = device_scale_factor_;
applied_delta =
@@ -2652,7 +2645,8 @@
scale_from_viewport_to_screen_space,
viewport_point, pending_delta);
} else {
- applied_delta = ScrollLayerWithLocalDelta(layer_impl, pending_delta);
+ applied_delta = ScrollLayerWithLocalDelta(
+ layer_impl, pending_delta, active_tree_->total_page_scale_factor());
}
const float kEpsilon = 0.1f;
@@ -2774,7 +2768,8 @@
gfx::Vector2dF delta = gfx::Vector2dF(0.f, page);
- gfx::Vector2dF applied_delta = ScrollLayerWithLocalDelta(layer_impl, delta);
+ gfx::Vector2dF applied_delta =
+ ScrollLayerWithLocalDelta(layer_impl, delta, 1.f);
if (!applied_delta.IsZero()) {
client_->SetNeedsCommitOnImplThread();
@@ -3251,9 +3246,9 @@
// task), fall back to physical time. This should still be monotonic.
if (current_begin_frame_args_.IsValid())
return current_begin_frame_args_;
- return BeginFrameArgs::Create(gfx::FrameTime::Now(), base::TimeTicks(),
- BeginFrameArgs::DefaultInterval(),
- BeginFrameArgs::NORMAL);
+ return BeginFrameArgs::Create(
+ BEGINFRAME_FROM_HERE, gfx::FrameTime::Now(), base::TimeTicks(),
+ BeginFrameArgs::DefaultInterval(), BeginFrameArgs::NORMAL);
}
scoped_refptr<base::debug::ConvertableToTraceFormat>
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index d1b29ca..900e658 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -481,8 +481,6 @@
// Only valid for synchronous (non-scheduled) single-threaded case.
void SynchronouslyInitializeAllTiles();
- bool CanUseZeroCopyRasterizer() const;
- bool CanUseOneCopyRasterizer() const;
virtual void CreateResourceAndRasterWorkerPool(
scoped_ptr<RasterWorkerPool>* raster_worker_pool,
scoped_ptr<ResourcePool>* resource_pool,
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 7151689..4e070e2 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -945,7 +945,7 @@
}
// Scrolling after a pinch gesture should always be in local space. The
- // scroll deltas do not have the page scale factor applied.
+ // scroll deltas have the page scale factor applied.
{
host_impl_->active_tree()->SetPageScaleFactorAndLimits(
page_scale_factor, min_page_scale, max_page_scale);
@@ -968,9 +968,8 @@
scoped_ptr<ScrollAndScaleSet> scroll_info =
host_impl_->ProcessScrollDeltas();
- ExpectContains(*scroll_info.get(),
- scroll_layer->id(),
- scroll_delta);
+ ExpectContains(*scroll_info.get(), scroll_layer->id(),
+ gfx::Vector2d(0, scroll_delta.y() / page_scale_delta));
}
}
@@ -1395,7 +1394,8 @@
0) {}
BeginFrameArgs CurrentBeginFrameArgs() const override {
- return CreateBeginFrameArgsForTesting(fake_current_physical_time_);
+ return CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE,
+ fake_current_physical_time_);
}
void SetCurrentPhysicalTimeTicksForTest(base::TimeTicks fake_now) {
@@ -3596,7 +3596,7 @@
host_impl_->ScrollBy(gfx::Point(), wheel_scroll_delta);
host_impl_->ScrollEnd();
- // The scale should not have been applied to the scroll delta.
+ // It should apply the scale factor to the scroll delta for the wheel event.
scroll_info = host_impl_->ProcessScrollDeltas();
ExpectContains(*scroll_info.get(),
scroll_layer->id(),
@@ -7800,6 +7800,41 @@
EXPECT_EQ(1u, raw_replica_mask_layer->did_become_active_call_count());
}
+TEST_F(LayerTreeHostImplTest, WheelScrollWithPageScaleFactorOnInnerLayer) {
+ LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
+ host_impl_->SetViewportSize(gfx::Size(50, 50));
+ DrawFrame();
+
+ EXPECT_EQ(scroll_layer, host_impl_->InnerViewportScrollLayer());
+
+ float min_page_scale = 1.f, max_page_scale = 4.f;
+ float page_scale_factor = 1.f;
+
+ // The scroll deltas should have the page scale factor applied.
+ {
+ host_impl_->active_tree()->SetPageScaleFactorAndLimits(
+ page_scale_factor, min_page_scale, max_page_scale);
+ host_impl_->active_tree()->SetPageScaleDelta(1.f);
+ scroll_layer->SetScrollDelta(gfx::Vector2d());
+
+ float page_scale_delta = 2.f;
+ host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture);
+ host_impl_->PinchGestureBegin();
+ host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point());
+ host_impl_->PinchGestureEnd();
+ host_impl_->ScrollEnd();
+
+ gfx::Vector2dF scroll_delta(0, 5);
+ EXPECT_EQ(InputHandler::ScrollStarted,
+ host_impl_->ScrollBegin(gfx::Point(), InputHandler::Wheel));
+ EXPECT_VECTOR_EQ(gfx::Vector2dF(), scroll_layer->TotalScrollOffset());
+
+ host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+ host_impl_->ScrollEnd();
+ EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 2.5), scroll_layer->TotalScrollOffset());
+ }
+}
+
class LayerTreeHostImplCountingLostSurfaces : public LayerTreeHostImplTest {
public:
LayerTreeHostImplCountingLostSurfaces() : num_lost_surfaces_(0) {}
diff --git a/cc/trees/layer_tree_host_pixeltest_masks.cc b/cc/trees/layer_tree_host_pixeltest_masks.cc
index c494914..1235e15 100644
--- a/cc/trees/layer_tree_host_pixeltest_masks.cc
+++ b/cc/trees/layer_tree_host_pixeltest_masks.cc
@@ -47,6 +47,13 @@
}
}
+ scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
+ const gfx::Rect& clip,
+ GraphicsContextStatus gc_status) override {
+ NOTIMPLEMENTED();
+ return DisplayItemList::Create();
+ }
+
private:
gfx::Size bounds_;
};
diff --git a/cc/trees/layer_tree_host_pixeltest_on_demand_raster.cc b/cc/trees/layer_tree_host_pixeltest_on_demand_raster.cc
index e7dd149..a5ccb8b 100644
--- a/cc/trees/layer_tree_host_pixeltest_on_demand_raster.cc
+++ b/cc/trees/layer_tree_host_pixeltest_on_demand_raster.cc
@@ -80,6 +80,13 @@
paint);
}
+ scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
+ const gfx::Rect& clip,
+ GraphicsContextStatus gc_status) override {
+ NOTIMPLEMENTED();
+ return DisplayItemList::Create();
+ }
+
private:
gfx::Rect layer_rect_;
};
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index f589c84..51c5d7e 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -1112,6 +1112,12 @@
if (test_layer_)
test_layer_->SetOpacity(0.f);
}
+ scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
+ const gfx::Rect& clip,
+ GraphicsContextStatus gc_status) override {
+ NOTIMPLEMENTED();
+ return DisplayItemList::Create();
+ }
bool FillsBoundsCompletely() const override { return false; }
private:
@@ -2321,6 +2327,13 @@
++paint_count_;
}
+ scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
+ const gfx::Rect& clip,
+ GraphicsContextStatus gc_status) override {
+ NOTIMPLEMENTED();
+ return DisplayItemList::Create();
+ }
+
bool FillsBoundsCompletely() const override { return false; }
private:
@@ -2591,6 +2604,13 @@
layer_->SetBounds(gfx::Size(2, 2));
}
+ scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
+ const gfx::Rect& clip,
+ GraphicsContextStatus gc_status) override {
+ NOTIMPLEMENTED();
+ return DisplayItemList::Create();
+ }
+
bool FillsBoundsCompletely() const override { return false; }
private:
@@ -5653,6 +5673,9 @@
TestWebGraphicsContext3D::Create();
context3d->set_support_image(true);
context3d->set_support_sync_query(true);
+#if defined(OS_MACOSX)
+ context3d->set_support_texture_rectangle(true);
+#endif
if (delegating_renderer())
return FakeOutputSurface::CreateDelegating3d(context3d.Pass());
@@ -5840,4 +5863,59 @@
MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousDrawWhenCreatingVisibleTiles);
+class LayerTreeHostTestOneActivatePerManageTiles : public LayerTreeHostTest {
+ public:
+ LayerTreeHostTestOneActivatePerManageTiles()
+ : notify_ready_to_activate_count_(0u), scheduled_manage_tiles_count_(0) {}
+
+ void SetupTree() override {
+ client_.set_fill_with_nonsolid_color(true);
+ scoped_refptr<FakePictureLayer> root_layer =
+ FakePictureLayer::Create(&client_);
+ root_layer->SetBounds(gfx::Size(1500, 1500));
+ root_layer->SetIsDrawable(true);
+
+ layer_tree_host()->SetRootLayer(root_layer);
+ LayerTreeHostTest::SetupTree();
+ }
+
+ void BeginTest() override {
+ layer_tree_host()->SetViewportSize(gfx::Size(16, 16));
+ PostSetNeedsCommitToMainThread();
+ }
+
+ void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
+ bool success) override {
+ ASSERT_TRUE(success);
+ host_impl->tile_manager()->SetScheduledRasterTaskLimitForTesting(1);
+ }
+
+ void NotifyReadyToActivateOnThread(LayerTreeHostImpl* impl) override {
+ ++notify_ready_to_activate_count_;
+ EndTestAfterDelayMs(100);
+ }
+
+ void ScheduledActionManageTiles() override {
+ ++scheduled_manage_tiles_count_;
+ }
+
+ void AfterTest() override {
+ // Expect at most a notification for each scheduled manage tiles, plus one
+ // for the initial commit (which doesn't go through scheduled actions).
+ // The reason this is not an equality is because depending on timing, we
+ // might get a manage tiles but not yet get a notification that we're
+ // ready to activate. The intent of a test is to ensure that we don't
+ // get more than one notification per manage tiles, so this is OK.
+ EXPECT_LE(notify_ready_to_activate_count_,
+ 1u + scheduled_manage_tiles_count_);
+ }
+
+ protected:
+ FakeContentLayerClient client_;
+ size_t notify_ready_to_activate_count_;
+ size_t scheduled_manage_tiles_count_;
+};
+
+MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestOneActivatePerManageTiles);
+
} // namespace cc
diff --git a/cc/trees/layer_tree_host_unittest_animation.cc b/cc/trees/layer_tree_host_unittest_animation.cc
index 8318192..f6bc4d9 100644
--- a/cc/trees/layer_tree_host_unittest_animation.cc
+++ b/cc/trees/layer_tree_host_unittest_animation.cc
@@ -106,13 +106,12 @@
LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback);
// Add a layer animation and confirm that
-// LayerTreeHostImpl::updateAnimationState does get called and continues to
-// get called.
+// LayerTreeHostImpl::UpdateAnimationState does get called.
class LayerTreeHostAnimationTestAddAnimation
: public LayerTreeHostAnimationTest {
public:
LayerTreeHostAnimationTestAddAnimation()
- : num_begin_frames_(0), received_animation_started_notification_(false) {}
+ : update_animation_state_was_called_(false) {}
void BeginTest() override {
PostAddInstantAnimationToMainThread(layer_tree_host()->root_layer());
@@ -120,53 +119,28 @@
void UpdateAnimationState(LayerTreeHostImpl* host_impl,
bool has_unfinished_animation) override {
- if (!num_begin_frames_) {
- // The animation had zero duration so LayerTreeHostImpl should no
- // longer need to animate its layers.
- EXPECT_FALSE(has_unfinished_animation);
- num_begin_frames_++;
- return;
- }
-
- if (received_animation_started_notification_) {
- EXPECT_LT(base::TimeTicks(), start_time_);
-
- LayerAnimationController* controller_impl =
- host_impl->active_tree()->root_layer()->layer_animation_controller();
- Animation* animation_impl =
- controller_impl->GetAnimation(Animation::Opacity);
- if (animation_impl)
- controller_impl->RemoveAnimation(animation_impl->id());
-
- EndTest();
- }
+ EXPECT_FALSE(has_unfinished_animation);
+ update_animation_state_was_called_ = true;
}
void NotifyAnimationStarted(base::TimeTicks monotonic_time,
Animation::TargetProperty target_property,
int group) override {
- received_animation_started_notification_ = true;
- start_time_ = monotonic_time;
- if (num_begin_frames_) {
- EXPECT_LT(base::TimeTicks(), start_time_);
+ EXPECT_LT(base::TimeTicks(), monotonic_time);
- LayerAnimationController* controller =
- layer_tree_host()->root_layer()->layer_animation_controller();
- Animation* animation =
- controller->GetAnimation(Animation::Opacity);
- if (animation)
- controller->RemoveAnimation(animation->id());
+ LayerAnimationController* controller =
+ layer_tree_host()->root_layer()->layer_animation_controller();
+ Animation* animation = controller->GetAnimation(Animation::Opacity);
+ if (animation)
+ controller->RemoveAnimation(animation->id());
- EndTest();
- }
+ EndTest();
}
- void AfterTest() override {}
+ void AfterTest() override { EXPECT_TRUE(update_animation_state_was_called_); }
private:
- int num_begin_frames_;
- bool received_animation_started_notification_;
- base::TimeTicks start_time_;
+ bool update_animation_state_was_called_;
};
SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestAddAnimation);
@@ -531,9 +505,7 @@
class LayerTreeHostAnimationTestSynchronizeAnimationStartTimes
: public LayerTreeHostAnimationTest {
public:
- LayerTreeHostAnimationTestSynchronizeAnimationStartTimes()
- : main_start_time_(-1.0),
- impl_start_time_(-1.0) {}
+ LayerTreeHostAnimationTestSynchronizeAnimationStartTimes() {}
void SetupTree() override {
LayerTreeHostAnimationTest::SetupTree();
@@ -553,12 +525,9 @@
layer_animation_controller();
Animation* animation =
controller->GetAnimation(Animation::Opacity);
- main_start_time_ =
- (animation->start_time() - base::TimeTicks()).InSecondsF();
+ main_start_time_ = animation->start_time();
controller->RemoveAnimation(animation->id());
-
- if (impl_start_time_ > 0.0)
- EndTest();
+ EndTest();
}
void UpdateAnimationState(LayerTreeHostImpl* impl_host,
@@ -571,21 +540,17 @@
if (!animation)
return;
- impl_start_time_ =
- (animation->start_time() - base::TimeTicks()).InSecondsF();
- controller->RemoveAnimation(animation->id());
-
- if (main_start_time_ > 0.0)
- EndTest();
+ impl_start_time_ = animation->start_time();
}
void AfterTest() override {
- EXPECT_FLOAT_EQ(impl_start_time_, main_start_time_);
+ EXPECT_EQ(impl_start_time_, main_start_time_);
+ EXPECT_LT(base::TimeTicks(), impl_start_time_);
}
private:
- double main_start_time_;
- double impl_start_time_;
+ base::TimeTicks main_start_time_;
+ base::TimeTicks impl_start_time_;
FakeContentLayerClient client_;
scoped_refptr<FakeContentLayer> content_;
};
diff --git a/cc/trees/layer_tree_settings.cc b/cc/trees/layer_tree_settings.cc
index e792427..0771eb8 100644
--- a/cc/trees/layer_tree_settings.cc
+++ b/cc/trees/layer_tree_settings.cc
@@ -61,10 +61,13 @@
strict_layer_property_change_checking(false),
use_one_copy(false),
use_zero_copy(false),
+ use_image_external(false),
ignore_root_layer_flings(false),
scheduled_raster_task_limit(32),
use_occlusion_for_tile_prioritization(false),
- record_full_layer(false) {
+ record_full_layer(false),
+ use_display_lists(false),
+ main_thread_should_always_be_low_latency(false) {
}
LayerTreeSettings::~LayerTreeSettings() {}
diff --git a/cc/trees/layer_tree_settings.h b/cc/trees/layer_tree_settings.h
index ebbe7f7..438344b 100644
--- a/cc/trees/layer_tree_settings.h
+++ b/cc/trees/layer_tree_settings.h
@@ -73,10 +73,13 @@
bool strict_layer_property_change_checking;
bool use_one_copy;
bool use_zero_copy;
+ bool use_image_external;
bool ignore_root_layer_flings;
size_t scheduled_raster_task_limit;
bool use_occlusion_for_tile_prioritization;
bool record_full_layer;
+ bool use_display_lists;
+ bool main_thread_should_always_be_low_latency;
LayerTreeDebugState initial_debug_state;
};
diff --git a/cc/trees/single_thread_proxy.cc b/cc/trees/single_thread_proxy.cc
index 5a40d7e..9a13457 100644
--- a/cc/trees/single_thread_proxy.cc
+++ b/cc/trees/single_thread_proxy.cc
@@ -430,9 +430,8 @@
// equivalent of blocking commit until activation and also running
// all tasks posted during commit/activation before CommitComplete.
MainThreadTaskRunner()->PostTask(
- FROM_HERE,
- base::Bind(&SingleThreadProxy::CommitComplete,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::Bind(&SingleThreadProxy::CommitComplete,
+ weak_factory_.GetWeakPtr()));
}
timing_history_.DidActivateSyncTree();
@@ -493,8 +492,8 @@
{
BeginFrameArgs begin_frame_args(BeginFrameArgs::Create(
- frame_begin_time, base::TimeTicks(), BeginFrameArgs::DefaultInterval(),
- BeginFrameArgs::SYNCHRONOUS));
+ BEGINFRAME_FROM_HERE, frame_begin_time, base::TimeTicks(),
+ BeginFrameArgs::DefaultInterval(), BeginFrameArgs::SYNCHRONOUS));
DoBeginMainFrame(begin_frame_args);
DoCommit();
