blob: e09dab729b4d227b9bbc93061485a671f2effb11 [file] [log] [blame]
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_UI_BROWSER_WINDOW_H_
#define CHROME_BROWSER_UI_BROWSER_WINDOW_H_
#include <memory>
#include <optional>
#include <string>
#include <vector>
#include "base/feature_list.h"
#include "base/functional/callback_forward.h"
#include "base/functional/callback_helpers.h"
#include "build/branding_buildflags.h"
#include "build/build_config.h"
#include "chrome/browser/apps/link_capturing/intent_picker_info.h"
#include "chrome/browser/lifetime/browser_close_manager.h"
#include "chrome/browser/share/share_attempt.h"
#include "chrome/browser/signin/chrome_signin_helper.h"
#include "chrome/browser/ui/bookmarks/bookmark_bar.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/exclusive_access/exclusive_access_bubble_type.h"
#include "chrome/browser/ui/hats/hats_service.h"
#include "chrome/browser/ui/page_action/page_action_icon_type.h"
#include "chrome/browser/ui/translate/partial_translate_bubble_model.h"
#include "chrome/browser/ui/webui/tab_search/tab_search.mojom.h"
#include "chrome/common/buildflags.h"
#include "components/content_settings/core/common/content_settings_types.h"
#include "components/translate/core/browser/translate_step.h"
#include "components/translate/core/common/translate_errors.h"
#include "ui/base/base_window.h"
#include "ui/base/interaction/element_identifier.h"
#include "ui/base/mojom/window_show_state.mojom-forward.h"
#include "ui/base/window_open_disposition.h"
#include "ui/gfx/native_widget_types.h"
#include "url/origin.h"
#if BUILDFLAG(IS_ANDROID)
#error This file should only be included on desktop.
#endif
class Browser;
class BrowserView;
class DownloadBubbleUIController;
class ExclusiveAccessContext;
class ExtensionsContainer;
class FindBar;
class GURL;
class LocationBar;
class SharingDialog;
class StatusBubble;
struct SharingDialogData;
namespace autofill {
class AutofillBubbleHandler;
} // namespace autofill
namespace content {
class WebContents;
struct NativeWebKeyboardEvent;
enum class KeyboardEventProcessingResult;
} // namespace content
namespace gfx {
class Size;
}
namespace qrcode_generator {
class QRCodeGeneratorBubbleView;
} // namespace qrcode_generator
namespace send_tab_to_self {
class SendTabToSelfBubbleView;
} // namespace send_tab_to_self
namespace sharing_hub {
class ScreenshotCapturedBubble;
class SharingHubBubbleView;
} // namespace sharing_hub
namespace signin_metrics {
enum class AccessPoint;
}
namespace ui {
class ColorProvider;
class NativeTheme;
class ThemeProvider;
} // namespace ui
namespace views {
class Button;
class WebView;
} // namespace views
namespace web_modal {
class WebContentsModalDialogHost;
}
enum class ShowTranslateBubbleResult {
// The Full Page Translate bubble was successfully shown.
SUCCESS,
// The various reasons for which the Full Page Translate bubble could fail to
// be shown.
BROWSER_WINDOW_NOT_VALID,
BROWSER_WINDOW_MINIMIZED,
BROWSER_WINDOW_NOT_ACTIVE,
WEB_CONTENTS_NOT_ACTIVE,
EDITABLE_FIELD_IS_ACTIVE,
};
enum class BrowserThemeChangeType {
// User changes the browser theme.
kBrowserTheme,
// User changes the OS native theme.
kNativeTheme,
// A web app sets a theme color at launch, or changes theme color.
kWebAppTheme
};
////////////////////////////////////////////////////////////////////////////////
// BrowserWindow interface
// An interface implemented by the "view" of the Browser window.
// This interface includes ui::BaseWindow methods as well as Browser window
// specific methods.
//
// NOTE: All getters may return NULL.
//
class BrowserWindow : public ui::BaseWindow {
public:
virtual ~BrowserWindow() = default;
//////////////////////////////////////////////////////////////////////////////
// ui::BaseWindow interface notes:
// Closes the window as soon as possible. If the window is not in a drag
// session, it will close immediately; otherwise, it will move offscreen (so
// events are still fired) until the drag ends, then close. This assumes
// that the Browser is not immediately destroyed, but will be eventually
// destroyed by other means (eg, the tab strip going to zero elements).
// Bad things happen if the Browser dtor is called directly as a result of
// invoking this method.
// virtual void Close() = 0;
// Browser::OnWindowDidShow should be called after showing the window.
// virtual void Show() = 0;
//////////////////////////////////////////////////////////////////////////////
// Browser specific methods:
// Returns the browser window currently hosting `web_contents`. If no browser
// window exists this returns null.
static BrowserWindow* FindBrowserWindowWithWebContents(
content::WebContents* web_contents);
// Returns true if the browser window is on the current workspace (a.k.a.
// virtual desktop) or if we can't tell. False otherwise.
//
// On Windows, it must not be called while application is dispatching an input
// synchronous call like SendMessage, because IsWindowOnCurrentVirtualDesktop
// will return an error.
virtual bool IsOnCurrentWorkspace() const = 0;
// Returns true if the browser window is visible on the screen.
virtual bool IsVisibleOnScreen() const = 0;
// Sets the shown |ratio| of the browser's top controls (a.k.a. top-chrome) as
// a result of gesture scrolling in |web_contents|.
virtual void SetTopControlsShownRatio(content::WebContents* web_contents,
float ratio) = 0;
// Whether or not the renderer's viewport size should be shrunk by the height
// of the browser's top controls.
// As top-chrome is slided up or down, we don't actually resize the web
// contents (for perf reasons) but we have to do a bunch of adjustments on the
// renderer side to make it appear to the user like we're resizing things
// smoothly:
//
// 1) Expose content beyond the web contents rect by expanding the clip.
// 2) Push bottom-fixed elements around until we get a resize. As top-chrome
// hides, we push the fixed elements down by an equivalent amount so that
// they appear to stay fixed to the viewport bottom.
//
// Only when the user releases their finger to finish the scroll do we
// actually resize the web contents and clear these adjustments. So web
// contents has two possible sizes, viewport filling and shrunk by the top
// controls.
//
// The GetTopControlsHeight is a static number that never changes (as long as
// the top-chrome slide with gesture scrolls feature is enabled). To get the
// actual "showing" height as the user sees, you multiply this by the shown
// ratio. However, it's not enough to know this value, the renderer also needs
// to know which direction it should be doing the above-mentioned adjustments.
// That's what the DoBrowserControlsShrinkRendererSize bit is for. It tells
// the renderer whether it's currently in the "viewport filling" or the
// "shrunk by top controls" state.
// The returned value should never change while sliding top-chrome is in
// progress (either due to an in-progress gesture scroll, or due to a
// renderer-initiated animation of the top controls shown ratio).
virtual bool DoBrowserControlsShrinkRendererSize(
const content::WebContents* contents) const = 0;
// Returns the native theme associated with the frame.
virtual ui::NativeTheme* GetNativeTheme() = 0;
// Returns the ThemeProvider associated with the frame.
virtual const ui::ThemeProvider* GetThemeProvider() const = 0;
// Returns the ColorProvider associated with the frame.
virtual const ui::ColorProvider* GetColorProvider() const = 0;
// Returns the context for use with ElementTracker, InteractionSequence, etc.
virtual ui::ElementContext GetElementContext() = 0;
// Returns the height of the browser's top controls. This height doesn't
// change with the current shown ratio above. Renderers will call this to
// calculate the top-chrome shown ratio from the gesture scroll offset.
//
// Note: This should always return 0 if hiding top-chrome with page gesture
// scrolls is disabled. This is needed so the renderer scrolls the page
// immediately rather than changing the shown ratio, thinking that top-chrome
// and the page's top edge are moving.
virtual int GetTopControlsHeight() const = 0;
// Propagates to the browser that gesture scrolling has changed state.
virtual void SetTopControlsGestureScrollInProgress(bool in_progress) = 0;
// Return the status bubble(s) associated with the frame. In a split view,
// there will be multiple status bubbles with the active one listed first.
// It is possible for this to be empty.
virtual std::vector<StatusBubble*> GetStatusBubbles() = 0;
// Inform the frame that the selected tab favicon or title has changed. Some
// frames may need to refresh their title bar.
virtual void UpdateTitleBar() = 0;
// Invoked when the state of the bookmark bar changes. This is only invoked if
// the state changes for the current tab, it is not sent when switching tabs.
virtual void BookmarkBarStateChanged(
BookmarkBar::AnimateChangeType change_type) = 0;
// Temporarily force shows the bookmark bar for the provided |duration|.
virtual void TemporarilyShowBookmarkBar(base::TimeDelta duration) = 0;
// Inform the frame that the dev tools window for the selected tab has
// changed.
virtual void UpdateDevTools(content::WebContents* inspected_web_contents) = 0;
// Update any loading animations running in the window. |is_visible| is true
// if the window is visible.
virtual void UpdateLoadingAnimations(bool is_visible) = 0;
// Sets the starred state for the current tab.
virtual void SetStarredState(bool is_starred) = 0;
// Checks if the browser popup is a tab modal popup.
virtual bool IsTabModalPopupDeprecated() const = 0;
// Sets whether the browser popup is a tab modal popup. Tab modal popups, used
// by autofill features, intentionally disable save card prompts because they
// are not intended for saving new card details.
virtual void SetIsTabModalPopupDeprecated(
bool is_tab_modal_popup_deprecated) = 0;
// Called when the active tab changes. Subclasses which implement
// TabStripModelObserver should implement this instead of ActiveTabChanged();
// the Browser will call this method while processing that one.
virtual void OnActiveTabChanged(content::WebContents* old_contents,
content::WebContents* new_contents,
int index,
int reason) = 0;
// Called when a tab is detached. Subclasses which implement
// TabStripModelObserver should implement this instead of processing this
// in OnTabStripModelChanged(); the Browser will call this method.
virtual void OnTabDetached(content::WebContents* contents,
bool was_active) = 0;
// Called to force the zoom state to for the active tab to be recalculated.
// |can_show_bubble| is true when a user presses the zoom up or down keyboard
// shortcuts and will be false in other cases (e.g. switching tabs, "clicking"
// + or - in the app menu to change zoom).
virtual void ZoomChangedForActiveTab(bool can_show_bubble) = 0;
// Windows and GTK remove the browser controls in fullscreen, but Mac and Ash
// keep the controls in a slide-down panel.
virtual bool ShouldHideUIForFullscreen() const = 0;
// Returns true if the fullscreen bubble is visible.
virtual bool IsFullscreenBubbleVisible() const = 0;
// True when we do not want to allow exiting fullscreen, e.g. in Chrome OS
// Kiosk session.
virtual bool IsForceFullscreen() const = 0;
virtual void SetForceFullscreen(bool force_fullscreen) = 0;
// Returns the size of WebContents in the browser. This may be called before
// the TabStripModel has an active tab.
virtual gfx::Size GetContentsSize() const = 0;
// Resizes the window to fit a WebContents of a certain size. This should only
// be called after the TabStripModel has an active tab.
virtual void SetContentsSize(const gfx::Size& size) = 0;
// Updates the visual state of the specified page action icon if present on
// the window.
virtual void UpdatePageActionIcon(PageActionIconType type) = 0;
// Returns the AutofillBubbleHandler responsible for handling all
// Autofill-related bubbles.
virtual autofill::AutofillBubbleHandler* GetAutofillBubbleHandler() = 0;
// Executes the action for the specified page action icon.
virtual void ExecutePageActionIconForTesting(PageActionIconType type) = 0;
// Returns the location bar.
virtual LocationBar* GetLocationBar() const = 0;
// Tries to focus the location bar. Clears the window focus (to avoid
// inconsistent state) if this fails.
virtual void SetFocusToLocationBar(bool select_all) = 0;
// Informs the view whether or not a load is in progress for the current tab.
// The view can use this notification to update the reload/stop button.
virtual void UpdateReloadStopState(bool is_loading, bool force) = 0;
// Updates the toolbar with the state for the specified |contents|.
virtual void UpdateToolbar(content::WebContents* contents) = 0;
// Updates the toolbar's visible security state. Returns true if the toolbar
// was redrawn.
virtual bool UpdateToolbarSecurityState() = 0;
// Updates whether or not the custom tab bar is visible. Animates the
// transition if |animate| is true.
virtual void UpdateCustomTabBarVisibility(bool visible, bool animate) = 0;
// Updates the visibility of the scrim that covers the content area.
virtual void SetContentScrimVisibility(bool visible) = 0;
// Updates the visibility of the scrim that covers the devtools area.
virtual void SetDevToolsScrimVisibility(bool visible) = 0;
// Resets the toolbar's tab state for |contents|.
virtual void ResetToolbarTabState(content::WebContents* contents) = 0;
// Focuses the toolbar (for accessibility).
virtual void FocusToolbar() = 0;
// Returns the ExtensionsContainer associated with the window, if any.
virtual ExtensionsContainer* GetExtensionsContainer() = 0;
// Called from toolbar subviews during their show/hide animations.
virtual void ToolbarSizeChanged(bool is_animating) = 0;
// Called when the associated window's tab dragging status changed.
virtual void TabDraggingStatusChanged(bool is_dragging) = 0;
// Called when a link is opened in the window from a user gesture.
// Link will be opened with |disposition|.
// TODO(crbug.com/40719979): see if this can't be piped through TabStripModel
// events instead.
virtual void LinkOpeningFromGesture(WindowOpenDisposition disposition) = 0;
// Focuses the app menu like it was a menu bar.
//
// Not used on the Mac, which has a "normal" menu bar.
virtual void FocusAppMenu() = 0;
// Focuses the bookmarks toolbar (for accessibility).
virtual void FocusBookmarksToolbar() = 0;
// Focuses a visible but inactive popup for accessibility.
virtual void FocusInactivePopupForAccessibility() = 0;
// Moves keyboard focus to the next pane.
virtual void RotatePaneFocus(bool forwards) = 0;
// Moves keyboard focus directly to the web contents pane.
virtual void FocusWebContentsPane() = 0;
// Returns whether the bookmark bar is visible or not.
virtual bool IsBookmarkBarVisible() const = 0;
// Returns whether the bookmark bar is animating or not.
virtual bool IsBookmarkBarAnimating() const = 0;
// Returns whether the tab strip is editable (for extensions).
virtual bool IsTabStripEditable() const = 0;
// Forces the tab strip into a not editable state for testing.
virtual void SetTabStripNotEditableForTesting() = 0;
// Returns whether the toolbar is available or not. It's called "Visible()"
// to follow the name convention. But it does not indicate the visibility of
// the toolbar, i.e. toolbar may be hidden, and only visible when the mouse
// cursor is at a certain place.
// TODO(zijiehe): Rename Visible() functions into Available() to match their
// original meaning.
virtual bool IsToolbarVisible() const = 0;
// Returns whether the toolbar is showing up on the screen.
// TODO(zijiehe): Rename this function into IsToolbarVisible() once other
// Visible() functions are renamed to Available().
virtual bool IsToolbarShowing() const = 0;
// Returns whether the location bar is visible.
virtual bool IsLocationBarVisible() const = 0;
// Shows the dialog for a sharing feature.
virtual SharingDialog* ShowSharingDialog(content::WebContents* contents,
SharingDialogData data) = 0;
// Shows the Update Recommended dialog box.
virtual void ShowUpdateChromeDialog() = 0;
// Shows the intent picker bubble. |app_info| contains the app candidates to
// display, if |show_stay_in_chrome| is false, the 'Stay in
// Chrome' (used for non-http(s) queries) button is hidden, if
// |show_remember_selection| is false, the "remember my choice" checkbox is
// hidden and |callback| helps to continue the flow back to either
// AppsNavigationThrottle or ArcExternalProtocolDialog capturing the user's
// decision and storing UMA metrics.
virtual void ShowIntentPickerBubble(
std::vector<apps::IntentPickerAppInfo> app_info,
bool show_stay_in_chrome,
bool show_remember_selection,
apps::IntentPickerBubbleType bubble_type,
const std::optional<url::Origin>& initiating_origin,
IntentPickerResponse callback) = 0;
// Shows the Bookmark bubble. |url| is the URL being bookmarked,
// |already_bookmarked| is true if the url is already bookmarked.
virtual void ShowBookmarkBubble(const GURL& url, bool already_bookmarked) = 0;
// Shows the Screenshot bubble.
virtual sharing_hub::ScreenshotCapturedBubble* ShowScreenshotCapturedBubble(
content::WebContents* contents,
const gfx::Image& image) = 0;
// Shows the QR Code generator bubble. |url| is the URL for the initial code.
virtual qrcode_generator::QRCodeGeneratorBubbleView*
ShowQRCodeGeneratorBubble(content::WebContents* contents,
const GURL& url,
bool show_back_button) = 0;
// Shows the "send tab to self" device picker bubble. This must only be called
// as a direct result of user action.
virtual send_tab_to_self::SendTabToSelfBubbleView*
ShowSendTabToSelfDevicePickerBubble(content::WebContents* contents) = 0;
// Shows the "send tab to self" promo bubble. This must only be called as a
// direct result of user action.
virtual send_tab_to_self::SendTabToSelfBubbleView*
ShowSendTabToSelfPromoBubble(content::WebContents* contents,
bool show_signin_button) = 0;
#if BUILDFLAG(IS_CHROMEOS)
// Returns the PageActionIconView for the Sharing Hub.
virtual views::Button* GetSharingHubIconButton() = 0;
// Toggles the multitask menu on the browser frame size button.
virtual void ToggleMultitaskMenu() const = 0;
#else
// Shows the Sharing Hub bubble. This must only be called as a direct result
// of user action.
virtual sharing_hub::SharingHubBubbleView* ShowSharingHubBubble(
share::ShareAttempt attempt) = 0;
#endif // BUILDFLAG(IS_CHROMEOS)
// Shows the Full Page Translate bubble.
//
// |is_user_gesture| is true when the bubble is shown on the user's deliberate
// action.
virtual ShowTranslateBubbleResult ShowTranslateBubble(
content::WebContents* contents,
translate::TranslateStep step,
const std::string& source_language,
const std::string& target_language,
translate::TranslateErrors error_type,
bool is_user_gesture) = 0;
// Shows the Partial Translate bubble.
virtual void StartPartialTranslate(const std::string& source_language,
const std::string& target_language,
const std::u16string& text_selection) = 0;
// Shows the one-click sign in confirmation UI. |email| holds the full email
// address of the account that has signed in.
virtual void ShowOneClickSigninConfirmation(
const std::u16string& email,
base::OnceCallback<void(bool)> confirmed_callback) = 0;
// Returns the TopContainerView.
virtual views::View* GetTopContainer() = 0;
// Returns the LensOverlayView.
virtual views::View* GetLensOverlayView() = 0;
// Returns the DownloadBubbleUIController. Returns null if Download Bubble
// UI is not enabled, or if the download toolbar button does not exist.
virtual DownloadBubbleUIController* GetDownloadBubbleUIController() = 0;
// Shows the confirmation dialog box warning that the browser is closing with
// in-progress downloads.
// This method should call |callback| with the user's response.
virtual void ConfirmBrowserCloseWithPendingDownloads(
int download_count,
Browser::DownloadCloseType dialog_type,
base::OnceCallback<void(bool)> callback) = 0;
// ThemeService calls this when a user has changed their theme, indicating
// that it's time to redraw everything.
virtual void UserChangedTheme(BrowserThemeChangeType theme_change_type) = 0;
// Shows the app menu (for accessibility).
virtual void ShowAppMenu() = 0;
// Allows the BrowserWindow object to handle the specified mouse event
// before sending it to the renderer.
virtual bool PreHandleMouseEvent(const blink::WebMouseEvent& event) = 0;
// Allows the BrowserWindow object to handle a mouse drag update
// before sending it to the renderer.
// `point` is relative to the content view.
virtual void PreHandleDragUpdate(const content::DropData& drop_data,
const gfx::PointF& point) = 0;
virtual void PreHandleDragExit() = 0;
virtual void HandleDragEnded() = 0;
// Allows the BrowserWindow object to handle the specified keyboard event
// before sending it to the renderer.
virtual content::KeyboardEventProcessingResult PreHandleKeyboardEvent(
const input::NativeWebKeyboardEvent& event) = 0;
// Allows the BrowserWindow object to handle the specified keyboard event,
// if the renderer did not process it.
virtual bool HandleKeyboardEvent(
const input::NativeWebKeyboardEvent& event) = 0;
// Construct a FindBar implementation for the |browser|.
virtual std::unique_ptr<FindBar> CreateFindBar() = 0;
// Return the WebContentsModalDialogHost for use in positioning web contents
// modal dialogs within the browser window. This can sometimes be NULL (for
// instance during tab drag on Views/Win32).
virtual web_modal::WebContentsModalDialogHost*
GetWebContentsModalDialogHost() = 0;
// Construct a BrowserWindow implementation for the specified |browser|.
static BrowserWindow* CreateBrowserWindow(std::unique_ptr<Browser> browser,
bool user_gesture,
bool in_tab_dragging);
virtual void ShowAvatarBubbleFromAvatarButton(bool is_source_accelerator) = 0;
// Attempts showing the In-Produce-Help for profile Switching. This is called
// after creating a new profile or opening an existing profile. If the profile
// customization bubble is shown, the IPH should be shown after.
virtual void MaybeShowProfileSwitchIPH() = 0;
// Attempts showing the In-Product-Help for supervised user profiles.
// This should be invoked for new signed-in supervised profiles created
// by FRE, the profile picker, profile menu or chrome menu.
// If the profile customization bubble is shown, the IPH should be shown
// after.
// TODO(351333491): To specify if this will be invoked on signing-in/turning
// on sync for an existing profile.
virtual void MaybeShowSupervisedUserProfileSignInIPH() = 0;
// Shows User Happiness Tracking Survey's dialog after the survey associated
// with |site_id| has been successfully loaded. Failure to load the survey
// will result in the dialog not being shown. |product_specific_bits_data| and
// |product_specific_string_data| should contain key-value pairs where the
// keys match the field names set for the survey in hats_service.cc, and the
// values are those which will be associated with the survey response.
// The parameters |hats_histogram_name| and |hats_survey_ukm_id| allows HaTS
// to log to UMA and UKM, respectively. These values are are populated in
// chrome/browser/ui/hats/survey_config.cc and can be configured in finch.
// Surveys that opt-in to UMA and UKM will need to have surveys reviewed by
// privacy to ensure they are appropriate to log to UMA and/or UKM. This is
// enforced through the OWNERS mechanism.
virtual void ShowHatsDialog(
const std::string& site_id,
const std::optional<std::string>& hats_histogram_name,
const std::optional<uint64_t> hats_survey_ukm_id,
base::OnceClosure success_callback,
base::OnceClosure failure_callback,
const SurveyBitsData& product_specific_bits_data,
const SurveyStringData& product_specific_string_data) = 0;
// Returns object implementing ExclusiveAccessContext interface.
virtual ExclusiveAccessContext* GetExclusiveAccessContext() = 0;
// Returns the platform-specific ID of the workspace the browser window
// currently resides in.
virtual std::string GetWorkspace() const = 0;
virtual bool IsVisibleOnAllWorkspaces() const = 0;
// Shows the platform specific emoji picker.
virtual void ShowEmojiPanel() = 0;
// Opens the eye dropper.
virtual std::unique_ptr<content::EyeDropper> OpenEyeDropper(
content::RenderFrameHost* frame,
content::EyeDropperListener* listener) = 0;
// Shows a confirmation dialog about enabling caret browsing.
virtual void ShowCaretBrowsingDialog() = 0;
// Create and open the tab search bubble. Optionally force it to open to the
// given section and organization feature.
virtual void CreateTabSearchBubble(
tab_search::mojom::TabSearchSection section,
tab_search::mojom::TabOrganizationFeature organization_feature) = 0;
void CreateTabSearchBubble(tab_search::mojom::TabSearchSection section =
tab_search::mojom::TabSearchSection::kSearch) {
CreateTabSearchBubble(section,
tab_search::mojom::TabOrganizationFeature::kNone);
}
// Closes the tab search bubble if open for the given browser instance.
virtual void CloseTabSearchBubble() = 0;
// Shows an Incognito clear browsing data dialog.
virtual void ShowIncognitoClearBrowsingDataDialog() = 0;
// Shows an Incognito history disclaimer dialog.
virtual void ShowIncognitoHistoryDisclaimerDialog() = 0;
// Returns true when the borderless mode should be displayed instead
// of a full titlebar. This is only supported for desktop web apps.
virtual bool IsBorderlessModeEnabled() const = 0;
// Notifies `BrowserView` about the resizable boolean having been set with
// `window.setResizable(bool)` API.
virtual void OnWebApiWindowResizableChanged() = 0;
// Returns the overall resizability of the `BrowserView` when considering
// both the value set by the `window.setResizable(bool)` API and browser's
// "native" resizability.
virtual bool GetCanResize() = 0;
virtual ui::mojom::WindowShowState GetWindowShowState() const = 0;
// Shows the Chrome Labs bubble if enabled.
virtual void ShowChromeLabs() = 0;
// Returns the WebView backing the tab-contents area of the BrowserWindow.
virtual views::WebView* GetContentsWebView() = 0;
// In production code BrowserView is the only subclass for BrowserWindow. The
// fact that this is not true in some tests is a problem with the tests. See
// https://crbug.com/360163254.
virtual BrowserView* AsBrowserView() = 0;
protected:
// Synchronously destroys the Browser.
// TODO(crbug.com/413168662): This can be removed once the ownership structure
// is updated and Browser owns BrowserWindow.
friend class Browser;
virtual void DestroyBrowser() = 0;
};
#endif // CHROME_BROWSER_UI_BROWSER_WINDOW_H_