// 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.

#ifndef COMPONENTS_TEST_RUNNER_WEB_FRAME_TEST_PROXY_H_
#define COMPONENTS_TEST_RUNNER_WEB_FRAME_TEST_PROXY_H_

#include <memory>
#include <utility>

#include "base/logging.h"
#include "base/macros.h"
#include "components/test_runner/test_runner_export.h"
#include "components/test_runner/web_frame_test_client.h"
#include "third_party/WebKit/public/platform/WebEffectiveConnectionType.h"
#include "third_party/WebKit/public/platform/WebString.h"
#include "third_party/WebKit/public/web/WebFrameClient.h"
#include "third_party/WebKit/public/web/WebLocalFrame.h"

namespace test_runner {

class TEST_RUNNER_EXPORT WebFrameTestProxyBase {
 public:
  void set_test_client(std::unique_ptr<WebFrameTestClient> client) {
    DCHECK(client);
    DCHECK(!test_client_);
    test_client_ = std::move(client);
  }

  blink::WebLocalFrame* web_frame() const { return web_frame_; }
  void set_web_frame(blink::WebLocalFrame* frame) {
    DCHECK(frame);
    DCHECK(!web_frame_);
    web_frame_ = frame;
  }

 protected:
  WebFrameTestProxyBase();
  ~WebFrameTestProxyBase();
  blink::WebFrameClient* test_client() { return test_client_.get(); }

 private:
  std::unique_ptr<WebFrameTestClient> test_client_;
  blink::WebLocalFrame* web_frame_;

  DISALLOW_COPY_AND_ASSIGN(WebFrameTestProxyBase);
};

// WebFrameTestProxy is used during LayoutTests and always instantiated, at time
// of writing with Base=RenderFrameImpl. It does not directly inherit from it
// for layering purposes.
template <class Base, typename P>
class WebFrameTestProxy : public Base, public WebFrameTestProxyBase {
 public:
  explicit WebFrameTestProxy(P p) : Base(p) {}

  virtual ~WebFrameTestProxy() {}

  // WebFrameClient implementation.
  blink::WebPlugin* createPlugin(
      blink::WebLocalFrame* frame,
      const blink::WebPluginParams& params) override {
    blink::WebPlugin* plugin = test_client()->createPlugin(frame, params);
    if (plugin)
      return plugin;
    return Base::createPlugin(frame, params);
  }

  blink::WebScreenOrientationClient* webScreenOrientationClient() override {
    return test_client()->webScreenOrientationClient();
  }

  void didAddMessageToConsole(const blink::WebConsoleMessage& message,
                              const blink::WebString& source_name,
                              unsigned source_line,
                              const blink::WebString& stack_trace) override {
    test_client()->didAddMessageToConsole(message, source_name, source_line,
                                          stack_trace);
    Base::didAddMessageToConsole(
        message, source_name, source_line, stack_trace);
  }

  bool canCreatePluginWithoutRenderer(
      const blink::WebString& mime_type) override {
    const char suffix[] = "-can-create-without-renderer";
    return mime_type.utf8().find(suffix) != std::string::npos;
  }

  void loadURLExternally(const blink::WebURLRequest& request,
                         blink::WebNavigationPolicy policy,
                         const blink::WebString& suggested_name,
                         bool replaces_current_history_item) override {
    test_client()->loadURLExternally(request, policy, suggested_name,
                                     replaces_current_history_item);
    Base::loadURLExternally(request, policy, suggested_name,
                            replaces_current_history_item);
  }

  void didStartProvisionalLoad(blink::WebLocalFrame* frame) override {
    test_client()->didStartProvisionalLoad(frame);
    Base::didStartProvisionalLoad(frame);
  }

  void didReceiveServerRedirectForProvisionalLoad(
      blink::WebLocalFrame* frame) override {
    test_client()->didReceiveServerRedirectForProvisionalLoad(frame);
    Base::didReceiveServerRedirectForProvisionalLoad(frame);
  }

  void didFailProvisionalLoad(
      blink::WebLocalFrame* frame,
      const blink::WebURLError& error,
      blink::WebHistoryCommitType commit_type) override {
    test_client()->didFailProvisionalLoad(frame, error, commit_type);
    // If the test finished, don't notify the embedder of the failed load,
    // as we already destroyed the document loader.
    if (!frame->provisionalDataSource())
      return;
    Base::didFailProvisionalLoad(frame, error, commit_type);
  }

  void didCommitProvisionalLoad(
      blink::WebLocalFrame* frame,
      const blink::WebHistoryItem& item,
      blink::WebHistoryCommitType commit_type) override {
    test_client()->didCommitProvisionalLoad(frame, item, commit_type);
    Base::didCommitProvisionalLoad(frame, item, commit_type);
  }

  void didReceiveTitle(blink::WebLocalFrame* frame,
                       const blink::WebString& title,
                       blink::WebTextDirection direction) override {
    test_client()->didReceiveTitle(frame, title, direction);
    Base::didReceiveTitle(frame, title, direction);
  }

  void didChangeIcon(blink::WebLocalFrame* frame,
                     blink::WebIconURL::Type icon_type) override {
    test_client()->didChangeIcon(frame, icon_type);
    Base::didChangeIcon(frame, icon_type);
  }

  void didFinishDocumentLoad(blink::WebLocalFrame* frame) override {
    test_client()->didFinishDocumentLoad(frame);
    Base::didFinishDocumentLoad(frame);
  }

  void didHandleOnloadEvents(blink::WebLocalFrame* frame) override {
    test_client()->didHandleOnloadEvents(frame);
    Base::didHandleOnloadEvents(frame);
  }

