src/content/shell/renderer/test_runner/web_frame_test_proxy.h

   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 "content/test/test_media_stream_renderer_factory.h"
  15 #include "third_party/WebKit/public/platform/WebString.h"
  16
  17 namespace content {
  18
  19 // Templetized wrapper around RenderFrameImpl objects, which implement
  20 // the WebFrameClient interface.
  21 template <class Base, typename P, typename R>
  22 class WebFrameTestProxy : public Base {
  23  public:
  24   WebFrameTestProxy(P p, R r) : Base(p, r), base_proxy_(NULL) {}
  25
  26   virtual ~WebFrameTestProxy() {}
  27
  28   void set_base_proxy(WebTestProxyBase* proxy) { base_proxy_ = proxy; }
  29
  30   // WebFrameClient implementation.
  31   virtual blink::WebPlugin* createPlugin(blink::WebLocalFrame* frame,
  32                                          const blink::WebPluginParams& params) {
  33     blink::WebPlugin* plugin = base_proxy_->CreatePlugin(frame, params);
  34     if (plugin)
  35       return plugin;
  36     return Base::createPlugin(frame, params);
  37   }
  38
  39   virtual blink::WebScreenOrientationClient* webScreenOrientationClient() {
  40     return base_proxy_->GetScreenOrientationClientMock();
  41   }
  42
  43   virtual void didAddMessageToConsole(const blink::WebConsoleMessage& message,
  44                                       const blink::WebString& source_name,
  45                                       unsigned source_line,
  46                                       const blink::WebString& stack_trace) {
  47     base_proxy_->DidAddMessageToConsole(message, source_name, source_line);
  48     Base::didAddMessageToConsole(
  49         message, source_name, source_line, stack_trace);
  50   }
  51
  52   virtual bool canCreatePluginWithoutRenderer(
  53       const blink::WebString& mime_type) {
  54     using blink::WebString;
  55
  56     const CR_DEFINE_STATIC_LOCAL(
  57         WebString, suffix, ("-can-create-without-renderer"));
  58     return mime_type.utf8().find(suffix.utf8()) != std::string::npos;
  59   }
  60
  61   virtual void loadURLExternally(blink::WebLocalFrame* frame,
  62                                  const blink::WebURLRequest& request,
  63                                  blink::WebNavigationPolicy policy,
  64                                  const blink::WebString& suggested_name) {
  65     base_proxy_->LoadURLExternally(frame, request, policy, suggested_name);
  66     Base::loadURLExternally(frame, request, policy, suggested_name);
  67   }
  68
  69   virtual void didStartProvisionalLoad(blink::WebLocalFrame* frame,
  70                                        bool isTransitionNavigation) {
  71     base_proxy_->DidStartProvisionalLoad(frame);
  72     Base::didStartProvisionalLoad(frame, isTransitionNavigation);
  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(blink::WebLocalFrame* frame,
  82                                       const blink::WebURLError& error) {
  83     // If the test finished, don't notify the embedder of the failed load,
  84     // as we already destroyed the document loader.
  85     if (base_proxy_->DidFailProvisionalLoad(frame, error))
  86       return;
  87     Base::didFailProvisionalLoad(frame, error);
  88   }
  89
  90   virtual void didCommitProvisionalLoad(
  91       blink::WebLocalFrame* frame,
  92       const blink::WebHistoryItem& item,
  93       blink::WebHistoryCommitType commit_type) {
  94     base_proxy_->DidCommitProvisionalLoad(frame, item, commit_type);
  95     Base::didCommitProvisionalLoad(frame, item, commit_type);
  96   }
  97
  98   virtual void didReceiveTitle(blink::WebLocalFrame* frame,
  99                                const blink::WebString& title,
 100                                blink::WebTextDirection direction) {
 101     base_proxy_->DidReceiveTitle(frame, title, direction);
 102     Base::didReceiveTitle(frame, title, direction);
 103   }
 104
 105   virtual void didChangeIcon(blink::WebLocalFrame* frame,
 106                              blink::WebIconURL::Type icon_type) {
 107     base_proxy_->DidChangeIcon(frame, icon_type);
 108     Base::didChangeIcon(frame, icon_type);
 109   }
 110
 111   virtual void didFinishDocumentLoad(blink::WebLocalFrame* frame) {
 112     base_proxy_->DidFinishDocumentLoad(frame);
 113     Base::didFinishDocumentLoad(frame);
 114   }
 115
 116   virtual void didHandleOnloadEvents(blink::WebLocalFrame* frame) {
 117     base_proxy_->DidHandleOnloadEvents(frame);
 118     Base::didHandleOnloadEvents(frame);
 119   }
 120
 121   virtual void didFailLoad(blink::WebLocalFrame* frame,
 122                            const blink::WebURLError& error) {
 123     base_proxy_->DidFailLoad(frame, error);
 124     Base::didFailLoad(frame, error);
 125   }
 126
 127   virtual void didFinishLoad(blink::WebLocalFrame* frame) {
 128     Base::didFinishLoad(frame);
 129     base_proxy_->DidFinishLoad(frame);
 130   }
 131
 132   virtual blink::WebNotificationPresenter* notificationPresenter() {
 133     return base_proxy_->GetNotificationPresenter();
 134   }
 135
 136   virtual void didChangeSelection(bool is_selection_empty) {
 137     base_proxy_->DidChangeSelection(is_selection_empty);
 138     Base::didChangeSelection(is_selection_empty);
 139   }
 140
 141   virtual blink::WebColorChooser* createColorChooser(
 142       blink::WebColorChooserClient* client,
 143       const blink::WebColor& initial_color,
 144       const blink::WebVector<blink::WebColorSuggestion>& suggestions) {
 145     return base_proxy_->CreateColorChooser(client, initial_color, suggestions);
 146   }
 147
 148   virtual void runModalAlertDialog(const blink::WebString& message) {
 149     base_proxy_->delegate_->PrintMessage(std::string("ALERT: ") +
 150                                          message.utf8().data() + "\n");
 151   }
 152
 153   virtual bool runModalConfirmDialog(const blink::WebString& message) {
 154     base_proxy_->delegate_->PrintMessage(std::string("CONFIRM: ") +
 155                                          message.utf8().data() + "\n");
 156     return true;
 157   }
 158
 159   virtual bool runModalPromptDialog(const blink::WebString& message,
 160                                     const blink::WebString& default_value,
 161                                     blink::WebString*) {
 162     base_proxy_->delegate_->PrintMessage(
 163         std::string("PROMPT: ") + message.utf8().data() + ", default text: " +
 164         default_value.utf8().data() + "\n");
 165     return true;
 166   }
 167
 168   virtual bool runModalBeforeUnloadDialog(bool is_reload,
 169                                           const blink::WebString& message) {
 170     base_proxy_->delegate_->PrintMessage(std::string("CONFIRM NAVIGATION: ") +
 171                                          message.utf8().data() + "\n");
 172     return !base_proxy_->test_interfaces_->GetTestRunner()
 173                 ->shouldStayOnPageAfterHandlingBeforeUnload();
 174   }
 175
 176   virtual void showContextMenu(
 177       const blink::WebContextMenuData& context_menu_data) {
 178     base_proxy_->ShowContextMenu(Base::GetWebFrame(),
 179                                  context_menu_data);
 180     Base::showContextMenu(context_menu_data);
 181   }
 182
 183   virtual void didDetectXSS(blink::WebLocalFrame* frame,
 184                             const blink::WebURL& insecure_url,
 185                             bool did_block_entire_page) {
 186     // This is not implemented in RenderFrameImpl, so need to explicitly call
 187     // into the base proxy.
 188     base_proxy_->DidDetectXSS(frame, insecure_url, did_block_entire_page);
 189     Base::didDetectXSS(frame, insecure_url, did_block_entire_page);
 190   }
 191
 192   virtual void didDispatchPingLoader(blink::WebLocalFrame* frame,
 193                                      const blink::WebURL& url) {
 194     // This is not implemented in RenderFrameImpl, so need to explicitly call
 195     // into the base proxy.
 196     base_proxy_->DidDispatchPingLoader(frame, url);
 197     Base::didDispatchPingLoader(frame, url);
 198   }
 199
 200   virtual void willRequestResource(blink::WebLocalFrame* frame,
 201                                    const blink::WebCachedURLRequest& request) {
 202     // This is not implemented in RenderFrameImpl, so need to explicitly call
 203     // into the base proxy.
 204     base_proxy_->WillRequestResource(frame, request);
 205     Base::willRequestResource(frame, request);
 206   }
 207
 208   virtual void didCreateDataSource(blink::WebLocalFrame* frame,
 209                                    blink::WebDataSource* ds) {
 210     Base::didCreateDataSource(frame, ds);
 211   }
 212
 213   virtual void willSendRequest(blink::WebLocalFrame* frame,
 214                                unsigned identifier,
 215                                blink::WebURLRequest& request,
 216                                const blink::WebURLResponse& redirect_response) {
 217     Base::willSendRequest(frame, identifier, request, redirect_response);
 218     base_proxy_->WillSendRequest(frame, identifier, request, redirect_response);
 219   }
 220
 221   virtual void didReceiveResponse(blink::WebLocalFrame* frame,
 222                                   unsigned identifier,
 223                                   const blink::WebURLResponse& response) {
 224     base_proxy_->DidReceiveResponse(frame, identifier, response);
 225     Base::didReceiveResponse(frame, identifier, response);
 226   }
 227
 228   virtual void didChangeResourcePriority(
 229       blink::WebLocalFrame* frame,
 230       unsigned identifier,
 231       const blink::WebURLRequest::Priority& priority,
 232       int intra_priority_value) {
 233     // This is not implemented in RenderFrameImpl, so need to explicitly call
 234     // into the base proxy.
 235     base_proxy_->DidChangeResourcePriority(
 236         frame, identifier, priority, intra_priority_value);
 237     Base::didChangeResourcePriority(
 238         frame, identifier, priority, intra_priority_value);
 239   }
 240
 241   virtual void didFinishResourceLoad(blink::WebLocalFrame* frame,
 242                                      unsigned identifier) {
 243     base_proxy_->DidFinishResourceLoad(frame, identifier);
 244     Base::didFinishResourceLoad(frame, identifier);
 245   }
 246
 247   virtual blink::WebNavigationPolicy decidePolicyForNavigation(
 248       const blink::WebFrameClient::NavigationPolicyInfo& info) {
 249     blink::WebNavigationPolicy policy = base_proxy_->DecidePolicyForNavigation(
 250         info);
 251     if (policy == blink::WebNavigationPolicyIgnore)
 252       return policy;
 253
 254     return Base::decidePolicyForNavigation(info);
 255   }
 256
 257   virtual void willStartUsingPeerConnectionHandler(
 258       blink::WebLocalFrame* frame,
 259       blink::WebRTCPeerConnectionHandler* handler) {
 260     // RenderFrameImpl::willStartUsingPeerConnectionHandler can not be mocked.
 261     // See http://crbug/363285.
 262   }
 263
 264   virtual blink::WebUserMediaClient* userMediaClient() {
 265     return base_proxy_->GetUserMediaClient();
 266   }
 267
 268   virtual blink::WebMIDIClient* webMIDIClient() {
 269     return base_proxy_->GetWebMIDIClient();
 270   }
 271
 272   virtual bool willCheckAndDispatchMessageEvent(
 273       blink::WebLocalFrame* source_frame,
 274       blink::WebFrame* target_frame,
 275       blink::WebSecurityOrigin target,
 276       blink::WebDOMMessageEvent event) {
 277     if (base_proxy_->WillCheckAndDispatchMessageEvent(
 278             source_frame, target_frame, target, event))
 279       return true;
 280     return Base::willCheckAndDispatchMessageEvent(
 281         source_frame, target_frame, target, event);
 282   }
 283
 284   virtual void didStopLoading() {
 285     base_proxy_->DidStopLoading();
 286     Base::didStopLoading();
 287   }
 288
 289  private:
 290 #if defined(ENABLE_WEBRTC)
 291   virtual scoped_ptr<MediaStreamRendererFactory> CreateRendererFactory()
 292       OVERRIDE {
 293     return scoped_ptr<MediaStreamRendererFactory>(
 294         new TestMediaStreamRendererFactory());
 295   }
 296 #endif
 297
 298   WebTestProxyBase* base_proxy_;
 299
 300   DISALLOW_COPY_AND_ASSIGN(WebFrameTestProxy);
 301 };
 302
 303 }  // namespace content
 304
 305 #endif  // CONTENT_SHELL_RENDERER_TEST_RUNNER_WEB_FRAME_TEST_PROXY_H_