1 // Copyright 2012 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef CONTENT_PUBLIC_BROWSER_WEB_CONTENTS_DELEGATE_H_
6 #define CONTENT_PUBLIC_BROWSER_WEB_CONTENTS_DELEGATE_H_
15 #include "base/functional/callback.h"
16 #include "base/memory/scoped_refptr.h"
17 #include "build/build_config.h"
18 #include "content/common/content_export.h"
19 #include "content/public/browser/eye_dropper.h"
20 #include "content/public/browser/fullscreen_types.h"
21 #include "content/public/browser/invalidate_type.h"
22 #include "content/public/browser/media_stream_request.h"
23 #include "content/public/browser/serial_chooser.h"
24 #include "content/public/browser/web_contents.h"
25 #include "content/public/common/window_container_type.mojom-forward.h"
26 #include "third_party/blink/public/common/mediastream/media_stream_request.h"
27 #include "third_party/blink/public/common/page/drag_operation.h"
28 #include "third_party/blink/public/mojom/choosers/color_chooser.mojom-forward.h"
29 #include "third_party/blink/public/mojom/frame/blocked_navigation_types.mojom.h"
30 #include "third_party/blink/public/mojom/frame/fullscreen.mojom-forward.h"
31 #include "third_party/blink/public/mojom/manifest/display_mode.mojom.h"
32 #include "third_party/skia/include/core/SkColor.h"
33 #include "ui/base/window_open_disposition.h"
34 #include "ui/gfx/geometry/rect_f.h"
35 #include "ui/gfx/native_widget_types.h"
37 #if BUILDFLAG(IS_ANDROID)
38 #include "base/android/scoped_java_ref.h"
51 class FileChooserParams;
58 class EyeDropperListener;
59 class FileSelectListener;
60 class JavaScriptDialogManager;
61 class RenderFrameHost;
62 class RenderWidgetHost;
63 class SessionStorageNamespace;
65 struct ContextMenuParams;
67 struct MediaPlayerWatchTime;
68 struct NativeWebKeyboardEvent;
70 } // namespace content
74 class GeolocationContext;
88 class WebGestureEvent;
89 enum class ProtocolHandlerSecurityLevel;
94 class AudioStreamBrokerFactory;
97 enum class KeyboardEventProcessingResult;
99 // Result of an EnterPictureInPicture request.
100 enum class PictureInPictureResult {
101 // The request was successful.
104 // Picture-in-Picture is not supported by the embedder.
108 // Objects implement this interface to get notified about changes in the
109 // WebContents and to provide necessary functionality. If a method doesn't
110 // change state, e.g. has no return value, then it can move to
111 // WebContentsObserver if many places want to observe the change. If the
112 // implementation of one of the methods below would be shared by many or all of
113 // WebContentsDelegate implementations then it can go on ContentBrowserClient.
114 class CONTENT_EXPORT WebContentsDelegate {
116 WebContentsDelegate();
118 // Opens a new URL inside the passed in WebContents (if source is 0 open
119 // in the current front-most tab), unless |disposition| indicates the url
120 // should be opened in a new tab or window.
122 // A nullptr source indicates the current tab (callers should probably use
123 // OpenURL() for these cases which does it for you).
125 // Returns the WebContents the URL is opened in, or nullptr if the URL wasn't
126 // opened immediately. Note that the URL might be opened in another context
127 // when a nullptr is returned.
128 virtual WebContents* OpenURLFromTab(WebContents* source,
129 const OpenURLParams& params);
131 // Allows the delegate to optionally cancel navigations that attempt to
132 // transfer to a different process between the start of the network load and
133 // commit. Defaults to true.
134 virtual bool ShouldAllowRendererInitiatedCrossProcessNavigation(
135 bool is_outermost_main_frame_navigation);
137 // Called to inform the delegate that the WebContents's navigation state
138 // changed. The |changed_flags| indicates the parts of the navigation state
139 // that have been updated.
140 virtual void NavigationStateChanged(WebContents* source,
141 InvalidateTypes changed_flags) {}
143 // Called to inform the delegate that the WebContent's visible
144 // security state changed and that security UI should be updated.
145 virtual void VisibleSecurityStateChanged(WebContents* source) {}
147 // Creates a new tab with the already-created WebContents `new_contents`.
148 // The window for the added contents should be reparented correctly when this
149 // method returns. `target_url` is set to the value provided when
150 // `new_contents` was created. If `disposition` is NEW_POPUP,
151 // `window_features` should hold the initial position, size and other
152 // properties of the window. If `was_blocked` is non-nullptr, then
153 // `*was_blocked` will be set to true if the popup gets blocked, and left
154 // unchanged otherwise.
155 virtual void AddNewContents(
157 std::unique_ptr<WebContents> new_contents,
158 const GURL& target_url,
159 WindowOpenDisposition disposition,
160 const blink::mojom::WindowFeatures& window_features,
162 bool* was_blocked) {}
164 // Selects the specified contents, bringing its container to the front.
165 virtual void ActivateContents(WebContents* contents) {}
167 // Notifies the delegate that this contents is starting or is done loading
168 // some resource. The delegate should use this notification to represent
169 // loading feedback. See WebContents::IsLoading()
170 // |should_show_loading_ui| indicates whether a load start should be visible
171 // in UI elements. It is generally true for different-document navigations and
172 // false for most same-document navigations (because same-documents are
173 // typically instantaneous so there's no point in flickering the UI). The
174 // exception is the navigation API's intercept(), which is the sole type
175 // of same-document navigation that is asynchronous, and therefore a UI change
177 virtual void LoadingStateChanged(WebContents* source,
178 bool should_show_loading_ui) {}
180 // Request the delegate to close this web contents, and do whatever cleanup
182 virtual void CloseContents(WebContents* source) {}
184 // Request the delegate to resize this WebContents to the specified size in
185 // screen coordinates. The embedder is free to ignore the request.
186 virtual void SetContentsBounds(WebContents* source, const gfx::Rect& bounds) {
189 // Notification that the target URL has changed.
190 virtual void UpdateTargetURL(WebContents* source,
193 // Notification that there was a mouse event, along with the type of event.
194 // If |motion| is true, this is a normal motion event. If |exited| is true,
195 // the pointer left the contents area.
196 virtual void ContentsMouseEvent(WebContents* source,
200 // Request the delegate to change the zoom level of the current tab.
201 virtual void ContentsZoomChange(bool zoom_in) {}
203 // Called to determine if the WebContents can be overscrolled with touch/wheel
205 virtual bool CanOverscrollContent();
207 // Returns true if javascript dialogs and unload alerts are suppressed.
209 virtual bool ShouldSuppressDialogs(WebContents* source);
211 // Returns whether pending NavigationEntries for aborted browser-initiated
212 // navigations should be preserved (and thus returned from GetVisibleURL).
213 // Defaults to false.
214 virtual bool ShouldPreserveAbortedURLs(WebContents* source);
216 // A message was added to the console of a frame of the page. Returning true
217 // indicates that the delegate handled the message. If false is returned the
218 // default logging mechanism will be used for the message.
219 // NOTE: If you only need to monitor messages added to the console, rather
220 // than change the behavior when they are added, prefer using
221 // WebContentsObserver::OnDidAddMessageToConsole().
222 virtual bool DidAddMessageToConsole(
224 blink::mojom::ConsoleMessageLevel log_level,
225 const std::u16string& message,
227 const std::u16string& source_id);
229 // Tells us that we've finished firing this tab's beforeunload event.
230 // The proceed bool tells us whether the user chose to proceed closing the
231 // tab. Returns true if the tab can continue on firing its unload event.
232 // If we're closing the entire browser, then we'll want to delay firing
233 // unload events until all the beforeunload events have fired.
234 virtual void BeforeUnloadFired(WebContents* tab,
236 bool* proceed_to_fire_unload);
238 // Returns true if the location bar should be focused by default rather than
239 // the page contents. NOTE: this is only used if WebContents can't determine
240 // for itself whether the location bar should be focused by default. For a
241 // complete check, you should use WebContents::FocusLocationBarByDefault().
242 virtual bool ShouldFocusLocationBarByDefault(WebContents* source);
244 // Sets focus to the location bar or some other place that is appropriate.
245 // This is called when the tab wants to encourage user input, like for the
247 virtual void SetFocusToLocationBar() {}
249 // Returns whether the page should be focused when transitioning from crashed
250 // to live. Default is true.
251 virtual bool ShouldFocusPageAfterCrash();
253 // Returns whether the page should resume accepting requests for the new
254 // window. This is used when window creation is asynchronous
255 // and the navigations need to be delayed. Default is true.
256 virtual bool ShouldResumeRequestsForCreatedWindow();
258 // This is called when WebKit tells us that it is done tabbing through
259 // controls on the page. Provides a way for WebContentsDelegates to handle
260 // this. Returns true if the delegate successfully handled it.
261 virtual bool TakeFocus(WebContents* source,
264 // Asks the delegate if the given tab can download.
265 // Invoking the |callback| synchronously is OK.
266 virtual void CanDownload(const GURL& url,
267 const std::string& request_method,
268 base::OnceCallback<void(bool)> callback);
270 // Asks the delegate to open/show the context menu based on `params`.
272 // The `render_frame_host` represents the frame that requests the context menu
273 // (typically this frame is focused, but this is not necessarily the case -
274 // see https://crbug.com/1257907#c14).
276 // Returns true if the context menu operation was handled by the delegate.
277 virtual bool HandleContextMenu(RenderFrameHost& render_frame_host,
278 const ContextMenuParams& params);
280 // Allows delegates to handle keyboard events before sending to the renderer.
281 // See enum for description of return values.
282 virtual KeyboardEventProcessingResult PreHandleKeyboardEvent(
284 const NativeWebKeyboardEvent& event);
286 // Allows delegates to handle unhandled keyboard messages coming back from
287 // the renderer. Returns true if the event was handled, false otherwise. A
288 // true value means no more processing should happen on the event. The default
289 // return value is false
290 virtual bool HandleKeyboardEvent(WebContents* source,
291 const NativeWebKeyboardEvent& event);
293 // Allows delegates to handle gesture events before sending to the renderer.
294 // Returns true if the |event| was handled and thus shouldn't be processed
295 // by the renderer's event handler. Note that the touch events that create
296 // the gesture are always passed to the renderer since the gesture is created
297 // and dispatched after the touches return without being "preventDefault()"ed.
298 virtual bool PreHandleGestureEvent(
300 const blink::WebGestureEvent& event);
302 // Called when an external drag event enters the web contents window. Return
303 // true to allow dragging and dropping on the web contents window or false to
304 // cancel the operation. This method is used by Chromium Embedded Framework.
305 virtual bool CanDragEnter(WebContents* source,
306 const DropData& data,
307 blink::DragOperationsMask operations_allowed);
309 // Shows the repost form confirmation dialog box.
310 virtual void ShowRepostFormWarningDialog(WebContents* source) {}
312 // Allows delegate to override navigation to the history entries.
313 // Returns true to allow WebContents to continue with the default processing.
314 virtual bool OnGoToEntryOffset(int offset);
316 // Allows delegate to control whether a new WebContents can be created by
317 // the WebContents itself.
319 // If an delegate returns true, it can optionally also override
320 // CreateCustomWebContents() below to provide their own WebContents.
321 virtual bool IsWebContentsCreationOverridden(
322 SiteInstance* source_site_instance,
323 mojom::WindowContainerType window_container_type,
324 const GURL& opener_url,
325 const std::string& frame_name,
326 const GURL& target_url);
328 // Allow delegate to creates a custom WebContents when
329 // WebContents::CreateNewWindow() is called. This function is only called
330 // when IsWebContentsCreationOverridden() returns true.
332 // In general, a delegate should return a pointer to a created WebContents
333 // so that the opener can be given a references to it as appropriate.
334 // Returning nullptr also makes sense if the delegate wishes to suppress
335 // all window creation, or if the delegate wants to ensure the opener
336 // cannot get a reference effectively creating a new browsing instance.
337 virtual WebContents* CreateCustomWebContents(
338 RenderFrameHost* opener,
339 SiteInstance* source_site_instance,
340 bool is_new_browsing_instance,
341 const GURL& opener_url,
342 const std::string& frame_name,
343 const GURL& target_url,
344 const StoragePartitionConfig& partition_config,
345 SessionStorageNamespace* session_storage_namespace);
347 // Notifies the delegate about the creation of a new WebContents. This
348 // typically happens when popups are created.
349 virtual void WebContentsCreated(WebContents* source_contents,
350 int opener_render_process_id,
351 int opener_render_frame_id,
352 const std::string& frame_name,
353 const GURL& target_url,
354 WebContents* new_contents) {}
356 // Notifies the embedder that a new WebContents dedicated for hosting a
357 // prerendered page has been created. `prerender_web_contents` will host an
358 // initial empty primary page and a prerendered page. The prerendered page
359 // will be activated as a primary page on prerender activation.
360 // `prerender_web_contents` is not visible until the activation.
362 // This function is called only when this delegate is
363 // PrerenderWebContentsDelegate. This delegate and `prerender_web_contents`
364 // are owned by a prerender handle. `prerender_web_contents` outlives this
366 virtual void PrerenderWebContentsCreated(
367 WebContents* prerender_web_contents) {}
369 // Notifies the embedder that a new WebContents has been created to contain
370 // the contents of a portal.
371 virtual void PortalWebContentsCreated(WebContents* portal_web_contents) {}
373 // Notifies the embedder that an existing WebContents that it manages (e.g., a
374 // browser tab) has become the contents of a portal.
376 // During portal activation, WebContentsDelegate::ActivatePortalWebContents
377 // will be called to release the delegate's management of a WebContents.
378 // Shortly afterward, the portal will assume ownership of the contents and
379 // call this function to indicate that this is complete, passing the
380 // swapped-out contents as |portal_web_contents|.
382 // Implementations will likely want to apply changes analogous to those they
383 // would apply to a new WebContents in PortalWebContentsCreated.
384 virtual void WebContentsBecamePortal(WebContents* portal_web_contents) {}
386 // Notification that one of the frames in the WebContents is hung. |source| is
387 // the WebContents that is hung, and |render_widget_host| is the
388 // RenderWidgetHost that, while routing events to it, discovered the hang.
390 // |hang_monitor_restarter| can be used to restart the timer used to
391 // detect the hang. The timer is typically restarted when the renderer has
392 // become active, the tab got hidden, or the user has chosen to wait some
395 // Useful member functions on |render_widget_host|:
396 // - Getting the hung render process: GetProcess()
397 // - Querying whether the process is still hung: IsCurrentlyUnresponsive()
398 virtual void RendererUnresponsive(
400 RenderWidgetHost* render_widget_host,
401 base::RepeatingClosure hang_monitor_restarter) {}
403 // Notification that a process in the WebContents is no longer hung. |source|
404 // is the WebContents that was hung, and |render_widget_host| is the
405 // RenderWidgetHost that was passed in an earlier call to
406 // RendererUnresponsive().
407 virtual void RendererResponsive(WebContents* source,
408 RenderWidgetHost* render_widget_host) {}
410 #if BUILDFLAG(IS_TIZEN_TV)
411 virtual void DidEdgeScrollBy(const gfx::Point& offset, bool handled) {}
412 virtual void MoveFocusToBrowser(int direction) {}
414 virtual void UpdateTooltipUnderCursor(const std::u16string& text) {}
416 // Returns a pointer to a service to manage JavaScript dialogs. May return
417 // nullptr in which case dialogs aren't shown.
418 virtual JavaScriptDialogManager* GetJavaScriptDialogManager(
419 WebContents* source);
421 #if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_APPLE) || BUILDFLAG(IS_EFL)
422 // Called when color chooser should open. Returns the opened color chooser.
423 // Returns nullptr if we failed to open the color chooser. The color chooser
424 // is supported/required for Android or iOS.
425 virtual std::unique_ptr<ColorChooser> OpenColorChooser(
426 WebContents* web_contents,
428 const std::vector<blink::mojom::ColorSuggestionPtr>& suggestions);
431 // Called when an eye dropper should open. Returns the eye dropper window.
432 // The eye dropper is responsible for calling listener->ColorSelected() or
433 // listener->ColorSelectionCanceled().
434 // The ownership of the returned pointer is transferred to the caller.
435 virtual std::unique_ptr<EyeDropper> OpenEyeDropper(
436 RenderFrameHost* frame,
437 EyeDropperListener* listener);
439 // Called when a file selection is to be done.
440 // This function is responsible for calling listener->FileSelected() or
441 // listener->FileSelectionCanceled().
442 virtual void RunFileChooser(RenderFrameHost* render_frame_host,
443 scoped_refptr<FileSelectListener> listener,
444 const blink::mojom::FileChooserParams& params);
446 // Request to enumerate a directory. This is equivalent to running the file
447 // chooser in directory-enumeration mode and having the user select the given
449 // This function is responsible for calling listener->FileSelected() or
450 // listener->FileSelectionCanceled().
451 virtual void EnumerateDirectory(WebContents* web_contents,
452 scoped_refptr<FileSelectListener> listener,
453 const base::FilePath& path);
455 // Creates an info bar for the user to control the receiving of the SMS.
456 virtual void CreateSmsPrompt(RenderFrameHost*,
457 const std::vector<url::Origin>&,
458 const std::string& one_time_code,
459 base::OnceCallback<void()> on_confirm,
460 base::OnceCallback<void()> on_cancel);
462 // Returns whether the RFH can use Additional Windowing Controls APIs.
463 // https://github.com/ivansandrk/additional-windowing-controls/blob/main/awc-explainer.md
464 virtual bool CanUseWindowingControls(RenderFrameHost* requesting_frame);
466 // Sends the resizable boolean set via `window.setResizable(bool)` API to
467 // `BrowserView`. Passing std::nullopt will reset the resizable state to the
469 virtual void SetCanResizeFromWebAPI(absl::optional<bool> can_resize) {}
470 virtual bool GetCanResize();
471 virtual void MinimizeFromWebAPI() {}
472 virtual void MaximizeFromWebAPI() {}
473 virtual void RestoreFromWebAPI() {}
475 // Returns whether entering fullscreen with |EnterFullscreenModeForTab()| is
477 virtual bool CanEnterFullscreenModeForTab(
478 RenderFrameHost* requesting_frame,
479 const blink::mojom::FullscreenOptions& options);
481 // Called when the renderer puts a tab into fullscreen mode.
482 // |requesting_frame| is the specific content frame requesting fullscreen.
483 // |CanEnterFullscreenModeForTab()| must return true on entry.
484 virtual void EnterFullscreenModeForTab(
485 RenderFrameHost* requesting_frame,
486 const blink::mojom::FullscreenOptions& options) {}
488 virtual void FullscreenStateChangedForTab(
489 RenderFrameHost* requesting_frame,
490 const blink::mojom::FullscreenOptions& options) {}
492 // Called when the renderer puts a tab out of fullscreen mode.
493 virtual void ExitFullscreenModeForTab(WebContents*) {}
495 // Returns true if `web_contents` is, or is transitioning to, tab-fullscreen.
496 virtual bool IsFullscreenForTabOrPending(const WebContents* web_contents);
498 // Returns fullscreen state information about the given `web_contents`.
499 virtual FullscreenState GetFullscreenState(
500 const WebContents* web_contents) const;
502 // Returns the actual display mode of the top-level browsing context.
503 // For example, it should return 'blink::mojom::DisplayModeFullscreen'
504 // whenever the browser window is put to fullscreen mode (either by the end
505 // user, or HTML API or from a web manifest setting). See
506 // http://w3c.github.io/manifest/#dfn-display-mode
507 virtual blink::mojom::DisplayMode GetDisplayMode(
508 const WebContents* web_contents);
510 // Returns the security level to use for Navigator.RegisterProtocolHandler().
511 virtual blink::ProtocolHandlerSecurityLevel GetProtocolHandlerSecurityLevel(
512 RenderFrameHost* requesting_frame);
514 // Register a new handler for URL requests with the given scheme.
515 // |user_gesture| is true if the registration is made in the context of a user
517 virtual void RegisterProtocolHandler(RenderFrameHost* requesting_frame,
518 const std::string& protocol,
520 bool user_gesture) {}
522 // Unregister the registered handler for URL requests with the given scheme.
523 // |user_gesture| is true if the registration is made in the context of a user
525 virtual void UnregisterProtocolHandler(RenderFrameHost* requesting_frame,
526 const std::string& protocol,
528 bool user_gesture) {}
530 // Result of string search in the page. This includes the number of matches
531 // found and the selection rect (in screen coordinates) for the string found.
532 // If |final_update| is false, it indicates that more results follow.
533 virtual void FindReply(WebContents* web_contents,
535 int number_of_matches,
536 const gfx::Rect& selection_rect,
537 int active_match_ordinal,
538 bool final_update) {}
540 #if defined(TIZEN_TBM_SUPPORT)
541 virtual void DidRenderOffscreenFrame(void* buffer) {}
544 #if BUILDFLAG(IS_EFL)
545 virtual void DidChangeInputType(bool is_password_field) {}
546 virtual void DidReceiveNonEmtpyLayoutFrame() {}
547 virtual void DidRenderFrame() {}
548 virtual void BackgroundColorReceived(int callback_id, SkColor bg_color) {}
549 virtual void OnDidChangeFocusedNodeBounds(
550 const gfx::RectF& focused_node_bounds) {}
551 virtual void OnGetMainFrameScrollbarVisible(int callback_id, bool visible) {}
552 virtual void WillDraw(int rotation, gfx::Size frame_data_output_size) {}
555 #if BUILDFLAG(IS_ANDROID)
556 // Provides the rects of the current find-in-page matches.
557 // Sent as a reply to RequestFindMatchRects.
558 virtual void FindMatchRectsReply(WebContents* web_contents,
560 const std::vector<gfx::RectF>& rects,
561 const gfx::RectF& active_rect) {}
564 // Invoked when the preferred size of the contents has been changed.
565 virtual void UpdatePreferredSize(WebContents* web_contents,
566 const gfx::Size& pref_size) {}
568 // Invoked when the contents auto-resized and the container should match it.
569 virtual void ResizeDueToAutoResize(WebContents* web_contents,
570 const gfx::Size& new_size) {}
572 // Requests to lock the mouse. Once the request is approved or rejected,
573 // GotResponseToLockMouseRequest() will be called on the requesting tab
575 virtual void RequestToLockMouse(WebContents* web_contents,
577 bool last_unlocked_by_target);
579 // Notification that the page has lost the mouse lock.
580 virtual void LostMouseLock() {}
582 // Requests keyboard lock. Once the request is approved or rejected,
583 // GotResponseToKeyboardLockRequest() will be called on |web_contents|.
584 virtual void RequestKeyboardLock(WebContents* web_contents,
585 bool esc_key_locked);
587 // Notification that the keyboard lock request has been canceled.
588 virtual void CancelKeyboardLockRequest(WebContents* web_contents) {}
590 // Asks permission to use the camera and/or microphone. If permission is
591 // granted, a call should be made to |callback| with the devices. If the
592 // request is denied, a call should be made to |callback| with an empty list
593 // of devices. |request| has the details of the request (e.g. which of audio
594 // and/or video devices are requested, and lists of available devices).
595 virtual void RequestMediaAccessPermission(WebContents* web_contents,
596 const MediaStreamRequest& request,
597 MediaResponseCallback callback);
599 // Checks if we have permission to access the microphone or camera. Note that
600 // this does not query the user. |type| must be MEDIA_DEVICE_AUDIO_CAPTURE
601 // or MEDIA_DEVICE_VIDEO_CAPTURE.
602 virtual bool CheckMediaAccessPermission(RenderFrameHost* render_frame_host,
603 const GURL& security_origin,
604 blink::mojom::MediaStreamType type);
606 // Returns the ID of the default device for the given media device |type|.
607 // If the returned value is an empty string, it means that there is no
608 // default device for the given |type|.
609 virtual std::string GetDefaultMediaDeviceID(
610 WebContents* web_contents,
611 blink::mojom::MediaStreamType type);
613 // Returns the human-readable name for title in Media Controls.
614 // If the returned value is an empty string, it means that there is no
615 // human-readable name.
616 // For example, this returns an extension name for title instead of extension
618 virtual std::string GetTitleForMediaControls(WebContents* web_contents);
620 // Returns AudioStreamBrokerFactory to use to create AudioStreamBroker when
621 // creating audio I/O streams. Returned `AudioStreamBrokerFactory` is used and
622 // deleted on the IO thread.
623 virtual std::unique_ptr<AudioStreamBrokerFactory>
624 CreateAudioStreamBrokerFactory(WebContents* web_contents);
626 #if BUILDFLAG(IS_ANDROID)
627 // Returns true if the given media should be blocked to load.
628 virtual bool ShouldBlockMediaRequest(const GURL& url);
630 // Tells the delegate to enter overlay mode.
631 // Overlay mode means that we are currently using AndroidOverlays to display
632 // video, and that the compositor's surface should support alpha and not be
633 // marked as opaque. See media/base/android/android_overlay.h.
634 virtual void SetOverlayMode(bool use_overlay_mode) {}
637 // Returns the size for the new render view created for the pending entry in
638 // |web_contents|; if there's no size, returns an empty size.
639 // This is optional for implementations of WebContentsDelegate; if the
640 // delegate doesn't provide a size, the current WebContentsView's size will be
642 virtual gfx::Size GetSizeForNewRenderView(WebContents* web_contents);
644 // Returns true if the WebContents is never user-visible, thus the renderer
645 // never needs to produce pixels for display.
646 virtual bool IsNeverComposited(WebContents* web_contents);
648 // Askss |guest_web_contents| to perform the same. If this returns true, the
649 // default behavior is suppressed.
650 virtual bool GuestSaveFrame(WebContents* guest_web_contents);
652 // Called in response to a request to save a frame. If this returns true, the
653 // default behavior is suppressed.
654 virtual bool SaveFrame(const GURL& url,
655 const Referrer& referrer,
656 RenderFrameHost* rfh);
658 // Called when a suspicious navigation of the main frame has been blocked.
659 // Allows the delegate to provide some UI to let the user know about the
660 // blocked navigation and give them the option to recover from it.
661 // |blocked_url| is the blocked navigation target, |initiator_url| is the URL
662 // of the frame initiating the navigation, |reason| specifies why the
663 // navigation was blocked.
664 virtual void OnDidBlockNavigation(
665 WebContents* web_contents,
666 const GURL& blocked_url,
667 const GURL& initiator_url,
668 blink::mojom::NavigationBlockedReason reason) {}
670 // Reports that passive mixed content was found at the specified url.
671 virtual void PassiveInsecureContentFound(const GURL& resource_url) {}
673 // Checks if running of active mixed content is allowed for the specified
675 virtual bool ShouldAllowRunningInsecureContent(WebContents* web_contents,
676 bool allowed_per_prefs,
677 const url::Origin& origin,
678 const GURL& resource_url);
680 virtual void SetTopControlsShownRatio(WebContents* web_contents,
683 // Requests to get browser controls info such as the height/min height of the
684 // top/bottom controls, and whether to animate these changes to height or
685 // whether they will shrink the Blink's view size. Note that they are not
686 // complete in the sense that there is no API to tell content to poll these
687 // values again, except part of resize. But this is not needed by embedder
688 // because it's always accompanied by view size change. The values returned
689 // by these APIs are in physical pixels (not DIPs).
690 virtual int GetTopControlsHeight();
691 virtual int GetTopControlsMinHeight();
692 virtual int GetBottomControlsHeight();
693 virtual int GetBottomControlsMinHeight();
694 virtual bool ShouldAnimateBrowserControlsHeightChanges();
695 virtual bool DoBrowserControlsShrinkRendererSize(WebContents* web_contents);
696 virtual int GetVirtualKeyboardHeight(WebContents* web_contents);
697 // Returns true if the top controls should only expand at the top of the page,
698 // so they'll only be visible if the page is scrolled to the top.
699 virtual bool OnlyExpandTopControlsAtPageTop();
701 // Propagates to the browser that gesture scrolling has changed state. This is
702 // used by the browser to assist in controlling the behavior of sliding the
703 // top controls as a result of page gesture scrolling while in tablet mode.
704 virtual void SetTopControlsGestureScrollInProgress(bool in_progress) {}
706 // Requests to print an out-of-process subframe for the specified WebContents.
707 // |rect| is the rectangular area where its content resides in its parent
708 // frame. |document_cookie| is a unique id for a printed document associated
709 // with a print job. |subframe_host| is the RenderFrameHost of the subframe
711 virtual void PrintCrossProcessSubframe(WebContents* web_contents,
712 const gfx::Rect& rect,
714 RenderFrameHost* subframe_host) const {
717 // Requests to capture a paint preview of a subframe for the specified
718 // WebContents. |rect| is the rectangular area where its content resides in
719 // its parent frame. |guid| is a globally unique identitier for an entire
720 // paint preview. |render_frame_host| is the RenderFrameHost of the subframe
722 virtual void CapturePaintPreviewOfSubframe(
723 WebContents* web_contents,
724 const gfx::Rect& rect,
725 const base::UnguessableToken& guid,
726 RenderFrameHost* render_frame_host) {}
728 // Notifies the Picture-in-Picture controller that there is a new player
729 // entering Picture-in-Picture.
730 // Returns the result of the enter request.
731 virtual PictureInPictureResult EnterPictureInPicture(
732 WebContents* web_contents);
734 // Updates the Picture-in-Picture controller with a signal that
735 // Picture-in-Picture mode has ended.
736 virtual void ExitPictureInPicture() {}
738 #if BUILDFLAG(IS_TIZEN_TV)
739 virtual void VideoPlayingStatusReceived(bool is_playing, int callback_id) {}
740 virtual void NotifyPlaybackState(int state,
742 const std::string& url,
743 const std::string& mime_type,
744 bool* media_resource_acquired,
745 std::string* translated_url,
746 std::string* drm_info) {}
747 // Notify Media State to Web browser
748 virtual void NotifyMediaStateChanged(uint32_t type,
751 virtual bool IsHighBitRate() const { return false; }
752 virtual void UpdateEventData(void* data) {}
753 virtual void NotifyParentalRatingInfo(const std::string& info,
754 const std::string& url) {}
755 virtual void NotifyDownloadableFontInfo(const std::string& scheme_id_uri,
756 const std::string& value,
757 const std::string& data,
759 virtual void NotifyAudioTracksCount(int player_id, unsigned count) {}
760 virtual void NotifySubtitleState(int state, double time_stamp = 0.0) {}
761 virtual void NotifySubtitlePlay(int active_track_id,
762 const std::string& url,
763 const std::string& lang) {}
764 virtual void NotifySubtitleData(int track_id,
766 const std::string& data,
768 virtual void UpdateCurrentTime(double current_time) {}
769 virtual void NotifyFirstTimeStamp(unsigned long long timestamp,
771 int time_base_den) {}
772 virtual void NotifyPESData(const std::string& buf,
774 int media_position) {}
775 virtual void ShowMicOpenedNotification(bool show) {}
778 #if BUILDFLAG(IS_ANDROID)
779 // Updates information to determine whether a user gesture should carryover to
780 // future navigations. This is needed so navigations within a certain
781 // timeframe of a request initiated by a gesture will be treated as if they
782 // were initiated by a gesture too, otherwise the navigation may be blocked.
783 virtual void UpdateUserGestureCarryoverInfo(WebContents* web_contents) {}
786 // Returns true if lazy loading of images and frames should be enabled.
787 virtual bool ShouldAllowLazyLoad();
789 // Return true if the back forward cache is supported. This is not an
790 // indication that the cache will be used.
791 virtual bool IsBackForwardCacheSupported();
793 // Returns PreloadingEligibility::kEligible if Prerender2 (see
794 // content/browser/preloading/prerender/README.md for details) is supported.
795 // If it is not supported, returns the reason.
796 virtual PreloadingEligibility IsPrerender2Supported(
797 WebContents& web_contents);
799 // Requests the delegate to replace |predecessor_contents| with
800 // |portal_contents| in the container that holds |predecessor_contents|. If
801 // the delegate successfully replaces |predecessor_contents|, the return
802 // parameter passes ownership of |predecessor_contents|. Otherwise,
803 // |portal_contents| is returned.
804 virtual std::unique_ptr<WebContents> ActivatePortalWebContents(
805 WebContents* predecessor_contents,
806 std::unique_ptr<WebContents> portal_contents);
808 // If |old_contents| is being inspected by a DevTools window, it updates the
809 // window to inspect |new_contents| instead and calls |callback| after it
810 // finishes asynchronously. If no window is present, or no update is
811 // necessary, |callback| is run synchronously (immediately on the same stack).
812 virtual void UpdateInspectedWebContentsIfNecessary(
813 WebContents* old_contents,
814 WebContents* new_contents,
815 base::OnceCallback<void()> callback);
817 // Returns true if the widget's frame content needs to be stored before
818 // eviction and displayed until a new frame is generated. If false, a white
819 // solid color is displayed instead.
820 virtual bool ShouldShowStaleContentOnEviction(WebContents* source);
822 // Invoked when media playback is interrupted or completed.
823 virtual void MediaWatchTimeChanged(const MediaPlayerWatchTime& watch_time) {}
825 // Returns a InstalledWebappGeolocationContext if this web content is running
826 // in a installed webapp and geolocation should be deleagted from the
827 // installed webapp; otherwise returns nullptr.
828 virtual device::mojom::GeolocationContext*
829 GetInstalledWebappGeolocationContext();
831 // Returns a weak ptr to the web contents delegate.
832 virtual base::WeakPtr<WebContentsDelegate> GetDelegateWeakPtr();
834 // Whether the WebContents is privileged.
835 // It's used to prevent drag and drop between privileged and non-privileged
837 virtual bool IsPrivileged();
839 // Initiates previewing the given `url` within the given `web_contents`.
840 virtual void InitiatePreview(WebContents& web_contents, const GURL& url) {}
842 // CloseWatcher web API support. If the currently focused frame has a
843 // CloseWatcher registered in JavaScript, the CloseWatcher should receive the
844 // next "close" operation, based on what the OS convention for closing is.
845 // This function is called when the focused frame changes or a CloseWatcher
846 // is registered/unregistered to update whether the CloseWatcher should
848 virtual void DidChangeCloseSignalInterceptStatus() {}
850 // Whether the WebContents is running in preview mode.
851 virtual bool IsInPreviewMode() const;
853 // Notify the page uses a forbidden powerful API and cannot be shown in
855 virtual void CancelPreviewByMojoBinderPolicy(
856 const std::string& interface_name) {}
858 #if !BUILDFLAG(IS_ANDROID)
859 // Whether the WebContents should use per PWA instanced
860 // system media controls.
861 virtual bool ShouldUseInstancedSystemMediaControls() const;
862 #endif // !BUILDFLAG(IS_ANDROID)
865 virtual ~WebContentsDelegate();
868 friend class WebContentsImpl;
870 // Called when |this| becomes the WebContentsDelegate for |source|.
871 void Attach(WebContents* source);
873 // Called when |this| is no longer the WebContentsDelegate for |source|.
874 void Detach(WebContents* source);
876 // The WebContents that this is currently a delegate for.
877 std::set<WebContents*> attached_contents_;
880 } // namespace content
882 #endif // CONTENT_PUBLIC_BROWSER_WEB_CONTENTS_DELEGATE_H_