webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 152 insertions, 113 deletions

diff --git a/Source/WebCore/page/ChromeClient.h b/Source/WebCore/page/ChromeClient.h
index d7fe0f88b..1a4298c50 100644
--- a/Source/WebCore/page/ChromeClient.h
+++ b/Source/WebCore/page/ChromeClient.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple, Inc. All rights reserved.
+ * Copyright (C) 2006-2017 Apple, Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
  * Copyright (C) 2012 Samsung Electronics. All rights reserved.
  *
@@ -19,17 +19,19 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#ifndef ChromeClient_h
-#define ChromeClient_h
+#pragma once
 
 #include "AXObjectCache.h"
-#include "ConsoleAPITypes.h"
-#include "ConsoleTypes.h"
 #include "Cursor.h"
+#include "DatabaseDetails.h"
+#include "DisplayRefreshMonitor.h"
 #include "FocusDirection.h"
 #include "FrameLoader.h"
 #include "GraphicsContext.h"
+#include "HTMLMediaElementEnums.h"
 #include "HostWindow.h"
+#include "LayerFlushThrottleState.h"
+#include "MediaProducer.h"
 #include "PopupMenu.h"
 #include "PopupMenuClient.h"
 #include "RenderEmbeddedObject.h"
@@ -37,10 +39,15 @@
 #include "ScrollingCoordinator.h"
 #include "SearchPopupMenu.h"
 #include "WebCoreKeyboardUIMode.h"
+#include <runtime/ConsoleTypes.h>
 #include <wtf/Forward.h>
-#include <wtf/PassOwnPtr.h>
+#include <wtf/Seconds.h>
 #include <wtf/Vector.h>
 
+#if ENABLE(WIRELESS_PLAYBACK_TARGET)
+#include "MediaPlaybackTargetContext.h"
+#endif
+
 #if PLATFORM(IOS)
 #include "PlatformLayer.h"
 #define NSResponder WAKResponder
@@ -51,10 +58,6 @@ class WAKResponder;
 #endif
 #endif
 
