Changeset 142069 in webkit


Ignore:
Timestamp:
Feb 7, 2013 12:23:16 AM (11 years ago)
Author:
tkent@chromium.org
Message:

Fix style of Chrome.h and Page.h
​https://bugs.webkit.org/show_bug.cgi?id=109138

Reviewed by Ryosuke Niwa.

No new tests. Just style fixes.

  • page/Chrome.h:

(WebCore):
(Chrome):
(WebCore::Chrome::client):

  • page/Page.h:

(JSC):
(WebCore):
(WebCore::ArenaSize::ArenaSize):
(ArenaSize):
(Page):
(PageClients):
(WebCore::Page::theme):
(WebCore::Page::canStartMedia):
(WebCore::Page::editorClient):
(WebCore::Page::plugInClient):
(WebCore::Page::mainFrame):
(WebCore::Page::groupPtr):
(WebCore::Page::incrementSubframeCount):
(WebCore::Page::decrementSubframeCount):
(WebCore::Page::subframeCount):
(WebCore::Page::chrome):
(WebCore::Page::dragCaretController):
(WebCore::Page::dragController):
(WebCore::Page::focusController):
(WebCore::Page::contextMenuController):
(WebCore::Page::inspectorController):
(WebCore::Page::pointerLockController):
(WebCore::Page::validationMessageClient):
(WebCore::Page::settings):
(WebCore::Page::progress):
(WebCore::Page::backForward):
(WebCore::Page::featureObserver):
(WebCore::Page::viewMode):
(WebCore::Page::setTabKeyCyclesThroughElements):
(WebCore::Page::tabKeyCyclesThroughElements):
(WebCore::Page::scheduledRunLoopPairs):
(WebCore::Page::defersLoading):
(WebCore::Page::mediaVolume):
(WebCore::Page::pageScaleFactor):
(WebCore::Page::deviceScaleFactor):
(WebCore::Page::shouldSuppressScrollbarAnimations):
(WebCore::Page::pagination):
(WebCore::Page::isOnscreen):
(WebCore::Page::scriptedAnimationsSuspended):
(WebCore::Page::debugger):
(WebCore::Page::hasCustomHTMLTokenizerTimeDelay):
(WebCore::Page::customHTMLTokenizerTimeDelay):
(WebCore::Page::hasCustomHTMLTokenizerChunkSize):
(WebCore::Page::customHTMLTokenizerChunkSize):
(WebCore::Page::areMemoryCacheClientCallsEnabled):
(WebCore::Page::setEditable):
(WebCore::Page::isEditable):
(WebCore::Page::displayID):
(WebCore::Page::layoutMilestones):
(WebCore::Page::setIsPainting):
(WebCore::Page::isPainting):
(WebCore::Page::alternativeTextClient):
(WebCore::Page::checkSubframeCountConsistency):
(WebCore::Page::group):