  void didFailLoad(blink::WebLocalFrame* frame,
                   const blink::WebURLError& error,
                   blink::WebHistoryCommitType commit_type) override {
    test_client()->didFailLoad(frame, error, commit_type);
    Base::didFailLoad(frame, error, commit_type);
  }

  void didFinishLoad(blink::WebLocalFrame* frame) override {
    Base::didFinishLoad(frame);
    test_client()->didFinishLoad(frame);
  }

  void didNavigateWithinPage(blink::WebLocalFrame* frame,
                             const blink::WebHistoryItem& history_item,
                             blink::WebHistoryCommitType commit_type,
                             bool content_initiated) override {
    Base::didNavigateWithinPage(frame, history_item, commit_type,
                                content_initiated);
    test_client()->didNavigateWithinPage(frame, history_item, commit_type,
                                         content_initiated);
  }

  void didStopLoading() override {
    Base::didStopLoading();
    test_client()->didStopLoading();
  }

  void didChangeSelection(bool is_selection_empty) override {
    test_client()->didChangeSelection(is_selection_empty);
    Base::didChangeSelection(is_selection_empty);
  }

  blink::WebColorChooser* createColorChooser(
      blink::WebColorChooserClient* client,
      const blink::WebColor& initial_color,
      const blink::WebVector<blink::WebColorSuggestion>& suggestions) override {
    return test_client()->createColorChooser(client, initial_color,
                                             suggestions);
  }

  blink::WebEffectiveConnectionType getEffectiveConnectionType() override {
    if (test_client()->getEffectiveConnectionType() !=
        blink::WebEffectiveConnectionType::TypeUnknown) {
      return test_client()->getEffectiveConnectionType();
    }
    return Base::getEffectiveConnectionType();
  }

  void runModalAlertDialog(const blink::WebString& message) override {
    test_client()->runModalAlertDialog(message);
  }

  bool runModalConfirmDialog(const blink::WebString& message) override {
    return test_client()->runModalConfirmDialog(message);
  }

  bool runModalPromptDialog(const blink::WebString& message,
                            const blink::WebString& default_value,
                            blink::WebString* actual_value) override {
    return test_client()->runModalPromptDialog(message, default_value,
                                               actual_value);
  }

  bool runModalBeforeUnloadDialog(bool is_reload) override {
    return test_client()->runModalBeforeUnloadDialog(is_reload);
  }

  void showContextMenu(
      const blink::WebContextMenuData& context_menu_data) override {
    test_client()->showContextMenu(context_menu_data);
    Base::showContextMenu(context_menu_data);
  }

  void didDetectXSS(const blink::WebURL& insecure_url,
                    bool did_block_entire_page) override {
    // This is not implemented in RenderFrameImpl, so need to explicitly call
    // into the base proxy.
    test_client()->didDetectXSS(insecure_url, did_block_entire_page);
    Base::didDetectXSS(insecure_url, did_block_entire_page);
  }

  void didDispatchPingLoader(const blink::WebURL& url) override {
    // This is not implemented in RenderFrameImpl, so need to explicitly call
    // into the base proxy.
    test_client()->didDispatchPingLoader(url);
    Base::didDispatchPingLoader(url);
  }

  void willSendRequest(blink::WebLocalFrame* frame,
                       blink::WebURLRequest& request) override {
    Base::willSendRequest(frame, request);
    test_client()->willSendRequest(frame, request);
  }

  void didReceiveResponse(const blink::WebURLResponse& response) override {
    test_client()->didReceiveResponse(response);
    Base::didReceiveResponse(response);
  }

  blink::WebNavigationPolicy decidePolicyForNavigation(
      const blink::WebFrameClient::NavigationPolicyInfo& info) override {
    blink::WebNavigationPolicy policy =
        test_client()->decidePolicyForNavigation(info);
    if (policy == blink::WebNavigationPolicyIgnore)
      return policy;

    return Base::decidePolicyForNavigation(info);
  }

  void didStartLoading(bool to_different_document) override {
    Base::didStartLoading(to_different_document);
    test_client()->didStartLoading(to_different_document);
  }

  void willStartUsingPeerConnectionHandler(
      blink::WebRTCPeerConnectionHandler* handler) override {
    // RenderFrameImpl::willStartUsingPeerConnectionHandler can not be mocked.
    // See http://crbug/363285.
  }

  blink::WebUserMediaClient* userMediaClient() override {
    return test_client()->userMediaClient();
  }

  void postAccessibilityEvent(const blink::WebAXObject& object,
                              blink::WebAXEvent event) override {
    test_client()->postAccessibilityEvent(object, event);
    Base::postAccessibilityEvent(object, event);
  }

  void checkIfAudioSinkExistsAndIsAuthorized(
      const blink::WebString& sink_id,
      const blink::WebSecurityOrigin& security_origin,
      blink::WebSetSinkIdCallbacks* web_callbacks) override {
    test_client()->checkIfAudioSinkExistsAndIsAuthorized(
        sink_id, security_origin, web_callbacks);
  }

  void didClearWindowObject(blink::WebLocalFrame* frame) override {
    test_client()->didClearWindowObject(frame);
    Base::didClearWindowObject(frame);
  }
  bool runFileChooser(const blink::WebFileChooserParams& params,
                      blink::WebFileChooserCompletion* completion) override {
    return test_client()->runFileChooser(params, completion);
  }

 private:
  DISALLOW_COPY_AND_ASSIGN(WebFrameTestProxy);
};

}  // namespace test_runner

#endif  // COMPONENTS_TEST_RUNNER_WEB_FRAME_TEST_PROXY_H_