components/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 COMPONENTS_TEST_RUNNER_WEB_FRAME_TEST_PROXY_H_
   6 #define COMPONENTS_TEST_RUNNER_WEB_FRAME_TEST_PROXY_H_
   7
   8 #include "base/basictypes.h"
   9 #include "components/test_runner/mock_screen_orientation_client.h"
  10 #include "components/test_runner/web_test_delegate.h"
  11 #include "components/test_runner/web_test_interfaces.h"
  12 #include "components/test_runner/web_test_proxy.h"
  13 #include "components/test_runner/web_test_runner.h"
  14 #include "third_party/WebKit/public/platform/WebString.h"
  15
  16 namespace test_runner {
  17
  18 // Templetized wrapper around RenderFrameImpl objects, which implement
  19 // the WebFrameClient interface.
  20 template <class Base, typename P>
  21 class WebFrameTestProxy : public Base {
  22  public:
  23   explicit WebFrameTestProxy(P p) : Base(p), 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, bool empty) {
 114     base_proxy_->DidFinishDocumentLoad(frame);
 115     Base::didFinishDocumentLoad(frame, empty);
 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_->GetDelegate()->PrintMessage(std::string("ALERT: ") +
 149                                              message.utf8().data() + "\n");
 150   }
 151
 152   virtual bool runModalConfirmDialog(const blink::WebString& message) {
 153     base_proxy_->GetDelegate()->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_->GetDelegate()->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_->GetDelegate()->PrintMessage(
 170         std::string("CONFIRM NAVIGATION: ") + message.utf8().data() + "\n");
 171     return !base_proxy_->GetInterfaces()
 172                 ->TestRunner()
 173                 ->ShouldStayOnPageAfterHandlingBeforeUnload();
 174   }
 175
 176   virtual void showContextMenu(
 177       const blink::WebContextMenuData& context_menu_data) {
 178     base_proxy_->ShowContextMenu(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   }
 244
 245   virtual blink::WebNavigationPolicy decidePolicyForNavigation(
 246       const blink::WebFrameClient::NavigationPolicyInfo& info) {
 247     blink::WebNavigationPolicy policy = base_proxy_->DecidePolicyForNavigation(
 248         info);
 249     if (policy == blink::WebNavigationPolicyIgnore)
 250       return policy;
 251
 252     return Base::decidePolicyForNavigation(info);
 253   }
 254
 255   virtual void willStartUsingPeerConnectionHandler(
 256       blink::WebLocalFrame* frame,
 257       blink::WebRTCPeerConnectionHandler* handler) {
 258     // RenderFrameImpl::willStartUsingPeerConnectionHandler can not be mocked.
 259     // See http://crbug/363285.
 260   }
 261
 262   virtual blink::WebUserMediaClient* userMediaClient() {
 263     return base_proxy_->GetUserMediaClient();
 264   }
 265
 266   virtual bool willCheckAndDispatchMessageEvent(
 267       blink::WebLocalFrame* source_frame,
 268       blink::WebFrame* target_frame,
 269       blink::WebSecurityOrigin target,
 270       blink::WebDOMMessageEvent event) {
 271     if (base_proxy_->WillCheckAndDispatchMessageEvent(
 272             source_frame, target_frame, target, event))
 273       return true;
 274     return Base::willCheckAndDispatchMessageEvent(
 275         source_frame, target_frame, target, event);
 276   }
 277
 278   virtual void didStopLoading() {
 279     base_proxy_->DidStopLoading();
 280     Base::didStopLoading();
 281   }
 282
 283   virtual void postAccessibilityEvent(const blink::WebAXObject& object,
 284                                       blink::WebAXEvent event) {
 285     base_proxy_->PostAccessibilityEvent(object, event);
 286     Base::postAccessibilityEvent(object, event);
 287   }
 288
 289  private:
 290   WebTestProxyBase* base_proxy_;
 291
 292   DISALLOW_COPY_AND_ASSIGN(WebFrameTestProxy);
 293 };
 294
 295 }  // namespace test_runner
 296
 297 #endif  // COMPONENTS_TEST_RUNNER_WEB_FRAME_TEST_PROXY_H_