Location:
trunk/Source/WebCore
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r142068 r142069  
     12013-02-06  Kent Tamura  <tkent@chromium.org>
     2
     3        Fix style of Chrome.h and Page.h
     4        https://bugs.webkit.org/show_bug.cgi?id=109138
     5
     6        Reviewed by Ryosuke Niwa.
     7
     8        No new tests. Just style fixes.
     9
     10        * page/Chrome.h:
     11        (WebCore):
     12        (Chrome):
     13        (WebCore::Chrome::client):
     14        * page/Page.h:
     15        (JSC):
     16        (WebCore):
     17        (WebCore::ArenaSize::ArenaSize):
     18        (ArenaSize):
     19        (Page):
     20        (PageClients):
     21        (WebCore::Page::theme):
     22        (WebCore::Page::canStartMedia):
     23        (WebCore::Page::editorClient):
     24        (WebCore::Page::plugInClient):
     25        (WebCore::Page::mainFrame):
     26        (WebCore::Page::groupPtr):
     27        (WebCore::Page::incrementSubframeCount):
     28        (WebCore::Page::decrementSubframeCount):
     29        (WebCore::Page::subframeCount):
     30        (WebCore::Page::chrome):
     31        (WebCore::Page::dragCaretController):
     32        (WebCore::Page::dragController):
     33        (WebCore::Page::focusController):
     34        (WebCore::Page::contextMenuController):
     35        (WebCore::Page::inspectorController):
     36        (WebCore::Page::pointerLockController):
     37        (WebCore::Page::validationMessageClient):
     38        (WebCore::Page::settings):
     39        (WebCore::Page::progress):
     40        (WebCore::Page::backForward):
     41        (WebCore::Page::featureObserver):
     42        (WebCore::Page::viewMode):
     43        (WebCore::Page::setTabKeyCyclesThroughElements):
     44        (WebCore::Page::tabKeyCyclesThroughElements):
     45        (WebCore::Page::scheduledRunLoopPairs):
     46        (WebCore::Page::defersLoading):
     47        (WebCore::Page::mediaVolume):
     48        (WebCore::Page::pageScaleFactor):
     49        (WebCore::Page::deviceScaleFactor):
     50        (WebCore::Page::shouldSuppressScrollbarAnimations):
     51        (WebCore::Page::pagination):
     52        (WebCore::Page::isOnscreen):
     53        (WebCore::Page::scriptedAnimationsSuspended):
     54        (WebCore::Page::debugger):
     55        (WebCore::Page::hasCustomHTMLTokenizerTimeDelay):
     56        (WebCore::Page::customHTMLTokenizerTimeDelay):
     57        (WebCore::Page::hasCustomHTMLTokenizerChunkSize):
     58        (WebCore::Page::customHTMLTokenizerChunkSize):
     59        (WebCore::Page::areMemoryCacheClientCallsEnabled):
     60        (WebCore::Page::setEditable):
     61        (WebCore::Page::isEditable):
     62        (WebCore::Page::displayID):
     63        (WebCore::Page::layoutMilestones):
     64        (WebCore::Page::setIsPainting):
     65        (WebCore::Page::isPainting):
     66        (WebCore::Page::alternativeTextClient):
     67        (WebCore::Page::checkSubframeCountConsistency):
     68        (WebCore::Page::group):
     69
    1702013-02-06  Mike West  <mkwst@chromium.org>
    271

  • trunk/Source/WebCore/page/Chrome.h

    r134886 r142069  
    3737namespace WebCore {
    3838
    39     class ChromeClient;
    40 #if ENABLE(INPUT_TYPE_COLOR)
    41     class ColorChooser;
    42     class ColorChooserClient;
     39class ChromeClient;
     40class ColorChooser;
     41class ColorChooserClient;
     42class DateTimeChooser;
     43class DateTimeChooserClient;
     44class FileChooser;
     45class FileIconLoader;
     46class FloatRect;
     47class Frame;
     48class Geolocation;
     49class HitTestResult;
     50class IntRect;
     51class NavigationAction;
     52class Node;
     53class Page;
     54class PopupMenu;
     55class PopupMenuClient;
     56class PopupOpeningObserver;
     57class SearchPopupMenu;
     58
     59struct DateTimeChooserParameters;
     60struct FrameLoadRequest;
     61struct ViewportArguments;
     62struct WindowFeatures;
     63   
     64class Chrome : public HostWindow {
     65public:
     66    ~Chrome();
     67
     68    static PassOwnPtr<Chrome> create(Page*, ChromeClient*);
     69
     70    ChromeClient* client() { return m_client; }
     71
     72    // HostWindow methods.
     73    virtual void invalidateRootView(const IntRect&, bool) OVERRIDE;
     74    virtual void invalidateContentsAndRootView(const IntRect&, bool) OVERRIDE;
     75    virtual void invalidateContentsForSlowScroll(const IntRect&, bool) OVERRIDE;
     76    virtual void scroll(const IntSize&, const IntRect&, const IntRect&) OVERRIDE;
     77#if USE(TILED_BACKING_STORE)
     78    virtual void delegatedScrollRequested(const IntPoint& scrollPoint) OVERRIDE;
    4379#endif
    44     class DateTimeChooser;
    45     class DateTimeChooserClient;
    46     class FileChooser;
    47     class FileIconLoader;
    48     class FloatRect;
    49     class Frame;
    50     class Geolocation;
    51     class HitTestResult;
    52     class IntRect;
    53     class NavigationAction;
    54     class Node;
    55     class Page;
    56     class PopupMenu;
    57     class PopupMenuClient;
    58     class PopupOpeningObserver;
    59     class SearchPopupMenu;
    60 
    61     struct DateTimeChooserParameters;
    62     struct FrameLoadRequest;
    63     struct ViewportArguments;
    64     struct WindowFeatures;
    65    
    66     class Chrome : public HostWindow {
    67     public:
    68         ~Chrome();
    69 
    70         static PassOwnPtr<Chrome> create(Page*, ChromeClient*);
    71 
    72         ChromeClient* client() { return m_client; }
    73 
    74         // HostWindow methods.
    75 
    76         virtual void invalidateRootView(const IntRect&, bool) OVERRIDE;
    77         virtual void invalidateContentsAndRootView(const IntRect&, bool) OVERRIDE;
    78         virtual void invalidateContentsForSlowScroll(const IntRect&, bool);
    79         virtual void scroll(const IntSize&, const IntRect&, const IntRect&);
    80 #if USE(TILED_BACKING_STORE)
    81         virtual void delegatedScrollRequested(const IntPoint& scrollPoint);
    82 #endif
    83         virtual IntPoint screenToRootView(const IntPoint&) const OVERRIDE;
    84         virtual IntRect rootViewToScreen(const IntRect&) const OVERRIDE;
    85         virtual PlatformPageClient platformPageClient() const;
    86         virtual void scrollbarsModeDidChange() const;
    87         virtual void setCursor(const Cursor&);
    88         virtual void setCursorHiddenUntilMouseMoves(bool);
     80    virtual IntPoint screenToRootView(const IntPoint&) const OVERRIDE;
     81    virtual IntRect rootViewToScreen(const IntRect&) const OVERRIDE;
     82    virtual PlatformPageClient platformPageClient() const OVERRIDE;
     83    virtual void scrollbarsModeDidChange() const OVERRIDE;
     84    virtual void setCursor(const Cursor&) OVERRIDE;
     85    virtual void setCursorHiddenUntilMouseMoves(bool) OVERRIDE;
    8986
    9087#if ENABLE(REQUEST_ANIMATION_FRAME)
    91         virtual void scheduleAnimation();
     88    virtual void scheduleAnimation() OVERRIDE;
    9289#endif
    9390
    94         void scrollRectIntoView(const IntRect&) const;
     91    void scrollRectIntoView(const IntRect&) const;
    9592
    96         void contentsSizeChanged(Frame*, const IntSize&) const;
    97         void layoutUpdated(Frame*) const;
     93    void contentsSizeChanged(Frame*, const IntSize&) const;
     94    void layoutUpdated(Frame*) const;
    9895
    99         void setWindowRect(const FloatRect&) const;
    100         FloatRect windowRect() const;
     96    void setWindowRect(const FloatRect&) const;
     97    FloatRect windowRect() const;
    10198
    102         FloatRect pageRect() const;
    103        
    104         void focus() const;
    105         void unfocus() const;
     99    FloatRect pageRect() const;
    106100
    107         bool canTakeFocus(FocusDirection) const;
    108         void takeFocus(FocusDirection) const;
     101    void focus() const;
     102    void unfocus() const;
    109103
    110         void focusedNodeChanged(Node*) const;
    111         void focusedFrameChanged(Frame*) const;
     104    bool canTakeFocus(FocusDirection) const;
     105    void takeFocus(FocusDirection) const;
    112106
    113         Page* createWindow(Frame*, const FrameLoadRequest&, const WindowFeatures&, const NavigationAction&) const;
    114         void show() const;
     107    void focusedNodeChanged(Node*) const;
     108    void focusedFrameChanged(Frame*) const;
    115109
    116         bool canRunModal() const;
    117         bool canRunModalNow() const;
    118         void runModal() const;
     110    Page* createWindow(Frame*, const FrameLoadRequest&, const WindowFeatures&, const NavigationAction&) const;
     111    void show() const;
    119112
    120         void setToolbarsVisible(bool) const;
    121         bool toolbarsVisible() const;
    122        
    123         void setStatusbarVisible(bool) const;
    124         bool statusbarVisible() const;
    125        
    126         void setScrollbarsVisible(bool) const;
    127         bool scrollbarsVisible() const;
    128        
    129         void setMenubarVisible(bool) const;
    130         bool menubarVisible() const;
    131        
    132         void setResizable(bool) const;
     113    bool canRunModal() const;
     114    bool canRunModalNow() const;
     115    void runModal() const;
    133116
    134         bool canRunBeforeUnloadConfirmPanel();
    135         bool runBeforeUnloadConfirmPanel(const String& message, Frame* frame);
     117    void setToolbarsVisible(bool) const;
     118    bool toolbarsVisible() const;
    136119
    137         void closeWindowSoon();
     120    void setStatusbarVisible(bool) const;
     121    bool statusbarVisible() const;
    138122
    139         void runJavaScriptAlert(Frame*, const String&);
    140         bool runJavaScriptConfirm(Frame*, const String&);
    141         bool runJavaScriptPrompt(Frame*, const String& message, const String& defaultValue, String& result);
    142         void setStatusbarText(Frame*, const String&);
    143         bool shouldInterruptJavaScript();
     123    void setScrollbarsVisible(bool) const;
     124    bool scrollbarsVisible() const;
    144125
    145         IntRect windowResizerRect() const;
     126    void setMenubarVisible(bool) const;
     127    bool menubarVisible() const;
    146128
    147         void mouseDidMoveOverElement(const HitTestResult&, unsigned modifierFlags);
     129    void setResizable(bool) const;
    148130
    149         void setToolTip(const HitTestResult&);
     131    bool canRunBeforeUnloadConfirmPanel();
     132    bool runBeforeUnloadConfirmPanel(const String& message, Frame*);
    150133
    151         void print(Frame*);
     134    void closeWindowSoon();
     135
     136    void runJavaScriptAlert(Frame*, const String&);
     137    bool runJavaScriptConfirm(Frame*, const String&);
     138    bool runJavaScriptPrompt(Frame*, const String& message, const String& defaultValue, String& result);
     139    void setStatusbarText(Frame*, const String&);
     140    bool shouldInterruptJavaScript();
     141
     142    IntRect windowResizerRect() const;
     143
     144    void mouseDidMoveOverElement(const HitTestResult&, unsigned modifierFlags);
     145
     146    void setToolTip(const HitTestResult&);
     147
     148    void print(Frame*);
    152149
    153150#if ENABLE(INPUT_TYPE_COLOR)
    154         PassOwnPtr<ColorChooser> createColorChooser(ColorChooserClient*, const Color& initialColor);
     151    PassOwnPtr<ColorChooser> createColorChooser(ColorChooserClient*, const Color& initialColor);
    155152#endif
    156153#if ENABLE(DATE_AND_TIME_INPUT_TYPES)
    157         PassRefPtr<DateTimeChooser> openDateTimeChooser(DateTimeChooserClient*, const DateTimeChooserParameters&);
     154    PassRefPtr<DateTimeChooser> openDateTimeChooser(DateTimeChooserClient*, const DateTimeChooserParameters&);
    158155#endif
    159156
    160         void runOpenPanel(Frame*, PassRefPtr<FileChooser>);
    161         void loadIconForFiles(const Vector<String>&, FileIconLoader*);
     157    void runOpenPanel(Frame*, PassRefPtr<FileChooser>);
     158    void loadIconForFiles(const Vector<String>&, FileIconLoader*);
    162159#if ENABLE(DIRECTORY_UPLOAD)
    163         void enumerateChosenDirectory(FileChooser*);
     160    void enumerateChosenDirectory(FileChooser*);
    164161#endif
    165162
    166         void dispatchViewportPropertiesDidChange(const ViewportArguments&) const;
     163    void dispatchViewportPropertiesDidChange(const ViewportArguments&) const;
    167164
    168         bool requiresFullscreenForVideoPlayback();
     165    bool requiresFullscreenForVideoPlayback();
    169166
    170167#if PLATFORM(MAC)
    171         void focusNSView(NSView*);
     168    void focusNSView(NSView*);
    172169#endif
    173170
    174         bool selectItemWritingDirectionIsNatural();
    175         bool selectItemAlignmentFollowsMenuWritingDirection();
    176         bool hasOpenedPopup() const;
    177         PassRefPtr<PopupMenu> createPopupMenu(PopupMenuClient*) const;
    178         PassRefPtr<SearchPopupMenu> createSearchPopupMenu(PopupMenuClient*) const;
     171    bool selectItemWritingDirectionIsNatural();
     172    bool selectItemAlignmentFollowsMenuWritingDirection();
     173    bool hasOpenedPopup() const;
     174    PassRefPtr<PopupMenu> createPopupMenu(PopupMenuClient*) const;
     175    PassRefPtr<SearchPopupMenu> createSearchPopupMenu(PopupMenuClient*) const;
    179176
    180         void registerPopupOpeningObserver(PopupOpeningObserver*);
    181         void unregisterPopupOpeningObserver(PopupOpeningObserver*);
     177    void registerPopupOpeningObserver(PopupOpeningObserver*);
     178    void unregisterPopupOpeningObserver(PopupOpeningObserver*);
    182179
    183     private:
    184         Chrome(Page*, ChromeClient*);
    185         void notifyPopupOpeningObservers() const;
     180private:
     181    Chrome(Page*, ChromeClient*);
     182    void notifyPopupOpeningObservers() const;
    186183
    187         Page* m_page;
    188         ChromeClient* m_client;
    189         Vector<PopupOpeningObserver*> m_popupOpeningObservers;
    190     };
     184    Page* m_page;
     185    ChromeClient* m_client;
     186    Vector<PopupOpeningObserver*> m_popupOpeningObservers;
     187};
     188
    191189}
    192190

  • trunk/Source/WebCore/page/Page.h

    r139796 r142069  
    2323
    2424#include "FeatureObserver.h"
     25#include "FindOptions.h"
    2526#include "FrameLoaderTypes.h"
    26 #include "FindOptions.h"
    2727#include "LayoutMilestones.h"
    2828#include "LayoutRect.h"
    … …  
    4848
    4949namespace JSC {
    50     class Debugger;
     50class Debugger;
    5151}
    5252
    5353namespace WebCore {
    5454
    55     class AlternativeTextClient;
    56     class BackForwardController;
    57     class BackForwardList;
    58     class Chrome;
    59     class ChromeClient;
    60     class ClientRectList;
     55class AlternativeTextClient;
     56class BackForwardController;
     57class BackForwardList;
     58class Chrome;
     59class ChromeClient;
     60class ClientRectList;
     61class ContextMenuClient;
     62class ContextMenuController;
     63class Document;
     64class DragCaretController;
     65class DragClient;
     66class DragController;
     67class EditorClient;
     68class FocusController;
     69class Frame;
     70class FrameSelection;
     71class HaltablePlugin;
     72class HistoryItem;
     73class InspectorClient;
     74class InspectorController;
     75class MediaCanStartListener;
     76class Node;
     77class PageGroup;
     78class PlugInClient;
     79class PluginData;
     80class PluginViewBase;
     81class PointerLockController;
     82class ProgressTracker;
     83class Range;
     84class RenderObject;
     85class RenderTheme;
     86class VisibleSelection;
     87class ScrollableArea;
     88class ScrollingCoordinator;
     89class Settings;
     90class StorageNamespace;
     91class ValidationMessageClient;
     92
     93typedef uint64_t LinkHash;
     94
     95enum FindDirection { FindDirectionForward, FindDirectionBackward };
     96
     97float deviceScaleFactor(Frame*);
     98
     99struct ArenaSize {
     100    ArenaSize(size_t treeSize, size_t allocated)
     101        : treeSize(treeSize)
     102        , allocated(allocated)
     103    {
     104    }
     105    size_t treeSize;
     106    size_t allocated;
     107};
     108
     109class Page : public Supplementable<Page> {
     110    WTF_MAKE_NONCOPYABLE(Page);
     111    friend class Settings;
     112public:
     113    static void scheduleForcedStyleRecalcForAllPages();
     114
     115    // It is up to the platform to ensure that non-null clients are provided where required.
     116    struct PageClients {
     117        WTF_MAKE_NONCOPYABLE(PageClients); WTF_MAKE_FAST_ALLOCATED;
     118    public:
     119        PageClients();
     120        ~PageClients();
     121
     122        AlternativeTextClient* alternativeTextClient;
     123        ChromeClient* chromeClient;
    61124#if ENABLE(CONTEXT_MENUS)
    62     class ContextMenuClient;
    63     class ContextMenuController;
    64 #endif
    65     class Document;
    66     class DragCaretController;
    67     class DragClient;
    68     class DragController;
    69     class EditorClient;
    70     class FocusController;
    71     class Frame;
    72     class FrameSelection;
    73     class HaltablePlugin;
    74     class HistoryItem;
    75     class InspectorClient;
    76     class InspectorController;
    77     class MediaCanStartListener;
    78     class Node;
    79     class PageGroup;
    80     class PlugInClient;
    81     class PluginData;
    82     class PluginViewBase;
    83     class PointerLockController;
    84     class ProgressTracker;
    85     class Range;
    86     class RenderObject;
    87     class RenderTheme;
    88     class VisibleSelection;
    89     class ScrollableArea;
    90     class ScrollingCoordinator;
    91     class Settings;
    92     class StorageNamespace;
    93     class ValidationMessageClient;
    94 
    95     typedef uint64_t LinkHash;
    96 
    97     enum FindDirection { FindDirectionForward, FindDirectionBackward };
    98 
    99     float deviceScaleFactor(Frame*);
    100 
    101     struct ArenaSize {
    102         ArenaSize(size_t treeSize, size_t allocated)
    103             : treeSize(treeSize)
    104             , allocated(allocated)
    105         {
    106         }
    107         size_t treeSize;
    108         size_t allocated;
     125        ContextMenuClient* contextMenuClient;
     126#endif
     127        EditorClient* editorClient;
     128        DragClient* dragClient;
     129        InspectorClient* inspectorClient;
     130        PlugInClient* plugInClient;
     131        RefPtr<BackForwardList> backForwardClient;
     132        ValidationMessageClient* validationMessageClient;
    109133    };
    110134
    111     class Page : public Supplementable<Page> {
    112         WTF_MAKE_NONCOPYABLE(Page);
    113         friend class Settings;
    114     public:
    115         static void scheduleForcedStyleRecalcForAllPages();
    116 
    117         // It is up to the platform to ensure that non-null clients are provided where required.
    118         struct PageClients {
    119             WTF_MAKE_NONCOPYABLE(PageClients); WTF_MAKE_FAST_ALLOCATED;
    120         public:
    121             PageClients();
    122             ~PageClients();
    123 
    124             AlternativeTextClient* alternativeTextClient;
    125             ChromeClient* chromeClient;
     135    explicit Page(PageClients&);
     136    ~Page();
     137
     138    ArenaSize renderTreeSize() const;
     139
     140    void setNeedsRecalcStyleInAllFrames();
     141
     142    RenderTheme* theme() const { return m_theme.get(); }
     143
     144    ViewportArguments viewportArguments() const;
     145
     146    static void refreshPlugins(bool reload);
     147    PluginData* pluginData() const;
     148
     149    void setCanStartMedia(bool);
     150    bool canStartMedia() const { return m_canStartMedia; }
     151
     152    EditorClient* editorClient() const { return m_editorClient; }
     153    PlugInClient* plugInClient() const { return m_plugInClient; }
     154
     155    void setMainFrame(PassRefPtr<Frame>);
     156    Frame* mainFrame() const { return m_mainFrame.get(); }
     157
     158    bool openedByDOM() const;
     159    void setOpenedByDOM();
     160
     161    // DEPRECATED. Use backForward() instead of the following 6 functions.
     162    BackForwardList* backForwardList() const;
     163    bool goBack();
     164    bool goForward();
     165    bool canGoBackOrForward(int distance) const;
     166    void goBackOrForward(int distance);
     167    int getHistoryLength();
     168
     169    void goToItem(HistoryItem*, FrameLoadType);
     170
     171    void setGroupName(const String&);
     172    const String& groupName() const;
     173
     174    PageGroup& group();
     175    PageGroup* groupPtr() { return m_group; } // can return 0
     176
     177    void incrementSubframeCount() { ++m_subframeCount; }
     178    void decrementSubframeCount() { ASSERT(m_subframeCount); --m_subframeCount; }
     179    int subframeCount() const { checkSubframeCountConsistency(); return m_subframeCount; }
     180
     181    Chrome* chrome() const { return m_chrome.get(); }
     182    DragCaretController* dragCaretController() const { return m_dragCaretController.get(); }
     183#if ENABLE(DRAG_SUPPORT)
     184    DragController* dragController() const { return m_dragController.get(); }
     185#endif
     186    FocusController* focusController() const { return m_focusController.get(); }
    126187#if ENABLE(CONTEXT_MENUS)
    127             ContextMenuClient* contextMenuClient;
    128 #endif
    129             EditorClient* editorClient;
    130             DragClient* dragClient;
    131             InspectorClient* inspectorClient;
    132             PlugInClient* plugInClient;
    133             RefPtr<BackForwardList> backForwardClient;
    134             ValidationMessageClient* validationMessageClient;
    135         };
    136 
    137         explicit Page(PageClients&);
    138         ~Page();
    139 
    140         ArenaSize renderTreeSize() const;
    141 
    142         void setNeedsRecalcStyleInAllFrames();
    143 
    144         RenderTheme* theme() const { return m_theme.get(); };
    145 
    146         ViewportArguments viewportArguments() const;
    147 
    148         static void refreshPlugins(bool reload);
    149         PluginData* pluginData() const;
    150 
    151         void setCanStartMedia(bool);
    152         bool canStartMedia() const { return m_canStartMedia; }
    153 
    154         EditorClient* editorClient() const { return m_editorClient; }
    155         PlugInClient* plugInClient() const { return m_plugInClient; }
    156 
    157         void setMainFrame(PassRefPtr<Frame>);
    158         Frame* mainFrame() const { return m_mainFrame.get(); }
    159 
    160         bool openedByDOM() const;
    161         void setOpenedByDOM();
    162 
    163         // DEPRECATED. Use backForward() instead of the following 6 functions.
    164         BackForwardList* backForwardList() const;
    165         bool goBack();
    166         bool goForward();
    167         bool canGoBackOrForward(int distance) const;
    168         void goBackOrForward(int distance);
    169         int getHistoryLength();
    170 
    171         void goToItem(HistoryItem*, FrameLoadType);
    172 
    173         void setGroupName(const String&);
    174         const String& groupName() const;
    175 
    176         PageGroup& group() { if (!m_group) initGroup(); return *m_group; }
    177         PageGroup* groupPtr() { return m_group; } // can return 0
    178 
    179         void incrementSubframeCount() { ++m_subframeCount; }
    180         void decrementSubframeCount() { ASSERT(m_subframeCount); --m_subframeCount; }
    181         int subframeCount() const { checkSubframeCountConsistency(); return m_subframeCount; }
    182 
    183         Chrome* chrome() const { return m_chrome.get(); }
    184         DragCaretController* dragCaretController() const { return m_dragCaretController.get(); }
     188    ContextMenuController* contextMenuController() const { return m_contextMenuController.get(); }
     189#endif
     190#if ENABLE(INSPECTOR)
     191    InspectorController* inspectorController() const { return m_inspectorController.get(); }
     192#endif
     193#if ENABLE(POINTER_LOCK)
     194    PointerLockController* pointerLockController() const { return m_pointerLockController.get(); }
     195#endif
     196    ValidationMessageClient* validationMessageClient() const { return m_validationMessageClient; }
     197
     198    ScrollingCoordinator* scrollingCoordinator();
     199
     200    String scrollingStateTreeAsText();
     201    String mainThreadScrollingReasonsAsText();
     202    PassRefPtr<ClientRectList> nonFastScrollableRects(const Frame*);
     203
     204    Settings* settings() const { return m_settings.get(); }
     205    ProgressTracker* progress() const { return m_progress.get(); }
     206    BackForwardController* backForward() const { return m_backForwardController.get(); }
     207
     208    FeatureObserver* featureObserver() { return &m_featureObserver; }
     209
     210    enum ViewMode {
     211        ViewModeInvalid,
     212        ViewModeWindowed,
     213        ViewModeFloating,
     214        ViewModeFullscreen,
     215        ViewModeMaximized,
     216        ViewModeMinimized
     217    };
     218    static ViewMode stringToViewMode(const String&);
     219
     220    ViewMode viewMode() const { return m_viewMode; }
     221    void setViewMode(ViewMode);
     222
     223    void setTabKeyCyclesThroughElements(bool b) { m_tabKeyCyclesThroughElements = b; }
     224    bool tabKeyCyclesThroughElements() const { return m_tabKeyCyclesThroughElements; }
     225
     226    bool findString(const String&, FindOptions);
     227    // FIXME: Switch callers over to the FindOptions version and retire this one.
     228    bool findString(const String&, TextCaseSensitivity, FindDirection, bool shouldWrap);
     229
     230    PassRefPtr<Range> rangeOfString(const String&, Range*, FindOptions);
     231
     232    unsigned markAllMatchesForText(const String&, FindOptions, bool shouldHighlight, unsigned);
     233    // FIXME: Switch callers over to the FindOptions version and retire this one.
     234    unsigned markAllMatchesForText(const String&, TextCaseSensitivity, bool shouldHighlight, unsigned);
     235    void unmarkAllTextMatches();
     236
     237    // find all the Ranges for the matching text.
     238    // Upon return, indexForSelection will be one of the following:
     239    // 0 if there is no user selection
     240    // the index of the first range after the user selection
     241    // NoMatchBeforeUserSelection if there is no matching text after the user selection.
     242    enum { NoMatchBeforeUserSelection = -1 };
     243    void findStringMatchingRanges(const String&, FindOptions, int maxCount, Vector<RefPtr<Range> >*, int& indexForSelection);
     244#if PLATFORM(MAC)
     245    void addSchedulePair(PassRefPtr<SchedulePair>);
     246    void removeSchedulePair(PassRefPtr<SchedulePair>);
     247    SchedulePairHashSet* scheduledRunLoopPairs() { return m_scheduledRunLoopPairs.get(); }
     248
     249    OwnPtr<SchedulePairHashSet> m_scheduledRunLoopPairs;
     250#endif
     251
     252    const VisibleSelection& selection() const;
     253
     254    void setDefersLoading(bool);
     255    bool defersLoading() const { return m_defersLoading; }
     256
     257    void clearUndoRedoOperations();
     258
     259    bool inLowQualityImageInterpolationMode() const;
     260    void setInLowQualityImageInterpolationMode(bool = true);
     261
     262    float mediaVolume() const { return m_mediaVolume; }
     263    void setMediaVolume(float);
     264
     265    void setPageScaleFactor(float scale, const IntPoint& origin);
     266    float pageScaleFactor() const { return m_pageScaleFactor; }
     267
     268    float deviceScaleFactor() const { return m_deviceScaleFactor; }
     269    void setDeviceScaleFactor(float);
     270
     271    bool shouldSuppressScrollbarAnimations() const { return m_suppressScrollbarAnimations; }
     272    void setShouldSuppressScrollbarAnimations(bool suppressAnimations);
     273
     274    // Page and FrameView both store a Pagination value. Page::pagination() is set only by API,
     275    // and FrameView::pagination() is set only by CSS. Page::pagination() will affect all
     276    // FrameViews in the page cache, but FrameView::pagination() only affects the current
     277    // FrameView.
     278    const Pagination& pagination() const { return m_pagination; }
     279    void setPagination(const Pagination&);
     280
     281    unsigned pageCount() const;
     282
     283    // Notifications when the Page starts and stops being presented via a native window.
     284    void didMoveOnscreen();
     285    void willMoveOffscreen();
     286    bool isOnscreen() const { return m_isOnscreen; }
     287
     288    void windowScreenDidChange(PlatformDisplayID);
     289
     290    void suspendScriptedAnimations();
     291    void resumeScriptedAnimations();
     292    bool scriptedAnimationsSuspended() const { return m_scriptedAnimationsSuspended; }
     293
     294    void userStyleSheetLocationChanged();
     295    const String& userStyleSheet() const;
     296
     297    void dnsPrefetchingStateChanged();
     298    void storageBlockingStateChanged();
     299    void privateBrowsingStateChanged();
     300
     301    static void setDebuggerForAllPages(JSC::Debugger*);
     302    void setDebugger(JSC::Debugger*);
     303    JSC::Debugger* debugger() const { return m_debugger; }
     304
     305    static void removeAllVisitedLinks();
     306
     307    static void allVisitedStateChanged(PageGroup*);
     308    static void visitedStateChanged(PageGroup*, LinkHash visitedHash);
     309
     310    StorageNamespace* sessionStorage(bool optionalCreate = true);
     311    void setSessionStorage(PassRefPtr<StorageNamespace>);
     312
     313    void setCustomHTMLTokenizerTimeDelay(double);
     314    bool hasCustomHTMLTokenizerTimeDelay() const { return m_customHTMLTokenizerTimeDelay != -1; }
     315    double customHTMLTokenizerTimeDelay() const { ASSERT(m_customHTMLTokenizerTimeDelay != -1); return m_customHTMLTokenizerTimeDelay; }
     316
     317    void setCustomHTMLTokenizerChunkSize(int);
     318    bool hasCustomHTMLTokenizerChunkSize() const { return m_customHTMLTokenizerChunkSize != -1; }
     319    int customHTMLTokenizerChunkSize() const { ASSERT(m_customHTMLTokenizerChunkSize != -1); return m_customHTMLTokenizerChunkSize; }
     320
     321    void setMemoryCacheClientCallsEnabled(bool);
     322    bool areMemoryCacheClientCallsEnabled() const { return m_areMemoryCacheClientCallsEnabled; }
     323
     324    // Don't allow more than a certain number of frames in a page.
     325    // This seems like a reasonable upper bound, and otherwise mutually
     326    // recursive frameset pages can quickly bring the program to its knees
     327    // with exponential growth in the number of frames.
     328    static const int maxNumberOfFrames = 1000;
     329
     330    void setEditable(bool isEditable) { m_isEditable = isEditable; }
     331    bool isEditable() { return m_isEditable; }
     332
     333#if ENABLE(PAGE_VISIBILITY_API)
     334    PageVisibilityState visibilityState() const;
     335#endif
     336#if ENABLE(PAGE_VISIBILITY_API) || ENABLE(HIDDEN_PAGE_DOM_TIMER_THROTTLING)
     337    void setVisibilityState(PageVisibilityState, bool);
     338#endif
     339
     340    PlatformDisplayID displayID() const { return m_displayID; }
     341
     342    void addLayoutMilestones(LayoutMilestones);
     343    LayoutMilestones layoutMilestones() const { return m_layoutMilestones; }
     344
     345    bool isCountingRelevantRepaintedObjects() const;
     346    void startCountingRelevantRepaintedObjects();
     347    void resetRelevantPaintedObjectCounter();
     348    void addRelevantRepaintedObject(RenderObject*, const LayoutRect& objectPaintRect);
     349    void addRelevantUnpaintedObject(RenderObject*, const LayoutRect& objectPaintRect);
     350
     351    void suspendActiveDOMObjectsAndAnimations();
     352    void resumeActiveDOMObjectsAndAnimations();
     353#ifndef NDEBUG
     354    void setIsPainting(bool painting) { m_isPainting = painting; }
     355    bool isPainting() const { return m_isPainting; }
     356#endif
     357
     358    AlternativeTextClient* alternativeTextClient() const { return m_alternativeTextClient; }
     359
     360    bool hasSeenPlugin(const String& serviceType) const;
     361    bool hasSeenAnyPlugin() const;
     362    void sawPlugin(const String& serviceType);
     363    void resetSeenPlugins();
     364
     365    bool hasSeenMediaEngine(const String& engineName) const;
     366    bool hasSeenAnyMediaEngine() const;
     367    void sawMediaEngine(const String& engineName);
     368    void resetSeenMediaEngines();
     369
     370    void reportMemoryUsage(MemoryObjectInfo*) const;
     371
     372private:
     373    void initGroup();
     374
     375#if ASSERT_DISABLED
     376    void checkSubframeCountConsistency() const { }
     377#else
     378    void checkSubframeCountConsistency() const;
     379#endif
     380
     381    MediaCanStartListener* takeAnyMediaCanStartListener();
     382
     383    void setMinimumTimerInterval(double);
     384    double minimumTimerInterval() const;
     385
     386    void setTimerAlignmentInterval(double);
     387    double timerAlignmentInterval() const;
     388
     389    void collectPluginViews(Vector<RefPtr<PluginViewBase>, 32>& pluginViewBases);
     390
     391    OwnPtr<Chrome> m_chrome;
     392    OwnPtr<DragCaretController> m_dragCaretController;
     393
    185394#if ENABLE(DRAG_SUPPORT)
    186         DragController* dragController() const { return m_dragController.get(); }
    187 #endif
    188         FocusController* focusController() const { return m_focusController.get(); }
     395    OwnPtr<DragController> m_dragController;
     396#endif
     397    OwnPtr<FocusController> m_focusController;
    189398#if ENABLE(CONTEXT_MENUS)
    190         ContextMenuController* contextMenuController() const { return m_contextMenuController.get(); }
     399    OwnPtr<ContextMenuController> m_contextMenuController;
    191400#endif
    192401#if ENABLE(INSPECTOR)
    193         InspectorController* inspectorController() const { return m_inspectorController.get(); }
     402    OwnPtr<InspectorController> m_inspectorController;
    194403#endif
    195404#if ENABLE(POINTER_LOCK)
    196         PointerLockController* pointerLockController() const { return m_pointerLockController.get(); }
    197 #endif
    198         ValidationMessageClient* validationMessageClient() const { return m_validationMessageClient; }
    199 
    200         ScrollingCoordinator* scrollingCoordinator();
    201 
    202         String scrollingStateTreeAsText();
    203         String mainThreadScrollingReasonsAsText();
    204         PassRefPtr<ClientRectList> nonFastScrollableRects(const Frame*);
    205 
    206         Settings* settings() const { return m_settings.get(); }
    207         ProgressTracker* progress() const { return m_progress.get(); }
    208         BackForwardController* backForward() const { return m_backForwardController.get(); }
    209 
    210         FeatureObserver* featureObserver() { return &m_featureObserver; }
    211 
    212         enum ViewMode {
    213             ViewModeInvalid,
    214             ViewModeWindowed,
    215             ViewModeFloating,
    216             ViewModeFullscreen,
    217             ViewModeMaximized,
    218             ViewModeMinimized
    219         };
    220         static ViewMode stringToViewMode(const String&);
    221 
    222         ViewMode viewMode() const { return m_viewMode; }
    223         void setViewMode(ViewMode);
    224        
    225         void setTabKeyCyclesThroughElements(bool b) { m_tabKeyCyclesThroughElements = b; }
    226         bool tabKeyCyclesThroughElements() const { return m_tabKeyCyclesThroughElements; }
    227 
    228         bool findString(const String&, FindOptions);
    229         // FIXME: Switch callers over to the FindOptions version and retire this one.
    230         bool findString(const String&, TextCaseSensitivity, FindDirection, bool shouldWrap);
    231 
    232         PassRefPtr<Range> rangeOfString(const String&, Range*, FindOptions);
    233 
    234         unsigned markAllMatchesForText(const String&, FindOptions, bool shouldHighlight, unsigned);
    235         // FIXME: Switch callers over to the FindOptions version and retire this one.
    236         unsigned markAllMatchesForText(const String&, TextCaseSensitivity, bool shouldHighlight, unsigned);
    237         void unmarkAllTextMatches();
    238 
    239         // find all the Ranges for the matching text.
    240         // Upon return, indexForSelection will be one of the following:
    241         // 0 if there is no user selection
    242         // the index of the first range after the user selection
    243         // NoMatchBeforeUserSelection if there is no matching text after the user selection.
    244         enum { NoMatchBeforeUserSelection = -1 };
    245         void findStringMatchingRanges(const String&, FindOptions, int maxCount, Vector<RefPtr<Range> >*, int& indexForSelection);
    246 #if PLATFORM(MAC)
    247         void addSchedulePair(PassRefPtr<SchedulePair>);
    248         void removeSchedulePair(PassRefPtr<SchedulePair>);
    249         SchedulePairHashSet* scheduledRunLoopPairs() { return m_scheduledRunLoopPairs.get(); }
    250 
    251         OwnPtr<SchedulePairHashSet> m_scheduledRunLoopPairs;
    252 #endif
    253 
    254         const VisibleSelection& selection() const;
    255 
    256         void setDefersLoading(bool);
    257         bool defersLoading() const { return m_defersLoading; }
    258        
    259         void clearUndoRedoOperations();
    260 
    261         bool inLowQualityImageInterpolationMode() const;
    262         void setInLowQualityImageInterpolationMode(bool = true);
    263 
    264         float mediaVolume() const { return m_mediaVolume; }
    265         void setMediaVolume(float volume);
    266 
    267         void setPageScaleFactor(float scale, const IntPoint& origin);
    268         float pageScaleFactor() const { return m_pageScaleFactor; }
    269 
    270         float deviceScaleFactor() const { return m_deviceScaleFactor; }
    271         void setDeviceScaleFactor(float);
    272 
    273         bool shouldSuppressScrollbarAnimations() const { return m_suppressScrollbarAnimations; }
    274         void setShouldSuppressScrollbarAnimations(bool suppressAnimations);
    275 
    276         // Page and FrameView both store a Pagination value. Page::pagination() is set only by API,
    277         // and FrameView::pagination() is set only by CSS. Page::pagination() will affect all
    278         // FrameViews in the page cache, but FrameView::pagination() only affects the current
    279         // FrameView.
    280         const Pagination& pagination() const { return m_pagination; }
    281         void setPagination(const Pagination&);
    282 
    283         unsigned pageCount() const;
    284 
    285         // Notifications when the Page starts and stops being presented via a native window.
    286         void didMoveOnscreen();
    287         void willMoveOffscreen();
    288         bool isOnscreen() const { return m_isOnscreen; }
    289 
    290         void windowScreenDidChange(PlatformDisplayID);
    291        
    292         void suspendScriptedAnimations();
    293         void resumeScriptedAnimations();
    294         bool scriptedAnimationsSuspended() const { return m_scriptedAnimationsSuspended; }
    295        
    296         void userStyleSheetLocationChanged();
    297         const String& userStyleSheet() const;
    298 
    299         void dnsPrefetchingStateChanged();
    300         void storageBlockingStateChanged();
    301         void privateBrowsingStateChanged();
    302 
    303         static void setDebuggerForAllPages(JSC::Debugger*);
    304         void setDebugger(JSC::Debugger*);
    305         JSC::Debugger* debugger() const { return m_debugger; }
    306 
    307         static void removeAllVisitedLinks();
    308 
    309         static void allVisitedStateChanged(PageGroup*);
    310         static void visitedStateChanged(PageGroup*, LinkHash visitedHash);
    311 
    312         StorageNamespace* sessionStorage(bool optionalCreate = true);
    313         void setSessionStorage(PassRefPtr<StorageNamespace>);
    314 
    315         void setCustomHTMLTokenizerTimeDelay(double);
    316         bool hasCustomHTMLTokenizerTimeDelay() const { return m_customHTMLTokenizerTimeDelay != -1; }
    317         double customHTMLTokenizerTimeDelay() const { ASSERT(m_customHTMLTokenizerTimeDelay != -1); return m_customHTMLTokenizerTimeDelay; }
    318 
    319         void setCustomHTMLTokenizerChunkSize(int);
    320         bool hasCustomHTMLTokenizerChunkSize() const { return m_customHTMLTokenizerChunkSize != -1; }
    321         int customHTMLTokenizerChunkSize() const { ASSERT(m_customHTMLTokenizerChunkSize != -1); return m_customHTMLTokenizerChunkSize; }
    322 
    323         void setMemoryCacheClientCallsEnabled(bool);
    324         bool areMemoryCacheClientCallsEnabled() const { return m_areMemoryCacheClientCallsEnabled; }
    325 
    326         // Don't allow more than a certain number of frames in a page.
    327         // This seems like a reasonable upper bound, and otherwise mutually
    328         // recursive frameset pages can quickly bring the program to its knees
    329         // with exponential growth in the number of frames.
    330         static const int maxNumberOfFrames = 1000;
    331 
    332         void setEditable(bool isEditable) { m_isEditable = isEditable; }
    333         bool isEditable() { return m_isEditable; }
     405    OwnPtr<PointerLockController> m_pointerLockController;
     406#endif
     407    RefPtr<ScrollingCoordinator> m_scrollingCoordinator;
     408
     409    OwnPtr<Settings> m_settings;
     410    OwnPtr<ProgressTracker> m_progress;
     411
     412    OwnPtr<BackForwardController> m_backForwardController;
     413    RefPtr<Frame> m_mainFrame;
     414
     415    mutable RefPtr<PluginData> m_pluginData;
     416
     417    RefPtr<RenderTheme> m_theme;
     418
     419    EditorClient* m_editorClient;
     420    PlugInClient* m_plugInClient;
     421    ValidationMessageClient* m_validationMessageClient;
     422
     423    FeatureObserver m_featureObserver;
     424
     425    int m_subframeCount;
     426    String m_groupName;
     427    bool m_openedByDOM;
     428
     429    bool m_tabKeyCyclesThroughElements;
     430    bool m_defersLoading;
     431    unsigned m_defersLoadingCallCount;
     432
     433    bool m_inLowQualityInterpolationMode;
     434    bool m_cookieEnabled;
     435    bool m_areMemoryCacheClientCallsEnabled;
     436    float m_mediaVolume;
     437
     438    float m_pageScaleFactor;
     439    float m_deviceScaleFactor;
     440
     441    bool m_suppressScrollbarAnimations;
     442
     443    Pagination m_pagination;
     444
     445    String m_userStyleSheetPath;
     446    mutable String m_userStyleSheet;
     447    mutable bool m_didLoadUserStyleSheet;
     448    mutable time_t m_userStyleSheetModificationTime;
     449
     450    OwnPtr<PageGroup> m_singlePageGroup;
     451    PageGroup* m_group;
     452
     453    JSC::Debugger* m_debugger;
     454
     455    double m_customHTMLTokenizerTimeDelay;
     456    int m_customHTMLTokenizerChunkSize;
     457
     458    bool m_canStartMedia;
     459
     460    RefPtr<StorageNamespace> m_sessionStorage;
     461
     462    ViewMode m_viewMode;
     463
     464    double m_minimumTimerInterval;
     465
     466    double m_timerAlignmentInterval;
     467
     468    bool m_isEditable;
     469    bool m_isOnscreen;
    334470
    335471#if ENABLE(PAGE_VISIBILITY_API)
    336         PageVisibilityState visibilityState() const;
    337 #endif
    338 #if ENABLE(PAGE_VISIBILITY_API) || ENABLE(HIDDEN_PAGE_DOM_TIMER_THROTTLING)
    339         void setVisibilityState(PageVisibilityState, bool);
    340 #endif
    341 
    342         PlatformDisplayID displayID() const { return m_displayID; }
    343 
    344         void addLayoutMilestones(LayoutMilestones);
    345         LayoutMilestones layoutMilestones() const { return m_layoutMilestones; }
    346 
    347         bool isCountingRelevantRepaintedObjects() const;
    348         void startCountingRelevantRepaintedObjects();
    349         void resetRelevantPaintedObjectCounter();
    350         void addRelevantRepaintedObject(RenderObject*, const LayoutRect& objectPaintRect);
    351         void addRelevantUnpaintedObject(RenderObject*, const LayoutRect& objectPaintRect);
    352 
    353         void suspendActiveDOMObjectsAndAnimations();
    354         void resumeActiveDOMObjectsAndAnimations();
     472    PageVisibilityState m_visibilityState;
     473#endif
     474    PlatformDisplayID m_displayID;
     475
     476    LayoutMilestones m_layoutMilestones;
     477
     478    HashSet<RenderObject*> m_relevantUnpaintedRenderObjects;
     479    Region m_relevantPaintedRegion;
     480    Region m_relevantUnpaintedRegion;
     481    bool m_isCountingRelevantRepaintedObjects;
    355482#ifndef NDEBUG
    356         void setIsPainting(bool painting) { m_isPainting = painting; }
    357         bool isPainting() const { return m_isPainting; }
    358 #endif
    359 
    360         AlternativeTextClient* alternativeTextClient() const { return m_alternativeTextClient; }
    361 
    362         bool hasSeenPlugin(const String& serviceType) const;
    363         bool hasSeenAnyPlugin() const;
    364         void sawPlugin(const String& serviceType);
    365         void resetSeenPlugins();
    366 
    367         bool hasSeenMediaEngine(const String& engineName) const;
    368         bool hasSeenAnyMediaEngine() const;
    369         void sawMediaEngine(const String& engineName);
    370         void resetSeenMediaEngines();
    371 
    372         void reportMemoryUsage(MemoryObjectInfo*) const;
    373 
    374     private:
    375         void initGroup();
    376 
    377 #if ASSERT_DISABLED
    378         void checkSubframeCountConsistency() const { }
    379 #else
    380         void checkSubframeCountConsistency() const;
    381 #endif
    382 
    383         MediaCanStartListener* takeAnyMediaCanStartListener();
    384 
    385         void setMinimumTimerInterval(double);
    386         double minimumTimerInterval() const;
    387 
    388         void setTimerAlignmentInterval(double);
    389         double timerAlignmentInterval() const;
    390 
    391         void collectPluginViews(Vector<RefPtr<PluginViewBase>, 32>& pluginViewBases);
    392 
    393         OwnPtr<Chrome> m_chrome;
    394         OwnPtr<DragCaretController> m_dragCaretController;
    395 
    396 #if ENABLE(DRAG_SUPPORT)
    397         OwnPtr<DragController> m_dragController;
    398 #endif
    399         OwnPtr<FocusController> m_focusController;
    400 #if ENABLE(CONTEXT_MENUS)
    401         OwnPtr<ContextMenuController> m_contextMenuController;
    402 #endif
    403 #if ENABLE(INSPECTOR)
    404         OwnPtr<InspectorController> m_inspectorController;
    405 #endif
    406 #if ENABLE(POINTER_LOCK)
    407         OwnPtr<PointerLockController> m_pointerLockController;
    408 #endif
    409         RefPtr<ScrollingCoordinator> m_scrollingCoordinator;
    410 
    411         OwnPtr<Settings> m_settings;
    412         OwnPtr<ProgressTracker> m_progress;
    413        
    414         OwnPtr<BackForwardController> m_backForwardController;
    415         RefPtr<Frame> m_mainFrame;
    416 
    417         mutable RefPtr<PluginData> m_pluginData;
    418 
    419         RefPtr<RenderTheme> m_theme;
    420 
    421         EditorClient* m_editorClient;
    422         PlugInClient* m_plugInClient;
    423         ValidationMessageClient* m_validationMessageClient;
    424 
    425         FeatureObserver m_featureObserver;
    426 
    427         int m_subframeCount;
    428         String m_groupName;
    429         bool m_openedByDOM;
    430 
    431         bool m_tabKeyCyclesThroughElements;
    432         bool m_defersLoading;
    433         unsigned m_defersLoadingCallCount;
    434 
    435         bool m_inLowQualityInterpolationMode;
    436         bool m_cookieEnabled;
    437         bool m_areMemoryCacheClientCallsEnabled;
    438         float m_mediaVolume;
    439 
    440         float m_pageScaleFactor;
    441         float m_deviceScaleFactor;
    442 
    443         bool m_suppressScrollbarAnimations;
    444 
    445         Pagination m_pagination;
    446 
    447         String m_userStyleSheetPath;
    448         mutable String m_userStyleSheet;
    449         mutable bool m_didLoadUserStyleSheet;
    450         mutable time_t m_userStyleSheetModificationTime;
    451 
    452         OwnPtr<PageGroup> m_singlePageGroup;
    453         PageGroup* m_group;
    454 
    455         JSC::Debugger* m_debugger;
    456 
    457         double m_customHTMLTokenizerTimeDelay;
    458         int m_customHTMLTokenizerChunkSize;
    459 
    460         bool m_canStartMedia;
    461 
    462         RefPtr<StorageNamespace> m_sessionStorage;
    463 
    464         ViewMode m_viewMode;
    465 
    466         double m_minimumTimerInterval;
    467 
    468         double m_timerAlignmentInterval;
    469 
    470         bool m_isEditable;
    471         bool m_isOnscreen;
    472 
    473 #if ENABLE(PAGE_VISIBILITY_API)
    474         PageVisibilityState m_visibilityState;
    475 #endif
    476         PlatformDisplayID m_displayID;
    477 
    478         LayoutMilestones m_layoutMilestones;
    479 
    480         HashSet<RenderObject*> m_relevantUnpaintedRenderObjects;
    481         Region m_relevantPaintedRegion;
    482         Region m_relevantUnpaintedRegion;
    483         bool m_isCountingRelevantRepaintedObjects;
    484 #ifndef NDEBUG
    485         bool m_isPainting;
    486 #endif
    487         AlternativeTextClient* m_alternativeTextClient;
    488 
    489         bool m_scriptedAnimationsSuspended;
    490 
    491         HashSet<String> m_seenPlugins;
    492         HashSet<String> m_seenMediaEngines;
    493     };
     483    bool m_isPainting;
     484#endif
     485    AlternativeTextClient* m_alternativeTextClient;
     486
     487    bool m_scriptedAnimationsSuspended;
     488
     489    HashSet<String> m_seenPlugins;
     490    HashSet<String> m_seenMediaEngines;
     491};
     492
     493inline PageGroup& Page::group()
     494{
     495    if (!m_group)
     496        initGroup();
     497    return *m_group;
     498}
    494499
    495500} // namespace WebCore
Note: See TracChangeset for help on using the changeset viewer.