blob: 417db49caeea8afced0f991e36bb1472e9ff7614 [file] [log] [blame]
// Copyright (c) 2012 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.
#include <string>
#include <vector>
#include "content/public/browser/web_contents_delegate.h"
#include "ui/base/ui_base_types.h"
#include "ui/base/window_open_disposition.h"
#include "ui/web_dialogs/web_dialogs_export.h"
class GURL;
namespace content {
class RenderFrameHost;
class WebContents;
class WebUI;
class WebUIMessageHandler;
struct ContextMenuParams;
struct OpenURLParams;
namespace gfx {
class Size;
namespace ui {
class Accelerator;
// Implement this class to receive notifications.
class WEB_DIALOGS_EXPORT WebDialogDelegate {
enum class FrameKind {
kDialog, // Does not include a title bar or frame caption buttons.
kNonClient, // Includes a non client frame view with title & buttons.
// Returns the modal type for this dialog. Only called once, during
// WebDialogView creation.
virtual ModalType GetDialogModalType() const = 0;
// Returns the title of the dialog.
virtual std::u16string GetDialogTitle() const = 0;
// Returns the title to be read with screen readers.
virtual std::u16string GetAccessibleDialogTitle() const;
// Returns the dialog's name identifier. Used to identify this dialog for
// state restoration.
virtual std::string GetDialogName() const;
// Get the HTML file path for the content to load in the dialog.
virtual GURL GetDialogContentURL() const = 0;
// Get WebUIMessageHandler objects to handle messages from the HTML/JS page.
// The handlers are used to send and receive messages from the page while it
// is still open. Ownership of each handler is taken over by the WebUI
// hosting the page.
virtual void GetWebUIMessageHandlers(
std::vector<content::WebUIMessageHandler*>* handlers) const = 0;
// Get the size of the dialog. Implementations can safely assume |size| is a
// valid pointer. Callers should be able to handle the case where
// implementations do not write into |size|.
virtual void GetDialogSize(gfx::Size* size) const = 0;
// Get the minimum size of the dialog. The default implementation just calls
// GetDialogSize().
virtual void GetMinimumDialogSize(gfx::Size* size) const;
// Gets the JSON string input to use when showing the dialog.
virtual std::string GetDialogArgs() const = 0;
// Returns true if the dialog can ever be resized. Default implementation
// returns true.
bool can_resize() const { return can_resize_; }
void set_can_resize(bool can_resize) { can_resize_ = can_resize; }
// Returns true if the dialog can ever be maximized. Default implementation
// returns false.
virtual bool CanMaximizeDialog() const;
// Returns true if the dialog can ever be minimized. Default implementation
// returns false.
bool can_minimize() const { return can_minimize_; }
void set_can_minimize(bool can_minimize) { can_minimize_ = can_minimize; }
// A callback to notify the delegate that |source|'s loading state has
// changed.
virtual void OnLoadingStateChanged(content::WebContents* source) {}
// A callback to notify the delegate that a web dialog has been shown.
// |webui| is the WebUI with which the dialog is associated.
virtual void OnDialogShown(content::WebUI* webui) {}
// A callback to notify the delegate that the window is requesting to be
// closed. If this returns true, the dialog is closed, otherwise the
// dialog remains open. Default implementation returns true.
virtual bool OnDialogCloseRequested();
// Called when the dialog's window is certainly about to close, but teardown
// has not started yet. This differs from OnDialogCloseRequested in that
// OnDialogCloseRequested is part of the process of deciding whether to close
// a window, while OnDialogWillClose is called as soon as it is known for
// certain that the window is about to be closed.
virtual void OnDialogWillClose() {}
// A callback to notify the delegate that the dialog is about to close due to
// the user pressing the ESC key.
virtual void OnDialogClosingFromKeyEvent() {}
// A callback to notify the delegate that the dialog closed.
// IMPORTANT: Implementations should delete |this| here (unless they've
// arranged for the delegate to be deleted in some other way, e.g. by
// registering it as a message handler in the WebUI object).
virtual void OnDialogClosed(const std::string& json_retval) = 0;
// A callback to notify the delegate that the dialog is being closed in
// response to a "dialogClose" message from WebUI.
virtual void OnDialogCloseFromWebUI(const std::string& json_retval);
// A callback to notify the delegate that the contents are requesting
// to be closed. This could be in response to a number of events
// that are handled by the WebContents. If the output parameter
// is set to true, then the dialog is closed. The default is false.
// |out_close_dialog| is never NULL.
virtual void OnCloseContents(content::WebContents* source,
bool* out_close_dialog) = 0;
// Returns true if escape should immediately close the dialog. Default is
// true.
virtual bool ShouldCloseDialogOnEscape() const;
// A callback to allow the delegate to dictate that the window should not
// have a title bar. This is useful when presenting branded interfaces.
virtual bool ShouldShowDialogTitle() const = 0;
// A callback to allow the delegate to center title text. Default is
// false.
virtual bool ShouldCenterDialogTitleText() const;
// Returns true if the dialog should show a close button in the title bar.
// Default implementation returns true.
virtual bool ShouldShowCloseButton() const;
// A callback to allow the delegate to inhibit context menu or show
// customized menu.
// Returns true iff you do NOT want the standard context menu to be
// shown (because you want to handle it yourself).
virtual bool HandleContextMenu(content::RenderFrameHost* render_frame_host,
const content::ContextMenuParams& params);
// A callback to allow the delegate to open a new URL inside |source|.
// On return |out_new_contents| should contain the WebContents the URL
// is opened in. Return false to use the default handler.
virtual bool HandleOpenURLFromTab(content::WebContents* source,
const content::OpenURLParams& params,
content::WebContents** out_new_contents);
// A callback to control whether a WebContents will be created. Returns
// true to disallow the creation. Return false to use the default handler.
virtual bool HandleShouldOverrideWebContentsCreation();
// Stores the dialog bounds.
virtual void StoreDialogSize(const gfx::Size& dialog_size) {}
// Returns the accelerators handled by the delegate.
virtual std::vector<Accelerator> GetAccelerators();
// Returns true if |accelerator| is processed, otherwise false.
virtual bool AcceleratorPressed(const Accelerator& accelerator);
virtual void OnWebContentsFinishedLoad() {}
virtual void RequestMediaAccessPermission(
content::WebContents* web_contents,
const content::MediaStreamRequest& request,
content::MediaResponseCallback callback) {}
virtual bool CheckMediaAccessPermission(
content::RenderFrameHost* render_frame_host,
const GURL& security_origin,
blink::mojom::MediaStreamType type);
// Whether to use dialog frame view for non client frame view.
virtual FrameKind GetWebDialogFrameKind() const;
virtual ~WebDialogDelegate() = default;
bool can_minimize_ = false;
bool can_resize_ = true;
} // namespace ui