Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(150)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: content/shell/renderer/test_runner/web_frame_test_proxy.h

Issue 1167703002: Move test runner to a component (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 5 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« components/test_runner/common/OWNERS ('K') | « content/shell/renderer/test_runner/web_content_settings.cc ('k') | content/shell/renderer/test_runner/web_task.h » ('j') | content/test/BUILD.gn » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef CONTENT_SHELL_RENDERER_TEST_RUNNER_WEB_FRAME_TEST_PROXY_H_
6 #define CONTENT_SHELL_RENDERER_TEST_RUNNER_WEB_FRAME_TEST_PROXY_H_
7
8 #include "base/basictypes.h"
9 #include "content/shell/renderer/test_runner/mock_screen_orientation_client.h"
10 #include "content/shell/renderer/test_runner/test_interfaces.h"
11 #include "content/shell/renderer/test_runner/test_runner.h"
12 #include "content/shell/renderer/test_runner/web_test_delegate.h"
13 #include "content/shell/renderer/test_runner/web_test_proxy.h"
14 #include "third_party/WebKit/public/platform/WebString.h"
15
16 namespace content {
17
18 // Templetized wrapper around RenderFrameImpl objects, which implement
19 // the WebFrameClient interface.
20 template <class Base, typename P, typename R>
21 class WebFrameTestProxy : public Base {
22 public:
23 WebFrameTestProxy(P p, R r) : Base(p, r), base_proxy_(NULL) {}
24
25 virtual ~WebFrameTestProxy() {}
26
27 void set_base_proxy(WebTestProxyBase* proxy) { base_proxy_ = proxy; }
28
29 // WebFrameClient implementation.
30 virtual blink::WebPlugin* createPlugin(blink::WebLocalFrame* frame,
31 const blink::WebPluginParams& params) {
32 blink::WebPlugin* plugin = base_proxy_->CreatePlugin(frame, params);
33 if (plugin)
34 return plugin;
35 return Base::createPlugin(frame, params);
36 }
37
38 virtual blink::WebScreenOrientationClient* webScreenOrientationClient() {
39 return base_proxy_->GetScreenOrientationClientMock();
40 }
41
42 virtual void didAddMessageToConsole(const blink::WebConsoleMessage& message,
43 const blink::WebString& source_name,
44 unsigned source_line,
45 const blink::WebString& stack_trace) {
46 base_proxy_->DidAddMessageToConsole(message, source_name, source_line);
47 Base::didAddMessageToConsole(
48 message, source_name, source_line, stack_trace);
49 }
50
51 virtual bool canCreatePluginWithoutRenderer(
52 const blink::WebString& mime_type) {
53 using blink::WebString;
54
55 const CR_DEFINE_STATIC_LOCAL(
56 WebString, suffix, ("-can-create-without-renderer"));
57 return mime_type.utf8().find(suffix.utf8()) != std::string::npos;
58 }
59
60 virtual void loadURLExternally(blink::WebLocalFrame* frame,
61 const blink::WebURLRequest& request,
62 blink::WebNavigationPolicy policy,
63 const blink::WebString& suggested_name) {
64 base_proxy_->LoadURLExternally(frame, request, policy, suggested_name);
65 Base::loadURLExternally(frame, request, policy, suggested_name);
66 }
67
68 virtual void didStartProvisionalLoad(blink::WebLocalFrame* frame,
69 double triggeringEventTime) {
70 base_proxy_->DidStartProvisionalLoad(frame);
71 Base::didStartProvisionalLoad(
72 frame, triggeringEventTime);
73 }
74
75 virtual void didReceiveServerRedirectForProvisionalLoad(
76 blink::WebLocalFrame* frame) {
77 base_proxy_->DidReceiveServerRedirectForProvisionalLoad(frame);
78 Base::didReceiveServerRedirectForProvisionalLoad(frame);
79 }
80
81 virtual void didFailProvisionalLoad(
82 blink::WebLocalFrame* frame,
83 const blink::WebURLError& error,
84 blink::WebHistoryCommitType commit_type) {
85 // If the test finished, don't notify the embedder of the failed load,
86 // as we already destroyed the document loader.
87 if (base_proxy_->DidFailProvisionalLoad(frame, error, commit_type))
88 return;
89 Base::didFailProvisionalLoad(frame, error, commit_type);
90 }
91
92 virtual void didCommitProvisionalLoad(
93 blink::WebLocalFrame* frame,
94 const blink::WebHistoryItem& item,
95 blink::WebHistoryCommitType commit_type) {
96 base_proxy_->DidCommitProvisionalLoad(frame, item, commit_type);
97 Base::didCommitProvisionalLoad(frame, item, commit_type);
98 }
99
100 virtual void didReceiveTitle(blink::WebLocalFrame* frame,
101 const blink::WebString& title,
102 blink::WebTextDirection direction) {
103 base_proxy_->DidReceiveTitle(frame, title, direction);
104 Base::didReceiveTitle(frame, title, direction);
105 }
106
107 virtual void didChangeIcon(blink::WebLocalFrame* frame,
108 blink::WebIconURL::Type icon_type) {
109 base_proxy_->DidChangeIcon(frame, icon_type);
110 Base::didChangeIcon(frame, icon_type);
111 }
112
113 virtual void didFinishDocumentLoad(blink::WebLocalFrame* frame) {
114 base_proxy_->DidFinishDocumentLoad(frame);
115 Base::didFinishDocumentLoad(frame);
116 }
117
118 virtual void didHandleOnloadEvents(blink::WebLocalFrame* frame) {
119 base_proxy_->DidHandleOnloadEvents(frame);
120 Base::didHandleOnloadEvents(frame);
121 }
122
123 virtual void didFailLoad(blink::WebLocalFrame* frame,
124 const blink::WebURLError& error,
125 blink::WebHistoryCommitType commit_type) {
126 base_proxy_->DidFailLoad(frame, error, commit_type);
127 Base::didFailLoad(frame, error, commit_type);
128 }
129
130 virtual void didFinishLoad(blink::WebLocalFrame* frame) {
131 Base::didFinishLoad(frame);
132 base_proxy_->DidFinishLoad(frame);
133 }
134
135 virtual void didChangeSelection(bool is_selection_empty) {
136 base_proxy_->DidChangeSelection(is_selection_empty);
137 Base::didChangeSelection(is_selection_empty);
138 }
139
140 virtual blink::WebColorChooser* createColorChooser(
141 blink::WebColorChooserClient* client,
142 const blink::WebColor& initial_color,
143 const blink::WebVector<blink::WebColorSuggestion>& suggestions) {
144 return base_proxy_->CreateColorChooser(client, initial_color, suggestions);
145 }
146
147 virtual void runModalAlertDialog(const blink::WebString& message) {
148 base_proxy_->delegate_->PrintMessage(std::string("ALERT: ") +
149 message.utf8().data() + "\n");
150 }
151
152 virtual bool runModalConfirmDialog(const blink::WebString& message) {
153 base_proxy_->delegate_->PrintMessage(std::string("CONFIRM: ") +
154 message.utf8().data() + "\n");
155 return true;
156 }
157
158 virtual bool runModalPromptDialog(const blink::WebString& message,
159 const blink::WebString& default_value,
160 blink::WebString*) {
161 base_proxy_->delegate_->PrintMessage(
162 std::string("PROMPT: ") + message.utf8().data() + ", default text: " +
163 default_value.utf8().data() + "\n");
164 return true;
165 }
166
167 virtual bool runModalBeforeUnloadDialog(bool is_reload,
168 const blink::WebString& message) {
169 base_proxy_->delegate_->PrintMessage(std::string("CONFIRM NAVIGATION: ") +
170 message.utf8().data() + "\n");
171 return !base_proxy_->test_interfaces_->GetTestRunner()
172 ->shouldStayOnPageAfterHandlingBeforeUnload();
173 }
174
175 virtual void showContextMenu(
176 const blink::WebContextMenuData& context_menu_data) {
177 base_proxy_->ShowContextMenu(Base::GetWebFrame(),
178 context_menu_data);
179 Base::showContextMenu(context_menu_data);
180 }
181
182 virtual void didDetectXSS(blink::WebLocalFrame* frame,
183 const blink::WebURL& insecure_url,
184 bool did_block_entire_page) {
185 // This is not implemented in RenderFrameImpl, so need to explicitly call
186 // into the base proxy.
187 base_proxy_->DidDetectXSS(frame, insecure_url, did_block_entire_page);
188 Base::didDetectXSS(frame, insecure_url, did_block_entire_page);
189 }
190
191 virtual void didDispatchPingLoader(blink::WebLocalFrame* frame,
192 const blink::WebURL& url) {
193 // This is not implemented in RenderFrameImpl, so need to explicitly call
194 // into the base proxy.
195 base_proxy_->DidDispatchPingLoader(frame, url);
196 Base::didDispatchPingLoader(frame, url);
197 }
198
199 virtual void willRequestResource(blink::WebLocalFrame* frame,
200 const blink::WebCachedURLRequest& request) {
201 // This is not implemented in RenderFrameImpl, so need to explicitly call
202 // into the base proxy.
203 base_proxy_->WillRequestResource(frame, request);
204 Base::willRequestResource(frame, request);
205 }
206
207 virtual void didCreateDataSource(blink::WebLocalFrame* frame,
208 blink::WebDataSource* ds) {
209 Base::didCreateDataSource(frame, ds);
210 }
211
212 virtual void willSendRequest(blink::WebLocalFrame* frame,
213 unsigned identifier,
214 blink::WebURLRequest& request,
215 const blink::WebURLResponse& redirect_response) {
216 Base::willSendRequest(frame, identifier, request, redirect_response);
217 base_proxy_->WillSendRequest(frame, identifier, request, redirect_response);
218 }
219
220 virtual void didReceiveResponse(blink::WebLocalFrame* frame,
221 unsigned identifier,
222 const blink::WebURLResponse& response) {
223 base_proxy_->DidReceiveResponse(frame, identifier, response);
224 Base::didReceiveResponse(frame, identifier, response);
225 }
226
227 virtual void didChangeResourcePriority(
228 blink::WebLocalFrame* frame,
229 unsigned identifier,
230 const blink::WebURLRequest::Priority& priority,
231 int intra_priority_value) {
232 // This is not implemented in RenderFrameImpl, so need to explicitly call
233 // into the base proxy.
234 base_proxy_->DidChangeResourcePriority(
235 frame, identifier, priority, intra_priority_value);
236 Base::didChangeResourcePriority(
237 frame, identifier, priority, intra_priority_value);
238 }
239
240 virtual void didFinishResourceLoad(blink::WebLocalFrame* frame,
241 unsigned identifier) {
242 base_proxy_->DidFinishResourceLoad(frame, identifier);
243 Base::didFinishResourceLoad(frame, identifier);
244 }
245
246 virtual blink::WebNavigationPolicy decidePolicyForNavigation(
247 const blink::WebFrameClient::NavigationPolicyInfo& info) {
248 blink::WebNavigationPolicy policy = base_proxy_->DecidePolicyForNavigation(
249 info);
250 if (policy == blink::WebNavigationPolicyIgnore)
251 return policy;
252
253 return Base::decidePolicyForNavigation(info);
254 }
255
256 virtual void willStartUsingPeerConnectionHandler(
257 blink::WebLocalFrame* frame,
258 blink::WebRTCPeerConnectionHandler* handler) {
259 // RenderFrameImpl::willStartUsingPeerConnectionHandler can not be mocked.
260 // See http://crbug/363285.
261 }
262
263 virtual blink::WebUserMediaClient* userMediaClient() {
264 return base_proxy_->GetUserMediaClient();
265 }
266
267 virtual bool willCheckAndDispatchMessageEvent(
268 blink::WebLocalFrame* source_frame,
269 blink::WebFrame* target_frame,
270 blink::WebSecurityOrigin target,
271 blink::WebDOMMessageEvent event) {
272 if (base_proxy_->WillCheckAndDispatchMessageEvent(
273 source_frame, target_frame, target, event))
274 return true;
275 return Base::willCheckAndDispatchMessageEvent(
276 source_frame, target_frame, target, event);
277 }
278
279 virtual void didStopLoading() {
280 base_proxy_->DidStopLoading();
281 Base::didStopLoading();
282 }
283
284 private:
285 WebTestProxyBase* base_proxy_;
286
287 DISALLOW_COPY_AND_ASSIGN(WebFrameTestProxy);
288 };
289
290 } // namespace content
291
292 #endif // CONTENT_SHELL_RENDERER_TEST_RUNNER_WEB_FRAME_TEST_PROXY_H_
OLDNEW
« components/test_runner/common/OWNERS ('K') | « content/shell/renderer/test_runner/web_content_settings.cc ('k') | content/shell/renderer/test_runner/web_task.h » ('j') | content/test/BUILD.gn » ('J')

Powered by Google App Engine
This is Rietveld 408576698