#include "cc/trees/layer_tree_host_single_thread_client.h"
#include "cc/trees/layer_tree_impl.h"
#include "cc/trees/single_thread_proxy.h"
+#include "cc/trees/thread_proxy.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "ui/gfx/frame_time.h"
#include "ui/gfx/size_conversions.h"
TestHooks::~TestHooks() {}
-DrawSwapReadbackResult::DrawResult TestHooks::PrepareToDrawOnThread(
+DrawResult TestHooks::PrepareToDrawOnThread(
LayerTreeHostImpl* host_impl,
LayerTreeHostImpl::FrameData* frame_data,
- DrawSwapReadbackResult::DrawResult draw_result) {
+ DrawResult draw_result) {
return draw_result;
}
return base::TimeDelta::FromMilliseconds(16);
}
+// Adapts ThreadProxy for test. Injects test hooks for testing.
+class ThreadProxyForTest : public ThreadProxy {
+ public:
+ static scoped_ptr<Proxy> Create(
+ TestHooks* test_hooks,
+ LayerTreeHost* host,
+ scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+ scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
+ return make_scoped_ptr(
+ new ThreadProxyForTest(
+ test_hooks, host, main_task_runner, impl_task_runner))
+ .PassAs<Proxy>();
+ }
+
+ virtual ~ThreadProxyForTest() {}
+
+ void test() {
+ test_hooks_->Layout();
+ }
+
+ private:
+ TestHooks* test_hooks_;
+
+ virtual void ScheduledActionSendBeginMainFrame() OVERRIDE {
+ test_hooks_->ScheduledActionWillSendBeginMainFrame();
+ ThreadProxy::ScheduledActionSendBeginMainFrame();
+ test_hooks_->ScheduledActionSendBeginMainFrame();
+ }
+
+ virtual DrawResult ScheduledActionDrawAndSwapIfPossible() OVERRIDE {
+ DrawResult result = ThreadProxy::ScheduledActionDrawAndSwapIfPossible();
+ test_hooks_->ScheduledActionDrawAndSwapIfPossible();
+ return result;
+ }
+
+ virtual void ScheduledActionAnimate() OVERRIDE {
+ ThreadProxy::ScheduledActionAnimate();
+ test_hooks_->ScheduledActionAnimate();
+ }
+
+ virtual void ScheduledActionCommit() OVERRIDE {
+ ThreadProxy::ScheduledActionCommit();
+ test_hooks_->ScheduledActionCommit();
+ }
+
+ virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE {
+ ThreadProxy::ScheduledActionBeginOutputSurfaceCreation();
+ test_hooks_->ScheduledActionBeginOutputSurfaceCreation();
+ }
+
+ ThreadProxyForTest(
+ TestHooks* test_hooks,
+ LayerTreeHost* host,
+ scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+ scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner)
+ : ThreadProxy(host, main_task_runner, impl_task_runner),
+ test_hooks_(test_hooks) {}
+};
+
// Adapts LayerTreeHostImpl for test. Runs real code, then invokes test hooks.
class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
public:
virtual void CommitComplete() OVERRIDE {
LayerTreeHostImpl::CommitComplete();
test_hooks_->CommitCompleteOnThread(this);
-
- if (!settings().impl_side_painting) {
- test_hooks_->WillActivateTreeOnThread(this);
- test_hooks_->DidActivateTreeOnThread(this);
- }
}
- virtual DrawSwapReadbackResult::DrawResult PrepareToDraw(
- FrameData* frame,
- const gfx::Rect& damage_rect) OVERRIDE {
- DrawSwapReadbackResult::DrawResult draw_result =
- LayerTreeHostImpl::PrepareToDraw(frame, damage_rect);
+ virtual DrawResult PrepareToDraw(FrameData* frame) OVERRIDE {
+ DrawResult draw_result = LayerTreeHostImpl::PrepareToDraw(frame);
return test_hooks_->PrepareToDrawOnThread(this, frame, draw_result);
}
}
}
- virtual void ActivatePendingTree() OVERRIDE {
+ virtual void ActivateSyncTree() OVERRIDE {
test_hooks_->WillActivateTreeOnThread(this);
- LayerTreeHostImpl::ActivatePendingTree();
+ LayerTreeHostImpl::ActivateSyncTree();
DCHECK(!pending_tree());
test_hooks_->DidActivateTreeOnThread(this);
}
TestHooks* test_hooks,
LayerTreeHostClientForTesting* client,
const LayerTreeSettings& settings,
+ scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
scoped_ptr<LayerTreeHostForTesting> layer_tree_host(
new LayerTreeHostForTesting(test_hooks, client, settings));
- if (impl_task_runner.get())
- layer_tree_host->InitializeThreaded(impl_task_runner);
- else
- layer_tree_host->InitializeSingleThreaded(client);
+ if (impl_task_runner.get()) {
+ layer_tree_host->InitializeForTesting(
+ ThreadProxyForTest::Create(test_hooks,
+ layer_tree_host.get(),
+ main_task_runner,
+ impl_task_runner));
+ } else {
+ layer_tree_host->InitializeForTesting(SingleThreadProxy::Create(
+ layer_tree_host.get(), client, main_task_runner));
+ }
return layer_tree_host.Pass();
}
main_thread_weak_ptr_));
}
-void LayerTreeTest::PostReadbackToMainThread() {
- main_task_runner_->PostTask(
- FROM_HERE,
- base::Bind(&LayerTreeTest::DispatchReadback, main_thread_weak_ptr_));
-}
-
void LayerTreeTest::PostSetNeedsRedrawToMainThread() {
main_task_runner_->PostTask(FROM_HERE,
base::Bind(&LayerTreeTest::DispatchSetNeedsRedraw,
this,
client_.get(),
settings_,
+ base::MessageLoopProxy::current(),
impl_thread_ ? impl_thread_->message_loop_proxy() : NULL);
ASSERT_TRUE(layer_tree_host_);
void LayerTreeTest::SetupTree() {
if (!layer_tree_host_->root_layer()) {
scoped_refptr<Layer> root_layer = Layer::Create();
- root_layer->SetAnchorPoint(gfx::PointF());
root_layer->SetBounds(gfx::Size(1, 1));
root_layer->SetIsDrawable(true);
layer_tree_host_->SetRootLayer(root_layer);
}
void LayerTreeTest::RealEndTest() {
- if (layer_tree_host_ && proxy()->CommitPendingForTesting()) {
+ if (layer_tree_host_ && !timed_out_ &&
+ proxy()->MainFrameWillHappenForTesting()) {
main_task_runner_->PostTask(
FROM_HERE,
base::Bind(&LayerTreeTest::RealEndTest, main_thread_weak_ptr_));
layer_tree_host_->SetNeedsUpdateLayers();
}
-void LayerTreeTest::DispatchReadback() {
- DCHECK(!proxy() || proxy()->IsMainThread());
-
- if (layer_tree_host_) {
- char pixels[4];
- layer_tree_host()->CompositeAndReadback(&pixels, gfx::Rect(0, 0, 1, 1));
- }
-}
-
void LayerTreeTest::DispatchSetNeedsRedraw() {
DCHECK(!proxy() || proxy()->IsMainThread());