Roll Chrome into Mojo.
Update from https://crrev.com/313321
This roll is to pick up a fix which prevents -Wl,--as-needed being used
in Release ASAN builds.
This also has some manual changes to mojo only code to fix interface
changes from chromium (mainly, changes in skia interfaces, and changes
in cc). It updates a cc patch, which started failing to apply I also
added patch files to deal with the upstream move of mojo to
third_party/mojo/.
BUG=452105
TBR=jamesr@chromium.org
Review URL: https://codereview.chromium.org/885443002
diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index 2a8951b..eee115c 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -80,6 +80,8 @@
"debug/devtools_instrumentation.h",
"debug/frame_rate_counter.cc",
"debug/frame_rate_counter.h",
+ "debug/frame_timing_request.cc",
+ "debug/frame_timing_request.h",
"debug/frame_timing_tracker.cc",
"debug/frame_timing_tracker.h",
"debug/frame_viewer_instrumentation.cc",
@@ -394,6 +396,10 @@
"resources/raster_source.h",
"resources/raster_source_helper.cc",
"resources/raster_source_helper.h",
+ "resources/raster_tile_priority_queue_all.cc",
+ "resources/raster_tile_priority_queue_all.h",
+ "resources/raster_tile_priority_queue_required.cc",
+ "resources/raster_tile_priority_queue_required.h",
"resources/raster_tile_priority_queue.cc",
"resources/raster_tile_priority_queue.h",
"resources/rasterizer.h",
@@ -456,7 +462,6 @@
"resources/tiling_set_raster_queue_all.h",
"resources/tiling_set_raster_queue_required.cc",
"resources/tiling_set_raster_queue_required.h",
- "resources/tiling_set_raster_queue.h",
"resources/transferable_resource.cc",
"resources/transferable_resource.h",
"resources/transform_display_item.cc",
diff --git a/cc/blink/web_content_layer_impl.cc b/cc/blink/web_content_layer_impl.cc
index 5bd3667..abe3eb3 100644
--- a/cc/blink/web_content_layer_impl.cc
+++ b/cc/blink/web_content_layer_impl.cc
@@ -54,11 +54,8 @@
if (!client_)
return;
- // TODO(danakj): Stop passing this to blink it should always use LCD when it
- // wants to. crbug.com/430617
- bool can_use_lcd_text = true;
client_->paintContents(
- canvas, clip, can_use_lcd_text,
+ canvas, clip,
graphics_context_status == ContentLayerClient::GRAPHICS_CONTEXT_ENABLED
? blink::WebContentLayerClient::GraphicsContextEnabled
: blink::WebContentLayerClient::GraphicsContextDisabled);
@@ -72,9 +69,8 @@
return cc::DisplayItemList::Create();
WebDisplayItemListImpl list;
- bool can_use_lcd_text = true;
client_->paintContents(
- &list, clip, can_use_lcd_text,
+ &list, clip,
graphics_context_status == ContentLayerClient::GRAPHICS_CONTEXT_ENABLED
? blink::WebContentLayerClient::GraphicsContextEnabled
: blink::WebContentLayerClient::GraphicsContextDisabled);
diff --git a/cc/cc.gyp b/cc/cc.gyp
index 69d1907..49d2f64 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -106,6 +106,8 @@
'debug/devtools_instrumentation.h',
'debug/frame_rate_counter.cc',
'debug/frame_rate_counter.h',
+ 'debug/frame_timing_request.cc',
+ 'debug/frame_timing_request.h',
'debug/frame_timing_tracker.cc',
'debug/frame_timing_tracker.h',
'debug/frame_viewer_instrumentation.cc',
@@ -427,6 +429,10 @@
'resources/raster_source.h',
'resources/raster_source_helper.cc',
'resources/raster_source_helper.h',
+ 'resources/raster_tile_priority_queue_all.cc',
+ 'resources/raster_tile_priority_queue_all.h',
+ 'resources/raster_tile_priority_queue_required.cc',
+ 'resources/raster_tile_priority_queue_required.h',
'resources/raster_tile_priority_queue.cc',
'resources/raster_tile_priority_queue.h',
'resources/rasterizer.h',
@@ -490,7 +496,6 @@
'resources/tiling_set_raster_queue_all.h',
'resources/tiling_set_raster_queue_required.cc',
'resources/tiling_set_raster_queue_required.h',
- 'resources/tiling_set_raster_queue.h',
'resources/transferable_resource.cc',
'resources/transferable_resource.h',
'resources/transform_display_item.cc',
diff --git a/cc/cc_tests.gyp b/cc/cc_tests.gyp
index 74cb1bf..49337bc 100644
--- a/cc/cc_tests.gyp
+++ b/cc/cc_tests.gyp
@@ -444,6 +444,23 @@
},
],
}
- ]
+ ],
+ ['test_isolation_mode != "noop"', {
+ 'targets': [
+ {
+ 'target_name': 'cc_unittests_run',
+ 'type': 'none',
+ 'dependencies': [
+ 'cc_unittests',
+ ],
+ 'includes': [
+ '../build/isolate.gypi',
+ ],
+ 'sources': [
+ 'cc_unittests.isolate',
+ ],
+ },
+ ],
+ }],
],
}
diff --git a/cc/cc_unittests.isolate b/cc/cc_unittests.isolate
new file mode 100644
index 0000000..4e5ac92
--- /dev/null
+++ b/cc/cc_unittests.isolate
@@ -0,0 +1,83 @@
+# Copyright 2015 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.
+{
+ 'conditions': [
+ ['OS=="linux" or OS=="mac" or OS=="win"', {
+ 'variables': {
+ 'files': [
+ 'test/data/',
+ '../testing/test_env.py',
+ '<(PRODUCT_DIR)/cc_unittests<(EXECUTABLE_SUFFIX)',
+ ],
+ },
+ }],
+ ['OS=="linux"', {
+ 'variables': {
+ 'command': [
+ '../testing/xvfb.py',
+ '<(PRODUCT_DIR)',
+ '<(PRODUCT_DIR)/cc_unittests',
+ '--brave-new-test-launcher',
+ '--test-launcher-bot-mode',
+ '--asan=<(asan)',
+ '--lsan=<(lsan)',
+ ],
+ 'files': [
+ '../testing/xvfb.py',
+ '<(PRODUCT_DIR)/libffmpegsumo.so',
+ '<(PRODUCT_DIR)/libosmesa.so',
+ ],
+ },
+ }],
+ ['OS=="linux" and use_ozone==0', {
+ 'variables': {
+ 'files': [
+ '<(PRODUCT_DIR)/xdisplaycheck',
+ ],
+ },
+ }],
+ ['OS=="mac"', {
+ 'variables': {
+ 'command': [
+ '../testing/test_env.py',
+ '<(PRODUCT_DIR)/cc_unittests',
+ '--brave-new-test-launcher',
+ '--test-launcher-bot-mode',
+ '--asan=<(asan)',
+ '--lsan=<(lsan)',
+ ],
+ 'files': [
+ '<(PRODUCT_DIR)/ffmpegsumo.so',
+ '<(PRODUCT_DIR)/osmesa.so',
+ ],
+ },
+ }],
+ ['OS=="win"', {
+ 'variables': {
+ 'command': [
+ '../testing/test_env.py',
+ '<(PRODUCT_DIR)/cc_unittests.exe',
+ '--brave-new-test-launcher',
+ '--test-launcher-bot-mode',
+ '--asan=<(asan)',
+ '--lsan=<(lsan)',
+ ],
+ 'files': [
+ '<(PRODUCT_DIR)/ffmpegsumo.dll',
+ '<(PRODUCT_DIR)/osmesa.dll',
+ ],
+ },
+ }],
+ ['OS=="win" and (fastbuild==0 or fastbuild==1)', {
+ 'variables': {
+ 'files': [
+ '<(PRODUCT_DIR)/cc_unittests.exe.pdb',
+ ],
+ },
+ }],
+ ],
+ 'includes': [
+ '../base/base.isolate',
+ ],
+}
diff --git a/cc/debug/frame_timing_request.cc b/cc/debug/frame_timing_request.cc
new file mode 100644
index 0000000..6c54ea2
--- /dev/null
+++ b/cc/debug/frame_timing_request.cc
@@ -0,0 +1,17 @@
+// Copyright 2015 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/debug/frame_timing_request.h"
+
+namespace cc {
+
+FrameTimingRequest::FrameTimingRequest() : id_(0) {
+}
+
+FrameTimingRequest::FrameTimingRequest(int64_t request_id,
+ const gfx::Rect& rect)
+ : id_(request_id), rect_(rect) {
+}
+
+} // namespace cc
diff --git a/cc/debug/frame_timing_request.h b/cc/debug/frame_timing_request.h
new file mode 100644
index 0000000..7ab97de
--- /dev/null
+++ b/cc/debug/frame_timing_request.h
@@ -0,0 +1,31 @@
+// Copyright 2015 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_DEBUG_FRAME_TIMING_REQUEST_H_
+#define CC_DEBUG_FRAME_TIMING_REQUEST_H_
+
+#include "ui/gfx/geometry/rect.h"
+
+namespace cc {
+
+// This class represents a request to record frame timing information about the
+// given rect (in layer space) and an associated request id. When this request
+// is propagated to the active LayerImpl, it will cause events to be saved in
+// FrameTimingTracker, which in turn can be consumed by the requester.
+class FrameTimingRequest {
+ public:
+ FrameTimingRequest();
+ FrameTimingRequest(int64_t request_id, const gfx::Rect& rect);
+
+ int64_t id() const { return id_; }
+ const gfx::Rect& rect() const { return rect_; }
+
+ private:
+ int64_t id_;
+ gfx::Rect rect_;
+};
+
+} // namespace cc
+
+#endif // CC_DEBUG_FRAME_TIMING_REQUEST_H_
diff --git a/cc/debug/lap_timer.cc b/cc/debug/lap_timer.cc
index 27aaf34..10d26f9 100644
--- a/cc/debug/lap_timer.cc
+++ b/cc/debug/lap_timer.cc
@@ -11,9 +11,8 @@
namespace {
base::TimeTicks Now() {
- return base::TimeTicks::IsThreadNowSupported()
- ? base::TimeTicks::ThreadNow()
- : base::TimeTicks::HighResNow();
+ return base::TimeTicks::IsThreadNowSupported() ? base::TimeTicks::ThreadNow()
+ : base::TimeTicks::Now();
}
} // namespace
diff --git a/cc/debug/picture_record_benchmark.cc b/cc/debug/picture_record_benchmark.cc
index cc01448..d0d031d 100644
--- a/cc/debug/picture_record_benchmark.cc
+++ b/cc/debug/picture_record_benchmark.cc
@@ -104,12 +104,12 @@
for (int x = 0; x < x_limit; x += kPositionIncrement) {
gfx::Rect rect = gfx::Rect(x, y, width, height);
- base::TimeTicks start = base::TimeTicks::HighResNow();
+ base::TimeTicks start = base::TimeTicks::Now();
scoped_refptr<Picture> picture = Picture::Create(
rect, painter, tile_grid_size, false, Picture::RECORD_NORMALLY);
- base::TimeTicks end = base::TimeTicks::HighResNow();
+ base::TimeTicks end = base::TimeTicks::Now();
base::TimeDelta duration = end - start;
TotalTime& total_time = times_[dimensions];
total_time.first += duration;
diff --git a/cc/debug/rendering_stats_instrumentation.cc b/cc/debug/rendering_stats_instrumentation.cc
index c707e23..4a28a66 100644
--- a/cc/debug/rendering_stats_instrumentation.cc
+++ b/cc/debug/rendering_stats_instrumentation.cc
@@ -41,7 +41,7 @@
if (record_rendering_stats_) {
if (base::TimeTicks::IsThreadNowSupported())
return base::TimeTicks::ThreadNow();
- return base::TimeTicks::HighResNow();
+ return base::TimeTicks::Now();
}
return base::TimeTicks();
}
@@ -51,7 +51,7 @@
if (!start_time.is_null()) {
if (base::TimeTicks::IsThreadNowSupported())
return base::TimeTicks::ThreadNow() - start_time;
- return base::TimeTicks::HighResNow() - start_time;
+ return base::TimeTicks::Now() - start_time;
}
return base::TimeDelta();
}
diff --git a/cc/layers/delegated_renderer_layer_impl_unittest.cc b/cc/layers/delegated_renderer_layer_impl_unittest.cc
index 395d361..aaef9f2 100644
--- a/cc/layers/delegated_renderer_layer_impl_unittest.cc
+++ b/cc/layers/delegated_renderer_layer_impl_unittest.cc
@@ -769,9 +769,9 @@
&root_delegated_shared_quad_state,
&contrib_delegated_shared_quad_state);
- // When the layer owns a surface, then its position and translation are not
- // a part of its draw transform.
- EXPECT_EQ(gfx::Rect(10, 10, 35, 35).ToString(),
+ // When the layer owns a surface, then its translation is not part of its
+ // draw transform, but its scale is.
+ EXPECT_EQ(gfx::Rect(20, 20, 70, 70).ToString(),
root_delegated_shared_quad_state->clip_rect.ToString());
// Since the layer owns a surface it doesn't need to clip its quads, so
@@ -779,8 +779,9 @@
EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
gfx::Transform expected;
- // This is the transform within the source frame.
- expected.Scale(1.5, 1.5);
+ // This is the transform within the source frame scaled by the delegated
+ // render layer transform.
+ expected.Scale(3.0, 3.0);
expected.Translate(7.0, 7.0);
EXPECT_TRANSFORMATION_MATRIX_EQ(
expected, root_delegated_shared_quad_state->content_to_target_transform);
@@ -817,17 +818,18 @@
&root_delegated_shared_quad_state,
&contrib_delegated_shared_quad_state);
- // When the layer owns a surface, then its position and translation are not
- // a part of its draw transform. The clip_rect should be preserved.
- EXPECT_EQ(gfx::Rect(10, 10, 35, 35).ToString(),
+ // When the layer owns a surface, then its translation is not part of its
+ // draw transform, but its scale is.
+ EXPECT_EQ(gfx::Rect(20, 20, 70, 70).ToString(),
root_delegated_shared_quad_state->clip_rect.ToString());
// The quads had a clip and it should be preserved.
EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
gfx::Transform expected;
- // This is the transform within the source frame.
- expected.Scale(1.5, 1.5);
+ // This is the transform within the source frame scaled by the delegated
+ // render layer transform.
+ expected.Scale(3.0, 3.0);
expected.Translate(7.0, 7.0);
EXPECT_TRANSFORMATION_MATRIX_EQ(
expected, root_delegated_shared_quad_state->content_to_target_transform);
diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index 45e8a83..feb23fa 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -78,7 +78,8 @@
clip_parent_(nullptr),
replica_layer_(nullptr),
raster_scale_(0.f),
- client_(nullptr) {
+ client_(nullptr),
+ frame_timing_requests_dirty_(false) {
layer_animation_controller_ = LayerAnimationController::Create(layer_id_);
layer_animation_controller_->AddValueObserver(this);
layer_animation_controller_->set_value_provider(this);
@@ -1013,6 +1014,11 @@
layer_animation_controller_->PushAnimationUpdatesTo(
layer->layer_animation_controller());
+ if (frame_timing_requests_dirty_) {
+ layer->PassFrameTimingRequests(&frame_timing_requests_);
+ frame_timing_requests_dirty_ = false;
+ }
+
// Reset any state that should be cleared for the next update.
stacking_order_changed_ = false;
update_rect_ = gfx::Rect();
@@ -1287,4 +1293,11 @@
return xform;
}
+void Layer::SetFrameTimingRequests(
+ const std::vector<FrameTimingRequest>& requests) {
+ frame_timing_requests_ = requests;
+ frame_timing_requests_dirty_ = true;
+ SetNeedsCommit();
+}
+
} // namespace cc
diff --git a/cc/layers/layer.h b/cc/layers/layer.h
index 017df68..e434412 100644
--- a/cc/layers/layer.h
+++ b/cc/layers/layer.h
@@ -7,6 +7,7 @@
#include <set>
#include <string>
+#include <vector>
#include "base/callback.h"
#include "base/memory/ref_counted.h"
@@ -17,6 +18,7 @@
#include "cc/base/cc_export.h"
#include "cc/base/region.h"
#include "cc/base/scoped_ptr_vector.h"
+#include "cc/debug/frame_timing_request.h"
#include "cc/debug/micro_benchmark.h"
#include "cc/layers/draw_properties.h"
#include "cc/layers/layer_lists.h"
@@ -505,6 +507,9 @@
return has_render_surface_;
}
+ // Sets new frame timing requests for this layer.
+ void SetFrameTimingRequests(const std::vector<FrameTimingRequest>& requests);
+
protected:
friend class LayerImpl;
friend class TreeSynchronizer;
@@ -697,6 +702,10 @@
scoped_ptr<RenderSurface> render_surface_;
gfx::Rect visible_rect_from_property_trees_;
+
+ std::vector<FrameTimingRequest> frame_timing_requests_;
+ bool frame_timing_requests_dirty_;
+
DISALLOW_COPY_AND_ASSIGN(Layer);
};
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index 5bef67d..d099a63 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -70,7 +70,8 @@
needs_push_properties_(false),
num_dependents_need_push_properties_(0),
sorting_context_id_(0),
- current_draw_mode_(DRAW_MODE_NONE) {
+ current_draw_mode_(DRAW_MODE_NONE),
+ frame_timing_requests_dirty_(false) {
DCHECK_GT(layer_id_, 0);
DCHECK(layer_tree_impl_);
layer_tree_impl_->RegisterLayer(this);
@@ -607,6 +608,11 @@
layer->SetStackingOrderChanged(stacking_order_changed_);
layer->SetDebugInfo(debug_info_);
+ if (frame_timing_requests_dirty_) {
+ layer->PassFrameTimingRequests(&frame_timing_requests_);
+ frame_timing_requests_dirty_ = false;
+ }
+
// Reset any state that should be cleared for the next update.
stacking_order_changed_ = false;
update_rect_ = gfx::Rect();
@@ -1024,6 +1030,13 @@
NoteLayerPropertyChangedForSubtree();
}
+void LayerImpl::PassFrameTimingRequests(
+ std::vector<FrameTimingRequest>* requests) {
+ frame_timing_requests_.swap(*requests);
+ frame_timing_requests_dirty_ = true;
+ SetNeedsPushProperties();
+}
+
void LayerImpl::SetTransform(const gfx::Transform& transform) {
if (transform_ == transform)
return;
@@ -1552,6 +1565,17 @@
NOTREACHED();
}
}
+
+ if (!frame_timing_requests_.empty()) {
+ state->BeginArray("frame_timing_requests");
+ for (const auto& request : frame_timing_requests_) {
+ state->BeginDictionary();
+ state->SetInteger("request_id", request.id());
+ MathUtil::AddToTracedValue("request_rect", request.rect(), state);
+ state->EndDictionary();
+ }
+ state->EndArray();
+ }
}
bool LayerImpl::IsDrawnRenderSurfaceLayerListMember() const {
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index d1cf053..f52b5de 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -7,6 +7,7 @@
#include <set>
#include <string>
+#include <vector>
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
@@ -18,6 +19,7 @@
#include "cc/base/cc_export.h"
#include "cc/base/region.h"
#include "cc/base/scoped_ptr_vector.h"
+#include "cc/debug/frame_timing_request.h"
#include "cc/input/input_handler.h"
#include "cc/input/scrollbar.h"
#include "cc/layers/draw_properties.h"
@@ -566,6 +568,12 @@
void Set3dSortingContextId(int id);
int sorting_context_id() { return sorting_context_id_; }
+ void PassFrameTimingRequests(
+ std::vector<FrameTimingRequest>* frame_timing_requests);
+ const std::vector<FrameTimingRequest>& frame_timing_requests() const {
+ return frame_timing_requests_;
+ }
+
protected:
LayerImpl(LayerTreeImpl* layer_impl, int id);
@@ -720,6 +728,10 @@
scoped_refptr<base::debug::ConvertableToTraceFormat> debug_info_;
scoped_ptr<RenderSurfaceImpl> render_surface_;
+
+ std::vector<FrameTimingRequest> frame_timing_requests_;
+ bool frame_timing_requests_dirty_;
+
DISALLOW_COPY_AND_ASSIGN(LayerImpl);
};
diff --git a/cc/layers/picture_layer.cc b/cc/layers/picture_layer.cc
index 98e8dcb..a55318e 100644
--- a/cc/layers/picture_layer.cc
+++ b/cc/layers/picture_layer.cc
@@ -85,12 +85,11 @@
if (host->settings().use_display_lists) {
recording_source_.reset(new DisplayListRecordingSource);
} else {
- recording_source_.reset(new PicturePile);
+ recording_source_.reset(
+ new PicturePile(host->settings().minimum_contents_scale,
+ host->settings().default_tile_grid_size));
}
}
- recording_source_->SetMinContentsScale(
- host->settings().minimum_contents_scale);
- recording_source_->SetTileGridSize(host->settings().default_tile_grid_size);
recording_source_->SetSlowdownRasterScaleFactor(
host->debug_state().slow_down_raster_scale_factor);
}
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 3dbce3c..813bc47 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -82,7 +82,6 @@
low_res_raster_contents_scale_(0.f),
raster_source_scale_is_fixed_(false),
was_screen_space_transform_animating_(false),
- should_update_tile_priorities_(false),
only_used_low_res_last_append_quads_(false),
is_mask_(is_mask),
nearest_neighbor_(false) {
@@ -462,8 +461,6 @@
if (draw_transform_is_animating())
raster_source_->SetShouldAttemptToUseDistanceFieldText();
- should_update_tile_priorities_ = true;
-
return UpdateTilePriorities(occlusion_in_content_space);
}
@@ -557,6 +554,9 @@
invalidation_.Swap(new_invalidation);
bool can_have_tilings = CanHaveTilings();
+ DCHECK_IMPLIES(
+ pending_set,
+ can_have_tilings == GetPendingOrActiveTwinLayer()->CanHaveTilings());
// Need to call UpdateTiles again if CanHaveTilings changed.
if (could_have_tilings != can_have_tilings)
@@ -589,9 +589,8 @@
void PictureLayerImpl::ReleaseResources() {
// Recreate tilings with new settings, since some of those might change when
- // we release resources. If tilings_ is null, then leave it as null.
- if (tilings_)
- tilings_ = CreatePictureLayerTilingSet();
+ // we release resources.
+ tilings_ = CreatePictureLayerTilingSet();
ResetRasterScale();
// To avoid an edge case after lost context where the tree is up to date but
@@ -784,8 +783,7 @@
}
void PictureLayerImpl::RemoveAllTilings() {
- if (tilings_)
- tilings_->RemoveAllTilings();
+ tilings_->RemoveAllTilings();
// If there are no tilings, then raster scales are no longer meaningful.
ResetRasterScale();
}
@@ -1076,10 +1074,6 @@
raster_contents_scale_ = 0.f;
low_res_raster_contents_scale_ = 0.f;
raster_source_scale_is_fixed_ = false;
-
- // When raster scales aren't valid, don't update tile priorities until
- // this layer has been updated via UpdateDrawProperties.
- should_update_tile_priorities_ = false;
}
bool PictureLayerImpl::CanHaveTilings() const {
diff --git a/cc/layers/picture_layer_impl.h b/cc/layers/picture_layer_impl.h
index e6554cd..86f1424 100644
--- a/cc/layers/picture_layer_impl.h
+++ b/cc/layers/picture_layer_impl.h
@@ -158,9 +158,6 @@
bool raster_source_scale_is_fixed_;
bool was_screen_space_transform_animating_;
- // A sanity state check to make sure UpdateTilePriorities only gets called
- // after a CalculateContentsScale/ManageTilings.
- bool should_update_tile_priorities_;
bool only_used_low_res_last_append_quads_;
const bool is_mask_;
diff --git a/cc/layers/picture_layer_impl_perftest.cc b/cc/layers/picture_layer_impl_perftest.cc
index c1c0dbb..c649e69 100644
--- a/cc/layers/picture_layer_impl_perftest.cc
+++ b/cc/layers/picture_layer_impl_perftest.cc
@@ -77,7 +77,7 @@
timer_.Reset();
do {
int count = num_tiles;
- scoped_ptr<TilingSetRasterQueue> queue(new TilingSetRasterQueueAll(
+ scoped_ptr<TilingSetRasterQueueAll> queue(new TilingSetRasterQueueAll(
pending_layer_->picture_layer_tiling_set(), false));
while (count--) {
ASSERT_TRUE(!queue->IsEmpty()) << "count: " << count;
@@ -100,7 +100,7 @@
timer_.Reset();
do {
- scoped_ptr<TilingSetRasterQueue> queue(new TilingSetRasterQueueAll(
+ scoped_ptr<TilingSetRasterQueueAll> queue(new TilingSetRasterQueueAll(
pending_layer_->picture_layer_tiling_set(), false));
timer_.NextLap();
} while (!timer_.HasTimeLimitExpired());
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index 0f4bf8d..79dfec6 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -1670,7 +1670,7 @@
int num_visible = 0;
int num_offscreen = 0;
- scoped_ptr<TilingSetRasterQueue> queue(new TilingSetRasterQueueAll(
+ scoped_ptr<TilingSetRasterQueueAll> queue(new TilingSetRasterQueueAll(
pending_layer_->picture_layer_tiling_set(), false));
for (; !queue->IsEmpty(); queue->Pop()) {
const Tile* tile = queue->Top();
@@ -2816,7 +2816,7 @@
int low_res_tile_count = 0u;
int high_res_tile_count = 0u;
int high_res_now_tiles = 0u;
- scoped_ptr<TilingSetRasterQueue> queue(new TilingSetRasterQueueAll(
+ scoped_ptr<TilingSetRasterQueueAll> queue(new TilingSetRasterQueueAll(
pending_layer_->picture_layer_tiling_set(), false));
while (!queue->IsEmpty()) {
Tile* tile = queue->Top();
@@ -2855,22 +2855,23 @@
EXPECT_EQ(low_res_tile_count + high_res_tile_count + non_ideal_tile_count,
static_cast<int>(unique_tiles.size()));
- queue.reset(new TilingSetRasterQueueRequired(
- pending_layer_->picture_layer_tiling_set(),
- RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW));
- EXPECT_TRUE(queue->IsEmpty());
+ scoped_ptr<TilingSetRasterQueueRequired> required_queue(
+ new TilingSetRasterQueueRequired(
+ pending_layer_->picture_layer_tiling_set(),
+ RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW));
+ EXPECT_TRUE(required_queue->IsEmpty());
- queue.reset(new TilingSetRasterQueueRequired(
+ required_queue.reset(new TilingSetRasterQueueRequired(
pending_layer_->picture_layer_tiling_set(),
RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION));
- EXPECT_FALSE(queue->IsEmpty());
+ EXPECT_FALSE(required_queue->IsEmpty());
int required_for_activation_count = 0;
- while (!queue->IsEmpty()) {
- Tile* tile = queue->Top();
+ while (!required_queue->IsEmpty()) {
+ Tile* tile = required_queue->Top();
EXPECT_TRUE(tile->required_for_activation());
EXPECT_FALSE(tile->IsReadyToDraw());
++required_for_activation_count;
- queue->Pop();
+ required_queue->Pop();
}
// All of the high res tiles should be required for activation, since there is
@@ -2968,9 +2969,10 @@
ActivateTree();
EXPECT_EQ(2u, active_layer_->num_tilings());
- scoped_ptr<TilingSetRasterQueue> queue(new TilingSetRasterQueueRequired(
- active_layer_->picture_layer_tiling_set(),
- RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW));
+ scoped_ptr<TilingSetRasterQueueRequired> queue(
+ new TilingSetRasterQueueRequired(
+ active_layer_->picture_layer_tiling_set(),
+ RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW));
EXPECT_FALSE(queue->IsEmpty());
while (!queue->IsEmpty()) {
Tile* tile = queue->Top();
@@ -2996,9 +2998,10 @@
pending_layer_->picture_layer_tiling_set()->FindTilingWithResolution(
HIGH_RESOLUTION));
- scoped_ptr<TilingSetRasterQueue> queue(new TilingSetRasterQueueRequired(
- pending_layer_->picture_layer_tiling_set(),
- RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION));
+ scoped_ptr<TilingSetRasterQueueRequired> queue(
+ new TilingSetRasterQueueRequired(
+ pending_layer_->picture_layer_tiling_set(),
+ RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION));
EXPECT_TRUE(queue->IsEmpty());
}
@@ -3973,7 +3976,7 @@
// No occlusion.
int unoccluded_tile_count = 0;
- scoped_ptr<TilingSetRasterQueue> queue(new TilingSetRasterQueueAll(
+ scoped_ptr<TilingSetRasterQueueAll> queue(new TilingSetRasterQueueAll(
pending_layer_->picture_layer_tiling_set(), false));
while (!queue->IsEmpty()) {
Tile* tile = queue->Top();
diff --git a/cc/layers/texture_layer.h b/cc/layers/texture_layer.h
index 15c9aa0..00c9e74 100644
--- a/cc/layers/texture_layer.h
+++ b/cc/layers/texture_layer.h
@@ -99,6 +99,7 @@
// Sets whether this texture should be Y-flipped at draw time. Defaults to
// true.
void SetFlipped(bool flipped);
+ bool flipped() const { return flipped_; }
// Sets whether this texture should use nearest neighbor interpolation as
// opposed to bilinear. Defaults to false.
diff --git a/cc/output/gl_renderer_unittest.cc b/cc/output/gl_renderer_unittest.cc
index 2ac339d..c5c1e4d 100644
--- a/cc/output/gl_renderer_unittest.cc
+++ b/cc/output/gl_renderer_unittest.cc
@@ -1378,6 +1378,54 @@
false);
}
+TEST_F(GLRendererTest, DrawFramePreservesFramebuffer) {
+ // When using render-to-FBO to display the surface, all rendering is done
+ // to a non-zero FBO. Make sure that the framebuffer is always restored to
+ // the correct framebuffer during rendering, if changed.
+ // Note: there is one path that will set it to 0, but that is after the render
+ // has finished.
+ FakeOutputSurfaceClient output_surface_client;
+ scoped_ptr<FakeOutputSurface> output_surface(
+ FakeOutputSurface::Create3d(TestWebGraphicsContext3D::Create().Pass()));
+ CHECK(output_surface->BindToClient(&output_surface_client));
+
+ scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
+ new TestSharedBitmapManager());
+ scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
+ output_surface.get(), shared_bitmap_manager.get(), NULL, NULL, 0, false,
+ 1));
+
+ RendererSettings settings;
+ FakeRendererClient renderer_client;
+ FakeRendererGL renderer(&renderer_client, &settings, output_surface.get(),
+ resource_provider.get());
+ EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
+
+ gfx::Rect device_viewport_rect(0, 0, 100, 100);
+ gfx::Rect viewport_rect(device_viewport_rect.size());
+ gfx::Rect quad_rect = gfx::Rect(20, 20, 20, 20);
+
+ RenderPassId root_pass_id(1, 0);
+ TestRenderPass* root_pass =
+ AddRenderPass(&render_passes_in_draw_order_, root_pass_id, viewport_rect,
+ gfx::Transform());
+ AddClippedQuad(root_pass, quad_rect, SK_ColorGREEN);
+
+ unsigned fbo;
+ gpu::gles2::GLES2Interface* gl =
+ output_surface->context_provider()->ContextGL();
+ gl->GenFramebuffers(1, &fbo);
+ output_surface->set_framebuffer(fbo);
+
+ renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
+ renderer.DrawFrame(&render_passes_in_draw_order_, 1.f, device_viewport_rect,
+ device_viewport_rect, false);
+
+ int bound_fbo;
+ gl->GetIntegerv(GL_FRAMEBUFFER_BINDING, &bound_fbo);
+ EXPECT_EQ(static_cast<int>(fbo), bound_fbo);
+}
+
TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {
gfx::Rect viewport_rect(1, 1);
diff --git a/cc/quads/checkerboard_draw_quad.cc b/cc/quads/checkerboard_draw_quad.cc
index 1451766..68d81c7 100644
--- a/cc/quads/checkerboard_draw_quad.cc
+++ b/cc/quads/checkerboard_draw_quad.cc
@@ -4,8 +4,8 @@
#include "cc/quads/checkerboard_draw_quad.h"
-#include "base/debug/trace_event_argument.h"
#include "base/logging.h"
+#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
namespace cc {
diff --git a/cc/quads/content_draw_quad_base.cc b/cc/quads/content_draw_quad_base.cc
index 0a2a2f4..171e90d 100644
--- a/cc/quads/content_draw_quad_base.cc
+++ b/cc/quads/content_draw_quad_base.cc
@@ -4,8 +4,8 @@
#include "cc/quads/content_draw_quad_base.h"
-#include "base/debug/trace_event_argument.h"
#include "base/logging.h"
+#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
#include "cc/base/math_util.h"
diff --git a/cc/quads/debug_border_draw_quad.cc b/cc/quads/debug_border_draw_quad.cc
index c907be7..43c7e6a 100644
--- a/cc/quads/debug_border_draw_quad.cc
+++ b/cc/quads/debug_border_draw_quad.cc
@@ -4,8 +4,8 @@
#include "cc/quads/debug_border_draw_quad.h"
-#include "base/debug/trace_event_argument.h"
#include "base/logging.h"
+#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
namespace cc {
diff --git a/cc/quads/draw_quad.cc b/cc/quads/draw_quad.cc
index f8f00b6..402dffe 100644
--- a/cc/quads/draw_quad.cc
+++ b/cc/quads/draw_quad.cc
@@ -4,8 +4,8 @@
#include "cc/quads/draw_quad.h"
-#include "base/debug/trace_event_argument.h"
#include "base/logging.h"
+#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
#include "cc/base/math_util.h"
#include "cc/debug/traced_value.h"
diff --git a/cc/quads/io_surface_draw_quad.cc b/cc/quads/io_surface_draw_quad.cc
index b0eba53..0cc8773 100644
--- a/cc/quads/io_surface_draw_quad.cc
+++ b/cc/quads/io_surface_draw_quad.cc
@@ -4,8 +4,8 @@
#include "cc/quads/io_surface_draw_quad.h"
-#include "base/debug/trace_event_argument.h"
#include "base/logging.h"
+#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
#include "cc/base/math_util.h"
diff --git a/cc/quads/picture_draw_quad.cc b/cc/quads/picture_draw_quad.cc
index 24c8c15..f36a782 100644
--- a/cc/quads/picture_draw_quad.cc
+++ b/cc/quads/picture_draw_quad.cc
@@ -4,7 +4,7 @@
#include "cc/quads/picture_draw_quad.h"
-#include "base/debug/trace_event_argument.h"
+#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
#include "cc/base/math_util.h"
#include "cc/resources/platform_color.h"
diff --git a/cc/quads/render_pass.cc b/cc/quads/render_pass.cc
index 0a77a90..2a6e69f 100644
--- a/cc/quads/render_pass.cc
+++ b/cc/quads/render_pass.cc
@@ -6,7 +6,7 @@
#include <algorithm>
-#include "base/debug/trace_event_argument.h"
+#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
#include "cc/base/math_util.h"
#include "cc/debug/traced_value.h"
diff --git a/cc/quads/render_pass_draw_quad.cc b/cc/quads/render_pass_draw_quad.cc
index ce5065f..41824c3 100644
--- a/cc/quads/render_pass_draw_quad.cc
+++ b/cc/quads/render_pass_draw_quad.cc
@@ -4,7 +4,7 @@
#include "cc/quads/render_pass_draw_quad.h"
-#include "base/debug/trace_event_argument.h"
+#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
#include "cc/base/math_util.h"
#include "cc/debug/traced_value.h"
diff --git a/cc/quads/shared_quad_state.cc b/cc/quads/shared_quad_state.cc
index e13a122..57670c6 100644
--- a/cc/quads/shared_quad_state.cc
+++ b/cc/quads/shared_quad_state.cc
@@ -4,7 +4,7 @@
#include "cc/quads/shared_quad_state.h"
-#include "base/debug/trace_event_argument.h"
+#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
#include "cc/base/math_util.h"
#include "cc/debug/traced_value.h"
diff --git a/cc/quads/solid_color_draw_quad.cc b/cc/quads/solid_color_draw_quad.cc
index a11b151..8b856e0 100644
--- a/cc/quads/solid_color_draw_quad.cc
+++ b/cc/quads/solid_color_draw_quad.cc
@@ -4,8 +4,8 @@
#include "cc/quads/solid_color_draw_quad.h"
-#include "base/debug/trace_event_argument.h"
#include "base/logging.h"
+#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
namespace cc {
diff --git a/cc/quads/stream_video_draw_quad.cc b/cc/quads/stream_video_draw_quad.cc
index 1f5f05e..3f12d39 100644
--- a/cc/quads/stream_video_draw_quad.cc
+++ b/cc/quads/stream_video_draw_quad.cc
@@ -4,8 +4,8 @@
#include "cc/quads/stream_video_draw_quad.h"
-#include "base/debug/trace_event_argument.h"
#include "base/logging.h"
+#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
#include "cc/base/math_util.h"
diff --git a/cc/quads/surface_draw_quad.cc b/cc/quads/surface_draw_quad.cc
index 7ed8f2e..7ed193c 100644
--- a/cc/quads/surface_draw_quad.cc
+++ b/cc/quads/surface_draw_quad.cc
@@ -4,8 +4,8 @@
#include "cc/quads/surface_draw_quad.h"
-#include "base/debug/trace_event_argument.h"
#include "base/logging.h"
+#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
namespace cc {
diff --git a/cc/quads/texture_draw_quad.cc b/cc/quads/texture_draw_quad.cc
index 5d01e81..4169090 100644
--- a/cc/quads/texture_draw_quad.cc
+++ b/cc/quads/texture_draw_quad.cc
@@ -4,8 +4,8 @@
#include "cc/quads/texture_draw_quad.h"
-#include "base/debug/trace_event_argument.h"
#include "base/logging.h"
+#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
#include "cc/base/math_util.h"
#include "ui/gfx/geometry/vector2d_f.h"
diff --git a/cc/quads/tile_draw_quad.cc b/cc/quads/tile_draw_quad.cc
index 88a4b3a..5d60bae 100644
--- a/cc/quads/tile_draw_quad.cc
+++ b/cc/quads/tile_draw_quad.cc
@@ -4,8 +4,8 @@
#include "cc/quads/tile_draw_quad.h"
-#include "base/debug/trace_event_argument.h"
#include "base/logging.h"
+#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
#include "third_party/khronos/GLES2/gl2.h"
diff --git a/cc/quads/yuv_video_draw_quad.cc b/cc/quads/yuv_video_draw_quad.cc
index 6d3a828..5d0fc55 100644
--- a/cc/quads/yuv_video_draw_quad.cc
+++ b/cc/quads/yuv_video_draw_quad.cc
@@ -4,8 +4,8 @@
#include "cc/quads/yuv_video_draw_quad.h"
-#include "base/debug/trace_event_argument.h"
#include "base/logging.h"
+#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
#include "cc/base/math_util.h"
diff --git a/cc/resources/bitmap_tile_task_worker_pool.cc b/cc/resources/bitmap_tile_task_worker_pool.cc
index c4bd1f2..1dc9377 100644
--- a/cc/resources/bitmap_tile_task_worker_pool.cc
+++ b/cc/resources/bitmap_tile_task_worker_pool.cc
@@ -6,9 +6,9 @@
#include <algorithm>
-#include "base/debug/trace_event.h"
-#include "base/debug/trace_event_argument.h"
#include "base/strings/stringprintf.h"
+#include "base/trace_event/trace_event.h"
+#include "base/trace_event/trace_event_argument.h"
#include "cc/debug/traced_value.h"
#include "cc/resources/raster_buffer.h"
#include "cc/resources/raster_source.h"
@@ -160,6 +160,10 @@
completed_tasks_.clear();
}
+ResourceFormat BitmapTileTaskWorkerPool::GetResourceFormat() {
+ return resource_provider_->best_texture_format();
+}
+
scoped_ptr<RasterBuffer> BitmapTileTaskWorkerPool::AcquireBufferForRaster(
const Resource* resource) {
return make_scoped_ptr<RasterBuffer>(
diff --git a/cc/resources/bitmap_tile_task_worker_pool.h b/cc/resources/bitmap_tile_task_worker_pool.h
index 4f5d970..404a3a5 100644
--- a/cc/resources/bitmap_tile_task_worker_pool.h
+++ b/cc/resources/bitmap_tile_task_worker_pool.h
@@ -38,6 +38,7 @@
void Shutdown() override;
void ScheduleTasks(TileTaskQueue* queue) override;
void CheckForCompletedTasks() override;
+ ResourceFormat GetResourceFormat() override;
// Overridden from TileTaskClient:
scoped_ptr<RasterBuffer> AcquireBufferForRaster(
diff --git a/cc/resources/content_layer_updater.cc b/cc/resources/content_layer_updater.cc
index 206d76b..7101dd1 100644
--- a/cc/resources/content_layer_updater.cc
+++ b/cc/resources/content_layer_updater.cc
@@ -4,7 +4,7 @@
#include "cc/resources/content_layer_updater.h"
-#include "base/debug/trace_event.h"
+#include "base/trace_event/trace_event.h"
#include "cc/resources/layer_painter.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkRect.h"
diff --git a/cc/resources/display_item_list.cc b/cc/resources/display_item_list.cc
index 6424fee..b27dea0 100644
--- a/cc/resources/display_item_list.cc
+++ b/cc/resources/display_item_list.cc
@@ -6,8 +6,8 @@
#include <string>
-#include "base/debug/trace_event.h"
-#include "base/debug/trace_event_argument.h"
+#include "base/trace_event/trace_event.h"
+#include "base/trace_event/trace_event_argument.h"
#include "cc/base/math_util.h"
#include "cc/debug/picture_debug_util.h"
#include "third_party/skia/include/core/SkCanvas.h"
diff --git a/cc/resources/display_item_list.h b/cc/resources/display_item_list.h
index 1076beb..2147848 100644
--- a/cc/resources/display_item_list.h
+++ b/cc/resources/display_item_list.h
@@ -5,9 +5,9 @@
#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 "base/trace_event/trace_event.h"
#include "cc/base/cc_export.h"
#include "cc/base/scoped_ptr_vector.h"
#include "cc/resources/display_item.h"
diff --git a/cc/resources/display_list_raster_source.cc b/cc/resources/display_list_raster_source.cc
index f3ff816..8ae2918 100644
--- a/cc/resources/display_list_raster_source.cc
+++ b/cc/resources/display_list_raster_source.cc
@@ -4,7 +4,7 @@
#include "cc/resources/display_list_raster_source.h"
-#include "base/debug/trace_event.h"
+#include "base/trace_event/trace_event.h"
#include "cc/base/region.h"
#include "cc/debug/debug_colors.h"
#include "cc/resources/display_item_list.h"
diff --git a/cc/resources/display_list_recording_source.cc b/cc/resources/display_list_recording_source.cc
index 64ad63b..7b98e50 100644
--- a/cc/resources/display_list_recording_source.cc
+++ b/cc/resources/display_list_recording_source.cc
@@ -106,13 +106,6 @@
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;
}
diff --git a/cc/resources/display_list_recording_source.h b/cc/resources/display_list_recording_source.h
index bc87c12..a2c8ea6 100644
--- a/cc/resources/display_list_recording_source.h
+++ b/cc/resources/display_list_recording_source.h
@@ -29,10 +29,8 @@
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;
gfx::Size GetTileGridSizeForTesting() const override;
diff --git a/cc/resources/eviction_tile_priority_queue.cc b/cc/resources/eviction_tile_priority_queue.cc
index 46fe5ee..b1ca48d 100644
--- a/cc/resources/eviction_tile_priority_queue.cc
+++ b/cc/resources/eviction_tile_priority_queue.cc
@@ -100,10 +100,6 @@
paired_queues_.make_heap(EvictionOrderComparator(tree_priority_));
}
-void EvictionTilePriorityQueue::Reset() {
- paired_queues_.clear();
-}
-
bool EvictionTilePriorityQueue::IsEmpty() const {
return paired_queues_.empty() || paired_queues_.front()->IsEmpty();
}
diff --git a/cc/resources/eviction_tile_priority_queue.h b/cc/resources/eviction_tile_priority_queue.h
index 1bf3c73..ab705f7 100644
--- a/cc/resources/eviction_tile_priority_queue.h
+++ b/cc/resources/eviction_tile_priority_queue.h
@@ -42,7 +42,6 @@
void Build(const std::vector<PictureLayerImpl::Pair>& paired_layers,
TreePriority tree_priority);
- void Reset();
bool IsEmpty() const;
Tile* Top();
diff --git a/cc/resources/gpu_rasterizer.cc b/cc/resources/gpu_rasterizer.cc
index 6f9786d..fe13af7 100644
--- a/cc/resources/gpu_rasterizer.cc
+++ b/cc/resources/gpu_rasterizer.cc
@@ -7,8 +7,8 @@
#include <algorithm>
#include "base/bind.h"
-#include "base/debug/trace_event.h"
#include "base/metrics/histogram.h"
+#include "base/trace_event/trace_event.h"
#include "cc/debug/devtools_instrumentation.h"
#include "cc/debug/frame_viewer_instrumentation.h"
#include "cc/output/context_provider.h"
@@ -59,6 +59,7 @@
void GpuRasterizer::RasterizeTiles(
const TileVector& tiles,
ResourcePool* resource_pool,
+ ResourceFormat resource_format,
const UpdateTileDrawInfoCallback& update_tile_draw_info) {
ScopedGpuRaster gpu_raster(context_provider_);
@@ -69,7 +70,7 @@
// See crbug.com/445919
scoped_ptr<ScopedResource> resource =
resource_pool->AcquireResource(tile->desired_texture_size(),
- resource_pool->default_format());
+ resource_format);
const ScopedResource* const_resource = resource.get();
RasterSource::SolidColorAnalysis analysis;
diff --git a/cc/resources/gpu_rasterizer.h b/cc/resources/gpu_rasterizer.h
index cbc9385..761b3a5 100644
--- a/cc/resources/gpu_rasterizer.h
+++ b/cc/resources/gpu_rasterizer.h
@@ -30,6 +30,7 @@
void RasterizeTiles(
const TileVector& tiles,
ResourcePool* resource_pool,
+ ResourceFormat resource_format,
const UpdateTileDrawInfoCallback& update_tile_draw_info) override;
private:
diff --git a/cc/resources/gpu_tile_task_worker_pool.cc b/cc/resources/gpu_tile_task_worker_pool.cc
index 8615730..02a46da 100644
--- a/cc/resources/gpu_tile_task_worker_pool.cc
+++ b/cc/resources/gpu_tile_task_worker_pool.cc
@@ -6,7 +6,7 @@
#include <algorithm>
-#include "base/debug/trace_event.h"
+#include "base/trace_event/trace_event.h"
#include "cc/resources/raster_buffer.h"
#include "cc/resources/raster_source.h"
#include "cc/resources/resource.h"
@@ -39,18 +39,22 @@
// static
scoped_ptr<TileTaskWorkerPool> GpuTileTaskWorkerPool::Create(
base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner) {
+ TaskGraphRunner* task_graph_runner,
+ ResourceProvider* resource_provider) {
return make_scoped_ptr<TileTaskWorkerPool>(
- new GpuTileTaskWorkerPool(task_runner, task_graph_runner));
+ new GpuTileTaskWorkerPool(
+ task_runner, task_graph_runner, resource_provider));
}
// TODO(hendrikw): This class should be removed. See crbug.com/444938.
GpuTileTaskWorkerPool::GpuTileTaskWorkerPool(
base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner)
+ TaskGraphRunner* task_graph_runner,
+ ResourceProvider* resource_provider)
: task_runner_(task_runner),
task_graph_runner_(task_graph_runner),
namespace_token_(task_graph_runner_->GetNamespaceToken()),
+ resource_provider_(resource_provider),
task_set_finished_weak_ptr_factory_(this),
weak_ptr_factory_(this) {
}
@@ -140,6 +144,10 @@
completed_tasks_.clear();
}
+ResourceFormat GpuTileTaskWorkerPool::GetResourceFormat() {
+ return resource_provider_->best_texture_format();
+}
+
void GpuTileTaskWorkerPool::CompleteTasks(const Task::Vector& tasks) {
for (auto& task : tasks) {
RasterTask* raster_task = static_cast<RasterTask*>(task.get());
diff --git a/cc/resources/gpu_tile_task_worker_pool.h b/cc/resources/gpu_tile_task_worker_pool.h
index 5d35ef9..6ac8548 100644
--- a/cc/resources/gpu_tile_task_worker_pool.h
+++ b/cc/resources/gpu_tile_task_worker_pool.h
@@ -10,6 +10,7 @@
#include "cc/resources/tile_task_worker_pool.h"
namespace cc {
+class ResourceProvider;
class CC_EXPORT GpuTileTaskWorkerPool : public TileTaskWorkerPool,
public TileTaskRunner,
@@ -19,7 +20,8 @@
static scoped_ptr<TileTaskWorkerPool> Create(
base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner);
+ TaskGraphRunner* task_graph_runner,
+ ResourceProvider* resource_provider);
// Overridden from TileTaskWorkerPool:
TileTaskRunner* AsTileTaskRunner() override;
@@ -29,6 +31,7 @@
void Shutdown() override;
void ScheduleTasks(TileTaskQueue* queue) override;
void CheckForCompletedTasks() override;
+ ResourceFormat GetResourceFormat() override;
// Overridden from TileTaskClient:
scoped_ptr<RasterBuffer> AcquireBufferForRaster(
@@ -37,7 +40,8 @@
private:
GpuTileTaskWorkerPool(base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner);
+ TaskGraphRunner* task_graph_runner,
+ ResourceProvider* resource_provider);
void OnTaskSetFinished(TaskSet task_set);
void CompleteTasks(const Task::Vector& tasks);
@@ -46,6 +50,7 @@
TaskGraphRunner* task_graph_runner_;
const NamespaceToken namespace_token_;
TileTaskRunnerClient* client_;
+ ResourceProvider* resource_provider_;
TaskSetCollection tasks_pending_;
diff --git a/cc/resources/one_copy_tile_task_worker_pool.cc b/cc/resources/one_copy_tile_task_worker_pool.cc
index d4a333f..fe5ecbf 100644
--- a/cc/resources/one_copy_tile_task_worker_pool.cc
+++ b/cc/resources/one_copy_tile_task_worker_pool.cc
@@ -7,9 +7,9 @@
#include <algorithm>
#include <limits>
-#include "base/debug/trace_event.h"
-#include "base/debug/trace_event_argument.h"
#include "base/strings/stringprintf.h"
+#include "base/trace_event/trace_event.h"
+#include "base/trace_event/trace_event_argument.h"
#include "cc/debug/traced_value.h"
#include "cc/resources/raster_buffer.h"
#include "cc/resources/resource_pool.h"
@@ -25,14 +25,14 @@
RasterBufferImpl(OneCopyTileTaskWorkerPool* worker_pool,
ResourceProvider* resource_provider,
ResourcePool* resource_pool,
+ ResourceFormat resource_format,
const Resource* resource)
: worker_pool_(worker_pool),
resource_provider_(resource_provider),
resource_pool_(resource_pool),
resource_(resource),
raster_resource_(
- resource_pool->AcquireResource(resource->size(),
- resource_pool->default_format())),
+ resource_pool->AcquireResource(resource->size(), resource_format)),
lock_(new ResourceProvider::ScopedWriteLockGpuMemoryBuffer(
resource_provider_,
raster_resource_->id())),
@@ -249,11 +249,17 @@
completed_tasks_.clear();
}
+ResourceFormat OneCopyTileTaskWorkerPool::GetResourceFormat() {
+ return resource_provider_->best_texture_format();
+}
+
scoped_ptr<RasterBuffer> OneCopyTileTaskWorkerPool::AcquireBufferForRaster(
const Resource* resource) {
- DCHECK_EQ(resource->format(), resource_pool_->default_format());
+ DCHECK_EQ(resource->format(), resource_provider_->best_texture_format());
return make_scoped_ptr<RasterBuffer>(
- new RasterBufferImpl(this, resource_provider_, resource_pool_, resource));
+ new RasterBufferImpl(this, resource_provider_, resource_pool_,
+ resource_provider_->best_texture_format(),
+ resource));
}
void OneCopyTileTaskWorkerPool::ReleaseBufferForRaster(
diff --git a/cc/resources/one_copy_tile_task_worker_pool.h b/cc/resources/one_copy_tile_task_worker_pool.h
index c5b30ba..4568d35 100644
--- a/cc/resources/one_copy_tile_task_worker_pool.h
+++ b/cc/resources/one_copy_tile_task_worker_pool.h
@@ -48,6 +48,7 @@
void Shutdown() override;
void ScheduleTasks(TileTaskQueue* queue) override;
void CheckForCompletedTasks() override;
+ ResourceFormat GetResourceFormat() override;
// Overridden from TileTaskClient:
scoped_ptr<RasterBuffer> AcquireBufferForRaster(
diff --git a/cc/resources/picture.cc b/cc/resources/picture.cc
index b1ca99d..003a8f1 100644
--- a/cc/resources/picture.cc
+++ b/cc/resources/picture.cc
@@ -9,8 +9,8 @@
#include <set>
#include "base/base64.h"
-#include "base/debug/trace_event.h"
-#include "base/debug/trace_event_argument.h"
+#include "base/trace_event/trace_event.h"
+#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
#include "cc/base/math_util.h"
#include "cc/base/util.h"
diff --git a/cc/resources/picture.h b/cc/resources/picture.h
index 75f92f2..ec76f45 100644
--- a/cc/resources/picture.h
+++ b/cc/resources/picture.h
@@ -11,11 +11,11 @@
#include "base/basictypes.h"
#include "base/containers/hash_tables.h"
-#include "base/debug/trace_event.h"
#include "base/lazy_instance.h"
#include "base/logging.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
+#include "base/trace_event/trace_event.h"
#include "cc/base/cc_export.h"
#include "cc/base/region.h"
#include "skia/ext/refptr.h"
diff --git a/cc/resources/picture_layer_tiling.cc b/cc/resources/picture_layer_tiling.cc
index aab740a..033f9f6 100644
--- a/cc/resources/picture_layer_tiling.cc
+++ b/cc/resources/picture_layer_tiling.cc
@@ -9,9 +9,9 @@
#include <limits>
#include <set>
-#include "base/debug/trace_event.h"
-#include "base/debug/trace_event_argument.h"
#include "base/logging.h"
+#include "base/trace_event/trace_event.h"
+#include "base/trace_event/trace_event_argument.h"
#include "cc/base/math_util.h"
#include "cc/resources/tile.h"
#include "cc/resources/tile_priority.h"
diff --git a/cc/resources/picture_pile.cc b/cc/resources/picture_pile.cc
index 1057d2d..f42244c 100644
--- a/cc/resources/picture_pile.cc
+++ b/cc/resources/picture_pile.cc
@@ -156,7 +156,8 @@
namespace cc {
-PicturePile::PicturePile()
+PicturePile::PicturePile(float min_contents_scale,
+ const gfx::Size& tile_grid_size)
: min_contents_scale_(0),
slow_down_raster_scale_factor_for_debug_(0),
can_use_lcd_text_(true),
@@ -166,6 +167,8 @@
pixel_record_distance_(kPixelDistanceToRecord),
is_suitable_for_gpu_rasterization_(true) {
tiling_.SetMaxTextureSize(gfx::Size(kBasePictureSize, kBasePictureSize));
+ SetMinContentsScale(min_contents_scale);
+ SetTileGridSize(tile_grid_size);
}
PicturePile::~PicturePile() {
diff --git a/cc/resources/picture_pile.h b/cc/resources/picture_pile.h
index 0a67c09..1e3368c 100644
--- a/cc/resources/picture_pile.h
+++ b/cc/resources/picture_pile.h
@@ -19,7 +19,7 @@
class CC_EXPORT PicturePile : public RecordingSource {
public:
- PicturePile();
+ PicturePile(float min_contents_scale, const gfx::Size& tile_grid_size);
~PicturePile() override;
// RecordingSource overrides.
@@ -34,10 +34,8 @@
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;
gfx::Size GetTileGridSizeForTesting() const override;
@@ -76,6 +74,9 @@
void Clear();
+ void SetMinContentsScale(float min_contents_scale);
+ void SetTileGridSize(const gfx::Size& tile_grid_size);
+
gfx::Rect PaddedRect(const PictureMapKey& key) const;
gfx::Rect PadRect(const gfx::Rect& rect) const;
diff --git a/cc/resources/picture_pile_impl.cc b/cc/resources/picture_pile_impl.cc
index 93d84c1..c56a88f 100644
--- a/cc/resources/picture_pile_impl.cc
+++ b/cc/resources/picture_pile_impl.cc
@@ -6,7 +6,7 @@
#include <limits>
#include <set>
-#include "base/debug/trace_event.h"
+#include "base/trace_event/trace_event.h"
#include "cc/base/region.h"
#include "cc/debug/debug_colors.h"
#include "cc/resources/picture_pile_impl.h"
diff --git a/cc/resources/picture_pile_unittest.cc b/cc/resources/picture_pile_unittest.cc
index 98ce3b1..4e3fe15 100644
--- a/cc/resources/picture_pile_unittest.cc
+++ b/cc/resources/picture_pile_unittest.cc
@@ -17,7 +17,10 @@
class PicturePileTestBase {
public:
- PicturePileTestBase() : min_scale_(0.125), frame_number_(0) {}
+ PicturePileTestBase()
+ : min_scale_(0.125),
+ pile_(min_scale_, gfx::Size(1000, 1000)),
+ frame_number_(0) {}
void InitializeData() {
pile_.SetTileGridSize(gfx::Size(1000, 1000));
@@ -53,8 +56,8 @@
}
FakeContentLayerClient client_;
- FakePicturePile pile_;
float min_scale_;
+ FakePicturePile pile_;
int frame_number_;
};
diff --git a/cc/resources/pixel_buffer_tile_task_worker_pool.cc b/cc/resources/pixel_buffer_tile_task_worker_pool.cc
index 7256f94..d79577d 100644
--- a/cc/resources/pixel_buffer_tile_task_worker_pool.cc
+++ b/cc/resources/pixel_buffer_tile_task_worker_pool.cc
@@ -7,9 +7,9 @@
#include <algorithm>
#include "base/containers/stack_container.h"
-#include "base/debug/trace_event.h"
-#include "base/debug/trace_event_argument.h"
#include "base/strings/stringprintf.h"
+#include "base/trace_event/trace_event.h"
+#include "base/trace_event/trace_event_argument.h"
#include "cc/debug/traced_value.h"
#include "cc/resources/raster_buffer.h"
#include "cc/resources/resource.h"
@@ -307,6 +307,10 @@
completed_raster_tasks_.clear();
}
+ResourceFormat PixelBufferTileTaskWorkerPool::GetResourceFormat() {
+ return resource_provider_->memory_efficient_texture_format();
+}
+
scoped_ptr<RasterBuffer> PixelBufferTileTaskWorkerPool::AcquireBufferForRaster(
const Resource* resource) {
return make_scoped_ptr<RasterBuffer>(
diff --git a/cc/resources/pixel_buffer_tile_task_worker_pool.h b/cc/resources/pixel_buffer_tile_task_worker_pool.h
index 1135dc9..8ee4b9c 100644
--- a/cc/resources/pixel_buffer_tile_task_worker_pool.h
+++ b/cc/resources/pixel_buffer_tile_task_worker_pool.h
@@ -46,6 +46,7 @@
void Shutdown() override;
void ScheduleTasks(TileTaskQueue* queue) override;
void CheckForCompletedTasks() override;
+ ResourceFormat GetResourceFormat() override;
// Overridden from TileTaskClient:
scoped_ptr<RasterBuffer> AcquireBufferForRaster(
diff --git a/cc/resources/prioritized_resource_manager.cc b/cc/resources/prioritized_resource_manager.cc
index 4598446..48177e3 100644
--- a/cc/resources/prioritized_resource_manager.cc
+++ b/cc/resources/prioritized_resource_manager.cc
@@ -6,7 +6,7 @@
#include <algorithm>
-#include "base/debug/trace_event.h"
+#include "base/trace_event/trace_event.h"
#include "cc/resources/prioritized_resource.h"
#include "cc/resources/priority_calculator.h"
#include "cc/trees/proxy.h"
diff --git a/cc/resources/raster_source_helper.cc b/cc/resources/raster_source_helper.cc
index f7ef305..34436e4 100644
--- a/cc/resources/raster_source_helper.cc
+++ b/cc/resources/raster_source_helper.cc
@@ -4,7 +4,7 @@
#include "cc/resources/raster_source_helper.h"
-#include "base/debug/trace_event.h"
+#include "base/trace_event/trace_event.h"
#include "cc/debug/debug_colors.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "ui/gfx/geometry/rect_conversions.h"
diff --git a/cc/resources/raster_tile_priority_queue.cc b/cc/resources/raster_tile_priority_queue.cc
index 08862f6..12fcaa7 100644
--- a/cc/resources/raster_tile_priority_queue.cc
+++ b/cc/resources/raster_tile_priority_queue.cc
@@ -1,348 +1,36 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
+// Copyright 2015 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_tile_priority_queue.h"
-#include "cc/resources/tiling_set_raster_queue_all.h"
-#include "cc/resources/tiling_set_raster_queue_required.h"
+#include "cc/resources/raster_tile_priority_queue_all.h"
+#include "cc/resources/raster_tile_priority_queue_required.h"
namespace cc {
-namespace {
-
-class RasterOrderComparator {
- public:
- explicit RasterOrderComparator(TreePriority tree_priority)
- : tree_priority_(tree_priority) {}
-
- bool operator()(
- const RasterTilePriorityQueue::PairedTilingSetQueue* a,
- const RasterTilePriorityQueue::PairedTilingSetQueue* b) const {
- // Note that in this function, we have to return true if and only if
- // a is strictly lower priority than b. Note that for the sake of
- // completeness, empty queue is considered to have lowest priority.
- if (a->IsEmpty() || b->IsEmpty())
- return b->IsEmpty() < a->IsEmpty();
-
- WhichTree a_tree = a->NextTileIteratorTree(tree_priority_);
- const TilingSetRasterQueue* a_queue =
- a_tree == ACTIVE_TREE ? a->active_queue() : a->pending_queue();
-
- WhichTree b_tree = b->NextTileIteratorTree(tree_priority_);
- const TilingSetRasterQueue* b_queue =
- b_tree == ACTIVE_TREE ? b->active_queue() : b->pending_queue();
-
- 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_);
- const TilePriority& b_priority =
- b_tile->priority_for_tree_priority(tree_priority_);
- bool prioritize_low_res = tree_priority_ == SMOOTHNESS_TAKES_PRIORITY;
-
- // In smoothness mode, we should return pending NOW tiles before active
- // EVENTUALLY tiles. So if both priorities here are eventually, we need to
- // check the pending priority.
- if (prioritize_low_res &&
- a_priority.priority_bin == TilePriority::EVENTUALLY &&
- b_priority.priority_bin == TilePriority::EVENTUALLY) {
- bool a_is_pending_now =
- a_tile->priority(PENDING_TREE).priority_bin == TilePriority::NOW;
- bool b_is_pending_now =
- b_tile->priority(PENDING_TREE).priority_bin == TilePriority::NOW;
- if (a_is_pending_now || b_is_pending_now)
- return a_is_pending_now < b_is_pending_now;
-
- // In case neither one is pending now, fall through.
- }
-
- // If the bin is the same but the resolution is not, then the order will be
- // determined by whether we prioritize low res or not.
- // TODO(vmpstr): Remove this when TilePriority is no longer a member of Tile
- // class but instead produced by the iterators.
- if (b_priority.priority_bin == a_priority.priority_bin &&
- b_priority.resolution != a_priority.resolution) {
- // Non ideal resolution should be sorted lower than other resolutions.
- if (a_priority.resolution == NON_IDEAL_RESOLUTION)
- return true;
-
- if (b_priority.resolution == NON_IDEAL_RESOLUTION)
- return false;
-
- if (prioritize_low_res)
- return b_priority.resolution == LOW_RESOLUTION;
- return b_priority.resolution == HIGH_RESOLUTION;
- }
-
- return b_priority.IsHigherPriorityThan(a_priority);
- }
-
- private:
- TreePriority tree_priority_;
-};
-
-WhichTree HigherPriorityTree(TreePriority tree_priority,
- const TilingSetRasterQueue* active_queue,
- const TilingSetRasterQueue* pending_queue,
- const Tile* shared_tile) {
- switch (tree_priority) {
- case SMOOTHNESS_TAKES_PRIORITY: {
- const Tile* active_tile = shared_tile ? shared_tile : active_queue->Top();
- const Tile* pending_tile =
- shared_tile ? shared_tile : pending_queue->Top();
-
- const TilePriority& active_priority = active_tile->priority(ACTIVE_TREE);
- const TilePriority& pending_priority =
- pending_tile->priority(PENDING_TREE);
-
- // If we're down to eventually bin tiles on the active tree, process the
- // pending tree to allow tiles required for activation to be initialized
- // when memory policy only allows prepaint.
- if (active_priority.priority_bin == TilePriority::EVENTUALLY &&
- pending_priority.priority_bin == TilePriority::NOW) {
- return PENDING_TREE;
- }
- return ACTIVE_TREE;
- }
- case NEW_CONTENT_TAKES_PRIORITY:
- return PENDING_TREE;
- case SAME_PRIORITY_FOR_BOTH_TREES: {
- const Tile* active_tile = shared_tile ? shared_tile : active_queue->Top();
- const Tile* pending_tile =
- shared_tile ? shared_tile : pending_queue->Top();
-
- const TilePriority& active_priority = active_tile->priority(ACTIVE_TREE);
- const TilePriority& pending_priority =
- pending_tile->priority(PENDING_TREE);
-
- if (active_priority.IsHigherPriorityThan(pending_priority))
- return ACTIVE_TREE;
- return PENDING_TREE;
- }
- default:
- NOTREACHED();
- return ACTIVE_TREE;
- }
-}
-
-scoped_ptr<TilingSetRasterQueue> CreateTilingSetRasterQueue(
- PictureLayerImpl* layer,
- TreePriority tree_priority,
- RasterTilePriorityQueue::Type type) {
- if (!layer)
- return nullptr;
- PictureLayerTilingSet* tiling_set = layer->picture_layer_tiling_set();
- if (type == RasterTilePriorityQueue::Type::ALL) {
- bool prioritize_low_res = tree_priority == SMOOTHNESS_TAKES_PRIORITY;
- return make_scoped_ptr(
- new TilingSetRasterQueueAll(tiling_set, prioritize_low_res));
- }
- return make_scoped_ptr(new TilingSetRasterQueueRequired(tiling_set, type));
-}
-
-} // namespace
-
-RasterTilePriorityQueue::RasterTilePriorityQueue() {
-}
-
-RasterTilePriorityQueue::~RasterTilePriorityQueue() {
-}
-
-void RasterTilePriorityQueue::Build(
+// static
+scoped_ptr<RasterTilePriorityQueue> RasterTilePriorityQueue::Create(
const std::vector<PictureLayerImpl::Pair>& paired_layers,
TreePriority tree_priority,
Type type) {
- tree_priority_ = tree_priority;
- for (std::vector<PictureLayerImpl::Pair>::const_iterator it =
- paired_layers.begin();
- it != paired_layers.end();
- ++it) {
- paired_queues_.push_back(
- make_scoped_ptr(new PairedTilingSetQueue(*it, tree_priority_, type)));
- }
- paired_queues_.make_heap(RasterOrderComparator(tree_priority_));
-}
-
-void RasterTilePriorityQueue::Reset() {
- paired_queues_.clear();
-}
-
-bool RasterTilePriorityQueue::IsEmpty() const {
- return paired_queues_.empty() || paired_queues_.front()->IsEmpty();
-}
-
-Tile* RasterTilePriorityQueue::Top() {
- DCHECK(!IsEmpty());
- return paired_queues_.front()->Top(tree_priority_);
-}
-
-void RasterTilePriorityQueue::Pop() {
- DCHECK(!IsEmpty());
-
- paired_queues_.pop_heap(RasterOrderComparator(tree_priority_));
- PairedTilingSetQueue* paired_queue = paired_queues_.back();
- paired_queue->Pop(tree_priority_);
- paired_queues_.push_heap(RasterOrderComparator(tree_priority_));
-}
-
-RasterTilePriorityQueue::PairedTilingSetQueue::PairedTilingSetQueue() {
-}
-
-RasterTilePriorityQueue::PairedTilingSetQueue::PairedTilingSetQueue(
- const PictureLayerImpl::Pair& layer_pair,
- TreePriority tree_priority,
- Type type)
- : has_both_layers_(false) {
switch (type) {
- case RasterTilePriorityQueue::Type::ALL:
- has_both_layers_ = layer_pair.active && layer_pair.pending;
- active_queue_ =
- CreateTilingSetRasterQueue(layer_pair.active, tree_priority, type);
- pending_queue_ =
- CreateTilingSetRasterQueue(layer_pair.pending, tree_priority, type);
- break;
- case RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION:
- pending_queue_ =
- CreateTilingSetRasterQueue(layer_pair.pending, tree_priority, type);
- break;
- case RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW:
- active_queue_ =
- CreateTilingSetRasterQueue(layer_pair.active, tree_priority, type);
- break;
+ case Type::ALL: {
+ scoped_ptr<RasterTilePriorityQueueAll> queue(
+ new RasterTilePriorityQueueAll);
+ queue->Build(paired_layers, tree_priority);
+ return queue.Pass();
+ }
+ case Type::REQUIRED_FOR_ACTIVATION:
+ case Type::REQUIRED_FOR_DRAW: {
+ scoped_ptr<RasterTilePriorityQueueRequired> queue(
+ new RasterTilePriorityQueueRequired);
+ queue->Build(paired_layers, type);
+ return queue.Pass();
+ }
}
- DCHECK_IMPLIES(has_both_layers_, active_queue_ && pending_queue_);
-
- SkipTilesReturnedByTwin(tree_priority);
-
- TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "PairedTilingSetQueue::PairedTilingSetQueue",
- TRACE_EVENT_SCOPE_THREAD, "state", StateAsValue());
-}
-
-RasterTilePriorityQueue::PairedTilingSetQueue::~PairedTilingSetQueue() {
- TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "PairedTilingSetQueue::~PairedTilingSetQueue",
- TRACE_EVENT_SCOPE_THREAD, "state", StateAsValue());
-}
-
-bool RasterTilePriorityQueue::PairedTilingSetQueue::IsEmpty() const {
- return (!active_queue_ || active_queue_->IsEmpty()) &&
- (!pending_queue_ || pending_queue_->IsEmpty());
-}
-
-Tile* RasterTilePriorityQueue::PairedTilingSetQueue::Top(
- TreePriority tree_priority) {
- DCHECK(!IsEmpty());
-
- WhichTree next_tree = NextTileIteratorTree(tree_priority);
- TilingSetRasterQueue* next_queue =
- next_tree == ACTIVE_TREE ? active_queue_.get() : pending_queue_.get();
- DCHECK(next_queue && !next_queue->IsEmpty());
- Tile* tile = next_queue->Top();
- DCHECK(returned_tiles_for_debug_.find(tile) ==
- returned_tiles_for_debug_.end());
- return tile;
-}
-
-void RasterTilePriorityQueue::PairedTilingSetQueue::Pop(
- TreePriority tree_priority) {
- DCHECK(!IsEmpty());
-
- WhichTree next_tree = NextTileIteratorTree(tree_priority);
- TilingSetRasterQueue* next_queue =
- next_tree == ACTIVE_TREE ? active_queue_.get() : pending_queue_.get();
- DCHECK(next_queue && !next_queue->IsEmpty());
- DCHECK(returned_tiles_for_debug_.insert(next_queue->Top()).second);
- next_queue->Pop();
-
- SkipTilesReturnedByTwin(tree_priority);
-
- // If no empty, use Top to do DCHECK the next iterator.
- DCHECK(IsEmpty() || Top(tree_priority));
-}
-
-void RasterTilePriorityQueue::PairedTilingSetQueue::SkipTilesReturnedByTwin(
- TreePriority tree_priority) {
- if (!has_both_layers_)
- return;
-
- // We have both layers (active and pending) thus we can encounter shared
- // tiles twice (from the active iterator and from the pending iterator).
- while (!IsEmpty()) {
- WhichTree next_tree = NextTileIteratorTree(tree_priority);
- TilingSetRasterQueue* next_queue =
- next_tree == ACTIVE_TREE ? active_queue_.get() : pending_queue_.get();
- DCHECK(next_queue && !next_queue->IsEmpty());
-
- // Accept all non-shared tiles.
- const Tile* tile = next_queue->Top();
- if (!tile->is_shared())
- break;
-
- // Accept a shared tile if the next tree is the higher priority one
- // corresponding the iterator (active or pending) which usually (but due
- // to spiral iterators not always) returns the shared tile first.
- if (next_tree == HigherPriorityTree(tree_priority, nullptr, nullptr, tile))
- break;
-
- next_queue->Pop();
- }
-}
-
-WhichTree RasterTilePriorityQueue::PairedTilingSetQueue::NextTileIteratorTree(
- TreePriority tree_priority) const {
- DCHECK(!IsEmpty());
-
- // If we only have one queue with tiles, return it.
- if (!active_queue_ || active_queue_->IsEmpty())
- return PENDING_TREE;
- if (!pending_queue_ || pending_queue_->IsEmpty())
- return ACTIVE_TREE;
-
- // Now both iterators have tiles, so we have to decide based on tree priority.
- return HigherPriorityTree(tree_priority, active_queue_.get(),
- pending_queue_.get(), nullptr);
-}
-
-scoped_refptr<base::debug::ConvertableToTraceFormat>
-RasterTilePriorityQueue::PairedTilingSetQueue::StateAsValue() const {
- scoped_refptr<base::debug::TracedValue> state =
- new base::debug::TracedValue();
-
- bool active_queue_has_tile = active_queue_ && !active_queue_->IsEmpty();
- TilePriority::PriorityBin active_priority_bin = TilePriority::EVENTUALLY;
- TilePriority::PriorityBin pending_priority_bin = TilePriority::EVENTUALLY;
- if (active_queue_has_tile) {
- active_priority_bin =
- active_queue_->Top()->priority(ACTIVE_TREE).priority_bin;
- pending_priority_bin =
- active_queue_->Top()->priority(PENDING_TREE).priority_bin;
- }
-
- state->BeginDictionary("active_queue");
- state->SetBoolean("has_tile", active_queue_has_tile);
- state->SetInteger("active_priority_bin", active_priority_bin);
- state->SetInteger("pending_priority_bin", pending_priority_bin);
- state->EndDictionary();
-
- bool pending_queue_has_tile = pending_queue_ && !pending_queue_->IsEmpty();
- active_priority_bin = TilePriority::EVENTUALLY;
- pending_priority_bin = TilePriority::EVENTUALLY;
- if (pending_queue_has_tile) {
- active_priority_bin =
- pending_queue_->Top()->priority(ACTIVE_TREE).priority_bin;
- pending_priority_bin =
- pending_queue_->Top()->priority(PENDING_TREE).priority_bin;
- }
-
- state->BeginDictionary("pending_queue");
- state->SetBoolean("has_tile", active_queue_has_tile);
- state->SetInteger("active_priority_bin", active_priority_bin);
- state->SetInteger("pending_priority_bin", pending_priority_bin);
- state->EndDictionary();
- return state;
+ NOTREACHED();
+ return nullptr;
}
} // namespace cc
diff --git a/cc/resources/raster_tile_priority_queue.h b/cc/resources/raster_tile_priority_queue.h
index 65c9247..5ee99f1 100644
--- a/cc/resources/raster_tile_priority_queue.h
+++ b/cc/resources/raster_tile_priority_queue.h
@@ -5,77 +5,35 @@
#ifndef CC_RESOURCES_RASTER_TILE_PRIORITY_QUEUE_H_
#define CC_RESOURCES_RASTER_TILE_PRIORITY_QUEUE_H_
-#include <set>
-#include <utility>
#include <vector>
#include "cc/base/cc_export.h"
#include "cc/layers/picture_layer_impl.h"
#include "cc/resources/tile_priority.h"
-#include "cc/resources/tiling_set_raster_queue.h"
namespace cc {
+class Tile;
-// TODO(vmpstr): Consider virtualizing this and adding ::Create with the
-// parameters of ::Build that would create a simpler queue for required only
-// tiles (ie, there's no need for the heap if all we're interested in are the
-// required tiles.
class CC_EXPORT RasterTilePriorityQueue {
public:
enum class Type { ALL, REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW };
- class PairedTilingSetQueue {
- public:
- PairedTilingSetQueue();
- PairedTilingSetQueue(const PictureLayerImpl::Pair& layer_pair,
- TreePriority tree_priority,
- Type type);
- ~PairedTilingSetQueue();
+ // TODO(vmpstr): Make this work with PictureLayerTilingSet pairs instead.
+ static scoped_ptr<RasterTilePriorityQueue> Create(
+ const std::vector<PictureLayerImpl::Pair>& paired_layers,
+ TreePriority tree_priority,
+ Type type);
- bool IsEmpty() const;
- Tile* Top(TreePriority tree_priority);
- void Pop(TreePriority tree_priority);
+ virtual ~RasterTilePriorityQueue() {}
- WhichTree NextTileIteratorTree(TreePriority tree_priority) const;
- void SkipTilesReturnedByTwin(TreePriority tree_priority);
+ virtual bool IsEmpty() const = 0;
+ virtual Tile* Top() = 0;
+ virtual void Pop() = 0;
- scoped_refptr<base::debug::ConvertableToTraceFormat> StateAsValue() const;
-
- const TilingSetRasterQueue* active_queue() const {
- return active_queue_.get();
- }
- const TilingSetRasterQueue* pending_queue() const {
- return pending_queue_.get();
- }
-
- private:
- scoped_ptr<TilingSetRasterQueue> active_queue_;
- scoped_ptr<TilingSetRasterQueue> pending_queue_;
- bool has_both_layers_;
-
- // Set of returned tiles (excluding the current one) for DCHECKing.
- std::set<const Tile*> returned_tiles_for_debug_;
- };
-
- RasterTilePriorityQueue();
- ~RasterTilePriorityQueue();
-
- void Build(const std::vector<PictureLayerImpl::Pair>& paired_layers,
- TreePriority tree_priority,
- Type type);
- void Reset();
-
- bool IsEmpty() const;
- Tile* Top();
- void Pop();
+ protected:
+ RasterTilePriorityQueue() {}
private:
- // TODO(vmpstr): This is potentially unnecessary if it becomes the case that
- // 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(RasterTilePriorityQueue);
};
diff --git a/cc/resources/raster_tile_priority_queue_all.cc b/cc/resources/raster_tile_priority_queue_all.cc
new file mode 100644
index 0000000..e9836cd
--- /dev/null
+++ b/cc/resources/raster_tile_priority_queue_all.cc
@@ -0,0 +1,322 @@
+// Copyright 2015 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_tile_priority_queue_all.h"
+
+#include "cc/resources/tiling_set_raster_queue_all.h"
+
+namespace cc {
+
+namespace {
+
+class RasterOrderComparator {
+ public:
+ explicit RasterOrderComparator(TreePriority tree_priority)
+ : tree_priority_(tree_priority) {}
+
+ bool operator()(
+ const RasterTilePriorityQueueAll::PairedTilingSetQueue* a,
+ const RasterTilePriorityQueueAll::PairedTilingSetQueue* b) const {
+ // Note that in this function, we have to return true if and only if
+ // a is strictly lower priority than b. Note that for the sake of
+ // completeness, empty queue is considered to have lowest priority.
+ if (a->IsEmpty() || b->IsEmpty())
+ return b->IsEmpty() < a->IsEmpty();
+
+ WhichTree a_tree = a->NextTileIteratorTree(tree_priority_);
+ const TilingSetRasterQueueAll* a_queue =
+ a_tree == ACTIVE_TREE ? a->active_queue() : a->pending_queue();
+
+ WhichTree b_tree = b->NextTileIteratorTree(tree_priority_);
+ const TilingSetRasterQueueAll* b_queue =
+ b_tree == ACTIVE_TREE ? b->active_queue() : b->pending_queue();
+
+ 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_);
+ const TilePriority& b_priority =
+ b_tile->priority_for_tree_priority(tree_priority_);
+ bool prioritize_low_res = tree_priority_ == SMOOTHNESS_TAKES_PRIORITY;
+
+ // In smoothness mode, we should return pending NOW tiles before active
+ // EVENTUALLY tiles. So if both priorities here are eventually, we need to
+ // check the pending priority.
+ if (prioritize_low_res &&
+ a_priority.priority_bin == TilePriority::EVENTUALLY &&
+ b_priority.priority_bin == TilePriority::EVENTUALLY) {
+ bool a_is_pending_now =
+ a_tile->priority(PENDING_TREE).priority_bin == TilePriority::NOW;
+ bool b_is_pending_now =
+ b_tile->priority(PENDING_TREE).priority_bin == TilePriority::NOW;
+ if (a_is_pending_now || b_is_pending_now)
+ return a_is_pending_now < b_is_pending_now;
+
+ // In case neither one is pending now, fall through.
+ }
+
+ // If the bin is the same but the resolution is not, then the order will be
+ // determined by whether we prioritize low res or not.
+ // TODO(vmpstr): Remove this when TilePriority is no longer a member of Tile
+ // class but instead produced by the iterators.
+ if (b_priority.priority_bin == a_priority.priority_bin &&
+ b_priority.resolution != a_priority.resolution) {
+ // Non ideal resolution should be sorted lower than other resolutions.
+ if (a_priority.resolution == NON_IDEAL_RESOLUTION)
+ return true;
+
+ if (b_priority.resolution == NON_IDEAL_RESOLUTION)
+ return false;
+
+ if (prioritize_low_res)
+ return b_priority.resolution == LOW_RESOLUTION;
+ return b_priority.resolution == HIGH_RESOLUTION;
+ }
+
+ return b_priority.IsHigherPriorityThan(a_priority);
+ }
+
+ private:
+ TreePriority tree_priority_;
+};
+
+WhichTree HigherPriorityTree(TreePriority tree_priority,
+ const TilingSetRasterQueueAll* active_queue,
+ const TilingSetRasterQueueAll* pending_queue,
+ const Tile* shared_tile) {
+ switch (tree_priority) {
+ case SMOOTHNESS_TAKES_PRIORITY: {
+ const Tile* active_tile = shared_tile ? shared_tile : active_queue->Top();
+ const Tile* pending_tile =
+ shared_tile ? shared_tile : pending_queue->Top();
+
+ const TilePriority& active_priority = active_tile->priority(ACTIVE_TREE);
+ const TilePriority& pending_priority =
+ pending_tile->priority(PENDING_TREE);
+
+ // If we're down to eventually bin tiles on the active tree, process the
+ // pending tree to allow tiles required for activation to be initialized
+ // when memory policy only allows prepaint.
+ if (active_priority.priority_bin == TilePriority::EVENTUALLY &&
+ pending_priority.priority_bin == TilePriority::NOW) {
+ return PENDING_TREE;
+ }
+ return ACTIVE_TREE;
+ }
+ case NEW_CONTENT_TAKES_PRIORITY:
+ return PENDING_TREE;
+ case SAME_PRIORITY_FOR_BOTH_TREES: {
+ const Tile* active_tile = shared_tile ? shared_tile : active_queue->Top();
+ const Tile* pending_tile =
+ shared_tile ? shared_tile : pending_queue->Top();
+
+ const TilePriority& active_priority = active_tile->priority(ACTIVE_TREE);
+ const TilePriority& pending_priority =
+ pending_tile->priority(PENDING_TREE);
+
+ if (active_priority.IsHigherPriorityThan(pending_priority))
+ return ACTIVE_TREE;
+ return PENDING_TREE;
+ }
+ default:
+ NOTREACHED();
+ return ACTIVE_TREE;
+ }
+}
+
+scoped_ptr<TilingSetRasterQueueAll> CreateTilingSetRasterQueue(
+ PictureLayerImpl* layer,
+ TreePriority tree_priority) {
+ if (!layer)
+ return nullptr;
+ PictureLayerTilingSet* tiling_set = layer->picture_layer_tiling_set();
+ bool prioritize_low_res = tree_priority == SMOOTHNESS_TAKES_PRIORITY;
+ return make_scoped_ptr(
+ new TilingSetRasterQueueAll(tiling_set, prioritize_low_res));
+}
+
+} // namespace
+
+RasterTilePriorityQueueAll::RasterTilePriorityQueueAll() {
+}
+
+RasterTilePriorityQueueAll::~RasterTilePriorityQueueAll() {
+}
+
+void RasterTilePriorityQueueAll::Build(
+ const std::vector<PictureLayerImpl::Pair>& paired_layers,
+ TreePriority tree_priority) {
+ tree_priority_ = tree_priority;
+ for (std::vector<PictureLayerImpl::Pair>::const_iterator it =
+ paired_layers.begin();
+ it != paired_layers.end(); ++it) {
+ paired_queues_.push_back(
+ make_scoped_ptr(new PairedTilingSetQueue(*it, tree_priority_)));
+ }
+ paired_queues_.make_heap(RasterOrderComparator(tree_priority_));
+}
+
+bool RasterTilePriorityQueueAll::IsEmpty() const {
+ return paired_queues_.empty() || paired_queues_.front()->IsEmpty();
+}
+
+Tile* RasterTilePriorityQueueAll::Top() {
+ DCHECK(!IsEmpty());
+ return paired_queues_.front()->Top(tree_priority_);
+}
+
+void RasterTilePriorityQueueAll::Pop() {
+ DCHECK(!IsEmpty());
+
+ paired_queues_.pop_heap(RasterOrderComparator(tree_priority_));
+ PairedTilingSetQueue* paired_queue = paired_queues_.back();
+ paired_queue->Pop(tree_priority_);
+ paired_queues_.push_heap(RasterOrderComparator(tree_priority_));
+}
+
+RasterTilePriorityQueueAll::PairedTilingSetQueue::PairedTilingSetQueue() {
+}
+
+RasterTilePriorityQueueAll::PairedTilingSetQueue::PairedTilingSetQueue(
+ const PictureLayerImpl::Pair& layer_pair,
+ TreePriority tree_priority)
+ : active_queue_(
+ CreateTilingSetRasterQueue(layer_pair.active, tree_priority)),
+ pending_queue_(
+ CreateTilingSetRasterQueue(layer_pair.pending, tree_priority)),
+ has_both_layers_(layer_pair.active && layer_pair.pending) {
+ SkipTilesReturnedByTwin(tree_priority);
+
+ TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+ "PairedTilingSetQueue::PairedTilingSetQueue",
+ TRACE_EVENT_SCOPE_THREAD, "state", StateAsValue());
+}
+
+RasterTilePriorityQueueAll::PairedTilingSetQueue::~PairedTilingSetQueue() {
+ TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+ "PairedTilingSetQueue::~PairedTilingSetQueue",
+ TRACE_EVENT_SCOPE_THREAD, "state", StateAsValue());
+}
+
+bool RasterTilePriorityQueueAll::PairedTilingSetQueue::IsEmpty() const {
+ return (!active_queue_ || active_queue_->IsEmpty()) &&
+ (!pending_queue_ || pending_queue_->IsEmpty());
+}
+
+Tile* RasterTilePriorityQueueAll::PairedTilingSetQueue::Top(
+ TreePriority tree_priority) {
+ DCHECK(!IsEmpty());
+
+ WhichTree next_tree = NextTileIteratorTree(tree_priority);
+ TilingSetRasterQueueAll* next_queue =
+ next_tree == ACTIVE_TREE ? active_queue_.get() : pending_queue_.get();
+ DCHECK(next_queue && !next_queue->IsEmpty());
+ Tile* tile = next_queue->Top();
+ DCHECK(returned_tiles_for_debug_.find(tile) ==
+ returned_tiles_for_debug_.end());
+ return tile;
+}
+
+void RasterTilePriorityQueueAll::PairedTilingSetQueue::Pop(
+ TreePriority tree_priority) {
+ DCHECK(!IsEmpty());
+
+ WhichTree next_tree = NextTileIteratorTree(tree_priority);
+ TilingSetRasterQueueAll* next_queue =
+ next_tree == ACTIVE_TREE ? active_queue_.get() : pending_queue_.get();
+ DCHECK(next_queue && !next_queue->IsEmpty());
+ DCHECK(returned_tiles_for_debug_.insert(next_queue->Top()).second);
+ next_queue->Pop();
+
+ SkipTilesReturnedByTwin(tree_priority);
+
+ // If no empty, use Top to do DCHECK the next iterator.
+ DCHECK(IsEmpty() || Top(tree_priority));
+}
+
+void RasterTilePriorityQueueAll::PairedTilingSetQueue::SkipTilesReturnedByTwin(
+ TreePriority tree_priority) {
+ if (!has_both_layers_)
+ return;
+
+ // We have both layers (active and pending) thus we can encounter shared
+ // tiles twice (from the active iterator and from the pending iterator).
+ while (!IsEmpty()) {
+ WhichTree next_tree = NextTileIteratorTree(tree_priority);
+ TilingSetRasterQueueAll* next_queue =
+ next_tree == ACTIVE_TREE ? active_queue_.get() : pending_queue_.get();
+ DCHECK(next_queue && !next_queue->IsEmpty());
+
+ // Accept all non-shared tiles.
+ const Tile* tile = next_queue->Top();
+ if (!tile->is_shared())
+ break;
+
+ // Accept a shared tile if the next tree is the higher priority one
+ // corresponding the iterator (active or pending) which usually (but due
+ // to spiral iterators not always) returns the shared tile first.
+ if (next_tree == HigherPriorityTree(tree_priority, nullptr, nullptr, tile))
+ break;
+
+ next_queue->Pop();
+ }
+}
+
+WhichTree
+RasterTilePriorityQueueAll::PairedTilingSetQueue::NextTileIteratorTree(
+ TreePriority tree_priority) const {
+ DCHECK(!IsEmpty());
+
+ // If we only have one queue with tiles, return it.
+ if (!active_queue_ || active_queue_->IsEmpty())
+ return PENDING_TREE;
+ if (!pending_queue_ || pending_queue_->IsEmpty())
+ return ACTIVE_TREE;
+
+ // Now both iterators have tiles, so we have to decide based on tree priority.
+ return HigherPriorityTree(tree_priority, active_queue_.get(),
+ pending_queue_.get(), nullptr);
+}
+
+scoped_refptr<base::debug::ConvertableToTraceFormat>
+RasterTilePriorityQueueAll::PairedTilingSetQueue::StateAsValue() const {
+ scoped_refptr<base::debug::TracedValue> state =
+ new base::debug::TracedValue();
+
+ bool active_queue_has_tile = active_queue_ && !active_queue_->IsEmpty();
+ TilePriority::PriorityBin active_priority_bin = TilePriority::EVENTUALLY;
+ TilePriority::PriorityBin pending_priority_bin = TilePriority::EVENTUALLY;
+ if (active_queue_has_tile) {
+ active_priority_bin =
+ active_queue_->Top()->priority(ACTIVE_TREE).priority_bin;
+ pending_priority_bin =
+ active_queue_->Top()->priority(PENDING_TREE).priority_bin;
+ }
+
+ state->BeginDictionary("active_queue");
+ state->SetBoolean("has_tile", active_queue_has_tile);
+ state->SetInteger("active_priority_bin", active_priority_bin);
+ state->SetInteger("pending_priority_bin", pending_priority_bin);
+ state->EndDictionary();
+
+ bool pending_queue_has_tile = pending_queue_ && !pending_queue_->IsEmpty();
+ active_priority_bin = TilePriority::EVENTUALLY;
+ pending_priority_bin = TilePriority::EVENTUALLY;
+ if (pending_queue_has_tile) {
+ active_priority_bin =
+ pending_queue_->Top()->priority(ACTIVE_TREE).priority_bin;
+ pending_priority_bin =
+ pending_queue_->Top()->priority(PENDING_TREE).priority_bin;
+ }
+
+ state->BeginDictionary("pending_queue");
+ state->SetBoolean("has_tile", active_queue_has_tile);
+ state->SetInteger("active_priority_bin", active_priority_bin);
+ state->SetInteger("pending_priority_bin", pending_priority_bin);
+ state->EndDictionary();
+ return state;
+}
+
+} // namespace cc
diff --git a/cc/resources/raster_tile_priority_queue_all.h b/cc/resources/raster_tile_priority_queue_all.h
new file mode 100644
index 0000000..c2b8910
--- /dev/null
+++ b/cc/resources/raster_tile_priority_queue_all.h
@@ -0,0 +1,78 @@
+// Copyright 2015 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_TILE_PRIORITY_QUEUE_ALL_H_
+#define CC_RESOURCES_RASTER_TILE_PRIORITY_QUEUE_ALL_H_
+
+#include <set>
+#include <utility>
+#include <vector>
+
+#include "cc/base/cc_export.h"
+#include "cc/layers/picture_layer_impl.h"
+#include "cc/resources/raster_tile_priority_queue.h"
+#include "cc/resources/tile_priority.h"
+#include "cc/resources/tiling_set_raster_queue_all.h"
+
+namespace cc {
+
+class CC_EXPORT RasterTilePriorityQueueAll : public RasterTilePriorityQueue {
+ public:
+ class PairedTilingSetQueue {
+ public:
+ PairedTilingSetQueue();
+ PairedTilingSetQueue(const PictureLayerImpl::Pair& layer_pair,
+ TreePriority tree_priority);
+ ~PairedTilingSetQueue();
+
+ bool IsEmpty() const;
+ Tile* Top(TreePriority tree_priority);
+ void Pop(TreePriority tree_priority);
+
+ WhichTree NextTileIteratorTree(TreePriority tree_priority) const;
+ void SkipTilesReturnedByTwin(TreePriority tree_priority);
+
+ scoped_refptr<base::debug::ConvertableToTraceFormat> StateAsValue() const;
+
+ const TilingSetRasterQueueAll* active_queue() const {
+ return active_queue_.get();
+ }
+ const TilingSetRasterQueueAll* pending_queue() const {
+ return pending_queue_.get();
+ }
+
+ private:
+ scoped_ptr<TilingSetRasterQueueAll> active_queue_;
+ scoped_ptr<TilingSetRasterQueueAll> pending_queue_;
+ bool has_both_layers_;
+
+ // Set of returned tiles (excluding the current one) for DCHECKing.
+ std::set<const Tile*> returned_tiles_for_debug_;
+ };
+
+ RasterTilePriorityQueueAll();
+ ~RasterTilePriorityQueueAll() override;
+
+ bool IsEmpty() const override;
+ Tile* Top() override;
+ void Pop() override;
+
+ private:
+ friend class RasterTilePriorityQueue;
+
+ void Build(const std::vector<PictureLayerImpl::Pair>& paired_layers,
+ TreePriority tree_priority);
+
+ // TODO(vmpstr): This is potentially unnecessary if it becomes the case that
+ // 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(RasterTilePriorityQueueAll);
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_RASTER_TILE_PRIORITY_QUEUE_ALL_H_
diff --git a/cc/resources/raster_tile_priority_queue_required.cc b/cc/resources/raster_tile_priority_queue_required.cc
new file mode 100644
index 0000000..3bf00ed
--- /dev/null
+++ b/cc/resources/raster_tile_priority_queue_required.cc
@@ -0,0 +1,55 @@
+// Copyright 2015 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_tile_priority_queue_required.h"
+
+#include "cc/resources/tiling_set_raster_queue_required.h"
+
+namespace cc {
+
+RasterTilePriorityQueueRequired::RasterTilePriorityQueueRequired() {
+}
+
+RasterTilePriorityQueueRequired::~RasterTilePriorityQueueRequired() {
+}
+
+void RasterTilePriorityQueueRequired::Build(
+ const std::vector<PictureLayerImpl::Pair>& paired_layers,
+ Type type) {
+ DCHECK_NE(static_cast<int>(type), static_cast<int>(Type::ALL));
+ for (const auto& pair : paired_layers) {
+ PictureLayerTilingSet* tiling_set = nullptr;
+ if (type == Type::REQUIRED_FOR_DRAW && pair.active)
+ tiling_set = pair.active->picture_layer_tiling_set();
+ else if (type == Type::REQUIRED_FOR_ACTIVATION && pair.pending)
+ tiling_set = pair.pending->picture_layer_tiling_set();
+
+ if (!tiling_set)
+ continue;
+
+ scoped_ptr<TilingSetRasterQueueRequired> tiling_set_queue(
+ new TilingSetRasterQueueRequired(tiling_set, type));
+ if (tiling_set_queue->IsEmpty())
+ continue;
+ tiling_set_queues_.push_back(tiling_set_queue.Pass());
+ }
+}
+
+bool RasterTilePriorityQueueRequired::IsEmpty() const {
+ return tiling_set_queues_.empty();
+}
+
+Tile* RasterTilePriorityQueueRequired::Top() {
+ DCHECK(!IsEmpty());
+ return tiling_set_queues_.back()->Top();
+}
+
+void RasterTilePriorityQueueRequired::Pop() {
+ DCHECK(!IsEmpty());
+ tiling_set_queues_.back()->Pop();
+ if (tiling_set_queues_.back()->IsEmpty())
+ tiling_set_queues_.pop_back();
+}
+
+} // namespace cc
diff --git a/cc/resources/raster_tile_priority_queue_required.h b/cc/resources/raster_tile_priority_queue_required.h
new file mode 100644
index 0000000..02af2a6
--- /dev/null
+++ b/cc/resources/raster_tile_priority_queue_required.h
@@ -0,0 +1,39 @@
+// Copyright 2015 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_TILE_PRIORITY_QUEUE_REQUIRED_H_
+#define CC_RESOURCES_RASTER_TILE_PRIORITY_QUEUE_REQUIRED_H_
+
+#include <vector>
+
+#include "cc/layers/picture_layer_impl.h"
+#include "cc/resources/raster_tile_priority_queue.h"
+#include "cc/resources/tiling_set_raster_queue_required.h"
+
+namespace cc {
+class Tile;
+
+class RasterTilePriorityQueueRequired : public RasterTilePriorityQueue {
+ public:
+ RasterTilePriorityQueueRequired();
+ ~RasterTilePriorityQueueRequired() override;
+
+ bool IsEmpty() const override;
+ Tile* Top() override;
+ void Pop() override;
+
+ private:
+ friend class RasterTilePriorityQueue;
+
+ void Build(const std::vector<PictureLayerImpl::Pair>& paired_layers,
+ Type type);
+
+ ScopedPtrVector<TilingSetRasterQueueRequired> tiling_set_queues_;
+
+ DISALLOW_COPY_AND_ASSIGN(RasterTilePriorityQueueRequired);
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_RASTER_TILE_PRIORITY_QUEUE_REQUIRED_H_
diff --git a/cc/resources/rasterizer.h b/cc/resources/rasterizer.h
index 803aefa..95b9ce2 100644
--- a/cc/resources/rasterizer.h
+++ b/cc/resources/rasterizer.h
@@ -33,6 +33,7 @@
virtual void RasterizeTiles(
const TileVector& tiles,
ResourcePool* resource_pool,
+ ResourceFormat resource_format,
const UpdateTileDrawInfoCallback& update_tile_draw_info) = 0;
protected:
diff --git a/cc/resources/recording_source.h b/cc/resources/recording_source.h
index 7af2255..1e45047 100644
--- a/cc/resources/recording_source.h
+++ b/cc/resources/recording_source.h
@@ -37,13 +37,9 @@
virtual gfx::Size GetSize() const = 0;
virtual void SetEmptyBounds() = 0;
- virtual void SetMinContentsScale(float min_contents_scale) = 0;
virtual void SetSlowdownRasterScaleFactor(int factor) = 0;
virtual bool IsSuitableForGpuRasterization() const = 0;
- // TODO(hendrikw): This is an implementation detail, remove it when possible.
- virtual void SetTileGridSize(const gfx::Size& tile_grid_size) = 0;
-
// TODO(hendrikw): Figure out how to remove this.
virtual void SetUnsuitableForGpuRasterizationForTesting() = 0;
virtual gfx::Size GetTileGridSizeForTesting() const = 0;
diff --git a/cc/resources/resource_pool.cc b/cc/resources/resource_pool.cc
index f0a871d..2284780 100644
--- a/cc/resources/resource_pool.cc
+++ b/cc/resources/resource_pool.cc
@@ -9,12 +9,9 @@
namespace cc {
-ResourcePool::ResourcePool(ResourceProvider* resource_provider,
- GLenum target,
- ResourceFormat default_format)
+ResourcePool::ResourcePool(ResourceProvider* resource_provider, GLenum target)
: resource_provider_(resource_provider),
target_(target),
- default_format_(default_format),
max_memory_usage_bytes_(0),
max_unused_memory_usage_bytes_(0),
max_resource_count_(0),
diff --git a/cc/resources/resource_pool.h b/cc/resources/resource_pool.h
index 72467c9..f794559 100644
--- a/cc/resources/resource_pool.h
+++ b/cc/resources/resource_pool.h
@@ -19,11 +19,8 @@
class CC_EXPORT ResourcePool {
public:
static scoped_ptr<ResourcePool> Create(ResourceProvider* resource_provider,
- GLenum target,
- ResourceFormat default_format) {
- return make_scoped_ptr(new ResourcePool(resource_provider,
- target,
- default_format));
+ GLenum target) {
+ return make_scoped_ptr(new ResourcePool(resource_provider, target));
}
virtual ~ResourcePool();
@@ -52,12 +49,8 @@
}
size_t busy_resource_count() const { return busy_resources_.size(); }
- ResourceFormat default_format() const { return default_format_; }
-
protected:
- ResourcePool(ResourceProvider* resource_provider,
- GLenum target,
- ResourceFormat default_format);
+ ResourcePool(ResourceProvider* resource_provider, GLenum target);
bool ResourceUsageTooHigh();
@@ -66,9 +59,6 @@
ResourceProvider* resource_provider_;
const GLenum target_;
- // TODO(peterp): Remove the format state and let the clients keep track of
- // this instead.
- const ResourceFormat default_format_;
size_t max_memory_usage_bytes_;
size_t max_unused_memory_usage_bytes_;
size_t max_resource_count_;
diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc
index 38f79fb..4ba46b7 100644
--- a/cc/resources/resource_provider.cc
+++ b/cc/resources/resource_provider.cc
@@ -8,11 +8,11 @@
#include <limits>
#include "base/containers/hash_tables.h"
-#include "base/debug/trace_event.h"
#include "base/metrics/histogram.h"
#include "base/stl_util.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
+#include "base/trace_event/trace_event.h"
#include "cc/base/util.h"
#include "cc/output/gl_renderer.h" // For the GLC() macro.
#include "cc/resources/platform_color.h"
diff --git a/cc/resources/skpicture_content_layer_updater.cc b/cc/resources/skpicture_content_layer_updater.cc
index 3e6828f..ace97a4 100644
--- a/cc/resources/skpicture_content_layer_updater.cc
+++ b/cc/resources/skpicture_content_layer_updater.cc
@@ -4,7 +4,7 @@
#include "cc/resources/skpicture_content_layer_updater.h"
-#include "base/debug/trace_event.h"
+#include "base/trace_event/trace_event.h"
#include "cc/debug/rendering_stats_instrumentation.h"
#include "cc/resources/layer_painter.h"
#include "cc/resources/prioritized_resource.h"
diff --git a/cc/resources/software_rasterizer.cc b/cc/resources/software_rasterizer.cc
index 6ffedac..6060e9e 100644
--- a/cc/resources/software_rasterizer.cc
+++ b/cc/resources/software_rasterizer.cc
@@ -23,6 +23,7 @@
void SoftwareRasterizer::RasterizeTiles(
const TileVector& tiles,
ResourcePool* resource_pool,
+ ResourceFormat resource_format,
const UpdateTileDrawInfoCallback& update_tile_draw_info) {
}
diff --git a/cc/resources/software_rasterizer.h b/cc/resources/software_rasterizer.h
index 7cb33f2..6cb751f 100644
--- a/cc/resources/software_rasterizer.h
+++ b/cc/resources/software_rasterizer.h
@@ -24,6 +24,7 @@
void RasterizeTiles(
const TileVector& tiles,
ResourcePool* resource_pool,
+ ResourceFormat resource_format,
const UpdateTileDrawInfoCallback& update_tile_draw_info) override;
private:
diff --git a/cc/resources/task_graph_runner.cc b/cc/resources/task_graph_runner.cc
index bcbc0dd..1a67faa 100644
--- a/cc/resources/task_graph_runner.cc
+++ b/cc/resources/task_graph_runner.cc
@@ -6,9 +6,9 @@
#include <algorithm>
-#include "base/debug/trace_event.h"
#include "base/strings/stringprintf.h"
#include "base/threading/thread_restrictions.h"
+#include "base/trace_event/trace_event.h"
namespace cc {
namespace {
diff --git a/cc/resources/texture_uploader.cc b/cc/resources/texture_uploader.cc
index 9526fcb..3d0f681 100644
--- a/cc/resources/texture_uploader.cc
+++ b/cc/resources/texture_uploader.cc
@@ -7,8 +7,8 @@
#include <algorithm>
#include <vector>
-#include "base/debug/trace_event.h"
#include "base/metrics/histogram.h"
+#include "base/trace_event/trace_event.h"
#include "cc/base/util.h"
#include "cc/resources/resource.h"
#include "gpu/GLES2/gl2extchromium.h"
diff --git a/cc/resources/tile.cc b/cc/resources/tile.cc
index 6734bab..b0b4525 100644
--- a/cc/resources/tile.cc
+++ b/cc/resources/tile.cc
@@ -6,7 +6,7 @@
#include <algorithm>
-#include "base/debug/trace_event_argument.h"
+#include "base/trace_event/trace_event_argument.h"
#include "cc/base/math_util.h"
#include "cc/debug/traced_value.h"
#include "cc/resources/tile_manager.h"
diff --git a/cc/resources/tile_draw_info.h b/cc/resources/tile_draw_info.h
index b6bc6d8..8437f5b 100644
--- a/cc/resources/tile_draw_info.h
+++ b/cc/resources/tile_draw_info.h
@@ -5,8 +5,8 @@
#ifndef CC_RESOURCES_TILE_DRAW_INFO_H_
#define CC_RESOURCES_TILE_DRAW_INFO_H_
-#include "base/debug/trace_event_argument.h"
#include "base/memory/scoped_ptr.h"
+#include "base/trace_event/trace_event_argument.h"
#include "cc/resources/platform_color.h"
#include "cc/resources/resource_provider.h"
#include "cc/resources/scoped_resource.h"
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 81ae8b5..da888cd 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -9,10 +9,10 @@
#include <string>
#include "base/bind.h"
-#include "base/debug/trace_event_argument.h"
#include "base/json/json_writer.h"
#include "base/logging.h"
#include "base/metrics/histogram.h"
+#include "base/trace_event/trace_event_argument.h"
#include "cc/debug/devtools_instrumentation.h"
#include "cc/debug/frame_viewer_instrumentation.h"
#include "cc/debug/traced_value.h"
@@ -240,7 +240,6 @@
task_runner_.get(),
base::Bind(&TileManager::CheckIfMoreTilesNeedToBePrepared,
base::Unretained(this))),
- eviction_priority_queue_is_up_to_date_(false),
did_notify_ready_to_activate_(false),
did_notify_ready_to_draw_(false) {
tile_task_runner_->SetClient(this);
@@ -360,11 +359,11 @@
CleanUpReleasedTiles();
TileVector tiles_that_need_to_be_rasterized;
- RasterTilePriorityQueue raster_priority_queue;
- client_->BuildRasterQueue(&raster_priority_queue,
- global_state_.tree_priority,
- RasterTilePriorityQueue::Type::ALL);
- AssignGpuMemoryToTiles(&raster_priority_queue, scheduled_raster_task_limit_,
+ scoped_ptr<RasterTilePriorityQueue> raster_priority_queue(
+ client_->BuildRasterQueue(global_state_.tree_priority,
+ RasterTilePriorityQueue::Type::ALL));
+ AssignGpuMemoryToTiles(raster_priority_queue.get(),
+ scheduled_raster_task_limit_,
&tiles_that_need_to_be_rasterized);
// Schedule tile tasks.
@@ -374,15 +373,12 @@
did_notify_ready_to_draw_ = false;
} else {
if (global_state_.hard_memory_limit_in_bytes == 0) {
- // TODO(vmpstr): Add a function to unconditionally create an eviction
- // queue and guard the rest of the calls sites with this flag, instead of
- // clearing here and building, which is a bit awkward.
- eviction_priority_queue_is_up_to_date_ = false;
resource_pool_->CheckBusyResources(false);
MemoryUsage memory_limit(0, 0);
MemoryUsage memory_usage(resource_pool_->acquired_memory_usage_bytes(),
resource_pool_->acquired_resource_count());
- FreeTileResourcesUntilUsageIsWithinLimit(memory_limit, &memory_usage);
+ FreeTileResourcesUntilUsageIsWithinLimit(nullptr, memory_limit,
+ &memory_usage);
}
did_notify_ready_to_activate_ = false;
@@ -411,12 +407,12 @@
FreeResourcesForReleasedTiles();
CleanUpReleasedTiles();
- RasterTilePriorityQueue required_for_draw_queue;
- client_->BuildRasterQueue(&required_for_draw_queue,
- global_state_.tree_priority,
- RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
+ scoped_ptr<RasterTilePriorityQueue> required_for_draw_queue(
+ client_->BuildRasterQueue(
+ global_state_.tree_priority,
+ RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW));
TileVector tiles_that_need_to_be_rasterized;
- AssignGpuMemoryToTiles(&required_for_draw_queue,
+ AssignGpuMemoryToTiles(required_for_draw_queue.get(),
std::numeric_limits<size_t>::max(),
&tiles_that_need_to_be_rasterized);
@@ -427,21 +423,21 @@
// Run and complete all raster task synchronously.
rasterizer_->RasterizeTiles(
tiles_that_need_to_be_rasterized, resource_pool_,
+ tile_task_runner_->GetResourceFormat(),
base::Bind(&TileManager::UpdateTileDrawInfo, base::Unretained(this)));
// Use on-demand raster for any required-for-draw tiles that have not been
// assigned memory after reaching a steady memory state.
// TODO(hendrikw): Figure out why this would improve jank on some tests - See
// crbug.com/449288
- required_for_draw_queue.Reset();
- client_->BuildRasterQueue(&required_for_draw_queue,
- global_state_.tree_priority,
- RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
+ required_for_draw_queue = client_->BuildRasterQueue(
+ global_state_.tree_priority,
+ RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
// Use on-demand raster for any tiles that have not been been assigned
// memory. This ensures that we draw even when OOM.
- for (; !required_for_draw_queue.IsEmpty(); required_for_draw_queue.Pop()) {
- Tile* tile = required_for_draw_queue.Top();
+ for (; !required_for_draw_queue->IsEmpty(); required_for_draw_queue->Pop()) {
+ Tile* tile = required_for_draw_queue->Top();
tile->draw_info().set_rasterize_on_demand();
client_->NotifyTileStateChanged(tile);
}
@@ -492,54 +488,50 @@
state->EndDictionary();
}
-void TileManager::RebuildEvictionQueueIfNeeded() {
- TRACE_EVENT1("cc",
- "TileManager::RebuildEvictionQueueIfNeeded",
- "eviction_priority_queue_is_up_to_date",
- eviction_priority_queue_is_up_to_date_);
- if (eviction_priority_queue_is_up_to_date_)
- return;
-
- eviction_priority_queue_.Reset();
- client_->BuildEvictionQueue(&eviction_priority_queue_,
- global_state_.tree_priority);
- eviction_priority_queue_is_up_to_date_ = true;
-}
-
-bool TileManager::FreeTileResourcesUntilUsageIsWithinLimit(
+scoped_ptr<EvictionTilePriorityQueue>
+TileManager::FreeTileResourcesUntilUsageIsWithinLimit(
+ scoped_ptr<EvictionTilePriorityQueue> eviction_priority_queue,
const MemoryUsage& limit,
MemoryUsage* usage) {
while (usage->Exceeds(limit)) {
- RebuildEvictionQueueIfNeeded();
- if (eviction_priority_queue_.IsEmpty())
- return false;
+ if (!eviction_priority_queue) {
+ eviction_priority_queue =
+ client_->BuildEvictionQueue(global_state_.tree_priority);
+ }
+ if (eviction_priority_queue->IsEmpty())
+ break;
- Tile* tile = eviction_priority_queue_.Top();
+ Tile* tile = eviction_priority_queue->Top();
*usage -= MemoryUsage::FromTile(tile);
FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
- eviction_priority_queue_.Pop();
+ eviction_priority_queue->Pop();
}
- return true;
+ return eviction_priority_queue;
}
-bool TileManager::FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
+scoped_ptr<EvictionTilePriorityQueue>
+TileManager::FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
+ scoped_ptr<EvictionTilePriorityQueue> eviction_priority_queue,
const MemoryUsage& limit,
const TilePriority& other_priority,
MemoryUsage* usage) {
while (usage->Exceeds(limit)) {
- RebuildEvictionQueueIfNeeded();
- if (eviction_priority_queue_.IsEmpty())
- return false;
+ if (!eviction_priority_queue) {
+ eviction_priority_queue =
+ client_->BuildEvictionQueue(global_state_.tree_priority);
+ }
+ if (eviction_priority_queue->IsEmpty())
+ break;
- Tile* tile = eviction_priority_queue_.Top();
+ Tile* tile = eviction_priority_queue->Top();
if (!other_priority.IsHigherPriorityThan(tile->combined_priority()))
- return false;
+ break;
*usage -= MemoryUsage::FromTile(tile);
FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
- eviction_priority_queue_.Pop();
+ eviction_priority_queue->Pop();
}
- return true;
+ return eviction_priority_queue;
}
bool TileManager::TilePriorityViolatesMemoryPolicy(
@@ -584,7 +576,7 @@
MemoryUsage memory_usage(resource_pool_->acquired_memory_usage_bytes(),
resource_pool_->acquired_resource_count());
- eviction_priority_queue_is_up_to_date_ = false;
+ scoped_ptr<EvictionTilePriorityQueue> eviction_priority_queue;
for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) {
Tile* tile = raster_priority_queue->Top();
TilePriority priority = tile->combined_priority();
@@ -615,7 +607,7 @@
MemoryUsage memory_required_by_tile_to_be_scheduled;
if (!tile->raster_task_.get()) {
memory_required_by_tile_to_be_scheduled = MemoryUsage::FromConfig(
- tile->desired_texture_size(), resource_pool_->default_format());
+ tile->desired_texture_size(), tile_task_runner_->GetResourceFormat());
}
bool tile_is_needed_now = priority.priority_bin == TilePriority::NOW;
@@ -626,10 +618,14 @@
MemoryUsage& tile_memory_limit =
tile_is_needed_now ? hard_memory_limit : soft_memory_limit;
- bool memory_usage_is_within_limit =
+ const MemoryUsage& scheduled_tile_memory_limit =
+ tile_memory_limit - memory_required_by_tile_to_be_scheduled;
+ eviction_priority_queue =
FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
- tile_memory_limit - memory_required_by_tile_to_be_scheduled,
+ eviction_priority_queue.Pass(), scheduled_tile_memory_limit,
priority, &memory_usage);
+ bool memory_usage_is_within_limit =
+ !memory_usage.Exceeds(scheduled_tile_memory_limit);
// If we couldn't fit the tile into our current memory limit, then we're
// done.
@@ -647,7 +643,8 @@
// Note that we should try and further reduce memory in case the above loop
// didn't reduce memory. This ensures that we always release as many resources
// as possible to stay within the memory limit.
- FreeTileResourcesUntilUsageIsWithinLimit(hard_memory_limit, &memory_usage);
+ eviction_priority_queue = FreeTileResourcesUntilUsageIsWithinLimit(
+ eviction_priority_queue.Pass(), hard_memory_limit, &memory_usage);
UMA_HISTOGRAM_BOOLEAN("TileManager.ExceededMemoryBudget",
!had_enough_memory_to_schedule_tiles_needed_now);
@@ -746,7 +743,7 @@
scoped_refptr<RasterTask> TileManager::CreateRasterTask(Tile* tile) {
scoped_ptr<ScopedResource> resource =
resource_pool_->AcquireResource(tile->desired_texture_size(),
- resource_pool_->default_format());
+ tile_task_runner_->GetResourceFormat());
const ScopedResource* const_resource = resource.get();
// Create and queue all image decode tasks that this tile depends on.
@@ -944,10 +941,11 @@
// When OOM, keep re-assigning memory until we reach a steady state
// where top-priority tiles are initialized.
TileVector tiles_that_need_to_be_rasterized;
- RasterTilePriorityQueue raster_priority_queue;
- client_->BuildRasterQueue(&raster_priority_queue, global_state_.tree_priority,
- RasterTilePriorityQueue::Type::ALL);
- AssignGpuMemoryToTiles(&raster_priority_queue, scheduled_raster_task_limit_,
+ scoped_ptr<RasterTilePriorityQueue> raster_priority_queue(
+ client_->BuildRasterQueue(global_state_.tree_priority,
+ RasterTilePriorityQueue::Type::ALL));
+ AssignGpuMemoryToTiles(raster_priority_queue.get(),
+ scheduled_raster_task_limit_,
&tiles_that_need_to_be_rasterized);
// |tiles_that_need_to_be_rasterized| will be empty when we reach a
@@ -977,20 +975,20 @@
// we used for AssignGpuMemoryToTiles, since the AssignGpuMemoryToTiles call
// could have evicted some tiles that would not be picked up by the old raster
// queue.
- RasterTilePriorityQueue required_for_activation_queue;
- client_->BuildRasterQueue(
- &required_for_activation_queue, global_state_.tree_priority,
- RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
+ scoped_ptr<RasterTilePriorityQueue> required_for_activation_queue(
+ client_->BuildRasterQueue(
+ global_state_.tree_priority,
+ RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION));
// If we have tiles to mark as rasterize on demand, but we don't allow
// rasterize on demand, then skip activation and return early.
- if (!required_for_activation_queue.IsEmpty() && !allow_rasterize_on_demand)
+ if (!required_for_activation_queue->IsEmpty() && !allow_rasterize_on_demand)
return;
// Mark required tiles as rasterize on demand.
- for (; !required_for_activation_queue.IsEmpty();
- required_for_activation_queue.Pop()) {
- Tile* tile = required_for_activation_queue.Top();
+ for (; !required_for_activation_queue->IsEmpty();
+ required_for_activation_queue->Pop()) {
+ Tile* tile = required_for_activation_queue->Top();
tile->draw_info().set_rasterize_on_demand();
client_->NotifyTileStateChanged(tile);
}
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index e93373a..f945f7c 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -60,15 +60,15 @@
// Given an empty raster tile priority queue, this will build a priority queue
// that will return tiles in order in which they should be rasterized.
// Note if the queue was previous built, Reset must be called on it.
- virtual void BuildRasterQueue(RasterTilePriorityQueue* queue,
- TreePriority tree_priority,
- RasterTilePriorityQueue::Type type) = 0;
+ virtual scoped_ptr<RasterTilePriorityQueue> BuildRasterQueue(
+ TreePriority tree_priority,
+ RasterTilePriorityQueue::Type type) = 0;
// Given an empty eviction tile priority queue, this will build a priority
// queue that will return tiles in order in which they should be evicted.
// Note if the queue was previous built, Reset must be called on it.
- virtual void BuildEvictionQueue(EvictionTilePriorityQueue* queue,
- TreePriority tree_priority) = 0;
+ virtual scoped_ptr<EvictionTilePriorityQueue> BuildEvictionQueue(
+ TreePriority tree_priority) = 0;
protected:
virtual ~TileManagerClient() {}
@@ -138,9 +138,9 @@
void InitializeTilesWithResourcesForTesting(const std::vector<Tile*>& tiles) {
for (size_t i = 0; i < tiles.size(); ++i) {
TileDrawInfo& draw_info = tiles[i]->draw_info();
- draw_info.resource_ =
- resource_pool_->AcquireResource(tiles[i]->desired_texture_size(),
- resource_pool_->default_format());
+ draw_info.resource_ = resource_pool_->AcquireResource(
+ tiles[i]->desired_texture_size(),
+ tile_task_runner_->GetResourceFormat());
}
}
@@ -247,10 +247,14 @@
SkPixelRef* pixel_ref);
scoped_refptr<RasterTask> CreateRasterTask(Tile* tile);
- void RebuildEvictionQueueIfNeeded();
- bool FreeTileResourcesUntilUsageIsWithinLimit(const MemoryUsage& limit,
- MemoryUsage* usage);
- bool FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
+ scoped_ptr<EvictionTilePriorityQueue>
+ FreeTileResourcesUntilUsageIsWithinLimit(
+ scoped_ptr<EvictionTilePriorityQueue> eviction_priority_queue,
+ const MemoryUsage& limit,
+ MemoryUsage* usage);
+ scoped_ptr<EvictionTilePriorityQueue>
+ FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
+ scoped_ptr<EvictionTilePriorityQueue> eviction_priority_queue,
const MemoryUsage& limit,
const TilePriority& oother_priority,
MemoryUsage* usage);
@@ -292,8 +296,6 @@
std::vector<Tile*> released_tiles_;
- ResourceFormat resource_format_;
-
// Queue used when scheduling raster tasks.
TileTaskQueue raster_queue_;
@@ -305,9 +307,6 @@
UniqueNotifier ready_to_draw_check_notifier_;
UniqueNotifier more_tiles_need_prepare_check_notifier_;
- EvictionTilePriorityQueue eviction_priority_queue_;
- bool eviction_priority_queue_is_up_to_date_;
-
bool did_notify_ready_to_activate_;
bool did_notify_ready_to_draw_;
diff --git a/cc/resources/tile_manager_perftest.cc b/cc/resources/tile_manager_perftest.cc
index 911e5c9..bb4ce7c 100644
--- a/cc/resources/tile_manager_perftest.cc
+++ b/cc/resources/tile_manager_perftest.cc
@@ -64,6 +64,9 @@
}
completed_tasks_.clear();
}
+ ResourceFormat GetResourceFormat() override {
+ return RGBA_8888;
+ }
// Overridden from TileTaskClient:
scoped_ptr<RasterBuffer> AcquireBufferForRaster(
@@ -180,9 +183,8 @@
timer_.Reset();
do {
- RasterTilePriorityQueue queue;
- host_impl_.BuildRasterQueue(&queue, priorities[priority_count],
- RasterTilePriorityQueue::Type::ALL);
+ scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
+ priorities[priority_count], RasterTilePriorityQueue::Type::ALL));
priority_count = (priority_count + 1) % arraysize(priorities);
timer_.NextLap();
} while (!timer_.HasTimeLimitExpired());
@@ -211,13 +213,12 @@
timer_.Reset();
do {
int count = tile_count;
- RasterTilePriorityQueue queue;
- host_impl_.BuildRasterQueue(&queue, priorities[priority_count],
- RasterTilePriorityQueue::Type::ALL);
+ scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
+ priorities[priority_count], RasterTilePriorityQueue::Type::ALL));
while (count--) {
- ASSERT_FALSE(queue.IsEmpty());
- ASSERT_TRUE(queue.Top() != NULL);
- queue.Pop();
+ ASSERT_FALSE(queue->IsEmpty());
+ ASSERT_TRUE(queue->Top() != NULL);
+ queue->Pop();
}
priority_count = (priority_count + 1) % arraysize(priorities);
timer_.NextLap();
@@ -251,8 +252,8 @@
timer_.Reset();
do {
- EvictionTilePriorityQueue queue;
- host_impl_.BuildEvictionQueue(&queue, priorities[priority_count]);
+ scoped_ptr<EvictionTilePriorityQueue> queue(
+ host_impl_.BuildEvictionQueue(priorities[priority_count]));
priority_count = (priority_count + 1) % arraysize(priorities);
timer_.NextLap();
} while (!timer_.HasTimeLimitExpired());
@@ -287,12 +288,12 @@
timer_.Reset();
do {
int count = tile_count;
- EvictionTilePriorityQueue queue;
- host_impl_.BuildEvictionQueue(&queue, priorities[priority_count]);
+ scoped_ptr<EvictionTilePriorityQueue> queue(
+ host_impl_.BuildEvictionQueue(priorities[priority_count]));
while (count--) {
- ASSERT_FALSE(queue.IsEmpty());
- ASSERT_TRUE(queue.Top() != NULL);
- queue.Pop();
+ ASSERT_FALSE(queue->IsEmpty());
+ ASSERT_TRUE(queue->Top() != NULL);
+ queue->Pop();
}
priority_count = (priority_count + 1) % arraysize(priorities);
timer_.NextLap();
diff --git a/cc/resources/tile_manager_unittest.cc b/cc/resources/tile_manager_unittest.cc
index aae4e3f..8b5ab3f 100644
--- a/cc/resources/tile_manager_unittest.cc
+++ b/cc/resources/tile_manager_unittest.cc
@@ -151,18 +151,17 @@
host_impl_.SetViewportSize(layer_bounds);
SetupDefaultTrees(layer_bounds);
- RasterTilePriorityQueue queue;
- host_impl_.BuildRasterQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL);
- EXPECT_FALSE(queue.IsEmpty());
+ scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
+ SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
+ EXPECT_FALSE(queue->IsEmpty());
size_t tile_count = 0;
std::set<Tile*> all_tiles;
- while (!queue.IsEmpty()) {
- EXPECT_TRUE(queue.Top());
- all_tiles.insert(queue.Top());
+ while (!queue->IsEmpty()) {
+ EXPECT_TRUE(queue->Top());
+ all_tiles.insert(queue->Top());
++tile_count;
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(tile_count, all_tiles.size());
@@ -170,12 +169,11 @@
// Sanity check, all tiles should be visible.
std::set<Tile*> smoothness_tiles;
- queue.Reset();
- host_impl_.BuildRasterQueue(&queue, SMOOTHNESS_TAKES_PRIORITY,
- RasterTilePriorityQueue::Type::ALL);
+ queue = host_impl_.BuildRasterQueue(SMOOTHNESS_TAKES_PRIORITY,
+ RasterTilePriorityQueue::Type::ALL);
bool had_low_res = false;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile);
EXPECT_EQ(TilePriority::NOW, tile->priority(ACTIVE_TREE).priority_bin);
EXPECT_EQ(TilePriority::NOW, tile->priority(PENDING_TREE).priority_bin);
@@ -183,35 +181,34 @@
had_low_res = true;
else
smoothness_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(all_tiles, smoothness_tiles);
EXPECT_TRUE(had_low_res);
// Check that everything is required for activation.
- queue.Reset();
- host_impl_.BuildRasterQueue(
- &queue, SMOOTHNESS_TAKES_PRIORITY,
+ queue = host_impl_.BuildRasterQueue(
+ SMOOTHNESS_TAKES_PRIORITY,
RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
std::set<Tile*> required_for_activation_tiles;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile->required_for_activation());
required_for_activation_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(all_tiles, required_for_activation_tiles);
// Check that everything is required for draw.
- queue.Reset();
- host_impl_.BuildRasterQueue(&queue, SMOOTHNESS_TAKES_PRIORITY,
- RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
+ queue = host_impl_.BuildRasterQueue(
+ SMOOTHNESS_TAKES_PRIORITY,
+ RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
std::set<Tile*> required_for_draw_tiles;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile->required_for_draw());
required_for_draw_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(all_tiles, required_for_draw_tiles);
@@ -268,13 +265,12 @@
tile_count = 0;
size_t correct_order_tiles = 0u;
// Here we expect to get increasing ACTIVE_TREE priority_bin.
- queue.Reset();
- host_impl_.BuildRasterQueue(&queue, SMOOTHNESS_TAKES_PRIORITY,
- RasterTilePriorityQueue::Type::ALL);
+ queue = host_impl_.BuildRasterQueue(SMOOTHNESS_TAKES_PRIORITY,
+ RasterTilePriorityQueue::Type::ALL);
std::set<Tile*> expected_required_for_draw_tiles;
std::set<Tile*> expected_required_for_activation_tiles;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile);
if (!last_tile)
@@ -312,7 +308,7 @@
expected_required_for_draw_tiles.insert(tile);
if (tile->required_for_activation())
expected_required_for_activation_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(tile_count, smoothness_tiles.size());
@@ -322,31 +318,30 @@
EXPECT_GT(correct_order_tiles, 3 * tile_count / 4);
// Check that we have consistent required_for_activation tiles.
- queue.Reset();
- host_impl_.BuildRasterQueue(
- &queue, SMOOTHNESS_TAKES_PRIORITY,
+ queue = host_impl_.BuildRasterQueue(
+ SMOOTHNESS_TAKES_PRIORITY,
RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
required_for_activation_tiles.clear();
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile->required_for_activation());
required_for_activation_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(expected_required_for_activation_tiles,
required_for_activation_tiles);
EXPECT_NE(all_tiles, required_for_activation_tiles);
// Check that we have consistent required_for_draw tiles.
- queue.Reset();
- host_impl_.BuildRasterQueue(&queue, SMOOTHNESS_TAKES_PRIORITY,
- RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
+ queue = host_impl_.BuildRasterQueue(
+ SMOOTHNESS_TAKES_PRIORITY,
+ RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
required_for_draw_tiles.clear();
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile->required_for_draw());
required_for_draw_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(expected_required_for_draw_tiles, required_for_draw_tiles);
EXPECT_NE(all_tiles, required_for_draw_tiles);
@@ -355,12 +350,11 @@
last_tile = NULL;
size_t increasing_distance_tiles = 0u;
// Here we expect to get increasing PENDING_TREE priority_bin.
- queue.Reset();
- host_impl_.BuildRasterQueue(&queue, NEW_CONTENT_TAKES_PRIORITY,
- RasterTilePriorityQueue::Type::ALL);
+ queue = host_impl_.BuildRasterQueue(NEW_CONTENT_TAKES_PRIORITY,
+ RasterTilePriorityQueue::Type::ALL);
tile_count = 0;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile);
if (!last_tile)
@@ -385,7 +379,7 @@
last_tile = tile;
new_content_tiles.insert(tile);
++tile_count;
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(tile_count, new_content_tiles.size());
@@ -395,31 +389,30 @@
EXPECT_GE(increasing_distance_tiles, 3 * tile_count / 4);
// Check that we have consistent required_for_activation tiles.
- queue.Reset();
- host_impl_.BuildRasterQueue(
- &queue, NEW_CONTENT_TAKES_PRIORITY,
+ queue = host_impl_.BuildRasterQueue(
+ NEW_CONTENT_TAKES_PRIORITY,
RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
required_for_activation_tiles.clear();
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile->required_for_activation());
required_for_activation_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(expected_required_for_activation_tiles,
required_for_activation_tiles);
EXPECT_NE(new_content_tiles, required_for_activation_tiles);
// Check that we have consistent required_for_draw tiles.
- queue.Reset();
- host_impl_.BuildRasterQueue(&queue, NEW_CONTENT_TAKES_PRIORITY,
- RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
+ queue = host_impl_.BuildRasterQueue(
+ NEW_CONTENT_TAKES_PRIORITY,
+ RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
required_for_draw_tiles.clear();
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile->required_for_draw());
required_for_draw_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(expected_required_for_draw_tiles, required_for_draw_tiles);
EXPECT_NE(new_content_tiles, required_for_draw_tiles);
@@ -485,14 +478,13 @@
// The actual test will now build different queues and verify that the queues
// return the same information as computed manually above.
- RasterTilePriorityQueue queue;
- host_impl_.BuildRasterQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL);
+ scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
+ SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
std::set<Tile*> actual_now_tiles;
std::set<Tile*> actual_all_tiles;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
- queue.Pop();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
+ queue->Pop();
if (tile->combined_priority().priority_bin == TilePriority::NOW)
actual_now_tiles.insert(tile);
actual_all_tiles.insert(tile);
@@ -500,25 +492,24 @@
EXPECT_EQ(expected_now_tiles, actual_now_tiles);
EXPECT_EQ(expected_all_tiles, actual_all_tiles);
- queue.Reset();
- host_impl_.BuildRasterQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
+ queue = host_impl_.BuildRasterQueue(
+ SAME_PRIORITY_FOR_BOTH_TREES,
+ RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
std::set<Tile*> actual_required_for_draw_tiles;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
- queue.Pop();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
+ queue->Pop();
actual_required_for_draw_tiles.insert(tile);
}
EXPECT_EQ(expected_required_for_draw_tiles, actual_required_for_draw_tiles);
- queue.Reset();
- host_impl_.BuildRasterQueue(
- &queue, SAME_PRIORITY_FOR_BOTH_TREES,
+ queue = host_impl_.BuildRasterQueue(
+ SAME_PRIORITY_FOR_BOTH_TREES,
RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
std::set<Tile*> actual_required_for_activation_tiles;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
- queue.Pop();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
+ queue->Pop();
actual_required_for_activation_tiles.insert(tile);
}
EXPECT_EQ(expected_required_for_activation_tiles,
@@ -552,22 +543,21 @@
CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
host_impl_.pending_tree()->UpdateDrawProperties();
- RasterTilePriorityQueue queue;
host_impl_.SetRequiresHighResToDraw();
- host_impl_.BuildRasterQueue(&queue, SMOOTHNESS_TAKES_PRIORITY,
- RasterTilePriorityQueue::Type::ALL);
- EXPECT_FALSE(queue.IsEmpty());
+ scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
+ SMOOTHNESS_TAKES_PRIORITY, RasterTilePriorityQueue::Type::ALL));
+ EXPECT_FALSE(queue->IsEmpty());
// Get all the tiles that are NOW or SOON and make sure they are ready to
// draw.
std::vector<Tile*> all_tiles;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
if (tile->combined_priority().priority_bin >= TilePriority::EVENTUALLY)
break;
all_tiles.push_back(tile);
- queue.Pop();
+ queue->Pop();
}
tile_manager()->InitializeTilesWithResourcesForTesting(
@@ -583,20 +573,19 @@
host_impl_.SetViewportSize(layer_bounds);
SetupDefaultTrees(layer_bounds);
- EvictionTilePriorityQueue empty_queue;
- host_impl_.BuildEvictionQueue(&empty_queue, SAME_PRIORITY_FOR_BOTH_TREES);
- EXPECT_TRUE(empty_queue.IsEmpty());
+ scoped_ptr<EvictionTilePriorityQueue> empty_queue(
+ host_impl_.BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
+ EXPECT_TRUE(empty_queue->IsEmpty());
std::set<Tile*> all_tiles;
size_t tile_count = 0;
- RasterTilePriorityQueue raster_queue;
- host_impl_.BuildRasterQueue(&raster_queue, SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL);
- while (!raster_queue.IsEmpty()) {
+ scoped_ptr<RasterTilePriorityQueue> raster_queue(host_impl_.BuildRasterQueue(
+ SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
+ while (!raster_queue->IsEmpty()) {
++tile_count;
- EXPECT_TRUE(raster_queue.Top());
- all_tiles.insert(raster_queue.Top());
- raster_queue.Pop();
+ EXPECT_TRUE(raster_queue->Top());
+ all_tiles.insert(raster_queue->Top());
+ raster_queue->Pop();
}
EXPECT_EQ(tile_count, all_tiles.size());
@@ -605,20 +594,20 @@
tile_manager()->InitializeTilesWithResourcesForTesting(
std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
- EvictionTilePriorityQueue queue;
- host_impl_.BuildEvictionQueue(&queue, SMOOTHNESS_TAKES_PRIORITY);
- EXPECT_FALSE(queue.IsEmpty());
+ scoped_ptr<EvictionTilePriorityQueue> queue(
+ host_impl_.BuildEvictionQueue(SMOOTHNESS_TAKES_PRIORITY));
+ EXPECT_FALSE(queue->IsEmpty());
// Sanity check, all tiles should be visible.
std::set<Tile*> smoothness_tiles;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile);
EXPECT_EQ(TilePriority::NOW, tile->priority(ACTIVE_TREE).priority_bin);
EXPECT_EQ(TilePriority::NOW, tile->priority(PENDING_TREE).priority_bin);
EXPECT_TRUE(tile->HasResource());
smoothness_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(all_tiles, smoothness_tiles);
@@ -675,12 +664,11 @@
smoothness_tiles.clear();
tile_count = 0;
// Here we expect to get increasing ACTIVE_TREE priority_bin.
- queue.Reset();
- host_impl_.BuildEvictionQueue(&queue, SMOOTHNESS_TAKES_PRIORITY);
+ queue = host_impl_.BuildEvictionQueue(SMOOTHNESS_TAKES_PRIORITY);
int distance_increasing = 0;
int distance_decreasing = 0;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile);
EXPECT_TRUE(tile->HasResource());
@@ -706,7 +694,7 @@
last_tile = tile;
++tile_count;
smoothness_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(3, distance_increasing);
@@ -717,12 +705,11 @@
std::set<Tile*> new_content_tiles;
last_tile = NULL;
// Here we expect to get increasing PENDING_TREE priority_bin.
- queue.Reset();
- host_impl_.BuildEvictionQueue(&queue, NEW_CONTENT_TAKES_PRIORITY);
+ queue = host_impl_.BuildEvictionQueue(NEW_CONTENT_TAKES_PRIORITY);
distance_decreasing = 0;
distance_increasing = 0;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile);
if (!last_tile)
@@ -746,7 +733,7 @@
last_tile = tile;
new_content_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(3, distance_increasing);
@@ -787,14 +774,13 @@
std::set<Tile*> all_tiles;
size_t tile_count = 0;
- RasterTilePriorityQueue raster_queue;
- host_impl_.BuildRasterQueue(&raster_queue, SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL);
- while (!raster_queue.IsEmpty()) {
+ scoped_ptr<RasterTilePriorityQueue> raster_queue(host_impl_.BuildRasterQueue(
+ SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
+ while (!raster_queue->IsEmpty()) {
++tile_count;
- EXPECT_TRUE(raster_queue.Top());
- all_tiles.insert(raster_queue.Top());
- raster_queue.Pop();
+ EXPECT_TRUE(raster_queue->Top());
+ all_tiles.insert(raster_queue->Top());
+ raster_queue->Pop();
}
EXPECT_EQ(tile_count, all_tiles.size());
EXPECT_EQ(32u, tile_count);
@@ -843,10 +829,10 @@
TreePriority tree_priority = NEW_CONTENT_TAKES_PRIORITY;
size_t occluded_count = 0u;
Tile* last_tile = NULL;
- EvictionTilePriorityQueue queue;
- host_impl_.BuildEvictionQueue(&queue, tree_priority);
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ scoped_ptr<EvictionTilePriorityQueue> queue(
+ host_impl_.BuildEvictionQueue(tree_priority));
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
if (!last_tile)
last_tile = tile;
@@ -872,7 +858,7 @@
}
}
last_tile = tile;
- queue.Pop();
+ queue->Pop();
}
size_t expected_occluded_count =
pending_child_high_res_tiles.size() + pending_child_low_res_tiles.size();
@@ -969,10 +955,10 @@
TreePriority tree_priority = NEW_CONTENT_TAKES_PRIORITY;
std::set<Tile*> new_content_tiles;
size_t tile_count = 0;
- EvictionTilePriorityQueue queue;
- host_impl_.BuildEvictionQueue(&queue, tree_priority);
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ scoped_ptr<EvictionTilePriorityQueue> queue(
+ host_impl_.BuildEvictionQueue(tree_priority));
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
const TilePriority& pending_priority = tile->priority(PENDING_TREE);
EXPECT_NE(std::numeric_limits<float>::infinity(),
pending_priority.distance_to_visible);
@@ -982,7 +968,7 @@
EXPECT_EQ(TilePriority::NOW, pending_priority.priority_bin);
new_content_tiles.insert(tile);
++tile_count;
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(tile_count, new_content_tiles.size());
EXPECT_EQ(all_tiles, new_content_tiles);
@@ -993,24 +979,22 @@
host_impl_.SetViewportSize(layer_bounds);
SetupDefaultTrees(layer_bounds);
- RasterTilePriorityQueue queue;
- host_impl_.BuildRasterQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL);
- EXPECT_FALSE(queue.IsEmpty());
+ scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
+ SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
+ EXPECT_FALSE(queue->IsEmpty());
size_t tile_count = 0;
std::set<Tile*> all_tiles;
- while (!queue.IsEmpty()) {
- EXPECT_TRUE(queue.Top());
- all_tiles.insert(queue.Top());
+ while (!queue->IsEmpty()) {
+ EXPECT_TRUE(queue->Top());
+ all_tiles.insert(queue->Top());
++tile_count;
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(tile_count, all_tiles.size());
EXPECT_EQ(16u, tile_count);
- queue.Reset();
for (int i = 1; i < 10; ++i) {
scoped_ptr<FakePictureLayerImpl> pending_layer =
FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
@@ -1019,17 +1003,17 @@
pending_layer_->AddChild(pending_layer.Pass());
}
- host_impl_.BuildRasterQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL);
- EXPECT_FALSE(queue.IsEmpty());
+ queue = host_impl_.BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
+ RasterTilePriorityQueue::Type::ALL);
+ EXPECT_FALSE(queue->IsEmpty());
tile_count = 0;
all_tiles.clear();
- while (!queue.IsEmpty()) {
- EXPECT_TRUE(queue.Top());
- all_tiles.insert(queue.Top());
+ while (!queue->IsEmpty()) {
+ EXPECT_TRUE(queue->Top());
+ all_tiles.insert(queue->Top());
++tile_count;
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(tile_count, all_tiles.size());
EXPECT_EQ(16u, tile_count);
@@ -1040,18 +1024,17 @@
host_impl_.SetViewportSize(layer_bounds);
SetupDefaultTrees(layer_bounds);
- RasterTilePriorityQueue raster_queue;
- host_impl_.BuildRasterQueue(&raster_queue, SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL);
- EXPECT_FALSE(raster_queue.IsEmpty());
+ scoped_ptr<RasterTilePriorityQueue> raster_queue(host_impl_.BuildRasterQueue(
+ SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
+ EXPECT_FALSE(raster_queue->IsEmpty());
size_t tile_count = 0;
std::set<Tile*> all_tiles;
- while (!raster_queue.IsEmpty()) {
- EXPECT_TRUE(raster_queue.Top());
- all_tiles.insert(raster_queue.Top());
+ while (!raster_queue->IsEmpty()) {
+ EXPECT_TRUE(raster_queue->Top());
+ all_tiles.insert(raster_queue->Top());
++tile_count;
- raster_queue.Pop();
+ raster_queue->Pop();
}
EXPECT_EQ(tile_count, all_tiles.size());
EXPECT_EQ(16u, tile_count);
@@ -1059,7 +1042,6 @@
std::vector<Tile*> tiles(all_tiles.begin(), all_tiles.end());
host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
- EvictionTilePriorityQueue queue;
for (int i = 1; i < 10; ++i) {
scoped_ptr<FakePictureLayerImpl> pending_layer =
FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
@@ -1068,16 +1050,17 @@
pending_layer_->AddChild(pending_layer.Pass());
}
- host_impl_.BuildEvictionQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES);
- EXPECT_FALSE(queue.IsEmpty());
+ scoped_ptr<EvictionTilePriorityQueue> queue(
+ host_impl_.BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
+ EXPECT_FALSE(queue->IsEmpty());
tile_count = 0;
all_tiles.clear();
- while (!queue.IsEmpty()) {
- EXPECT_TRUE(queue.Top());
- all_tiles.insert(queue.Top());
+ while (!queue->IsEmpty()) {
+ EXPECT_TRUE(queue->Top());
+ all_tiles.insert(queue->Top());
++tile_count;
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(tile_count, all_tiles.size());
EXPECT_EQ(16u, tile_count);
@@ -1121,7 +1104,7 @@
// 3. Third iteration ensures that no tiles are returned, since they were all
// marked as ready to draw.
for (int i = 0; i < 3; ++i) {
- scoped_ptr<TilingSetRasterQueue> queue(
+ scoped_ptr<TilingSetRasterQueueAll> queue(
new TilingSetRasterQueueAll(tiling_set.get(), false));
// There are 3 bins in TilePriority.
@@ -1231,7 +1214,7 @@
Tile* last_tile = NULL;
int eventually_bin_order_correct_count = 0;
int eventually_bin_order_incorrect_count = 0;
- scoped_ptr<TilingSetRasterQueue> queue(
+ scoped_ptr<TilingSetRasterQueueAll> queue(
new TilingSetRasterQueueAll(tiling_set.get(), false));
for (; !queue->IsEmpty(); queue->Pop()) {
if (!last_tile)
diff --git a/cc/resources/tile_priority.cc b/cc/resources/tile_priority.cc
index 26826af..5ef26f2 100644
--- a/cc/resources/tile_priority.cc
+++ b/cc/resources/tile_priority.cc
@@ -4,7 +4,7 @@
#include "cc/resources/tile_priority.h"
-#include "base/debug/trace_event_argument.h"
+#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
#include "cc/base/math_util.h"
diff --git a/cc/resources/tile_priority.h b/cc/resources/tile_priority.h
index d161057..405ca92 100644
--- a/cc/resources/tile_priority.h
+++ b/cc/resources/tile_priority.h
@@ -9,8 +9,8 @@
#include <limits>
#include <string>
-#include "base/debug/trace_event_argument.h"
#include "base/memory/scoped_ptr.h"
+#include "base/trace_event/trace_event_argument.h"
#include "cc/base/cc_export.h"
namespace base {
diff --git a/cc/resources/tile_task_runner.h b/cc/resources/tile_task_runner.h
index 1de0f4f..70c2c25 100644
--- a/cc/resources/tile_task_runner.h
+++ b/cc/resources/tile_task_runner.h
@@ -160,6 +160,9 @@
// Check for completed tasks and dispatch reply callbacks.
virtual void CheckForCompletedTasks() = 0;
+ // Returns the format to use for the tiles.
+ virtual ResourceFormat GetResourceFormat() = 0;
+
protected:
virtual ~TileTaskRunner() {}
};
diff --git a/cc/resources/tile_task_worker_pool.cc b/cc/resources/tile_task_worker_pool.cc
index e1eaa57..aac8d02 100644
--- a/cc/resources/tile_task_worker_pool.cc
+++ b/cc/resources/tile_task_worker_pool.cc
@@ -6,10 +6,10 @@
#include <algorithm>
-#include "base/debug/trace_event.h"
#include "base/lazy_instance.h"
#include "base/strings/stringprintf.h"
#include "base/threading/simple_thread.h"
+#include "base/trace_event/trace_event.h"
#include "cc/base/scoped_ptr_deque.h"
#include "cc/resources/raster_source.h"
#include "skia/ext/refptr.h"
diff --git a/cc/resources/tile_task_worker_pool_perftest.cc b/cc/resources/tile_task_worker_pool_perftest.cc
index 49d7588..483b71f 100644
--- a/cc/resources/tile_task_worker_pool_perftest.cc
+++ b/cc/resources/tile_task_worker_pool_perftest.cc
@@ -257,7 +257,7 @@
case TILE_TASK_WORKER_POOL_TYPE_ONE_COPY:
Create3dOutputSurfaceAndResourceProvider();
staging_resource_pool_ = ResourcePool::Create(resource_provider_.get(),
- GL_TEXTURE_2D, RGBA_8888);
+ GL_TEXTURE_2D);
tile_task_worker_pool_ = OneCopyTileTaskWorkerPool::Create(
task_runner_.get(), task_graph_runner_.get(),
context_provider_.get(), resource_provider_.get(),
@@ -266,7 +266,8 @@
case TILE_TASK_WORKER_POOL_TYPE_GPU:
Create3dOutputSurfaceAndResourceProvider();
tile_task_worker_pool_ = GpuTileTaskWorkerPool::Create(
- task_runner_.get(), task_graph_runner_.get());
+ task_runner_.get(), task_graph_runner_.get(),
+ resource_provider_.get());
break;
case TILE_TASK_WORKER_POOL_TYPE_BITMAP:
CreateSoftwareOutputSurfaceAndResourceProvider();
diff --git a/cc/resources/tile_task_worker_pool_unittest.cc b/cc/resources/tile_task_worker_pool_unittest.cc
index 59b833f..68758f6 100644
--- a/cc/resources/tile_task_worker_pool_unittest.cc
+++ b/cc/resources/tile_task_worker_pool_unittest.cc
@@ -152,7 +152,7 @@
case TILE_TASK_WORKER_POOL_TYPE_ONE_COPY:
Create3dOutputSurfaceAndResourceProvider();
staging_resource_pool_ = ResourcePool::Create(resource_provider_.get(),
- GL_TEXTURE_2D, RGBA_8888);
+ GL_TEXTURE_2D);
tile_task_worker_pool_ = OneCopyTileTaskWorkerPool::Create(
base::MessageLoopProxy::current().get(),
TileTaskWorkerPool::GetTaskGraphRunner(), context_provider_.get(),
@@ -162,7 +162,8 @@
Create3dOutputSurfaceAndResourceProvider();
tile_task_worker_pool_ = GpuTileTaskWorkerPool::Create(
base::MessageLoopProxy::current().get(),
- TileTaskWorkerPool::GetTaskGraphRunner());
+ TileTaskWorkerPool::GetTaskGraphRunner(),
+ resource_provider_.get());
break;
case TILE_TASK_WORKER_POOL_TYPE_BITMAP:
CreateSoftwareOutputSurfaceAndResourceProvider();
diff --git a/cc/resources/tiling_set_raster_queue.h b/cc/resources/tiling_set_raster_queue.h
deleted file mode 100644
index 0a131a9..0000000
--- a/cc/resources/tiling_set_raster_queue.h
+++ /dev/null
@@ -1,23 +0,0 @@
-// 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_RASTER_QUEUE_H_
-#define CC_RESOURCES_TILING_SET_RASTER_QUEUE_H_
-
-namespace cc {
-class Tile;
-
-class TilingSetRasterQueue {
- public:
- virtual ~TilingSetRasterQueue() {}
-
- virtual Tile* Top() = 0;
- virtual const Tile* Top() const = 0;
- virtual void Pop() = 0;
- virtual bool IsEmpty() const = 0;
-};
-
-} // namespace cc
-
-#endif // CC_RESOURCES_TILING_SET_RASTER_QUEUE_H_
diff --git a/cc/resources/tiling_set_raster_queue_all.h b/cc/resources/tiling_set_raster_queue_all.h
index bea70d3..5577c6c 100644
--- a/cc/resources/tiling_set_raster_queue_all.h
+++ b/cc/resources/tiling_set_raster_queue_all.h
@@ -9,23 +9,21 @@
#include "cc/resources/picture_layer_tiling_set.h"
#include "cc/resources/tile.h"
#include "cc/resources/tile_priority.h"
-#include "cc/resources/tiling_set_raster_queue.h"
namespace cc {
// This queue returns all tiles required to be rasterized from HIGH_RESOLUTION
// and LOW_RESOLUTION tilings.
-class CC_EXPORT TilingSetRasterQueueAll
- : public NON_EXPORTED_BASE(TilingSetRasterQueue) {
+class CC_EXPORT TilingSetRasterQueueAll {
public:
TilingSetRasterQueueAll(PictureLayerTilingSet* tiling_set,
bool prioritize_low_res);
- ~TilingSetRasterQueueAll() override;
+ ~TilingSetRasterQueueAll();
- Tile* Top() override;
- const Tile* Top() const override;
- void Pop() override;
- bool IsEmpty() const override;
+ Tile* Top();
+ const Tile* Top() const;
+ void Pop();
+ bool IsEmpty() const;
private:
class TilingIterator {
diff --git a/cc/resources/tiling_set_raster_queue_required.h b/cc/resources/tiling_set_raster_queue_required.h
index 5feb05b..6e278e6 100644
--- a/cc/resources/tiling_set_raster_queue_required.h
+++ b/cc/resources/tiling_set_raster_queue_required.h
@@ -9,24 +9,22 @@
#include "cc/resources/picture_layer_tiling_set.h"
#include "cc/resources/raster_tile_priority_queue.h"
#include "cc/resources/tile.h"
-#include "cc/resources/tiling_set_raster_queue.h"
namespace cc {
// This queue only returns tiles that are required for either activation or
// draw, as specified by RasterTilePriorityQueue::Type passed in the
// constructor.
-class CC_EXPORT TilingSetRasterQueueRequired
- : public NON_EXPORTED_BASE(TilingSetRasterQueue) {
+class CC_EXPORT TilingSetRasterQueueRequired {
public:
TilingSetRasterQueueRequired(PictureLayerTilingSet* tiling_set,
RasterTilePriorityQueue::Type type);
- ~TilingSetRasterQueueRequired() override;
+ ~TilingSetRasterQueueRequired();
- Tile* Top() override;
- const Tile* Top() const override;
- void Pop() override;
- bool IsEmpty() const override;
+ Tile* Top();
+ const Tile* Top() const;
+ void Pop();
+ bool IsEmpty() const;
private:
// This iterator will return all tiles that are in the NOW bin on the given
diff --git a/cc/resources/video_resource_updater.cc b/cc/resources/video_resource_updater.cc
index 4369e08..6375057 100644
--- a/cc/resources/video_resource_updater.cc
+++ b/cc/resources/video_resource_updater.cc
@@ -7,7 +7,7 @@
#include <algorithm>
#include "base/bind.h"
-#include "base/debug/trace_event.h"
+#include "base/trace_event/trace_event.h"
#include "cc/output/gl_renderer.h"
#include "cc/resources/resource_provider.h"
#include "gpu/GLES2/gl2extchromium.h"
@@ -388,6 +388,8 @@
TextureMailbox(mailbox_holder->mailbox,
mailbox_holder->texture_target,
mailbox_holder->sync_point));
+ external_resources.mailboxes.back().set_allow_overlay(
+ video_frame->allow_overlay());
external_resources.release_callbacks.push_back(
base::Bind(&ReturnTexture, AsWeakPtr(), video_frame));
return external_resources;
diff --git a/cc/resources/zero_copy_tile_task_worker_pool.cc b/cc/resources/zero_copy_tile_task_worker_pool.cc
index 6ef78f4..5fd082d 100644
--- a/cc/resources/zero_copy_tile_task_worker_pool.cc
+++ b/cc/resources/zero_copy_tile_task_worker_pool.cc
@@ -6,9 +6,9 @@
#include <algorithm>
-#include "base/debug/trace_event.h"
-#include "base/debug/trace_event_argument.h"
#include "base/strings/stringprintf.h"
+#include "base/trace_event/trace_event.h"
+#include "base/trace_event/trace_event_argument.h"
#include "cc/debug/traced_value.h"
#include "cc/resources/raster_buffer.h"
#include "cc/resources/resource.h"
@@ -165,6 +165,10 @@
completed_tasks_.clear();
}
+ResourceFormat ZeroCopyTileTaskWorkerPool::GetResourceFormat() {
+ return resource_provider_->best_texture_format();
+}
+
scoped_ptr<RasterBuffer> ZeroCopyTileTaskWorkerPool::AcquireBufferForRaster(
const Resource* resource) {
return make_scoped_ptr<RasterBuffer>(
diff --git a/cc/resources/zero_copy_tile_task_worker_pool.h b/cc/resources/zero_copy_tile_task_worker_pool.h
index 9cc5ee9..8d3c0cf 100644
--- a/cc/resources/zero_copy_tile_task_worker_pool.h
+++ b/cc/resources/zero_copy_tile_task_worker_pool.h
@@ -38,6 +38,7 @@
void Shutdown() override;
void ScheduleTasks(TileTaskQueue* queue) override;
void CheckForCompletedTasks() override;
+ ResourceFormat GetResourceFormat() override;
// Overridden from TileTaskClient:
scoped_ptr<RasterBuffer> AcquireBufferForRaster(
diff --git a/cc/scheduler/delay_based_time_source.cc b/cc/scheduler/delay_based_time_source.cc
index cd214fd..dbfdc0d 100644
--- a/cc/scheduler/delay_based_time_source.cc
+++ b/cc/scheduler/delay_based_time_source.cc
@@ -36,7 +36,7 @@
} // namespace
// The following methods correspond to the DelayBasedTimeSource that uses
-// the base::TimeTicks::HighResNow as the timebase.
+// the base::TimeTicks::Now as the timebase.
scoped_refptr<DelayBasedTimeSourceHighRes> DelayBasedTimeSourceHighRes::Create(
base::TimeDelta interval,
base::SingleThreadTaskRunner* task_runner) {
@@ -53,7 +53,7 @@
DelayBasedTimeSourceHighRes::~DelayBasedTimeSourceHighRes() {}
base::TimeTicks DelayBasedTimeSourceHighRes::Now() const {
- return base::TimeTicks::HighResNow();
+ return base::TimeTicks::Now();
}
// The following methods correspond to the DelayBasedTimeSource that uses
diff --git a/cc/scheduler/delay_based_time_source.h b/cc/scheduler/delay_based_time_source.h
index 9f670d1..ea03f9d 100644
--- a/cc/scheduler/delay_based_time_source.h
+++ b/cc/scheduler/delay_based_time_source.h
@@ -95,7 +95,9 @@
DISALLOW_COPY_AND_ASSIGN(DelayBasedTimeSource);
};
-// DelayBasedTimeSource uses base::TimeTicks::HighResNow as its timebase.
+// DelayBasedTimeSource that once used base::TimeTicks::HighResNow as its time
+// source, but is now a no-op.
+// TODO(brianderson): Remove along with gfx::/FrameTime.http://crbug.com/447329
class DelayBasedTimeSourceHighRes : public DelayBasedTimeSource {
public:
static scoped_refptr<DelayBasedTimeSourceHighRes> Create(
diff --git a/cc/scheduler/scheduler.cc b/cc/scheduler/scheduler.cc
index 35f13f4..691b6dc 100644
--- a/cc/scheduler/scheduler.cc
+++ b/cc/scheduler/scheduler.cc
@@ -399,7 +399,7 @@
// If the scheduler is busy, we queue the BeginFrame to be handled later as
// a BeginRetroFrame.
bool Scheduler::OnBeginFrameMixInDelegate(const BeginFrameArgs& args) {
- TRACE_EVENT1("cc", "Scheduler::BeginFrame", "args", args.AsValue());
+ TRACE_EVENT1("cc,benchmark", "Scheduler::BeginFrame", "args", args.AsValue());
// Deliver BeginFrames to children.
if (settings_.forward_begin_frames_to_children &&
@@ -461,7 +461,7 @@
// BeginRetroFrame is called for BeginFrames that we've deferred because
// the scheduler was in the middle of processing a previous BeginFrame.
void Scheduler::BeginRetroFrame() {
- TRACE_EVENT0("cc", "Scheduler::BeginRetroFrame");
+ TRACE_EVENT0("cc,benchmark", "Scheduler::BeginRetroFrame");
DCHECK(!settings_.using_synchronous_renderer_compositor);
DCHECK(!begin_retro_frame_args_.empty());
DCHECK(!begin_retro_frame_task_.IsCancelled());
@@ -537,7 +537,7 @@
void Scheduler::BeginImplFrame(const BeginFrameArgs& args) {
bool main_thread_is_in_high_latency_mode =
state_machine_.MainThreadIsInHighLatencyMode();
- TRACE_EVENT2("cc",
+ TRACE_EVENT2("cc,benchmark",
"Scheduler::BeginImplFrame",
"args",
args.AsValue(),
@@ -635,7 +635,7 @@
}
void Scheduler::OnBeginImplFrameDeadline() {
- TRACE_EVENT0("cc", "Scheduler::OnBeginImplFrameDeadline");
+ TRACE_EVENT0("cc,benchmark", "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
diff --git a/cc/scheduler/scheduler_state_machine.cc b/cc/scheduler/scheduler_state_machine.cc
index d54907f..c3a4a1e 100644
--- a/cc/scheduler/scheduler_state_machine.cc
+++ b/cc/scheduler/scheduler_state_machine.cc
@@ -875,6 +875,12 @@
if (pending_swaps_ >= max_pending_swaps_)
return false;
+ if (active_tree_needs_first_draw_)
+ return true;
+
+ if (!needs_redraw_)
+ return false;
+
// This is used to prioritize impl-thread draws when the main thread isn't
// producing anything, e.g., after an aborted commit. We also check that we
// don't have a pending tree -- otherwise we should give it a chance to
@@ -883,12 +889,6 @@
if (commit_state_ == COMMIT_STATE_IDLE && !has_pending_tree_)
return true;
- if (!needs_redraw_)
- return false;
-
- if (active_tree_needs_first_draw_)
- return true;
-
// Prioritize impl-thread draws in impl_latency_takes_priority_ mode.
if (impl_latency_takes_priority_)
return true;
diff --git a/cc/scheduler/scheduler_state_machine_unittest.cc b/cc/scheduler/scheduler_state_machine_unittest.cc
index 1f377b5..95e3684 100644
--- a/cc/scheduler/scheduler_state_machine_unittest.cc
+++ b/cc/scheduler/scheduler_state_machine_unittest.cc
@@ -49,6 +49,13 @@
state.OnBeginImplFrameIdle(); \
}
+#define SET_UP_STATE(state) \
+ state.SetCanStart(); \
+ state.UpdateState(state.NextAction()); \
+ state.CreateAndInitializeOutputSurfaceWithActivatedCommit(); \
+ state.SetVisible(true); \
+ state.SetCanDraw(true);
+
namespace cc {
namespace {
@@ -210,12 +217,8 @@
scheduler_settings.main_frame_before_activation_enabled = true;
StateMachine state(scheduler_settings);
state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
+ SET_UP_STATE(state)
state.SetNeedsRedraw(false);
- state.SetVisible(true);
- state.SetCanDraw(true);
state.SetNeedsCommit();
EXPECT_TRUE(state.BeginFrameNeeded());
@@ -270,11 +273,7 @@
TestFailedDrawForAnimationCheckerboardSetsNeedsCommitAndDoesNotDrawAgain) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
state.SetNeedsRedraw(true);
EXPECT_TRUE(state.RedrawPending());
EXPECT_TRUE(state.BeginFrameNeeded());
@@ -306,11 +305,7 @@
TEST(SchedulerStateMachineTest, TestFailedDrawForMissingHighResNeedsCommit) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
state.SetNeedsRedraw(true);
EXPECT_TRUE(state.RedrawPending());
EXPECT_TRUE(state.BeginFrameNeeded());
@@ -340,12 +335,7 @@
TestsetNeedsRedrawDuringFailedDrawDoesNotRemoveNeedsRedraw) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
-
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
state.SetNeedsRedraw(true);
EXPECT_TRUE(state.RedrawPending());
EXPECT_TRUE(state.BeginFrameNeeded());
@@ -382,11 +372,7 @@
SchedulerSettings scheduler_settings;
scheduler_settings.maximum_number_of_failed_draws_before_draw_is_forced_ = 1;
StateMachine state(scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
// Start a commit.
state.SetNeedsCommit();
@@ -440,11 +426,7 @@
draw_limit;
scheduler_settings.impl_side_painting = true;
StateMachine state(scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
// Start a commit.
state.SetNeedsCommit();
@@ -497,11 +479,7 @@
TEST(SchedulerStateMachineTest, TestFailedDrawIsRetriedInNextBeginImplFrame) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
// Start a draw.
state.SetNeedsRedraw(true);
@@ -540,11 +518,7 @@
TEST(SchedulerStateMachineTest, TestDoestDrawTwiceInSameFrame) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
state.SetNeedsRedraw(true);
// Draw the first frame.
@@ -744,12 +718,8 @@
TEST(SchedulerStateMachineTest, TestSetNeedsCommitIsNotLost) {
SchedulerSettings scheduler_settings;
StateMachine state(scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
+ SET_UP_STATE(state)
state.SetNeedsCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
EXPECT_TRUE(state.BeginFrameNeeded());
@@ -815,11 +785,7 @@
TEST(SchedulerStateMachineTest, TestFullCycle) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
// Start clean and set commit.
state.SetNeedsCommit();
@@ -865,11 +831,7 @@
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);
+ SET_UP_STATE(state)
// Start clean and set commit.
state.SetNeedsCommit();
@@ -930,11 +892,7 @@
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);
+ SET_UP_STATE(state)
// Start clean and set commit.
state.SetNeedsCommit();
@@ -1014,11 +972,7 @@
TEST(SchedulerStateMachineTest, TestFullCycleWithCommitRequestInbetween) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
// Start clean and set commit.
state.SetNeedsCommit();
@@ -1084,11 +1038,7 @@
TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseInvisible) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
// Start clean and set commit.
state.SetNeedsCommit();
@@ -1219,12 +1169,7 @@
TEST(SchedulerStateMachineTest, TestContextLostWhenCompletelyIdle) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
-
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
EXPECT_NE(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
state.NextAction());
@@ -1251,11 +1196,7 @@
// We use impl side painting because it's the more complicated version.
default_scheduler_settings.impl_side_painting = true;
StateMachine state(default_scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
EXPECT_NE(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
state.NextAction());
@@ -1378,11 +1319,7 @@
TEST(SchedulerStateMachineTest, TestContextLostWhileCommitInProgress) {
SchedulerSettings scheduler_settings;
StateMachine state(scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
// Get a commit in flight.
state.SetNeedsCommit();
@@ -1442,11 +1379,7 @@
TestContextLostWhileCommitInProgressAndAnotherCommitRequested) {
SchedulerSettings scheduler_settings;
StateMachine state(scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
// Get a commit in flight.
state.SetNeedsCommit();
@@ -1528,11 +1461,7 @@
TEST(SchedulerStateMachineTest, DontDrawBeforeCommitAfterLostOutputSurface) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
state.SetNeedsRedraw(true);
@@ -1552,11 +1481,7 @@
SchedulerSettings settings;
settings.impl_side_painting = true;
StateMachine state(settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
state.SetCommitState(
SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT);
@@ -1609,11 +1534,7 @@
TEST(SchedulerStateMachineTest, TestInitialActionsWhenContextLost) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
state.SetNeedsCommit();
state.DidLoseOutputSurface();
@@ -1636,12 +1557,7 @@
TEST(SchedulerStateMachineTest, ReportIfNotDrawing) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
-
- state.SetCanDraw(true);
- state.SetVisible(true);
+ SET_UP_STATE(state)
EXPECT_FALSE(state.PendingDrawsShouldBeAborted());
state.SetCanDraw(false);
@@ -1666,11 +1582,7 @@
SchedulerSettings settings;
settings.impl_side_painting = true;
StateMachine state(settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
// This test mirrors what happens during the first frame of a scroll gesture.
// First we get the input event and a BeginFrame.
@@ -1724,11 +1636,7 @@
SchedulerSettings settings;
settings.impl_side_painting = true;
StateMachine state(settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
// This test ensures that impl-draws are prioritized over main thread updates
// in prefer impl latency mode.
@@ -1782,11 +1690,7 @@
TestTriggerDeadlineImmediatelyOnLostOutputSurface) {
SchedulerSettings default_scheduler_settings;
StateMachine state(default_scheduler_settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
state.SetNeedsCommit();
@@ -1806,11 +1710,7 @@
SchedulerSettings settings;
settings.impl_side_painting = true;
StateMachine state(settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
// Test requesting an animation that, when run, causes us to draw.
state.SetNeedsAnimate();
@@ -1830,11 +1730,7 @@
SchedulerSettings settings;
settings.impl_side_painting = true;
StateMachine state(settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
// Check that animations are updated before we start a commit.
state.SetNeedsAnimate();
@@ -1858,11 +1754,7 @@
SchedulerSettings settings;
settings.impl_side_painting = true;
StateMachine state(settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
// Check that animations are updated before we start a commit.
state.SetNeedsAnimate();
@@ -1891,11 +1783,7 @@
SchedulerSettings settings;
settings.impl_side_painting = true;
StateMachine state(settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
// Test requesting an animation after we have already animated during this
// frame.
@@ -1918,11 +1806,7 @@
SchedulerSettings settings;
settings.forward_begin_frames_to_children = true;
StateMachine state(settings);
- state.SetCanStart();
- state.UpdateState(state.NextAction());
- state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetVisible(true);
- state.SetCanDraw(true);
+ SET_UP_STATE(state)
EXPECT_FALSE(state.BeginFrameNeeded());
state.SetChildrenNeedBeginFrames(true);
diff --git a/cc/scheduler/scheduler_unittest.cc b/cc/scheduler/scheduler_unittest.cc
index ea3cf10..29e4c49 100644
--- a/cc/scheduler/scheduler_unittest.cc
+++ b/cc/scheduler/scheduler_unittest.cc
@@ -2318,34 +2318,5 @@
EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 1);
}
-TEST(SchedulerTest, BeginMainFrameAbortedTriggersImmediateDeadline) {
- FakeSchedulerClient client;
- SchedulerSettings settings;
- settings.use_external_begin_frame_source = true;
-
- CREATE_SCHEDULER_AND_INIT_SURFACE(settings);
-
- scheduler->SetNeedsCommit();
- 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();
-
- client.task_runner().RunUntilTime(client.now_src()->Now());
- EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
-
- scheduler->BeginMainFrameAborted(CommitEarlyOutReason::ABORTED_NOT_VISIBLE);
-
- EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
- client.task_runner().RunUntilTime(client.now_src()->Now());
- EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
-
- EXPECT_NO_ACTION(client);
-}
-
} // namespace
} // namespace cc
diff --git a/cc/surfaces/display.cc b/cc/surfaces/display.cc
index 763b81c..72c31b5 100644
--- a/cc/surfaces/display.cc
+++ b/cc/surfaces/display.cc
@@ -42,6 +42,13 @@
Display::~Display() {
manager_->RemoveObserver(this);
+ if (aggregator_) {
+ for (const auto& id_entry : aggregator_->previous_contained_surfaces()) {
+ Surface* surface = manager_->GetSurfaceForId(id_entry.first);
+ if (surface)
+ surface->RunDrawCallbacks(SurfaceDrawStatus::DRAW_SKIPPED);
+ }
+ }
}
bool Display::Initialize(scoped_ptr<OutputSurface> output_surface) {
@@ -123,7 +130,7 @@
for (const auto& id_entry : aggregator_->previous_contained_surfaces()) {
Surface* surface = manager_->GetSurfaceForId(id_entry.first);
if (surface)
- surface->RunDrawCallbacks();
+ surface->RunDrawCallbacks(SurfaceDrawStatus::DRAWN);
}
DelegatedFrameData* frame_data = frame->delegated_frame_data.get();
@@ -168,7 +175,7 @@
client_->SetMemoryPolicy(policy);
}
-void Display::OnSurfaceDamaged(SurfaceId surface_id) {
+void Display::OnSurfaceDamaged(SurfaceId surface_id, bool* changed) {
if (aggregator_ &&
aggregator_->previous_contained_surfaces().count(surface_id)) {
Surface* surface = manager_->GetSurfaceForId(surface_id);
@@ -179,6 +186,10 @@
aggregator_->ReleaseResources(surface_id);
}
client_->DisplayDamaged();
+ *changed = true;
+ } else if (surface_id == current_surface_id_) {
+ client_->DisplayDamaged();
+ *changed = true;
}
}
diff --git a/cc/surfaces/display.h b/cc/surfaces/display.h
index 47c55bb..99e66fb 100644
--- a/cc/surfaces/display.h
+++ b/cc/surfaces/display.h
@@ -82,7 +82,7 @@
void SetFullRootLayerDamage() override {}
// SurfaceDamageObserver implementation.
- void OnSurfaceDamaged(SurfaceId surface) override;
+ void OnSurfaceDamaged(SurfaceId surface, bool* changed) override;
private:
void InitializeRenderer();
diff --git a/cc/surfaces/surface.cc b/cc/surfaces/surface.cc
index 98ae58c..25f3114 100644
--- a/cc/surfaces/surface.cc
+++ b/cc/surfaces/surface.cc
@@ -34,7 +34,7 @@
factory_->UnrefResources(current_resources);
}
if (!draw_callback_.is_null())
- draw_callback_.Run(false);
+ draw_callback_.Run(SurfaceDrawStatus::DRAW_SKIPPED);
}
void Surface::QueueFrame(scoped_ptr<CompositorFrame> frame,
@@ -56,7 +56,7 @@
factory_->UnrefResources(previous_resources);
}
if (!draw_callback_.is_null())
- draw_callback_.Run(false);
+ draw_callback_.Run(SurfaceDrawStatus::DRAW_SKIPPED);
draw_callback_ = callback;
factory_->manager()->DidSatisfySequences(
SurfaceIdAllocator::NamespaceForId(surface_id_),
@@ -106,11 +106,11 @@
current_frame_->metadata.latency_info.clear();
}
-void Surface::RunDrawCallbacks() {
+void Surface::RunDrawCallbacks(SurfaceDrawStatus drawn) {
if (!draw_callback_.is_null()) {
DrawCallback callback = draw_callback_;
draw_callback_ = DrawCallback();
- callback.Run(true);
+ callback.Run(drawn);
}
}
diff --git a/cc/surfaces/surface.h b/cc/surfaces/surface.h
index 96152a0..8e6d7a4 100644
--- a/cc/surfaces/surface.h
+++ b/cc/surfaces/surface.h
@@ -16,6 +16,7 @@
#include "cc/base/scoped_ptr_vector.h"
#include "cc/output/copy_output_request.h"
#include "cc/quads/render_pass_id.h"
+#include "cc/surfaces/surface_factory.h"
#include "cc/surfaces/surface_id.h"
#include "cc/surfaces/surface_sequence.h"
#include "cc/surfaces/surfaces_export.h"
@@ -34,7 +35,7 @@
class CC_SURFACES_EXPORT Surface {
public:
- using DrawCallback = base::Callback<void(bool)>;
+ using DrawCallback = SurfaceFactory::DrawCallback;
Surface(SurfaceId id, SurfaceFactory* factory);
~Surface();
@@ -55,7 +56,7 @@
int frame_index() const { return frame_index_; }
void TakeLatencyInfo(std::vector<ui::LatencyInfo>* latency_info);
- void RunDrawCallbacks();
+ void RunDrawCallbacks(SurfaceDrawStatus drawn);
base::WeakPtr<SurfaceFactory> factory() { return factory_; }
diff --git a/cc/surfaces/surface_aggregator.cc b/cc/surfaces/surface_aggregator.cc
index 9456dd2..15f4b53 100644
--- a/cc/surfaces/surface_aggregator.cc
+++ b/cc/surfaces/surface_aggregator.cc
@@ -433,6 +433,10 @@
provider_->DestroyChild(it->second);
surface_id_to_resource_child_id_.erase(it);
}
+
+ Surface* surface_ptr = manager_->GetSurfaceForId(surface.first);
+ if (surface_ptr)
+ surface_ptr->RunDrawCallbacks(SurfaceDrawStatus::DRAW_SKIPPED);
}
}
}
diff --git a/cc/surfaces/surface_damage_observer.h b/cc/surfaces/surface_damage_observer.h
index 379c9f7..62ee012 100644
--- a/cc/surfaces/surface_damage_observer.h
+++ b/cc/surfaces/surface_damage_observer.h
@@ -11,7 +11,9 @@
class SurfaceDamageObserver {
public:
- virtual void OnSurfaceDamaged(SurfaceId surface_id) = 0;
+ // Runs when a Surface is damaged. *changed should be set to true if this
+ // causes a Display to be damaged.
+ virtual void OnSurfaceDamaged(SurfaceId surface_id, bool* changed) = 0;
};
} // namespace cc
diff --git a/cc/surfaces/surface_factory.cc b/cc/surfaces/surface_factory.cc
index 7af7cb7..aead4f6 100644
--- a/cc/surfaces/surface_factory.cc
+++ b/cc/surfaces/surface_factory.cc
@@ -51,7 +51,8 @@
DCHECK(it != surface_map_.end());
DCHECK(it->second->factory().get() == this);
it->second->QueueFrame(frame.Pass(), callback);
- manager_->SurfaceModified(surface_id);
+ if (!manager_->SurfaceModified(surface_id))
+ it->second->RunDrawCallbacks(SurfaceDrawStatus::DRAW_SKIPPED);
}
void SurfaceFactory::RequestCopyOfSurface(
diff --git a/cc/surfaces/surface_factory.h b/cc/surfaces/surface_factory.h
index 7abd929..b6b627f 100644
--- a/cc/surfaces/surface_factory.h
+++ b/cc/surfaces/surface_factory.h
@@ -27,6 +27,8 @@
class SurfaceFactoryClient;
class SurfaceManager;
+enum class SurfaceDrawStatus { DRAW_SKIPPED, DRAWN };
+
// A SurfaceFactory is used to create surfaces that may share resources and
// receive returned resources for frames submitted to those surfaces. Resources
// submitted to frames created by a particular factory will be returned to that
@@ -35,9 +37,7 @@
class CC_SURFACES_EXPORT SurfaceFactory
: public base::SupportsWeakPtr<SurfaceFactory> {
public:
- // This callback is called with true if the frame was drawn, or false if it
- // was discarded.
- using DrawCallback = base::Callback<void(bool)>;
+ using DrawCallback = base::Callback<void(SurfaceDrawStatus)>;
SurfaceFactory(SurfaceManager* manager, SurfaceFactoryClient* client);
~SurfaceFactory();
diff --git a/cc/surfaces/surface_factory_unittest.cc b/cc/surfaces/surface_factory_unittest.cc
index 9d38689..b5c2a63 100644
--- a/cc/surfaces/surface_factory_unittest.cc
+++ b/cc/surfaces/surface_factory_unittest.cc
@@ -360,8 +360,10 @@
}
}
-void DrawCallback(bool* executed, bool* result, bool drawn) {
- *executed = true;
+void DrawCallback(uint32* execute_count,
+ SurfaceDrawStatus* result,
+ SurfaceDrawStatus drawn) {
+ *execute_count += 1;
*result = drawn;
}
@@ -377,17 +379,16 @@
frame_data->resource_list.push_back(resource);
scoped_ptr<CompositorFrame> frame(new CompositorFrame);
frame->delegated_frame_data = frame_data.Pass();
- bool executed = false;
- bool drawn = false;
+ uint32 execute_count = 0;
+ SurfaceDrawStatus drawn = SurfaceDrawStatus::DRAW_SKIPPED;
factory_.SubmitFrame(id, frame.Pass(),
- base::Bind(&DrawCallback, &executed, &drawn));
+ base::Bind(&DrawCallback, &execute_count, &drawn));
surface_id_ = SurfaceId();
- EXPECT_FALSE(executed);
factory_.DestroyAll();
- EXPECT_TRUE(executed);
- EXPECT_FALSE(drawn);
+ EXPECT_EQ(1u, execute_count);
+ EXPECT_EQ(SurfaceDrawStatus::DRAW_SKIPPED, drawn);
}
TEST_F(SurfaceFactoryTest, DestroySequence) {
diff --git a/cc/surfaces/surface_manager.cc b/cc/surfaces/surface_manager.cc
index 050f04b..117d82a 100644
--- a/cc/surfaces/surface_manager.cc
+++ b/cc/surfaces/surface_manager.cc
@@ -78,10 +78,12 @@
return it->second;
}
-void SurfaceManager::SurfaceModified(SurfaceId surface_id) {
+bool SurfaceManager::SurfaceModified(SurfaceId surface_id) {
DCHECK(thread_checker_.CalledOnValidThread());
- FOR_EACH_OBSERVER(
- SurfaceDamageObserver, observer_list_, OnSurfaceDamaged(surface_id));
+ bool changed = false;
+ FOR_EACH_OBSERVER(SurfaceDamageObserver, observer_list_,
+ OnSurfaceDamaged(surface_id, &changed));
+ return changed;
}
} // namespace cc
diff --git a/cc/surfaces/surface_manager.h b/cc/surfaces/surface_manager.h
index d630352..d7d78c4 100644
--- a/cc/surfaces/surface_manager.h
+++ b/cc/surfaces/surface_manager.h
@@ -42,7 +42,7 @@
observer_list_.RemoveObserver(obs);
}
- void SurfaceModified(SurfaceId surface_id);
+ bool SurfaceModified(SurfaceId surface_id);
// A frame for a surface satisfies a set of sequence numbers in a particular
// id namespace.
diff --git a/cc/test/data/scaled_render_surface_layer_gl.png b/cc/test/data/scaled_render_surface_layer_gl.png
new file mode 100644
index 0000000..e5802f7
--- /dev/null
+++ b/cc/test/data/scaled_render_surface_layer_gl.png
Binary files differ
diff --git a/cc/test/data/scaled_render_surface_layer_sw.png b/cc/test/data/scaled_render_surface_layer_sw.png
new file mode 100644
index 0000000..2a0ee21
--- /dev/null
+++ b/cc/test/data/scaled_render_surface_layer_sw.png
Binary files differ
diff --git a/cc/test/fake_output_surface.cc b/cc/test/fake_output_surface.cc
index 46efba0..d54d2d1 100644
--- a/cc/test/fake_output_surface.cc
+++ b/cc/test/fake_output_surface.cc
@@ -20,7 +20,8 @@
: OutputSurface(context_provider),
client_(NULL),
num_sent_frames_(0),
- has_external_stencil_test_(false) {
+ has_external_stencil_test_(false),
+ framebuffer_(0) {
if (delegated_rendering) {
capabilities_.delegated_rendering = true;
capabilities_.max_frames_pending = 1;
@@ -33,7 +34,8 @@
: OutputSurface(software_device.Pass()),
client_(NULL),
num_sent_frames_(0),
- has_external_stencil_test_(false) {
+ has_external_stencil_test_(false),
+ framebuffer_(0) {
if (delegated_rendering) {
capabilities_.delegated_rendering = true;
capabilities_.max_frames_pending = 1;
@@ -47,7 +49,8 @@
: OutputSurface(context_provider, software_device.Pass()),
client_(NULL),
num_sent_frames_(0),
- has_external_stencil_test_(false) {
+ has_external_stencil_test_(false),
+ framebuffer_(0) {
if (delegated_rendering) {
capabilities_.delegated_rendering = true;
capabilities_.max_frames_pending = 1;
@@ -78,6 +81,14 @@
client_->DidSwapBuffers();
}
+void FakeOutputSurface::BindFramebuffer() {
+ if (framebuffer_)
+ context_provider_->ContextGL()->BindFramebuffer(GL_FRAMEBUFFER,
+ framebuffer_);
+ else
+ OutputSurface::BindFramebuffer();
+}
+
bool FakeOutputSurface::BindToClient(OutputSurfaceClient* client) {
if (OutputSurface::BindToClient(client)) {
client_ = client;
diff --git a/cc/test/fake_output_surface.h b/cc/test/fake_output_surface.h
index f28fccc..a564eef 100644
--- a/cc/test/fake_output_surface.h
+++ b/cc/test/fake_output_surface.h
@@ -96,6 +96,9 @@
bool BindToClient(OutputSurfaceClient* client) override;
+ void set_framebuffer(unsigned framebuffer) { framebuffer_ = framebuffer; }
+ void BindFramebuffer() override;
+
using OutputSurface::ReleaseGL;
using OutputSurface::InitializeAndSetContext3d;
@@ -138,6 +141,7 @@
CompositorFrame last_sent_frame_;
size_t num_sent_frames_;
bool has_external_stencil_test_;
+ unsigned framebuffer_;
TransferableResourceArray resources_held_by_parent_;
scoped_ptr<ManagedMemoryPolicy> memory_policy_to_set_at_bind_;
gfx::Rect last_swap_rect_;
diff --git a/cc/test/fake_picture_layer_tiling_client.cc b/cc/test/fake_picture_layer_tiling_client.cc
index 293d4f6..cc308e5 100644
--- a/cc/test/fake_picture_layer_tiling_client.cc
+++ b/cc/test/fake_picture_layer_tiling_client.cc
@@ -23,9 +23,9 @@
FakePictureLayerTilingClient::FakePictureLayerTilingClient(
ResourceProvider* resource_provider)
: resource_pool_(
- ResourcePool::Create(resource_provider, GL_TEXTURE_2D, RGBA_8888)),
- tile_manager_(
- new FakeTileManager(&tile_manager_client_, resource_pool_.get())),
+ ResourcePool::Create(resource_provider, GL_TEXTURE_2D)),
+ tile_manager_(new FakeTileManager(
+ &tile_manager_client_, resource_pool_.get())),
pile_(FakePicturePileImpl::CreateInfiniteFilledPile()),
twin_set_(nullptr),
twin_tiling_(nullptr),
diff --git a/cc/test/fake_picture_pile.h b/cc/test/fake_picture_pile.h
index 4a7b65b..55b4c36 100644
--- a/cc/test/fake_picture_pile.h
+++ b/cc/test/fake_picture_pile.h
@@ -19,7 +19,9 @@
using PictureMapKey = PicturePile::PictureMapKey;
using PictureMap = PicturePile::PictureMap;
- FakePicturePile() : playback_allowed_event_(nullptr) {}
+ FakePicturePile(float min_contents_scale, const gfx::Size& tile_grid_size)
+ : PicturePile(min_contents_scale, tile_grid_size),
+ playback_allowed_event_(nullptr) {}
~FakePicturePile() override {}
// PicturePile overrides.
diff --git a/cc/test/fake_picture_pile_impl.cc b/cc/test/fake_picture_pile_impl.cc
index c400298..420b5d6 100644
--- a/cc/test/fake_picture_pile_impl.cc
+++ b/cc/test/fake_picture_pile_impl.cc
@@ -32,10 +32,11 @@
scoped_refptr<FakePicturePileImpl> FakePicturePileImpl::CreateFilledPile(
const gfx::Size& tile_size,
const gfx::Size& layer_bounds) {
- FakePicturePile pile;
+ FakePicturePile pile(ImplSidePaintingSettings().minimum_contents_scale,
+ ImplSidePaintingSettings().default_tile_grid_size);
+ pile.tiling().SetBorderTexels(0);
pile.tiling().SetTilingSize(layer_bounds);
pile.tiling().SetMaxTextureSize(tile_size);
- pile.SetTileGridSize(ImplSidePaintingSettings().default_tile_grid_size);
pile.SetRecordedViewport(gfx::Rect(layer_bounds));
pile.SetHasAnyRecordings(true);
@@ -51,10 +52,11 @@
scoped_refptr<FakePicturePileImpl> FakePicturePileImpl::CreateEmptyPile(
const gfx::Size& tile_size,
const gfx::Size& layer_bounds) {
- FakePicturePile pile;
+ FakePicturePile pile(ImplSidePaintingSettings().minimum_contents_scale,
+ ImplSidePaintingSettings().default_tile_grid_size);
+ pile.tiling().SetBorderTexels(0);
pile.tiling().SetTilingSize(layer_bounds);
pile.tiling().SetMaxTextureSize(tile_size);
- pile.SetTileGridSize(ImplSidePaintingSettings().default_tile_grid_size);
pile.SetRecordedViewport(gfx::Rect());
pile.SetHasAnyRecordings(false);
return make_scoped_refptr(new FakePicturePileImpl(&pile, nullptr));
@@ -64,10 +66,11 @@
FakePicturePileImpl::CreateEmptyPileThatThinksItHasRecordings(
const gfx::Size& tile_size,
const gfx::Size& layer_bounds) {
- FakePicturePile pile;
+ FakePicturePile pile(ImplSidePaintingSettings().minimum_contents_scale,
+ ImplSidePaintingSettings().default_tile_grid_size);
+ pile.tiling().SetBorderTexels(0);
pile.tiling().SetTilingSize(layer_bounds);
pile.tiling().SetMaxTextureSize(tile_size);
- pile.SetTileGridSize(ImplSidePaintingSettings().default_tile_grid_size);
// This simulates a false positive for this flag.
pile.SetRecordedViewport(gfx::Rect());
pile.SetHasAnyRecordings(true);
@@ -76,12 +79,12 @@
scoped_refptr<FakePicturePileImpl>
FakePicturePileImpl::CreateInfiniteFilledPile() {
- FakePicturePile pile;
gfx::Size size(std::numeric_limits<int>::max(),
std::numeric_limits<int>::max());
+ FakePicturePile pile(ImplSidePaintingSettings().minimum_contents_scale, size);
+ pile.tiling().SetBorderTexels(0);
pile.tiling().SetTilingSize(size);
pile.tiling().SetMaxTextureSize(size);
- pile.SetTileGridSize(size);
pile.SetRecordedViewport(gfx::Rect(size));
pile.SetHasAnyRecordings(true);
diff --git a/cc/test/fake_tile_manager.cc b/cc/test/fake_tile_manager.cc
index f876271..04e7cd6 100644
--- a/cc/test/fake_tile_manager.cc
+++ b/cc/test/fake_tile_manager.cc
@@ -46,6 +46,7 @@
}
completed_tasks_.clear();
}
+ ResourceFormat GetResourceFormat() override { return RGBA_8888; }
// Overridden from TileTaskClient:
scoped_ptr<RasterBuffer> AcquireBufferForRaster(
diff --git a/cc/test/fake_tile_manager_client.cc b/cc/test/fake_tile_manager_client.cc
index f6b3749..e22fd1e 100644
--- a/cc/test/fake_tile_manager_client.cc
+++ b/cc/test/fake_tile_manager_client.cc
@@ -19,4 +19,15 @@
return picture_layers_;
}
+scoped_ptr<RasterTilePriorityQueue> FakeTileManagerClient::BuildRasterQueue(
+ TreePriority tree_priority,
+ RasterTilePriorityQueue::Type type) {
+ return nullptr;
+}
+
+scoped_ptr<EvictionTilePriorityQueue> FakeTileManagerClient::BuildEvictionQueue(
+ TreePriority tree_priority) {
+ return nullptr;
+}
+
} // namespace cc
diff --git a/cc/test/fake_tile_manager_client.h b/cc/test/fake_tile_manager_client.h
index 843c59f..ef1eaca 100644
--- a/cc/test/fake_tile_manager_client.h
+++ b/cc/test/fake_tile_manager_client.h
@@ -21,11 +21,11 @@
void NotifyReadyToActivate() override {}
void NotifyReadyToDraw() override {}
void NotifyTileStateChanged(const Tile* tile) override {}
- void BuildRasterQueue(RasterTilePriorityQueue* queue,
- TreePriority tree_priority,
- RasterTilePriorityQueue::Type type) override {}
- void BuildEvictionQueue(EvictionTilePriorityQueue* queue,
- TreePriority tree_priority) override {}
+ scoped_ptr<RasterTilePriorityQueue> BuildRasterQueue(
+ TreePriority tree_priority,
+ RasterTilePriorityQueue::Type type) override;
+ scoped_ptr<EvictionTilePriorityQueue> BuildEvictionQueue(
+ TreePriority tree_priority) override;
private:
std::vector<PictureLayerImpl*> picture_layers_;
diff --git a/cc/test/layer_tree_pixel_resource_test.cc b/cc/test/layer_tree_pixel_resource_test.cc
index e3df017..f9f0ea4 100644
--- a/cc/test/layer_tree_pixel_resource_test.cc
+++ b/cc/test/layer_tree_pixel_resource_test.cc
@@ -168,8 +168,7 @@
EXPECT_EQ(PIXEL_TEST_SOFTWARE, test_type_);
*resource_pool =
ResourcePool::Create(resource_provider,
- draw_texture_target_,
- resource_provider->best_texture_format());
+ draw_texture_target_);
*tile_task_worker_pool = BitmapTileTaskWorkerPool::Create(
task_runner, TileTaskWorkerPool::GetTaskGraphRunner(),
@@ -180,20 +179,18 @@
EXPECT_EQ(PIXEL_TEST_GL, test_type_);
*resource_pool =
ResourcePool::Create(resource_provider,
- draw_texture_target_,
- resource_provider->best_texture_format());
+ draw_texture_target_);
*tile_task_worker_pool = GpuTileTaskWorkerPool::Create(
- task_runner, TileTaskWorkerPool::GetTaskGraphRunner());
+ task_runner, TileTaskWorkerPool::GetTaskGraphRunner(),
+ resource_provider);
break;
case ZERO_COPY_TILE_TASK_WORKER_POOL:
EXPECT_TRUE(context_provider);
EXPECT_EQ(PIXEL_TEST_GL, test_type_);
EXPECT_TRUE(host_impl->GetRendererCapabilities().using_image);
*resource_pool =
- ResourcePool::Create(resource_provider,
- draw_texture_target_,
- resource_provider->best_texture_format());
+ ResourcePool::Create(resource_provider, draw_texture_target_);
*tile_task_worker_pool = ZeroCopyTileTaskWorkerPool::Create(
task_runner, TileTaskWorkerPool::GetTaskGraphRunner(),
@@ -205,13 +202,9 @@
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,
- staging_texture_target_,
- resource_provider->best_texture_format());
+ ResourcePool::Create(resource_provider, staging_texture_target_);
*resource_pool =
- ResourcePool::Create(resource_provider,
- draw_texture_target_,
- resource_provider->best_texture_format());
+ ResourcePool::Create(resource_provider, draw_texture_target_);
*tile_task_worker_pool = OneCopyTileTaskWorkerPool::Create(
task_runner, TileTaskWorkerPool::GetTaskGraphRunner(),
@@ -221,9 +214,7 @@
EXPECT_TRUE(context_provider);
EXPECT_EQ(PIXEL_TEST_GL, test_type_);
*resource_pool = ResourcePool::Create(
- resource_provider,
- draw_texture_target_,
- resource_provider->memory_efficient_texture_format());
+ resource_provider, draw_texture_target_);
*tile_task_worker_pool = PixelBufferTileTaskWorkerPool::Create(
task_runner, TileTaskWorkerPool::GetTaskGraphRunner(),
diff --git a/cc/test/test_web_graphics_context_3d.cc b/cc/test/test_web_graphics_context_3d.cc
index 2d82f89..8aa392d 100644
--- a/cc/test/test_web_graphics_context_3d.cc
+++ b/cc/test/test_web_graphics_context_3d.cc
@@ -18,9 +18,6 @@
namespace cc {
-static const GLuint kFramebufferId = 1;
-static const GLuint kRenderbufferId = 2;
-
static unsigned s_context_id = 1;
const GLuint TestWebGraphicsContext3D::kExternalTextureId = 1337;
@@ -34,7 +31,8 @@
TestWebGraphicsContext3D::Namespace::Namespace()
: next_buffer_id(1),
next_image_id(1),
- next_texture_id(1) {
+ next_texture_id(1),
+ next_renderbuffer_id(1) {
}
TestWebGraphicsContext3D::Namespace::~Namespace() {
@@ -58,6 +56,8 @@
max_used_transfer_buffer_usage_bytes_(0),
next_program_id_(1000),
next_shader_id_(2000),
+ next_framebuffer_id_(1),
+ current_framebuffer_(0),
max_texture_size_(2048),
reshape_called_(false),
width_(0),
@@ -162,13 +162,13 @@
void TestWebGraphicsContext3D::genFramebuffers(
GLsizei count, GLuint* ids) {
for (int i = 0; i < count; ++i)
- ids[i] = kFramebufferId | context_id_ << 16;
+ ids[i] = NextFramebufferId();
}
void TestWebGraphicsContext3D::genRenderbuffers(
GLsizei count, GLuint* ids) {
for (int i = 0; i < count; ++i)
- ids[i] = kRenderbufferId | context_id_ << 16;
+ ids[i] = NextRenderbufferId();
}
void TestWebGraphicsContext3D::genTextures(GLsizei count, GLuint* ids) {
@@ -188,14 +188,19 @@
void TestWebGraphicsContext3D::deleteFramebuffers(
GLsizei count, GLuint* ids) {
- for (int i = 0; i < count; ++i)
- DCHECK_EQ(kFramebufferId | context_id_ << 16, ids[i]);
+ for (int i = 0; i < count; ++i) {
+ if (ids[i]) {
+ RetireFramebufferId(ids[i]);
+ if (ids[i] == current_framebuffer_)
+ current_framebuffer_ = 0;
+ }
+ }
}
void TestWebGraphicsContext3D::deleteRenderbuffers(
GLsizei count, GLuint* ids) {
for (int i = 0; i < count; ++i)
- DCHECK_EQ(kRenderbufferId | context_id_ << 16, ids[i]);
+ RetireRenderbufferId(ids[i]);
}
void TestWebGraphicsContext3D::deleteTextures(GLsizei count, GLuint* ids) {
@@ -294,16 +299,31 @@
void TestWebGraphicsContext3D::bindFramebuffer(
GLenum target, GLuint framebuffer) {
- if (!framebuffer)
- return;
- DCHECK_EQ(kFramebufferId | context_id_ << 16, framebuffer);
+ base::AutoLock lock_for_framebuffer_access(namespace_->lock);
+ if (framebuffer != 0 &&
+ framebuffer_set_.find(framebuffer) == framebuffer_set_.end()) {
+ ADD_FAILURE() << "bindFramebuffer called with unknown framebuffer";
+ } else if (framebuffer != 0 && (framebuffer >> 16) != context_id_) {
+ ADD_FAILURE()
+ << "bindFramebuffer called with framebuffer from other context";
+ } else {
+ current_framebuffer_ = framebuffer;
+ }
}
void TestWebGraphicsContext3D::bindRenderbuffer(
GLenum target, GLuint renderbuffer) {
if (!renderbuffer)
return;
- DCHECK_EQ(kRenderbufferId | context_id_ << 16, renderbuffer);
+ base::AutoLock lock_for_renderbuffer_access(namespace_->lock);
+ if (renderbuffer != 0 &&
+ namespace_->renderbuffer_set.find(renderbuffer) ==
+ namespace_->renderbuffer_set.end()) {
+ ADD_FAILURE() << "bindRenderbuffer called with unknown renderbuffer";
+ } else if ((renderbuffer >> 16) != context_id_) {
+ ADD_FAILURE()
+ << "bindRenderbuffer called with renderbuffer from other context";
+ }
}
void TestWebGraphicsContext3D::bindTexture(
@@ -370,6 +390,8 @@
*value = GL_TEXTURE0;
else if (pname == GL_UNPACK_ALIGNMENT)
*value = unpack_alignment_;
+ else if (pname == GL_FRAMEBUFFER_BINDING)
+ *value = current_framebuffer_;
}
void TestWebGraphicsContext3D::getProgramiv(GLuint program,
@@ -674,6 +696,37 @@
DCHECK_EQ(context_id, context_id_);
}
+GLuint TestWebGraphicsContext3D::NextFramebufferId() {
+ base::AutoLock lock_for_framebuffer_access(namespace_->lock);
+ GLuint id = next_framebuffer_id_++;
+ DCHECK(id < (1 << 16));
+ id |= context_id_ << 16;
+ framebuffer_set_.insert(id);
+ return id;
+}
+
+void TestWebGraphicsContext3D::RetireFramebufferId(GLuint id) {
+ base::AutoLock lock_for_framebuffer_access(namespace_->lock);
+ DCHECK(framebuffer_set_.find(id) != framebuffer_set_.end());
+ framebuffer_set_.erase(id);
+}
+
+GLuint TestWebGraphicsContext3D::NextRenderbufferId() {
+ base::AutoLock lock_for_renderbuffer_access(namespace_->lock);
+ GLuint id = namespace_->next_renderbuffer_id++;
+ DCHECK(id < (1 << 16));
+ id |= context_id_ << 16;
+ namespace_->renderbuffer_set.insert(id);
+ return id;
+}
+
+void TestWebGraphicsContext3D::RetireRenderbufferId(GLuint id) {
+ base::AutoLock lock_for_renderbuffer_access(namespace_->lock);
+ DCHECK(namespace_->renderbuffer_set.find(id) !=
+ namespace_->renderbuffer_set.end());
+ namespace_->renderbuffer_set.erase(id);
+}
+
void TestWebGraphicsContext3D::SetMaxTransferBufferUsageBytes(
size_t max_transfer_buffer_usage_bytes) {
test_capabilities_.max_transfer_buffer_usage_bytes =
diff --git a/cc/test/test_web_graphics_context_3d.h b/cc/test/test_web_graphics_context_3d.h
index 0c001d2..31182f8 100644
--- a/cc/test/test_web_graphics_context_3d.h
+++ b/cc/test/test_web_graphics_context_3d.h
@@ -352,6 +352,12 @@
virtual GLuint NextImageId();
virtual void RetireImageId(GLuint id);
+ virtual GLuint NextFramebufferId();
+ virtual void RetireFramebufferId(GLuint id);
+
+ virtual GLuint NextRenderbufferId();
+ virtual void RetireRenderbufferId(GLuint id);
+
void SetMaxTransferBufferUsageBytes(size_t max_transfer_buffer_usage_bytes);
size_t max_used_transfer_buffer_usage_bytes() const {
return max_used_transfer_buffer_usage_bytes_;
@@ -422,9 +428,11 @@
unsigned next_buffer_id;
unsigned next_image_id;
unsigned next_texture_id;
+ unsigned next_renderbuffer_id;
base::ScopedPtrHashMap<unsigned, Buffer> buffers;
base::hash_set<unsigned> images;
OrderedTextureMap textures;
+ base::hash_set<unsigned> renderbuffer_set;
private:
friend class base::RefCountedThreadSafe<Namespace>;
@@ -453,6 +461,9 @@
base::hash_set<unsigned> program_set_;
unsigned next_shader_id_;
base::hash_set<unsigned> shader_set_;
+ unsigned next_framebuffer_id_;
+ base::hash_set<unsigned> framebuffer_set_;
+ unsigned current_framebuffer_;
std::vector<TestWebGraphicsContext3D*> shared_contexts_;
int max_texture_size_;
bool reshape_called_;
diff --git a/cc/test/test_web_graphics_context_3d_unittest.cc b/cc/test/test_web_graphics_context_3d_unittest.cc
index 107f15c..06f5306 100644
--- a/cc/test/test_web_graphics_context_3d_unittest.cc
+++ b/cc/test/test_web_graphics_context_3d_unittest.cc
@@ -93,5 +93,19 @@
check_parameter_value(context.get(), GL_TEXTURE_MAG_FILTER, GL_NEAREST));
}
+TEST(TestWebGraphicsContext3DTest, UseMultipleRenderAndFramebuffers) {
+ scoped_ptr<TestWebGraphicsContext3D> context(
+ TestWebGraphicsContext3D::Create());
+
+ GLuint ids[2];
+ context->genFramebuffers(2, ids);
+ EXPECT_NE(ids[0], ids[1]);
+ context->deleteFramebuffers(2, ids);
+
+ context->genRenderbuffers(2, ids);
+ EXPECT_NE(ids[0], ids[1]);
+ context->deleteRenderbuffers(2, ids);
+}
+
} // namespace
} // namespace cc
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index 3e70aeb..e12e272 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -1831,14 +1831,6 @@
data_for_children.full_hierarchy_matrix =
data_from_ancestor.full_hierarchy_matrix;
- // If the subtree will scale layer contents by the transform hierarchy, then
- // we should scale things into the render surface by the transform hierarchy
- // to take advantage of that.
- gfx::Vector2dF render_surface_sublayer_scale =
- globals.can_adjust_raster_scales
- ? combined_transform_scales
- : gfx::Vector2dF(layer_scale_factors, layer_scale_factors);
-
bool render_to_separate_surface =
IsRootLayer(layer) ||
(globals.can_render_to_separate_surface && layer->render_surface());
@@ -1873,17 +1865,19 @@
// space which we do not want; so here we use the combined_transform
// instead of the draw_transform. However, we do need to add a different
// scale factor that accounts for the surface's pixel dimensions.
- combined_transform.Scale(1.0 / render_surface_sublayer_scale.x(),
- 1.0 / render_surface_sublayer_scale.y());
- render_surface->SetDrawTransform(combined_transform);
+ // Remove the combined_transform scale from the draw transform.
+ gfx::Transform draw_transform = combined_transform;
+ draw_transform.Scale(1.0 / combined_transform_scales.x(),
+ 1.0 / combined_transform_scales.y());
+ render_surface->SetDrawTransform(draw_transform);
// The owning layer's transform was re-parented by the surface, so the
// layer's new draw_transform only needs to scale the layer to surface
// space.
layer_draw_properties.target_space_transform.MakeIdentity();
- layer_draw_properties.target_space_transform.
- Scale(render_surface_sublayer_scale.x() / layer->contents_scale_x(),
- render_surface_sublayer_scale.y() / layer->contents_scale_y());
+ layer_draw_properties.target_space_transform.Scale(
+ combined_transform_scales.x() / layer->contents_scale_x(),
+ combined_transform_scales.y() / layer->contents_scale_y());
// Inside the surface's subtree, we scale everything to the owning layer's
// scale. The sublayer matrix transforms layer rects into target surface
@@ -1892,8 +1886,8 @@
// but we apply it explicitly to the owning layer and the remainder of the
// subtree independently.
DCHECK(data_for_children.parent_matrix.IsIdentity());
- data_for_children.parent_matrix.Scale(render_surface_sublayer_scale.x(),
- render_surface_sublayer_scale.y());
+ data_for_children.parent_matrix.Scale(combined_transform_scales.x(),
+ combined_transform_scales.y());
// Even if the |layer_is_drawn|, it only contributes to a drawn surface
// when the |layer_is_visible|.
@@ -2311,14 +2305,14 @@
// surface's subtree into layer space.
gfx::Transform screen_space_transform = layer->screen_space_transform();
screen_space_transform.Scale(
- layer->contents_scale_x() / render_surface_sublayer_scale.x(),
- layer->contents_scale_y() / render_surface_sublayer_scale.y());
+ layer->contents_scale_x() / combined_transform_scales.x(),
+ layer->contents_scale_y() / combined_transform_scales.y());
render_surface->SetScreenSpaceTransform(screen_space_transform);
if (layer->replica_layer()) {
gfx::Transform surface_origin_to_replica_origin_transform;
surface_origin_to_replica_origin_transform.Scale(
- render_surface_sublayer_scale.x(), render_surface_sublayer_scale.y());
+ combined_transform_scales.x(), combined_transform_scales.y());
surface_origin_to_replica_origin_transform.Translate(
layer->replica_layer()->position().x() +
layer->replica_layer()->transform_origin().x(),
@@ -2330,8 +2324,8 @@
-layer->replica_layer()->transform_origin().x(),
-layer->replica_layer()->transform_origin().y());
surface_origin_to_replica_origin_transform.Scale(
- 1.0 / render_surface_sublayer_scale.x(),
- 1.0 / render_surface_sublayer_scale.y());
+ 1.0 / combined_transform_scales.x(),
+ 1.0 / combined_transform_scales.y());
// Compute the replica's "originTransform" that maps from the replica's
// origin space to the target surface origin space.
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index 01941c1..238c3cb 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -5157,75 +5157,81 @@
EXPECT_FLOAT_EQ(initial_parent_scale,
parent->draw_transform().matrix().get(1, 1));
- // The child surface is scaled up during draw since its subtree is not scaled
+ // The child surface is not scaled up during draw since its subtree is scaled
// by the transform hierarchy.
EXPECT_FLOAT_EQ(
- initial_parent_scale * initial_child_scale,
+ 1.f,
surface_scale->render_surface()->draw_transform().matrix().get(0, 0));
EXPECT_FLOAT_EQ(
- initial_parent_scale * initial_child_scale,
+ 1.f,
surface_scale->render_surface()->draw_transform().matrix().get(1, 1));
- // The surface_scale's RenderSurface is scaled during draw, so the layer does
- // not need to be scaled when drawing into its surface.
- EXPECT_FLOAT_EQ(1.0, surface_scale->draw_transform().matrix().get(0, 0));
- EXPECT_FLOAT_EQ(1.0, surface_scale->draw_transform().matrix().get(1, 1));
+ // The surface_scale's RenderSurface is not scaled during draw, so the layer
+ // needs to be scaled when drawing into its surface.
+ EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale,
+ surface_scale->draw_transform().matrix().get(0, 0));
+ EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale,
+ surface_scale->draw_transform().matrix().get(1, 1));
- // The surface_scale_child_scale is scaled when drawing into its surface,
- // since its content bounds are not scaled by the transform hierarchy.
+ // The surface_scale_child_scale is not scaled when drawing into its surface,
+ // since its content bounds are scaled by the transform hierarchy.
EXPECT_FLOAT_EQ(
- initial_child_scale,
+ initial_child_scale * initial_child_scale * initial_parent_scale,
surface_scale_child_scale->draw_transform().matrix().get(0, 0));
EXPECT_FLOAT_EQ(
- initial_child_scale,
+ initial_child_scale * initial_child_scale * initial_parent_scale,
surface_scale_child_scale->draw_transform().matrix().get(1, 1));
- // The surface_scale_child_no_scale has a fixed contents scale of 1, so it
- // needs to be scaled by the device and page scale factors, along with the
- // transform hierarchy.
+ // The surface_scale_child_no_scale is scaled by the device scale, page scale
+ // and transform hierarchy.
EXPECT_FLOAT_EQ(
- device_scale_factor * page_scale_factor * initial_child_scale,
+ device_scale_factor * page_scale_factor * initial_parent_scale *
+ initial_child_scale * initial_child_scale,
surface_scale_child_no_scale->draw_transform().matrix().get(0, 0));
EXPECT_FLOAT_EQ(
- device_scale_factor * page_scale_factor * initial_child_scale,
+ device_scale_factor * page_scale_factor * initial_parent_scale *
+ initial_child_scale * initial_child_scale,
surface_scale_child_no_scale->draw_transform().matrix().get(1, 1));
- // The child surface is scaled up during draw since its subtree is not scaled
+ // The child surface is not scaled up during draw since its subtree is scaled
// by the transform hierarchy.
EXPECT_FLOAT_EQ(
- initial_parent_scale * initial_child_scale,
+ 1.f,
surface_no_scale->render_surface()->draw_transform().matrix().get(0, 0));
EXPECT_FLOAT_EQ(
- initial_parent_scale * initial_child_scale,
+ 1.f,
surface_no_scale->render_surface()->draw_transform().matrix().get(1, 1));
// The surface_no_scale layer has a fixed contents scale of 1, so it needs to
// be scaled by the device and page scale factors. Its surface is already
// scaled by the transform hierarchy so those don't need to scale the layer's
// drawing.
- EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor,
+ EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale *
+ device_scale_factor * page_scale_factor,
surface_no_scale->draw_transform().matrix().get(0, 0));
- EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor,
+ EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale *
+ device_scale_factor * page_scale_factor,
surface_no_scale->draw_transform().matrix().get(1, 1));
// The surface_no_scale_child_scale has its contents scaled by the page and
// device scale factors, but needs to be scaled by the transform hierarchy
// when drawing.
EXPECT_FLOAT_EQ(
- initial_child_scale,
+ initial_parent_scale * initial_child_scale * initial_child_scale,
surface_no_scale_child_scale->draw_transform().matrix().get(0, 0));
EXPECT_FLOAT_EQ(
- initial_child_scale,
+ initial_parent_scale * initial_child_scale * initial_child_scale,
surface_no_scale_child_scale->draw_transform().matrix().get(1, 1));
- // The surface_no_scale_child_no_scale has a fixed contents scale of 1, so it
- // needs to be scaled by the device and page scale factors. It also needs to
- // be scaled by any transform heirarchy below its target surface.
+ // The surface_no_scale_child_no_scale needs to be scaled by the device and
+ // page scale factors and by any transform heirarchy below its target surface.
EXPECT_FLOAT_EQ(
- device_scale_factor * page_scale_factor * initial_child_scale,
+ device_scale_factor * page_scale_factor * initial_parent_scale *
+ initial_child_scale * initial_child_scale,
surface_no_scale_child_no_scale->draw_transform().matrix().get(0, 0));
EXPECT_FLOAT_EQ(
- device_scale_factor * page_scale_factor * initial_child_scale,
+ device_scale_factor * page_scale_factor * initial_parent_scale *
+ initial_child_scale * initial_child_scale,
surface_no_scale_child_no_scale->draw_transform().matrix().get(1, 1));
}
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 3fe5f4a..3d31e8e 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -295,7 +295,7 @@
// Ensure all textures are returned so partial texture updates can happen
// during the commit. Impl-side-painting doesn't upload during commits, so
// is unaffected.
- if (!settings_.impl_side_painting)
+ if (!settings_.impl_side_painting && output_surface_)
output_surface_->ForceReclaimResources();
if (UsePendingTreeForSync())
@@ -691,7 +691,7 @@
render_surface->contributes_to_drawn_surface() ||
render_surface_layer->HasCopyRequest();
if (should_draw_into_render_pass)
- render_surface_layer->render_surface()->AppendRenderPasses(frame);
+ render_surface->AppendRenderPasses(frame);
}
// When we are displaying the HUD, change the root damage rect to cover the
@@ -1194,13 +1194,14 @@
}
}
-void LayerTreeHostImpl::BuildRasterQueue(RasterTilePriorityQueue* queue,
- TreePriority tree_priority,
- RasterTilePriorityQueue::Type type) {
+scoped_ptr<RasterTilePriorityQueue> LayerTreeHostImpl::BuildRasterQueue(
+ TreePriority tree_priority,
+ RasterTilePriorityQueue::Type type) {
TRACE_EVENT0("cc", "LayerTreeHostImpl::BuildRasterQueue");
picture_layer_pairs_.clear();
GetPictureLayerImplPairs(&picture_layer_pairs_, true);
- queue->Build(picture_layer_pairs_, tree_priority, type);
+ scoped_ptr<RasterTilePriorityQueue> queue(RasterTilePriorityQueue::Create(
+ picture_layer_pairs_, tree_priority, type));
if (!queue->IsEmpty()) {
// Only checking the Top() tile here isn't a definite answer that there is
@@ -1215,14 +1216,17 @@
} else {
required_for_draw_tile_is_top_of_raster_queue_ = false;
}
+ return queue;
}
-void LayerTreeHostImpl::BuildEvictionQueue(EvictionTilePriorityQueue* queue,
- TreePriority tree_priority) {
+scoped_ptr<EvictionTilePriorityQueue> LayerTreeHostImpl::BuildEvictionQueue(
+ TreePriority tree_priority) {
TRACE_EVENT0("cc", "LayerTreeHostImpl::BuildEvictionQueue");
+ scoped_ptr<EvictionTilePriorityQueue> queue(new EvictionTilePriorityQueue);
picture_layer_pairs_.clear();
GetPictureLayerImplPairs(&picture_layer_pairs_, false);
queue->Build(picture_layer_pairs_, tree_priority);
+ return queue;
}
const std::vector<PictureLayerImpl*>& LayerTreeHostImpl::GetPictureLayers()
@@ -1592,7 +1596,7 @@
active_tree()->FinishSwapPromises(&metadata);
for (size_t i = 0; i < metadata.latency_info.size(); i++) {
TRACE_EVENT_FLOW_STEP0(
- "input",
+ "input,benchmark",
"LatencyInfo.Flow",
TRACE_ID_DONT_MANGLE(metadata.latency_info[i].trace_id),
"SwapBuffers");
@@ -1969,9 +1973,7 @@
ContextProvider* context_provider = output_surface_->context_provider();
if (!context_provider) {
*resource_pool =
- ResourcePool::Create(resource_provider_.get(),
- GL_TEXTURE_2D,
- resource_provider_->best_texture_format());
+ ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D);
*tile_task_worker_pool = BitmapTileTaskWorkerPool::Create(
task_runner, TileTaskWorkerPool::GetTaskGraphRunner(),
@@ -1981,12 +1983,11 @@
if (use_gpu_rasterization_) {
*resource_pool =
- ResourcePool::Create(resource_provider_.get(),
- GL_TEXTURE_2D,
- resource_provider_->best_texture_format());
+ ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D);
*tile_task_worker_pool = GpuTileTaskWorkerPool::Create(
- task_runner, TileTaskWorkerPool::GetTaskGraphRunner());
+ task_runner, TileTaskWorkerPool::GetTaskGraphRunner(),
+ resource_provider_.get());
return;
}
@@ -2001,8 +2002,7 @@
if (settings_.use_zero_copy || IsSynchronousSingleThreaded()) {
*resource_pool =
- ResourcePool::Create(resource_provider_.get(), image_target,
- resource_provider_->best_texture_format());
+ ResourcePool::Create(resource_provider_.get(), image_target);
TaskGraphRunner* task_graph_runner;
if (IsSynchronousSingleThreaded()) {
@@ -2021,11 +2021,9 @@
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());
+ ResourcePool::Create(resource_provider_.get(), image_target);
*resource_pool =
- ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D,
- resource_provider_->best_texture_format());
+ ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D);
*tile_task_worker_pool = OneCopyTileTaskWorkerPool::Create(
task_runner, TileTaskWorkerPool::GetTaskGraphRunner(),
@@ -2036,8 +2034,7 @@
}
*resource_pool = ResourcePool::Create(
- resource_provider_.get(), GL_TEXTURE_2D,
- resource_provider_->memory_efficient_texture_format());
+ resource_provider_.get(), GL_TEXTURE_2D);
*tile_task_worker_pool = PixelBufferTileTaskWorkerPool::Create(
task_runner, TileTaskWorkerPool::GetTaskGraphRunner(), context_provider,
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 2728ff8..0765bb7 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -245,11 +245,11 @@
void NotifyReadyToActivate() override;
void NotifyReadyToDraw() override;
void NotifyTileStateChanged(const Tile* tile) override;
- void BuildRasterQueue(RasterTilePriorityQueue* queue,
- TreePriority tree_priority,
- RasterTilePriorityQueue::Type type) override;
- void BuildEvictionQueue(EvictionTilePriorityQueue* queue,
- TreePriority tree_priority) override;
+ scoped_ptr<RasterTilePriorityQueue> BuildRasterQueue(
+ TreePriority tree_priority,
+ RasterTilePriorityQueue::Type type) override;
+ scoped_ptr<EvictionTilePriorityQueue> BuildEvictionQueue(
+ TreePriority tree_priority) override;
// ScrollbarAnimationControllerClient implementation.
void PostDelayedScrollbarFade(const base::Closure& start_fade,
diff --git a/cc/trees/layer_tree_host_pixeltest_filters.cc b/cc/trees/layer_tree_host_pixeltest_filters.cc
index dc8cc4a..bf8e3e2 100644
--- a/cc/trees/layer_tree_host_pixeltest_filters.cc
+++ b/cc/trees/layer_tree_host_pixeltest_filters.cc
@@ -283,7 +283,7 @@
gfx::Rect rect(50, 50, 100, 100);
- static const int kInset = 3;
+ const int kInset = 3;
for (int i = 0; !rect.IsEmpty(); ++i) {
scoped_refptr<SolidColorLayer> layer =
CreateSolidColorLayer(rect, (i & 1) ? SK_ColorWHITE : SK_ColorRED);
@@ -334,6 +334,67 @@
base::FilePath(FILE_PATH_LITERAL("filter_on_scaled_layer.png")));
}
+class ImageScaledRenderSurface : public LayerTreeHostFiltersPixelTest {
+ protected:
+ void RunPixelTestType(PixelTestType test_type, base::FilePath image_name) {
+ // A filter will cause a render surface to be used. Here we force the
+ // render surface on, and scale the result to make sure that we rasterize at
+ // the correct resolution.
+ scoped_refptr<SolidColorLayer> background =
+ CreateSolidColorLayer(gfx::Rect(300, 300), SK_ColorBLUE);
+
+ scoped_refptr<SolidColorLayer> render_surface_layer =
+ CreateSolidColorLayer(gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
+
+ gfx::Rect rect(50, 50, 100, 100);
+
+ scoped_refptr<SolidColorLayer> child =
+ CreateSolidColorLayer(rect, SK_ColorRED);
+
+ gfx::Transform transform;
+ transform.Translate(rect.width() / 2.0, rect.height() / 2.0);
+ transform.RotateAboutZAxis(30.0);
+ transform.Translate(-rect.width() / 2.0, -rect.height() / 2.0);
+ child->SetTransform(transform);
+
+ render_surface_layer->AddChild(child);
+
+ gfx::Transform render_surface_transform;
+ render_surface_transform.Scale(1.5f, 1.5f);
+ render_surface_layer->SetTransform(render_surface_transform);
+ render_surface_layer->SetForceRenderSurface(true);
+
+ background->AddChild(render_surface_layer);
+
+ // Software has some huge differences in the AA'd pixels on the different
+ // trybots. See crbug.com/452198.
+ float percentage_pixels_large_error = 0.686f;
+ float percentage_pixels_small_error = 0.0f;
+ float average_error_allowed_in_bad_pixels = 16.f;
+ int large_error_allowed = 17;
+ int small_error_allowed = 0;
+ pixel_comparator_.reset(new FuzzyPixelComparator(
+ true, // discard_alpha
+ percentage_pixels_large_error, percentage_pixels_small_error,
+ average_error_allowed_in_bad_pixels, large_error_allowed,
+ small_error_allowed));
+
+ RunPixelTest(test_type, background, image_name);
+ }
+};
+
+TEST_F(ImageScaledRenderSurface, ImageRenderSurfaceScaled_GL) {
+ RunPixelTestType(
+ PIXEL_TEST_GL,
+ base::FilePath(FILE_PATH_LITERAL("scaled_render_surface_layer_gl.png")));
+}
+
+TEST_F(ImageScaledRenderSurface, ImageRenderSurfaceScaled_Software) {
+ RunPixelTestType(
+ PIXEL_TEST_SOFTWARE,
+ base::FilePath(FILE_PATH_LITERAL("scaled_render_surface_layer_sw.png")));
+}
+
} // namespace
} // namespace cc
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index 356bb5f..1e10588 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -41,6 +41,7 @@
#include "cc/test/fake_proxy.h"
#include "cc/test/fake_scoped_ui_resource.h"
#include "cc/test/geometry_test_utils.h"
+#include "cc/test/impl_side_painting_settings.h"
#include "cc/test/layer_tree_test.h"
#include "cc/test/test_shared_bitmap_manager.h"
#include "cc/test/test_web_graphics_context_3d.h"
@@ -5549,7 +5550,9 @@
pinch->SetIsContainerForFixedPositionLayers(true);
root->AddChild(pinch);
- scoped_ptr<FakePicturePile> pile(new FakePicturePile);
+ scoped_ptr<FakePicturePile> pile(
+ new FakePicturePile(ImplSidePaintingSettings().minimum_contents_scale,
+ ImplSidePaintingSettings().default_tile_grid_size));
pile->SetPlaybackAllowedEvent(&playback_allowed_event_);
scoped_refptr<FakePictureLayer> layer =
FakePictureLayer::CreateWithRecordingSource(&client_, pile.Pass());
@@ -5752,7 +5755,9 @@
scoped_refptr<Layer> root = Layer::Create();
root->SetBounds(gfx::Size(500, 500));
- scoped_ptr<FakePicturePile> pile(new FakePicturePile);
+ scoped_ptr<FakePicturePile> pile(
+ new FakePicturePile(ImplSidePaintingSettings().minimum_contents_scale,
+ ImplSidePaintingSettings().default_tile_grid_size));
scoped_refptr<FakePictureLayer> layer =
FakePictureLayer::CreateWithRecordingSource(&client_, pile.Pass());
layer->SetBounds(gfx::Size(500, 500));
@@ -5792,7 +5797,9 @@
void SetupTree() override {
client_.set_fill_with_nonsolid_color(true);
- scoped_ptr<FakePicturePile> pile(new FakePicturePile);
+ scoped_ptr<FakePicturePile> pile(
+ new FakePicturePile(ImplSidePaintingSettings().minimum_contents_scale,
+ ImplSidePaintingSettings().default_tile_grid_size));
scoped_refptr<FakePictureLayer> root =
FakePictureLayer::CreateWithRecordingSource(&client_, pile.Pass());
root->SetBounds(gfx::Size(viewport_size_.width(), 10000));
@@ -5812,12 +5819,11 @@
// Verify which tiles got resources using an eviction iterator, which has to
// return all tiles that have resources.
- EvictionTilePriorityQueue eviction_queue;
- host_impl->BuildEvictionQueue(&eviction_queue,
- SAME_PRIORITY_FOR_BOTH_TREES);
+ scoped_ptr<EvictionTilePriorityQueue> eviction_queue(
+ host_impl->BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
int tile_count = 0;
- for (; !eviction_queue.IsEmpty(); eviction_queue.Pop()) {
- Tile* tile = eviction_queue.Top();
+ for (; !eviction_queue->IsEmpty(); eviction_queue->Pop()) {
+ Tile* tile = eviction_queue->Top();
// Ensure this tile is within the viewport.
EXPECT_TRUE(tile->content_rect().Intersects(gfx::Rect(viewport_size_)));
// Ensure that the tile is 1/4 of the viewport tall (plus padding).
@@ -5863,7 +5869,9 @@
pinch->SetIsContainerForFixedPositionLayers(true);
root->AddChild(pinch);
- scoped_ptr<FakePicturePile> pile(new FakePicturePile);
+ scoped_ptr<FakePicturePile> pile(
+ new FakePicturePile(ImplSidePaintingSettings().minimum_contents_scale,
+ ImplSidePaintingSettings().default_tile_grid_size));
pile->SetPlaybackAllowedEvent(&playback_allowed_event_);
scoped_refptr<FakePictureLayer> layer =
FakePictureLayer::CreateWithRecordingSource(&client_, pile.Pass());
diff --git a/cc/trees/proxy_timing_history.cc b/cc/trees/proxy_timing_history.cc
index 9020ad5..90abad1 100644
--- a/cc/trees/proxy_timing_history.cc
+++ b/cc/trees/proxy_timing_history.cc
@@ -43,11 +43,11 @@
}
void ProxyTimingHistory::DidBeginMainFrame() {
- begin_main_frame_sent_time_ = base::TimeTicks::HighResNow();
+ begin_main_frame_sent_time_ = base::TimeTicks::Now();
}
void ProxyTimingHistory::DidCommit() {
- commit_complete_time_ = base::TimeTicks::HighResNow();
+ commit_complete_time_ = base::TimeTicks::Now();
base::TimeDelta begin_main_frame_to_commit_duration =
commit_complete_time_ - begin_main_frame_sent_time_;
@@ -64,7 +64,7 @@
void ProxyTimingHistory::DidActivateSyncTree() {
base::TimeDelta commit_to_activate_duration =
- base::TimeTicks::HighResNow() - commit_complete_time_;
+ base::TimeTicks::Now() - commit_complete_time_;
// Before adding the new data point to the timing history, see what we would
// have predicted for this frame. This allows us to keep track of the accuracy
@@ -77,12 +77,11 @@
}
void ProxyTimingHistory::DidStartDrawing() {
- start_draw_time_ = base::TimeTicks::HighResNow();
+ start_draw_time_ = base::TimeTicks::Now();
}
void ProxyTimingHistory::DidFinishDrawing() {
- base::TimeDelta draw_duration =
- base::TimeTicks::HighResNow() - start_draw_time_;
+ base::TimeDelta draw_duration = base::TimeTicks::Now() - start_draw_time_;
// Before adding the new data point to the timing history, see what we would
// have predicted for this frame. This allows us to keep track of the accuracy
diff --git a/cc/trees/single_thread_proxy.cc b/cc/trees/single_thread_proxy.cc
index e29f0d1..83e6bbe 100644
--- a/cc/trees/single_thread_proxy.cc
+++ b/cc/trees/single_thread_proxy.cc
@@ -484,14 +484,15 @@
}
void SingleThreadProxy::DidSwapBuffersCompleteOnImplThread() {
- TRACE_EVENT0("cc", "SingleThreadProxy::DidSwapBuffersCompleteOnImplThread");
+ TRACE_EVENT0("cc,benchmark",
+ "SingleThreadProxy::DidSwapBuffersCompleteOnImplThread");
if (scheduler_on_impl_thread_)
scheduler_on_impl_thread_->DidSwapBuffersComplete();
layer_tree_host_->DidCompleteSwapBuffers();
}
void SingleThreadProxy::CompositeImmediately(base::TimeTicks frame_begin_time) {
- TRACE_EVENT0("cc", "SingleThreadProxy::CompositeImmediately");
+ TRACE_EVENT0("cc,benchmark", "SingleThreadProxy::CompositeImmediately");
DCHECK(Proxy::IsMainThread());
base::AutoReset<bool> inside_composite(&inside_synchronous_composite_, true);
diff --git a/cc/trees/thread_proxy.cc b/cc/trees/thread_proxy.cc
index 4b360a4..329b3e8 100644
--- a/cc/trees/thread_proxy.cc
+++ b/cc/trees/thread_proxy.cc
@@ -349,7 +349,8 @@
}
void ThreadProxy::DidSwapBuffersCompleteOnImplThread() {
- TRACE_EVENT0("cc", "ThreadProxy::DidSwapBuffersCompleteOnImplThread");
+ TRACE_EVENT0("cc,benchmark",
+ "ThreadProxy::DidSwapBuffersCompleteOnImplThread");
DCHECK(IsImplThread());
impl().scheduler->DidSwapBuffersComplete();
Proxy::MainThreadTaskRunner()->PostTask(