-#if ENABLE(SQL_DATABASE)
-#include "DatabaseDetails.h"
-#endif
-
 OBJC_CLASS NSResponder;
 
 namespace WebCore {
@@ -70,12 +73,14 @@ class FileIconLoader;
 class FloatRect;
 class Frame;
 class Geolocation;
-class GraphicsContext3D;
 class GraphicsLayer;
 class GraphicsLayerFactory;
 class HTMLInputElement;
+class HTMLMediaElement;
+class HTMLVideoElement;
 class HitTestResult;
 class IntRect;
+class MediaSessionMetadata;
 class NavigationAction;
 class Node;
 class Page;
@@ -84,13 +89,17 @@ class SecurityOrigin;
 class ViewportConstraints;
 class Widget;
 
+#if ENABLE(VIDEO) && USE(GSTREAMER)
+class MediaPlayerRequestInstallMissingPluginsCallback;
+#endif
+
 struct DateTimeChooserParameters;
 struct FrameLoadRequest;
 struct GraphicsDeviceAdapter;
 struct ViewportArguments;
 struct WindowFeatures;
 
-class ChromeClient {
+class WEBCORE_EXPORT ChromeClient {
 public:
     virtual void chromeDestroyed() = 0;
 
@@ -114,7 +123,7 @@ public:
     // created Page has its show method called.
     // The FrameLoadRequest parameter is only for ChromeClient to check if the
     // request could be fulfilled. The ChromeClient should not load the request.
-    virtual Page* createWindow(Frame*, const FrameLoadRequest&, const WindowFeatures&, const NavigationAction&) = 0;
+    virtual Page* createWindow(Frame&, const FrameLoadRequest&, const WindowFeatures&, const NavigationAction&) = 0;
     virtual void show() = 0;
 
     virtual bool canRunModal() = 0;
@@ -135,67 +144,69 @@ public:
     virtual void setResizable(bool) = 0;
 
     virtual void addMessageToConsole(MessageSource, MessageLevel, const String& message, unsigned lineNumber, unsigned columnNumber, const String& sourceID) = 0;
-    // FIXME: Remove this MessageType variant once all the clients are updated.
-    virtual void addMessageToConsole(MessageSource source, MessageType, MessageLevel level, const String& message, unsigned lineNumber, unsigned columnNumber, const String& sourceID)
-    {
-        addMessageToConsole(source, level, message, lineNumber, columnNumber, sourceID);
-    }
 
     virtual bool canRunBeforeUnloadConfirmPanel() = 0;
-    virtual bool runBeforeUnloadConfirmPanel(const String& message, Frame*) = 0;
+    virtual bool runBeforeUnloadConfirmPanel(const String& message, Frame&) = 0;
 
     virtual void closeWindowSoon() = 0;
 
-    virtual void runJavaScriptAlert(Frame*, const String&) = 0;
-    virtual bool runJavaScriptConfirm(Frame*, const String&) = 0;
-    virtual bool runJavaScriptPrompt(Frame*, const String& message, const String& defaultValue, String& result) = 0;
+    virtual void runJavaScriptAlert(Frame&, const String&) = 0;
+    virtual bool runJavaScriptConfirm(Frame&, const String&) = 0;
+    virtual bool runJavaScriptPrompt(Frame&, const String& message, const String& defaultValue, String& result) = 0;
     virtual void setStatusbarText(const String&) = 0;
-    virtual bool shouldInterruptJavaScript() = 0;
     virtual KeyboardUIMode keyboardUIMode() = 0;
 
-    virtual IntRect windowResizerRect() const = 0;
-
-    // Methods used by HostWindow.
     virtual bool supportsImmediateInvalidation() { return false; }
-    virtual void invalidateRootView(const IntRect&, bool immediate) = 0;
-    virtual void invalidateContentsAndRootView(const IntRect&, bool immediate) = 0;
-    virtual void invalidateContentsForSlowScroll(const IntRect&, bool immediate) = 0;
+    virtual void invalidateRootView(const IntRect&) = 0;
+    virtual void invalidateContentsAndRootView(const IntRect&) = 0;
+    virtual void invalidateContentsForSlowScroll(const IntRect&) = 0;
     virtual void scroll(const IntSize&, const IntRect&, const IntRect&) = 0;
-#if USE(TILED_BACKING_STORE)
+
+#if USE(COORDINATED_GRAPHICS)
     virtual void delegatedScrollRequested(const IntPoint&) = 0;
 #endif
+
     virtual IntPoint screenToRootView(const IntPoint&) const = 0;
     virtual IntRect rootViewToScreen(const IntRect&) const = 0;
+
+#if PLATFORM(IOS)
+    virtual IntPoint accessibilityScreenToRootView(const IntPoint&) const = 0;
+    virtual IntRect rootViewToAccessibilityScreen(const IntRect&) const = 0;
+#endif    
+
     virtual PlatformPageClient platformPageClient() const = 0;
     virtual void scrollbarsModeDidChange() const = 0;
+
 #if ENABLE(CURSOR_SUPPORT)
     virtual void setCursor(const Cursor&) = 0;
     virtual void setCursorHiddenUntilMouseMoves(bool) = 0;
 #endif
-#if ENABLE(REQUEST_ANIMATION_FRAME) && !USE(REQUEST_ANIMATION_FRAME_TIMER)
+
+#if !USE(REQUEST_ANIMATION_FRAME_TIMER)
     virtual void scheduleAnimation() = 0;
 #endif
-    // End methods used by HostWindow.
+
+    virtual FloatSize screenSize() const { return const_cast<ChromeClient&>(*this).windowRect().size(); }
+    virtual FloatSize availableScreenSize() const { return const_cast<ChromeClient&>(*this).windowRect().size(); }
 
     virtual void dispatchViewportPropertiesDidChange(const ViewportArguments&) const { }
 
-    virtual void contentsSizeChanged(Frame*, const IntSize&) const = 0;
-    virtual void layoutUpdated(Frame*) const { }
+    virtual void contentsSizeChanged(Frame&, const IntSize&) const = 0;
     virtual void scrollRectIntoView(const IntRect&) const { }; // Currently only Mac has a non empty implementation.
 
     virtual bool shouldUnavailablePluginMessageBeButton(RenderEmbeddedObject::PluginUnavailabilityReason) const { return false; }
-    virtual void unavailablePluginButtonClicked(Element*, RenderEmbeddedObject::PluginUnavailabilityReason) const { }
+    virtual void unavailablePluginButtonClicked(Element&, RenderEmbeddedObject::PluginUnavailabilityReason) const { }
     virtual void mouseDidMoveOverElement(const HitTestResult&, unsigned modifierFlags) = 0;
 
     virtual void setToolTip(const String&, TextDirection) = 0;
 
-    virtual void print(Frame*) = 0;
+    virtual void print(Frame&) = 0;
 
     virtual Color underlayColor() const { return Color(); }
 
-#if ENABLE(SQL_DATABASE)
-    virtual void exceededDatabaseQuota(Frame*, const String& databaseName, DatabaseDetails) = 0;
-#endif
+    virtual void pageExtendedBackgroundColorDidChange(Color) const { }
+
+    virtual void exceededDatabaseQuota(Frame&, const String& databaseName, DatabaseDetails) = 0;
 
     // Callback invoked when the application cache fails to save a cache object
     // because storing it would grow the database file past its defined maximum
@@ -212,17 +223,12 @@ public:
     // storage, in bytes, needed to store the new cache along with all of the
     // other existing caches for the origin that would not be replaced by
     // the new cache.
-    virtual void reachedApplicationCacheOriginQuota(SecurityOrigin*, int64_t totalSpaceNeeded) = 0;
+    virtual void reachedApplicationCacheOriginQuota(SecurityOrigin&, int64_t totalSpaceNeeded) = 0;
 
 #if ENABLE(DASHBOARD_SUPPORT)
     virtual void annotatedRegionsChanged();
 #endif
 
-    virtual void populateVisitedLinks();
-
-    virtual FloatRect customHighlightRect(Node*, const AtomicString& type, const FloatRect& lineRect);
-    virtual void paintCustomHighlight(Node*, const AtomicString& type, const FloatRect& boxRect, const FloatRect& lineRect, bool behindText, bool entireLine);
-            
     virtual bool shouldReplaceWithGeneratedFileForUpload(const String& path, String& generatedFilename);
     virtual String generateReplacementFile(const String& path);
 
@@ -230,12 +236,14 @@ public:
     virtual void didPreventDefaultForEvent() = 0;
 #endif
 
+    virtual Seconds eventThrottlingDelay() { return 0_s; };
+
 #if PLATFORM(IOS)
-    virtual void didReceiveMobileDocType() = 0;
-    virtual void setNeedsScrollNotifications(Frame*, bool) = 0;
-    virtual void observedContentChange(Frame*) = 0;
-    virtual void clearContentChangeObservers(Frame*) = 0;
-    virtual void notifyRevealedSelectionByScrollingFrame(Frame*) = 0;
+    virtual void didReceiveMobileDocType(bool) = 0;
+    virtual void setNeedsScrollNotifications(Frame&, bool) = 0;
+    virtual void observedContentChange(Frame&) = 0;
+    virtual void clearContentChangeObservers(Frame&) = 0;
+    virtual void notifyRevealedSelectionByScrollingFrame(Frame&) = 0;
 
     enum LayoutType { NormalLayout, Scroll };
     virtual void didLayout(LayoutType = NormalLayout) = 0;
@@ -252,47 +260,44 @@ public:
 
     virtual bool fetchCustomFixedPositionLayoutRect(IntRect&) { return false; }
 
-    // FIXME: Use std::unique_ptr instead of OwnPtr.
-    virtual void updateViewportConstrainedLayers(HashMap<PlatformLayer*, OwnPtr<ViewportConstraints>>&, HashMap<PlatformLayer*, PlatformLayer*>&) { }
+    virtual void updateViewportConstrainedLayers(HashMap<PlatformLayer*, std::unique_ptr<ViewportConstraints>>&, HashMap<PlatformLayer*, PlatformLayer*>&) { }
 
     virtual void addOrUpdateScrollingLayer(Node*, PlatformLayer* scrollingLayer, PlatformLayer* contentsLayer, const IntSize& scrollSize, bool allowHorizontalScrollbar, bool allowVerticalScrollbar) = 0;
     virtual void removeScrollingLayer(Node*, PlatformLayer* scrollingLayer, PlatformLayer* contentsLayer) = 0;
 
     virtual void webAppOrientationsUpdated() = 0;
+    virtual void showPlaybackTargetPicker(bool hasVideo) = 0;
 #endif
 
-#if ENABLE(INPUT_TYPE_COLOR)
-    virtual PassOwnPtr<ColorChooser> createColorChooser(ColorChooserClient*, const Color&) = 0;
+#if ENABLE(ORIENTATION_EVENTS)
+    virtual int deviceOrientation() const = 0;
 #endif
 
-#if ENABLE(DATE_AND_TIME_INPUT_TYPES) && !PLATFORM(IOS)
-    virtual PassRefPtr<DateTimeChooser> openDateTimeChooser(DateTimeChooserClient*, const DateTimeChooserParameters&) = 0;
+#if ENABLE(INPUT_TYPE_COLOR)
+    virtual std::unique_ptr<ColorChooser> createColorChooser(ColorChooserClient&, const Color&) = 0;
 #endif
 
-    virtual void runOpenPanel(Frame*, PassRefPtr<FileChooser>) = 0;
+    virtual void runOpenPanel(Frame&, FileChooser&) = 0;
     // Asynchronous request to load an icon for specified filenames.
-    virtual void loadIconForFiles(const Vector<String>&, FileIconLoader*) = 0;
-
-#if ENABLE(DIRECTORY_UPLOAD)
-    // Asychronous request to enumerate all files in a directory chosen by the user.
-    virtual void enumerateChosenDirectory(FileChooser*) = 0;
-#endif
-
-    // Notification that the given form element has changed. This function
-    // will be called frequently, so handling should be very fast.
-    virtual void formStateDidChange(const Node*) = 0;
+    virtual void loadIconForFiles(const Vector<String>&, FileIconLoader&) = 0;
         
-    virtual void elementDidFocus(const Node*) { };
-    virtual void elementDidBlur(const Node*) { };
+    virtual void elementDidFocus(Element&) { }
+    virtual void elementDidBlur(Element&) { }
+    virtual void elementDidRefocus(Element&) { }
     
     virtual bool shouldPaintEntireContents() const { return false; }
+    virtual bool hasStablePageScaleFactor() const { return true; }
 
-#if USE(ACCELERATED_COMPOSITING)
     // Allows ports to customize the type of graphics layers created by this page.
-    virtual GraphicsLayerFactory* graphicsLayerFactory() const { return 0; }
+    virtual GraphicsLayerFactory* graphicsLayerFactory() const { return nullptr; }
+
+#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
+    virtual RefPtr<DisplayRefreshMonitor> createDisplayRefreshMonitor(PlatformDisplayID) const { return nullptr; }
+#endif
 
-    // Pass 0 as the GraphicsLayer to detatch the root layer.
-    virtual void attachRootGraphicsLayer(Frame*, GraphicsLayer*) = 0;
+    // Pass nullptr as the GraphicsLayer to detatch the root layer.
+    virtual void attachRootGraphicsLayer(Frame&, GraphicsLayer*) = 0;
+    virtual void attachViewOverlayGraphicsLayer(Frame&, GraphicsLayer*) = 0;
     // Sets a flag to specify that the next time content is drawn to the window,
     // the changes appear on the screen in synchrony with updates to GraphicsLayers.
     virtual void setNeedsOneShotDrawingSynchronization() = 0;
@@ -321,32 +326,40 @@ public:
     
     // Returns true if layer tree updates are disabled.
     virtual bool layerTreeStateIsFrozen() const { return false; }
-#endif
 
-    virtual PassRefPtr<ScrollingCoordinator> createScrollingCoordinator(Page*) const { return nullptr; }
+    virtual bool adjustLayerFlushThrottling(LayerFlushThrottleState::Flags) { return false; }
+
+    virtual RefPtr<ScrollingCoordinator> createScrollingCoordinator(Page&) const { return nullptr; }
 
 #if PLATFORM(WIN) && USE(AVFOUNDATION)
-    virtual GraphicsDeviceAdapter* graphicsDeviceAdapter() const { return 0; }
+    virtual GraphicsDeviceAdapter* graphicsDeviceAdapter() const { return nullptr; }
 #endif
 
-    virtual bool supportsFullscreenForNode(const Node*) { return false; }
-    virtual void enterFullscreenForNode(Node*) { }
-    virtual void exitFullscreenForNode(Node*) { }
+    virtual bool supportsVideoFullscreen(HTMLMediaElementEnums::VideoFullscreenMode) { return false; }
+
+#if ENABLE(VIDEO)
+    virtual void enterVideoFullscreenForVideoElement(HTMLVideoElement&, HTMLMediaElementEnums::VideoFullscreenMode) { }
+    virtual void setUpPlaybackControlsManager(HTMLMediaElement&) { }
+    virtual void clearPlaybackControlsManager() { }
+#endif
+
+    virtual void exitVideoFullscreenForVideoElement(HTMLVideoElement&) { }
+    virtual void exitVideoFullscreenToModeWithoutAnimation(HTMLVideoElement&, HTMLMediaElementEnums::VideoFullscreenMode) { }
     virtual bool requiresFullscreenForVideoPlayback() { return false; } 
 
 #if ENABLE(FULLSCREEN_API)
-    virtual bool supportsFullScreenForElement(const Element*, bool) { return false; }
-    virtual void enterFullScreenForElement(Element*) { }
+    virtual bool supportsFullScreenForElement(const Element&, bool) { return false; }
+    virtual void enterFullScreenForElement(Element&) { }
     virtual void exitFullScreenForElement(Element*) { }
     virtual void setRootFullScreenLayer(GraphicsLayer*) { }
 #endif
 
-#if USE(TILED_BACKING_STORE)
+#if USE(COORDINATED_GRAPHICS)
     virtual IntRect visibleRectForTiledBackingStore() const { return IntRect(); }
 #endif
 
-#if PLATFORM(MAC)
-    virtual NSResponder *firstResponder() { return 0; }
+#if PLATFORM(COCOA)
+    virtual NSResponder *firstResponder() { return nullptr; }
     virtual void makeFirstResponder(NSResponder *) { }
     // Focuses on the containing view associated with this page.
     virtual void makeFirstResponder() { }
@@ -366,42 +379,29 @@ public:
     virtual void AXFinishFrameLoad() = 0;
 #endif
 
-#if ENABLE(TOUCH_EVENTS)
-    virtual void needTouchEvents(bool) = 0;
-#endif
-
     virtual bool selectItemWritingDirectionIsNatural() = 0;
     virtual bool selectItemAlignmentFollowsMenuWritingDirection() = 0;
     // Checks if there is an opened popup, called by RenderMenuList::showPopup().
     virtual bool hasOpenedPopup() const = 0;
-    virtual PassRefPtr<PopupMenu> createPopupMenu(PopupMenuClient*) const = 0;
-    virtual PassRefPtr<SearchPopupMenu> createSearchPopupMenu(PopupMenuClient*) const = 0;
+    virtual RefPtr<PopupMenu> createPopupMenu(PopupMenuClient&) const = 0;
+    virtual RefPtr<SearchPopupMenu> createSearchPopupMenu(PopupMenuClient&) const = 0;
 
-    virtual void postAccessibilityNotification(AccessibilityObject*, AXObjectCache::AXNotification) { }
+    virtual void postAccessibilityNotification(AccessibilityObject&, AXObjectCache::AXNotification) { }
 
     virtual void notifyScrollerThumbIsVisibleInRect(const IntRect&) { }
-    virtual void recommendedScrollbarStyleDidChange(int /*newStyle*/) { }
+    virtual void recommendedScrollbarStyleDidChange(ScrollbarStyle) { }
 
-    enum DialogType {
-        AlertDialog = 0,
-        ConfirmDialog = 1,
-        PromptDialog = 2,
-        HTMLDialog = 3
-    };
-    virtual bool shouldRunModalDialogDuringPageDismissal(const DialogType&, const String& dialogMessage, FrameLoader::PageDismissalType) const { UNUSED_PARAM(dialogMessage); return true; }
+    virtual std::optional<ScrollbarOverlayStyle> preferredScrollbarOverlayStyle() { return ScrollbarOverlayStyleDefault; }
 
-    virtual void numWheelEventHandlersChanged(unsigned) = 0;
+    virtual void wheelEventHandlersChanged(bool hasHandlers) = 0;
         
     virtual bool isSVGImageChromeClient() const { return false; }
 
 #if ENABLE(POINTER_LOCK)
     virtual bool requestPointerLock() { return false; }
     virtual void requestPointerUnlock() { }
-    virtual bool isPointerLocked() { return false; }
 #endif
 
-    virtual void logDiagnosticMessage(const String& message, const String& description, const String& status) { UNUSED_PARAM(message); UNUSED_PARAM(description); UNUSED_PARAM(status); }
-
     virtual FloatSize minimumWindowSize() const { return FloatSize(100, 100); };
 
     virtual bool isEmptyChromeClient() const { return false; }
@@ -414,20 +414,59 @@ public:
     virtual void didAssociateFormControls(const Vector<RefPtr<Element>>&) { };
     virtual bool shouldNotifyOnFormChanges() { return false; };
 
-    virtual void didAddHeaderLayer(GraphicsLayer*) { }
-    virtual void didAddFooterLayer(GraphicsLayer*) { }
+    virtual void didAddHeaderLayer(GraphicsLayer&) { }
+    virtual void didAddFooterLayer(GraphicsLayer&) { }
+
+    virtual bool shouldUseTiledBackingForFrameView(const FrameView&) const { return false; }
+
+    virtual void isPlayingMediaDidChange(MediaProducer::MediaStateFlags, uint64_t) { }
+    virtual void didPlayMediaPreventedFromPlayingWithoutUserGesture() { }
+
+#if ENABLE(MEDIA_SESSION)
+    virtual void hasMediaSessionWithActiveMediaElementsDidChange(bool) { }
+    virtual void mediaSessionMetadataDidChange(const MediaSessionMetadata&) { }
+    virtual void focusedContentMediaElementDidChange(uint64_t) { }
+#endif
+
+#if ENABLE(SUBTLE_CRYPTO)
+    virtual bool wrapCryptoKey(const Vector<uint8_t>&, Vector<uint8_t>&) const { return false; }
+    virtual bool unwrapCryptoKey(const Vector<uint8_t>&, Vector<uint8_t>&) const { return false; }
+#endif
+
+#if ENABLE(TELEPHONE_NUMBER_DETECTION) && PLATFORM(MAC)
+    virtual void handleTelephoneNumberClick(const String&, const IntPoint&) { }
+#endif
+
+#if ENABLE(SERVICE_CONTROLS)
+    virtual void handleSelectionServiceClick(FrameSelection&, const Vector<String>&, const IntPoint&) { }
+    virtual bool hasRelevantSelectionServices(bool /*isTextOnly*/) const { return false; }
+#endif
+
+    virtual bool shouldDispatchFakeMouseMoveEvents() const { return true; }
+
+    virtual void handleAutoFillButtonClick(HTMLInputElement&) { }
+
+#if ENABLE(WIRELESS_PLAYBACK_TARGET)
+    virtual void addPlaybackTargetPickerClient(uint64_t /*contextId*/) { }
+    virtual void removePlaybackTargetPickerClient(uint64_t /*contextId*/) { }
+    virtual void showPlaybackTargetPicker(uint64_t /*contextId*/, const IntPoint&, bool /*isVideo*/) { }
+    virtual void playbackTargetPickerClientStateDidChange(uint64_t /*contextId*/, MediaProducer::MediaStateFlags) { }
+    virtual void setMockMediaPlaybackTargetPickerEnabled(bool)  { }
+    virtual void setMockMediaPlaybackTargetPickerState(const String&, MediaPlaybackTargetContext::State) { }
+#endif
+
+    virtual void imageOrMediaDocumentSizeChanged(const IntSize&) { }
+
+#if ENABLE(VIDEO) && USE(GSTREAMER)
+    virtual void requestInstallMissingMediaPlugins(const String& /*details*/, const String& /*description*/, MediaPlayerRequestInstallMissingPluginsCallback&) { }
+#endif
 
-    virtual bool shouldUseTiledBackingForFrameView(const FrameView*) const { return false; }
+    virtual void didInvalidateDocumentMarkerRects() { }
 
-    // These methods are used to report pages that are performing
-    // some task that we consider to be "active", and so the user
-    // would likely want the page to remain running uninterrupted.
-    virtual void incrementActivePageCount() { }
-    virtual void decrementActivePageCount() { }
+    virtual void reportProcessCPUTime(int64_t, ActivityStateForCPUSampling) { }
 
 protected:
     virtual ~ChromeClient() { }
 };
 
-}
-#endif // ChromeClient_h
+} // namespace WebCore