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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
// Copyright 2016 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 COMPONENTS_TEST_RUNNER_WEB_WIDGET_TEST_PROXY_H_
#define COMPONENTS_TEST_RUNNER_WEB_WIDGET_TEST_PROXY_H_
#include <memory>
#include "base/logging.h"
#include "base/macros.h"
#include "components/test_runner/test_runner_export.h"
#include "components/test_runner/web_widget_test_client.h"
#include "third_party/WebKit/public/web/WebWidgetClient.h"
namespace blink {
class WebLocalFrame;
class WebString;
class WebWidget;
}
namespace test_runner {
class EventSender;
class WebViewTestProxyBase;
class TEST_RUNNER_EXPORT WebWidgetTestProxyBase {
public:
blink::WebWidget* web_widget() { return web_widget_; }
void set_web_widget(blink::WebWidget* widget) {
DCHECK(widget);
DCHECK(!web_widget_);
web_widget_ = widget;
}
void set_widget_test_client(
std::unique_ptr<WebWidgetTestClient> widget_test_client) {
DCHECK(widget_test_client);
DCHECK(!widget_test_client_);
widget_test_client_ = std::move(widget_test_client);
}
WebViewTestProxyBase* web_view_test_proxy_base() const {
return web_view_test_proxy_base_;
}
void set_web_view_test_proxy_base(
WebViewTestProxyBase* web_view_test_proxy_base) {
DCHECK(web_view_test_proxy_base);
DCHECK(!web_view_test_proxy_base_);
web_view_test_proxy_base_ = web_view_test_proxy_base;
}
EventSender* event_sender() { return event_sender_.get(); }
void Reset();
void BindTo(blink::WebLocalFrame* frame);
protected:
WebWidgetTestProxyBase();
~WebWidgetTestProxyBase();
blink::WebWidgetClient* widget_test_client() {
return widget_test_client_.get();
}
private:
blink::WebWidget* web_widget_;
WebViewTestProxyBase* web_view_test_proxy_base_;
std::unique_ptr<WebWidgetTestClient> widget_test_client_;
std::unique_ptr<EventSender> event_sender_;
DISALLOW_COPY_AND_ASSIGN(WebWidgetTestProxyBase);
};
// WebWidgetTestProxy is used during LayoutTests and always instantiated, at
// time of writing with Base=RenderWidget. It does not directly inherit from it
// for layering purposes.
// The intent of that class is to wrap RenderWidget for tests purposes in
// order to reduce the amount of test specific code in the production code.
// WebWidgetTestProxy is only doing the glue between RenderWidget and
// WebWidgetTestProxyBase, that means that there is no logic living in this
// class except deciding which base class should be called (could be both).
//
// Examples of usage:
// * when a fooClient has a mock implementation, WebWidgetTestProxy can
// override the fooClient() call and have WebWidgetTestProxyBase return the
// mock implementation.
// * when a value needs to be overridden by LayoutTests, WebWidgetTestProxy can
// override RenderViewImpl's getter and call a getter from
// WebWidgetTestProxyBase instead. In addition, WebWidgetTestProxyBase will
// have a public setter that could be called from the TestRunner.
template <class Base, typename... Args>
class WebWidgetTestProxy : public Base, public WebWidgetTestProxyBase {
public:
explicit WebWidgetTestProxy(Args... args) : Base(args...) {}
// WebWidgetClient implementation.
blink::WebScreenInfo screenInfo() override {
blink::WebScreenInfo info = Base::screenInfo();
blink::WebScreenInfo test_info = widget_test_client()->screenInfo();
if (test_info.orientationType != blink::WebScreenOrientationUndefined) {
info.orientationType = test_info.orientationType;
info.orientationAngle = test_info.orientationAngle;
}
return info;
}
void scheduleAnimation() override {
Base::scheduleAnimation();
widget_test_client()->scheduleAnimation();
}
bool requestPointerLock() override {
return widget_test_client()->requestPointerLock();
}
void requestPointerUnlock() override {
widget_test_client()->requestPointerUnlock();
}
bool isPointerLocked() override {
return widget_test_client()->isPointerLocked();
}
void setToolTipText(const blink::WebString& text,
blink::WebTextDirection hint) override {
Base::setToolTipText(text, hint);
widget_test_client()->setToolTipText(text, hint);
}
void startDragging(blink::WebReferrerPolicy policy,
const blink::WebDragData& data,
blink::WebDragOperationsMask mask,
const blink::WebImage& image,
const blink::WebPoint& point) override {
widget_test_client()->startDragging(policy, data, mask, image, point);
// Don't forward this call to Base because we don't want to do a real
// drag-and-drop.
}
private:
virtual ~WebWidgetTestProxy() {}
DISALLOW_COPY_AND_ASSIGN(WebWidgetTestProxy);
};
} // namespace test_runner
#endif // COMPONENTS_TEST_RUNNER_WEB_WIDGET_TEST_PROXY_H_
|
