blob: 66340e7bbfff31d24fba738036a02dfe1f6a7f90 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "cc/test/layer_tree_test.h"
#include "cc/trees/thread_proxy.h"
#define THREAD_PROXY_TEST_F(TEST_FIXTURE_NAME) \
TEST_F(TEST_FIXTURE_NAME, MultiThread) { Run(true); }
// Do common tests for single thread proxy and thread proxy.
// TODO(simonhong): Add SINGLE_THREAD_PROXY_TEST_F
#define PROXY_TEST_SCHEDULED_ACTION(TEST_FIXTURE_NAME) \
THREAD_PROXY_TEST_F(TEST_FIXTURE_NAME);
namespace cc {
class ProxyTest : public LayerTreeTest {
protected:
ProxyTest() {}
~ProxyTest() override {}
void Run(bool threaded) {
// We don't need to care about delegating mode.
bool delegating_renderer = true;
RunTest(threaded, delegating_renderer);
}
void BeginTest() override {}
void AfterTest() override {}
private:
DISALLOW_COPY_AND_ASSIGN(ProxyTest);
};
class ProxyTestScheduledActionsBasic : public ProxyTest {
protected:
void BeginTest() override { proxy()->SetNeedsCommit(); }
void ScheduledActionBeginOutputSurfaceCreation() override {
EXPECT_EQ(0, action_phase_++);
}
void ScheduledActionSendBeginMainFrame() override {
EXPECT_EQ(1, action_phase_++);
}
void ScheduledActionCommit() override { EXPECT_EQ(2, action_phase_++); }
void ScheduledActionDrawAndSwapIfPossible() override {
EXPECT_EQ(3, action_phase_++);
EndTest();
}
void AfterTest() override { EXPECT_EQ(4, action_phase_); }
ProxyTestScheduledActionsBasic() : action_phase_(0) {
}
~ProxyTestScheduledActionsBasic() override {}
private:
int action_phase_;
DISALLOW_COPY_AND_ASSIGN(ProxyTestScheduledActionsBasic);
};
PROXY_TEST_SCHEDULED_ACTION(ProxyTestScheduledActionsBasic);
class ThreadProxyTest : public ProxyTest {
protected:
ThreadProxyTest() {}
~ThreadProxyTest() override {}
const ThreadProxy::MainThreadOnly& ThreadProxyMainOnly() const {
DCHECK(proxy());
DCHECK(proxy()->HasImplThread());
return static_cast<const ThreadProxy*>(proxy())->main();
}
const ThreadProxy::CompositorThreadOnly& ThreadProxyImplOnly() const {
DCHECK(proxy());
DCHECK(proxy()->HasImplThread());
return static_cast<const ThreadProxy*>(proxy())->impl();
}
private:
DISALLOW_COPY_AND_ASSIGN(ThreadProxyTest);
};
class ThreadProxyTestSetNeedsCommit : public ThreadProxyTest {
protected:
ThreadProxyTestSetNeedsCommit() {}
~ThreadProxyTestSetNeedsCommit() override {}
void BeginTest() override {
EXPECT_FALSE(ThreadProxyMainOnly().commit_requested);
EXPECT_FALSE(ThreadProxyMainOnly().commit_request_sent_to_impl_thread);
proxy()->SetNeedsCommit();
EXPECT_TRUE(ThreadProxyMainOnly().commit_requested);
EXPECT_TRUE(ThreadProxyMainOnly().commit_request_sent_to_impl_thread);
}
void DidBeginMainFrame() override {
EXPECT_FALSE(ThreadProxyMainOnly().commit_requested);
EXPECT_FALSE(ThreadProxyMainOnly().commit_request_sent_to_impl_thread);
EndTest();
}
private:
DISALLOW_COPY_AND_ASSIGN(ThreadProxyTestSetNeedsCommit);
};
THREAD_PROXY_TEST_F(ThreadProxyTestSetNeedsCommit);
} // namespace cc
|
