https://bugs.webkit.org/show_bug.cgi?id=138166
Reviewed by Andreas Kling.
Clean up virtual functions in html/ by:
- Making virtual functions final when possible
- Making classes final when possible
- Using 'override' when appropriate
- Explicitly marking functions / destructors as virtual when they are
inherently virtual
- Dropping virtual destructors when the class does not have subclasses
and mark the class as final, to get rid of unnecessary vtables
- Making isXXX() virtual functions private on XXX classes to avoid
unnecessary type checks
- De-virtualizing some functions that do not need to be virtual
- Dropping final for virtual functions in classes already marked as
final
No new tests, no behavior change.
* html/ButtonInputType.h:
* html/CheckboxInputType.h:
* html/ColorInputType.h:
* html/DOMSettableTokenList.h:
* html/DateInputType.h:
* html/DateTimeInputType.h:
* html/DateTimeLocalInputType.h:
* html/EmailInputType.h:
* html/FTPDirectoryDocument.h:
* html/HTMLAnchorElement.h:
* html/HTMLDetailsElement.cpp:
* html/HTMLFormControlElement.h:
* html/HTMLFormControlsCollection.h:
* html/HTMLFrameElement.h:
* html/HTMLFrameElementBase.h:
* html/HTMLFrameOwnerElement.h:
* html/HTMLInputElement.h:
* html/HTMLMarqueeElement.h:
* html/HTMLMediaElement.h:
* html/HTMLMediaSession.h:
(WebCore::HTMLMediaSession::requiresPlaybackTargetRouteMonitoring): Deleted.
* html/HTMLMeterElement.h:
* html/HTMLNameCollection.h:
* html/HTMLObjectElement.h:
* html/HTMLOptGroupElement.h:
* html/HTMLOptionElement.h:
* html/HTMLSpanElement.h:
* html/HTMLStyleElement.h:
* html/HTMLSummaryElement.cpp:
* html/HTMLSummaryElement.h:
* html/HTMLUnknownElement.h:
* html/HTMLVideoElement.h:
* html/HiddenInputType.h:
* html/ImageInputType.h:
* html/MediaKeyEvent.h:
* html/MonthInputType.h:
* html/NumberInputType.h:
* html/PasswordInputType.h:
* html/PublicURLManager.h:
* html/RadioInputType.h:
* html/ResetInputType.h:
* html/SubmitInputType.h:
* html/TelephoneInputType.h:
* html/TextInputType.h:
* html/TimeInputType.h:
* html/URLInputType.h:
* html/WeekInputType.h:
* html/canvas/ANGLEInstancedArrays.h:
* html/canvas/CanvasRenderingContext2D.h:
* html/canvas/DOMPath.h:
* html/canvas/EXTShaderTextureLOD.h:
* html/canvas/EXTTextureFilterAnisotropic.h:
* html/canvas/OESElementIndexUint.h:
* html/canvas/OESStandardDerivatives.h:
* html/canvas/OESTextureFloat.h:
* html/canvas/OESTextureFloatLinear.h:
* html/canvas/OESTextureHalfFloat.h:
* html/canvas/OESTextureHalfFloatLinear.h:
* html/canvas/OESVertexArrayObject.h:
* html/canvas/WebGLBuffer.h:
* html/canvas/WebGLCompressedTextureATC.h:
* html/canvas/WebGLCompressedTexturePVRTC.h:
* html/canvas/WebGLCompressedTextureS3TC.h:
* html/canvas/WebGLContextAttributes.h:
* html/canvas/WebGLContextEvent.h:
* html/canvas/WebGLDebugRendererInfo.h:
* html/canvas/WebGLDebugShaders.h:
* html/canvas/WebGLDepthTexture.h:
* html/canvas/WebGLDrawBuffers.h:
* html/canvas/WebGLFramebuffer.h:
(WebCore::WebGLFramebuffer::isFramebuffer): Deleted.
* html/canvas/WebGLLoseContext.h:
* html/canvas/WebGLProgram.h:
* html/canvas/WebGLRenderbuffer.h:
* html/canvas/WebGLRenderingContext.h:
* html/canvas/WebGLShader.h:
* html/canvas/WebGLSharedObject.h:
(WebCore::WebGLSharedObject::isFramebuffer): Deleted.
* html/canvas/WebGLTexture.h:
* html/canvas/WebGLVertexArrayObjectOES.h:
(WebCore::WebGLVertexArrayObjectOES::isVertexArray): Deleted.
* html/shadow/ImageControlsRootElement.h:
* html/shadow/InsertionPoint.h:
* html/shadow/MediaControlElementTypes.h:
* html/shadow/MediaControlElements.h:
* html/shadow/MediaControls.h:
* html/shadow/MediaControlsApple.h:
* html/shadow/SpinButtonElement.h:
* html/track/AudioTrack.h:
* html/track/AudioTrackList.h:
* html/track/DataCue.h:
(WebCore::DataCue::cueType): Deleted.
* html/track/InbandDataTextTrack.h:
* html/track/InbandGenericTextTrack.h:
* html/track/InbandTextTrack.h:
* html/track/InbandWebVTTTextTrack.h:
* html/track/LoadableTextTrack.h:
* html/track/TextTrackList.h:
* html/track/TrackEvent.h:
* html/track/VTTCue.h:
(WebCore::VTTCueBox::setFontSizeFromCaptionUserPrefs):
* html/track/VTTRegion.h:
* html/track/VideoTrack.h:
* html/track/VideoTrackList.h:
* html/track/WebVTTParser.h:
(WebCore::WebVTTCueData::~WebVTTCueData): Deleted.
git-svn-id: https://svn.webkit.org/repository/webkit/trunk@175328
268f45cc-cd09-0410-ab3c-
d52691b4dbfc
+2014-10-29 Chris Dumez <cdumez@apple.com>
+
+ Clean up virtual functions in html/
+ https://bugs.webkit.org/show_bug.cgi?id=138166
+
+ Reviewed by Andreas Kling.
+
+ Clean up virtual functions in html/ by:
+ - Making virtual functions final when possible
+ - Making classes final when possible
+ - Using 'override' when appropriate
+ - Explicitly marking functions / destructors as virtual when they are
+ inherently virtual
+ - Dropping virtual destructors when the class does not have subclasses
+ and mark the class as final, to get rid of unnecessary vtables
+ - Making isXXX() virtual functions private on XXX classes to avoid
+ unnecessary type checks
+ - De-virtualizing some functions that do not need to be virtual
+ - Dropping final for virtual functions in classes already marked as
+ final
+
+ No new tests, no behavior change.
+
+ * html/ButtonInputType.h:
+ * html/CheckboxInputType.h:
+ * html/ColorInputType.h:
+ * html/DOMSettableTokenList.h:
+ * html/DateInputType.h:
+ * html/DateTimeInputType.h:
+ * html/DateTimeLocalInputType.h:
+ * html/EmailInputType.h:
+ * html/FTPDirectoryDocument.h:
+ * html/HTMLAnchorElement.h:
+ * html/HTMLDetailsElement.cpp:
+ * html/HTMLFormControlElement.h:
+ * html/HTMLFormControlsCollection.h:
+ * html/HTMLFrameElement.h:
+ * html/HTMLFrameElementBase.h:
+ * html/HTMLFrameOwnerElement.h:
+ * html/HTMLInputElement.h:
+ * html/HTMLMarqueeElement.h:
+ * html/HTMLMediaElement.h:
+ * html/HTMLMediaSession.h:
+ (WebCore::HTMLMediaSession::requiresPlaybackTargetRouteMonitoring): Deleted.
+ * html/HTMLMeterElement.h:
+ * html/HTMLNameCollection.h:
+ * html/HTMLObjectElement.h:
+ * html/HTMLOptGroupElement.h:
+ * html/HTMLOptionElement.h:
+ * html/HTMLSpanElement.h:
+ * html/HTMLStyleElement.h:
+ * html/HTMLSummaryElement.cpp:
+ * html/HTMLSummaryElement.h:
+ * html/HTMLUnknownElement.h:
+ * html/HTMLVideoElement.h:
+ * html/HiddenInputType.h:
+ * html/ImageInputType.h:
+ * html/MediaKeyEvent.h:
+ * html/MonthInputType.h:
+ * html/NumberInputType.h:
+ * html/PasswordInputType.h:
+ * html/PublicURLManager.h:
+ * html/RadioInputType.h:
+ * html/ResetInputType.h:
+ * html/SubmitInputType.h:
+ * html/TelephoneInputType.h:
+ * html/TextInputType.h:
+ * html/TimeInputType.h:
+ * html/URLInputType.h:
+ * html/WeekInputType.h:
+ * html/canvas/ANGLEInstancedArrays.h:
+ * html/canvas/CanvasRenderingContext2D.h:
+ * html/canvas/DOMPath.h:
+ * html/canvas/EXTShaderTextureLOD.h:
+ * html/canvas/EXTTextureFilterAnisotropic.h:
+ * html/canvas/OESElementIndexUint.h:
+ * html/canvas/OESStandardDerivatives.h:
+ * html/canvas/OESTextureFloat.h:
+ * html/canvas/OESTextureFloatLinear.h:
+ * html/canvas/OESTextureHalfFloat.h:
+ * html/canvas/OESTextureHalfFloatLinear.h:
+ * html/canvas/OESVertexArrayObject.h:
+ * html/canvas/WebGLBuffer.h:
+ * html/canvas/WebGLCompressedTextureATC.h:
+ * html/canvas/WebGLCompressedTexturePVRTC.h:
+ * html/canvas/WebGLCompressedTextureS3TC.h:
+ * html/canvas/WebGLContextAttributes.h:
+ * html/canvas/WebGLContextEvent.h:
+ * html/canvas/WebGLDebugRendererInfo.h:
+ * html/canvas/WebGLDebugShaders.h:
+ * html/canvas/WebGLDepthTexture.h:
+ * html/canvas/WebGLDrawBuffers.h:
+ * html/canvas/WebGLFramebuffer.h:
+ (WebCore::WebGLFramebuffer::isFramebuffer): Deleted.
+ * html/canvas/WebGLLoseContext.h:
+ * html/canvas/WebGLProgram.h:
+ * html/canvas/WebGLRenderbuffer.h:
+ * html/canvas/WebGLRenderingContext.h:
+ * html/canvas/WebGLShader.h:
+ * html/canvas/WebGLSharedObject.h:
+ (WebCore::WebGLSharedObject::isFramebuffer): Deleted.
+ * html/canvas/WebGLTexture.h:
+ * html/canvas/WebGLVertexArrayObjectOES.h:
+ (WebCore::WebGLVertexArrayObjectOES::isVertexArray): Deleted.
+ * html/shadow/ImageControlsRootElement.h:
+ * html/shadow/InsertionPoint.h:
+ * html/shadow/MediaControlElementTypes.h:
+ * html/shadow/MediaControlElements.h:
+ * html/shadow/MediaControls.h:
+ * html/shadow/MediaControlsApple.h:
+ * html/shadow/SpinButtonElement.h:
+ * html/track/AudioTrack.h:
+ * html/track/AudioTrackList.h:
+ * html/track/DataCue.h:
+ (WebCore::DataCue::cueType): Deleted.
+ * html/track/InbandDataTextTrack.h:
+ * html/track/InbandGenericTextTrack.h:
+ * html/track/InbandTextTrack.h:
+ * html/track/InbandWebVTTTextTrack.h:
+ * html/track/LoadableTextTrack.h:
+ * html/track/TextTrackList.h:
+ * html/track/TrackEvent.h:
+ * html/track/VTTCue.h:
+ (WebCore::VTTCueBox::setFontSizeFromCaptionUserPrefs):
+ * html/track/VTTRegion.h:
+ * html/track/VideoTrack.h:
+ * html/track/VideoTrackList.h:
+ * html/track/WebVTTParser.h:
+ (WebCore::WebVTTCueData::~WebVTTCueData): Deleted.
+
2014-10-17 Sergio Villar Senin <svillar@igalia.com>
ASSERTION FAILED: growthShare > 0 in WebCore::RenderGrid::distributeSpaceToTracks
namespace WebCore {
-class ButtonInputType : public BaseButtonInputType {
+class ButtonInputType final : public BaseButtonInputType {
public:
explicit ButtonInputType(HTMLInputElement& element) : BaseButtonInputType(element) { }
namespace WebCore {
-class CheckboxInputType : public BaseCheckableInputType {
+class CheckboxInputType final : public BaseCheckableInputType {
public:
explicit CheckboxInputType(HTMLInputElement& element) : BaseCheckableInputType(element) { }
namespace WebCore {
-class ColorInputType : public BaseClickableWithKeyInputType, public ColorChooserClient {
+class ColorInputType final : public BaseClickableWithKeyInputType, public ColorChooserClient {
public:
explicit ColorInputType(HTMLInputElement& element) : BaseClickableWithKeyInputType(element) { }
virtual ~ColorInputType();
typedef int ExceptionCode;
-class DOMSettableTokenList : public DOMTokenList, public RefCounted<DOMSettableTokenList> {
+class DOMSettableTokenList final : public DOMTokenList, public RefCounted<DOMSettableTokenList> {
WTF_MAKE_FAST_ALLOCATED;
public:
static PassRefPtr<DOMSettableTokenList> create();
- virtual void ref() override final;
- virtual void deref() override final;
+ virtual void ref() override;
+ virtual void deref() override;
- virtual unsigned length() const override final;
- virtual const AtomicString item(unsigned index) const override final;
+ virtual unsigned length() const override;
+ virtual const AtomicString item(unsigned index) const override;
- virtual AtomicString value() const override final;
- virtual void setValue(const AtomicString&) override final;
+ virtual AtomicString value() const override;
+ virtual void setValue(const AtomicString&) override;
private:
- virtual bool containsInternal(const AtomicString&) const override final;
+ virtual bool containsInternal(const AtomicString&) const override;
AtomicString m_value;
SpaceSplitString m_tokens;
namespace WebCore {
-class DateInputType : public BaseChooserOnlyDateAndTimeInputType {
+class DateInputType final : public BaseChooserOnlyDateAndTimeInputType {
public:
explicit DateInputType(HTMLInputElement&);
namespace WebCore {
-class DateTimeInputType : public BaseChooserOnlyDateAndTimeInputType {
+class DateTimeInputType final : public BaseChooserOnlyDateAndTimeInputType {
public:
explicit DateTimeInputType(HTMLInputElement& element) : BaseDateTimeInputType(element) { }
namespace WebCore {
-class DateTimeLocalInputType : public BaseChooserOnlyDateAndTimeInputType {
+class DateTimeLocalInputType final : public BaseChooserOnlyDateAndTimeInputType {
public:
explicit DateTimeLocalInputType(HTMLInputElement& element) : BaseChooserOnlyDateAndTimeInputType(element) { }
namespace WebCore {
-class EmailInputType : public BaseTextInputType {
+class EmailInputType final : public BaseTextInputType {
public:
explicit EmailInputType(HTMLInputElement& element) : BaseTextInputType(element) { }
class DOMImplementation;
-class FTPDirectoryDocument : public HTMLDocument {
+class FTPDirectoryDocument final : public HTMLDocument {
public:
static PassRefPtr<FTPDirectoryDocument> create(Frame* frame, const URL& url)
{
bool isLiveLink() const;
- virtual bool willRespondToMouseClickEvents() override;
+ virtual bool willRespondToMouseClickEvents() override final;
bool hasRel(uint32_t relation) const;
virtual bool supportsFocus() const override;
virtual bool isMouseFocusable() const override;
virtual bool isKeyboardFocusable(KeyboardEvent*) const override;
- virtual void defaultEventHandler(Event*) override;
+ virtual void defaultEventHandler(Event*) override final;
virtual void setActive(bool active = true, bool pause = false) override final;
- virtual void accessKeyAction(bool sendMouseEvents) override;
- virtual bool isURLAttribute(const Attribute&) const override;
- virtual bool canStartSelection() const override;
+ virtual void accessKeyAction(bool sendMouseEvents) override final;
+ virtual bool isURLAttribute(const Attribute&) const override final;
+ virtual bool canStartSelection() const override final;
virtual String target() const override;
virtual short tabIndex() const override final;
- virtual bool draggable() const override;
+ virtual bool draggable() const override final;
void sendPings(const URL& destinationURL);
return selector;
};
-class DetailsContentElement : public InsertionPoint {
+class DetailsContentElement final : public InsertionPoint {
public:
static PassRefPtr<DetailsContentElement> create(Document&);
return adoptRef(new DetailsContentElement(document));
}
-class DetailsSummaryElement : public InsertionPoint {
+class DetailsSummaryElement final : public InsertionPoint {
public:
static PassRefPtr<DetailsSummaryElement> create(Document&);
virtual void refFormAssociatedElement() override { ref(); }
virtual void derefFormAssociatedElement() override { deref(); }
- virtual bool isFormControlElement() const override { return true; }
+ virtual bool isFormControlElement() const override final { return true; }
virtual bool alwaysCreateUserAgentShadowRoot() const override { return true; }
virtual short tabIndex() const override final;
// This class is just a big hack to find form elements even in malformed HTML elements.
// The famous <table><tr><form><td> problem.
-class HTMLFormControlsCollection : public HTMLCollection {
+class HTMLFormControlsCollection final : public HTMLCollection {
public:
static PassRef<HTMLFormControlsCollection> create(ContainerNode&, CollectionType);
virtual void parseAttribute(const QualifiedName&, const AtomicString&) override;
-#if ENABLE(FULLSCREEN_API)
- virtual bool allowFullScreen() const { return false; }
-#endif
-
bool m_frameBorder;
bool m_frameBorderSet;
};
URL location() const;
void setLocation(const String&);
- virtual ScrollbarMode scrollingMode() const override { return m_scrolling; }
+ virtual ScrollbarMode scrollingMode() const override final { return m_scrolling; }
int marginWidth() const { return m_marginWidth; }
int marginHeight() const { return m_marginHeight; }
int width();
int height();
- virtual bool canContainRangeEndPoint() const override { return false; }
+ virtual bool canContainRangeEndPoint() const override final { return false; }
protected:
HTMLFrameElementBase(const QualifiedName&, Document&);
bool isURLAllowed() const;
virtual void parseAttribute(const QualifiedName&, const AtomicString&) override;
- virtual InsertionNotificationRequest insertedInto(ContainerNode&) override;
- virtual void didNotifySubtreeInsertions(ContainerNode*) override;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode&) override final;
+ virtual void didNotifySubtreeInsertions(ContainerNode*) override final;
virtual void didAttachRenderers() override;
private:
- virtual bool supportsFocus() const override;
- virtual void setFocus(bool) override;
+ virtual bool supportsFocus() const override final;
+ virtual void setFocus(bool) override final;
- virtual bool isURLAttribute(const Attribute&) const override;
- virtual bool isHTMLContentAttribute(const Attribute&) const override;
+ virtual bool isURLAttribute(const Attribute&) const override final;
+ virtual bool isHTMLContentAttribute(const Attribute&) const override final;
- virtual bool isFrameElementBase() const override { return true; }
+ virtual bool isFrameElementBase() const override final { return true; }
void setNameAndOpenURL();
void openURL(LockHistory = LockHistory::Yes, LockBackForwardList = LockBackForwardList::Yes);
private:
virtual bool isKeyboardFocusable(KeyboardEvent*) const override;
- virtual bool isFrameOwnerElement() const override { return true; }
+ virtual bool isFrameOwnerElement() const override final { return true; }
Frame* m_contentFrame;
SandboxFlags m_sandboxFlags;
DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitspeechchange);
- virtual HTMLInputElement* toInputElement() override { return this; }
+ virtual HTMLInputElement* toInputElement() override final { return this; }
WEBCORE_EXPORT virtual bool shouldAutocomplete() const override;
// DOM Functions
void start();
- void stop() override;
+ virtual void stop() override;
int scrollAmount() const;
void setScrollAmount(int, ExceptionCode&);
DisplayMode displayMode() const { return m_displayMode; }
virtual void setDisplayMode(DisplayMode mode) { m_displayMode = mode; }
- virtual bool isMediaElement() const override { return true; }
+ virtual bool isMediaElement() const override final { return true; }
#if ENABLE(VIDEO_TRACK)
bool ignoreTrackDisplayUpdateRequests() const { return m_ignoreTrackDisplayUpdate > 0 || !m_textTracks || !m_cueTree.size(); }
class HTMLMediaElement;
class SourceBuffer;
-class HTMLMediaSession : public MediaSession {
+class HTMLMediaSession final : public MediaSession {
public:
static std::unique_ptr<HTMLMediaSession> create(MediaSessionClient&);
#endif
private:
- virtual bool requiresPlaybackTargetRouteMonitoring() const { return m_hasPlaybackTargetAvailabilityListeners; }
+ virtual bool requiresPlaybackTargetRouteMonitoring() const override { return m_hasPlaybackTargetAvailabilityListeners; }
BehaviorRestrictions m_restrictions;
bool m_hasPlaybackTargetAvailabilityListeners;
virtual bool supportLabels() const override { return true; }
- virtual bool recalcWillValidate() const { return false; }
virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) override;
virtual bool childShouldCreateRenderer(const Node&) const override;
virtual void parseAttribute(const QualifiedName&, const AtomicString&) override;
class HTMLNameCollection : public HTMLCollection {
public:
- ~HTMLNameCollection();
+ virtual ~HTMLNameCollection();
Document& document() { return downcast<Document>(ownerNode()); }
virtual void derefFormAssociatedElement() override { deref(); }
virtual HTMLFormElement* virtualForm() const override;
- virtual FormNamedItem* asFormNamedItem() override final { return this; }
- virtual HTMLObjectElement& asHTMLElement() override final { return *this; }
- virtual const HTMLObjectElement& asHTMLElement() const override final { return *this; }
+ virtual FormNamedItem* asFormNamedItem() override { return this; }
+ virtual HTMLObjectElement& asHTMLElement() override { return *this; }
+ virtual const HTMLObjectElement& asHTMLElement() const override { return *this; }
virtual bool isFormControlElement() const override { return false; }
private:
HTMLOptGroupElement(const QualifiedName&, Document&);
- virtual const AtomicString& formControlType() const;
+ const AtomicString& formControlType() const;
virtual bool isFocusable() const override;
virtual void parseAttribute(const QualifiedName&, const AtomicString&) override;
virtual bool rendererIsNeeded(const RenderStyle&) override { return false; }
static PassRefPtr<HTMLOptionElement> createForJSConstructor(Document&, const String& data, const String& value,
bool defaultSelected, bool selected, ExceptionCode&);
- WEBCORE_EXPORT virtual String text() const;
+ WEBCORE_EXPORT String text() const;
void setText(const String&, ExceptionCode&);
int index() const;
namespace WebCore {
-class HTMLSpanElement : public HTMLElement {
+class HTMLSpanElement final : public HTMLElement {
public:
static PassRefPtr<HTMLSpanElement> create(const QualifiedName&, Document&);
virtual void finishParsingChildren() override;
- virtual bool isLoading() const { return m_styleSheetOwner.isLoading(); }
+ bool isLoading() const { return m_styleSheetOwner.isLoading(); }
virtual bool sheetLoaded() override { return m_styleSheetOwner.sheetLoaded(document()); }
virtual void notifyLoadedSheetAndAllCriticalSubresources(bool errorOccurred) override;
virtual void startLoadingDynamicSheet() override { m_styleSheetOwner.startLoadingDynamicSheet(document()); }
using namespace HTMLNames;
-class SummaryContentElement : public InsertionPoint {
+class SummaryContentElement final : public InsertionPoint {
public:
static PassRefPtr<SummaryContentElement> create(Document&);
virtual void didAddUserAgentShadowRoot(ShadowRoot*) override;
HTMLDetailsElement* detailsElement() const;
- bool supportsFocus() const override;
+ virtual bool supportsFocus() const override;
};
}
return adoptRef(new HTMLUnknownElement(tagName, document));
}
- virtual bool isHTMLUnknownElement() const override { return true; }
-
private:
HTMLUnknownElement(const QualifiedName& tagName, Document& document)
: HTMLElement(tagName, document, CreateHTMLElement)
{
}
+
+ virtual bool isHTMLUnknownElement() const override { return true; }
};
} // namespace
virtual bool isURLAttribute(const Attribute&) const override;
virtual const AtomicString& imageSourceURL() const override;
- virtual bool hasAvailableVideoFrame() const;
+ bool hasAvailableVideoFrame() const;
virtual void updateDisplayState() override;
virtual void didMoveToNewDocument(Document* oldDocument) override;
virtual void setDisplayMode(DisplayMode) override;
namespace WebCore {
-class HiddenInputType : public InputType {
+class HiddenInputType final : public InputType {
public:
explicit HiddenInputType(HTMLInputElement& element) : InputType(element) { }
namespace WebCore {
-class ImageInputType : public BaseButtonInputType {
+class ImageInputType final : public BaseButtonInputType {
public:
explicit ImageInputType(HTMLInputElement&);
unsigned short systemCode;
};
-class MediaKeyEvent : public Event {
+class MediaKeyEvent final : public Event {
public:
virtual ~MediaKeyEvent();
namespace WebCore {
-class MonthInputType : public BaseChooserOnlyDateAndTimeInputType {
+class MonthInputType final : public BaseChooserOnlyDateAndTimeInputType {
public:
explicit MonthInputType(HTMLInputElement& element) : BaseChooserOnlyDateAndTimeInputType(element) { }
namespace WebCore {
-class NumberInputType : public TextFieldInputType {
+class NumberInputType final : public TextFieldInputType {
public:
explicit NumberInputType(HTMLInputElement& element) : TextFieldInputType(element) { }
namespace WebCore {
-class PasswordInputType : public BaseTextInputType {
+class PasswordInputType final : public BaseTextInputType {
public:
explicit PasswordInputType(HTMLInputElement& element) : BaseTextInputType(element) { }
class URLRegistry;
class URLRegistrable;
-class PublicURLManager : public ActiveDOMObject {
+class PublicURLManager final : public ActiveDOMObject {
WTF_MAKE_FAST_ALLOCATED;
public:
explicit PublicURLManager(ScriptExecutionContext*);
namespace WebCore {
-class RadioInputType : public BaseCheckableInputType {
+class RadioInputType final : public BaseCheckableInputType {
public:
explicit RadioInputType(HTMLInputElement& element) : BaseCheckableInputType(element) { }
namespace WebCore {
-class ResetInputType : public BaseButtonInputType {
+class ResetInputType final : public BaseButtonInputType {
public:
explicit ResetInputType(HTMLInputElement& element) : BaseButtonInputType(element) { }
namespace WebCore {
-class SubmitInputType : public BaseButtonInputType {
+class SubmitInputType final : public BaseButtonInputType {
public:
explicit SubmitInputType(HTMLInputElement& element) : BaseButtonInputType(element) { }
namespace WebCore {
-class TelephoneInputType : public BaseTextInputType {
+class TelephoneInputType final : public BaseTextInputType {
public:
explicit TelephoneInputType(HTMLInputElement& element) : BaseTextInputType(element) { }
namespace WebCore {
-class TextInputType : public BaseTextInputType {
+class TextInputType final : public BaseTextInputType {
public:
explicit TextInputType(HTMLInputElement& element) : BaseTextInputType(element) { }
namespace WebCore {
-class TimeInputType : public BaseChooserOnlyDateAndTimeInputType {
+class TimeInputType final : public BaseChooserOnlyDateAndTimeInputType {
public:
explicit TimeInputType(HTMLInputElement&);
namespace WebCore {
-class URLInputType : public BaseTextInputType {
+class URLInputType final : public BaseTextInputType {
public:
explicit URLInputType(HTMLInputElement& element) : BaseTextInputType(element) { }
namespace WebCore {
-class WeekInputType : public BaseChooserOnlyDateAndTimeInputType {
+class WeekInputType final : public BaseChooserOnlyDateAndTimeInputType {
public:
explicit WeekInputType(HTMLInputElement& element) : BaseChooserOnlyDateAndTimeInputType(element) { }
class WebGLRenderingContext;
-class ANGLEInstancedArrays : public WebGLExtension {
+class ANGLEInstancedArrays final : public WebGLExtension {
public:
explicit ANGLEInstancedArrays(WebGLRenderingContext*);
virtual ~ANGLEInstancedArrays();
typedef int ExceptionCode;
-class CanvasRenderingContext2D : public CanvasRenderingContext, public CanvasPathMethods {
+class CanvasRenderingContext2D final : public CanvasRenderingContext, public CanvasPathMethods {
public:
CanvasRenderingContext2D(HTMLCanvasElement*, bool usesCSSCompatibilityParseMode, bool usesDashboardCompatibilityMode);
virtual ~CanvasRenderingContext2D();
LTR
};
- struct State : FontSelectorClient {
+ struct State final : FontSelectorClient {
State();
virtual ~State();
namespace WebCore {
-class DOMPath : public RefCounted<DOMPath>, public CanvasPathMethods {
+class DOMPath final : public RefCounted<DOMPath>, public CanvasPathMethods {
WTF_MAKE_FAST_ALLOCATED;
public:
static PassRefPtr<DOMPath> create() { return adoptRef(new DOMPath); }
namespace WebCore {
-class EXTShaderTextureLOD : public WebGLExtension {
+class EXTShaderTextureLOD final : public WebGLExtension {
public:
explicit EXTShaderTextureLOD(WebGLRenderingContext*);
virtual ~EXTShaderTextureLOD();
namespace WebCore {
-class EXTTextureFilterAnisotropic : public WebGLExtension {
+class EXTTextureFilterAnisotropic final : public WebGLExtension {
public:
explicit EXTTextureFilterAnisotropic(WebGLRenderingContext*);
virtual ~EXTTextureFilterAnisotropic();
namespace WebCore {
-class OESElementIndexUint : public WebGLExtension {
+class OESElementIndexUint final : public WebGLExtension {
public:
explicit OESElementIndexUint(WebGLRenderingContext*);
virtual ~OESElementIndexUint();
namespace WebCore {
-class OESStandardDerivatives : public WebGLExtension {
+class OESStandardDerivatives final : public WebGLExtension {
public:
explicit OESStandardDerivatives(WebGLRenderingContext*);
virtual ~OESStandardDerivatives();
namespace WebCore {
-class OESTextureFloat : public WebGLExtension {
+class OESTextureFloat final : public WebGLExtension {
public:
OESTextureFloat(WebGLRenderingContext*);
virtual ~OESTextureFloat();
namespace WebCore {
-class OESTextureFloatLinear : public WebGLExtension {
+class OESTextureFloatLinear final : public WebGLExtension {
public:
explicit OESTextureFloatLinear(WebGLRenderingContext*);
virtual ~OESTextureFloatLinear();
namespace WebCore {
-class OESTextureHalfFloat : public WebGLExtension {
+class OESTextureHalfFloat final : public WebGLExtension {
public:
OESTextureHalfFloat(WebGLRenderingContext*);
virtual ~OESTextureHalfFloat();
namespace WebCore {
-class OESTextureHalfFloatLinear : public WebGLExtension {
+class OESTextureHalfFloatLinear final : public WebGLExtension {
public:
OESTextureHalfFloatLinear(WebGLRenderingContext*);
virtual ~OESTextureHalfFloatLinear();
typedef int ExceptionCode;
-class OESVertexArrayObject : public WebGLExtension {
+class OESVertexArrayObject final : public WebGLExtension {
public:
OESVertexArrayObject(WebGLRenderingContext*);
virtual ~OESVertexArrayObject();
namespace WebCore {
-class WebGLBuffer : public WebGLSharedObject {
+class WebGLBuffer final : public WebGLSharedObject {
public:
virtual ~WebGLBuffer();
class WebGLTexture;
-class WebGLCompressedTextureATC : public WebGLExtension {
+class WebGLCompressedTextureATC final : public WebGLExtension {
public:
explicit WebGLCompressedTextureATC(WebGLRenderingContext*);
virtual ~WebGLCompressedTextureATC();
namespace WebCore {
-class WebGLCompressedTexturePVRTC : public WebGLExtension {
+class WebGLCompressedTexturePVRTC final : public WebGLExtension {
public:
explicit WebGLCompressedTexturePVRTC(WebGLRenderingContext*);
virtual ~WebGLCompressedTexturePVRTC();
class WebGLTexture;
-class WebGLCompressedTextureS3TC : public WebGLExtension {
+class WebGLCompressedTextureS3TC final : public WebGLExtension {
public:
explicit WebGLCompressedTextureS3TC(WebGLRenderingContext*);
virtual ~WebGLCompressedTextureS3TC();
namespace WebCore {
-class WebGLContextAttributes : public CanvasContextAttributes {
+class WebGLContextAttributes final : public CanvasContextAttributes {
public:
virtual ~WebGLContextAttributes();
String statusMessage;
};
-class WebGLContextEvent : public Event {
+class WebGLContextEvent final : public Event {
public:
static PassRefPtr<WebGLContextEvent> create()
{
namespace WebCore {
-class WebGLDebugRendererInfo : public WebGLExtension {
+class WebGLDebugRendererInfo final : public WebGLExtension {
public:
enum EnumType {
UNMASKED_VENDOR_WEBGL = 0x9245,
typedef int ExceptionCode;
-class WebGLDebugShaders : public WebGLExtension {
+class WebGLDebugShaders final : public WebGLExtension {
public:
explicit WebGLDebugShaders(WebGLRenderingContext*);
virtual ~WebGLDebugShaders();
namespace WebCore {
-class WebGLDepthTexture : public WebGLExtension {
+class WebGLDepthTexture final : public WebGLExtension {
public:
explicit WebGLDepthTexture(WebGLRenderingContext*);
virtual ~WebGLDepthTexture();
namespace WebCore {
-class WebGLDrawBuffers : public WebGLExtension {
+class WebGLDrawBuffers final : public WebGLExtension {
public:
explicit WebGLDrawBuffers(WebGLRenderingContext*);
virtual ~WebGLDrawBuffers();
class WebGLRenderbuffer;
class WebGLTexture;
-class WebGLFramebuffer : public WebGLContextObject {
+class WebGLFramebuffer final : public WebGLContextObject {
public:
class WebGLAttachment : public RefCounted<WebGLAttachment> {
public:
virtual void deleteObjectImpl(GraphicsContext3D*, Platform3DObject) override;
private:
- virtual bool isFramebuffer() const { return true; }
-
WebGLAttachment* getAttachment(GC3Denum) const;
// Return false if framebuffer is incomplete.
class WebGLRenderingContext;
-class WebGLLoseContext : public WebGLExtension {
+class WebGLLoseContext final : public WebGLExtension {
public:
explicit WebGLLoseContext(WebGLRenderingContext*);
virtual ~WebGLLoseContext();
namespace WebCore {
-class WebGLProgram : public WebGLSharedObject {
+class WebGLProgram final : public WebGLSharedObject {
public:
virtual ~WebGLProgram();
namespace WebCore {
-class WebGLRenderbuffer : public WebGLSharedObject {
+class WebGLRenderbuffer final : public WebGLSharedObject {
public:
virtual ~WebGLRenderbuffer();
typedef int ExceptionCode;
-class WebGLRenderingContext : public CanvasRenderingContext, public ActiveDOMObject {
+class WebGLRenderingContext final : public CanvasRenderingContext, public ActiveDOMObject {
public:
static std::unique_ptr<WebGLRenderingContext> create(HTMLCanvasElement*, WebGLContextAttributes*);
virtual ~WebGLRenderingContext();
void markLayerComposited();
virtual void paintRenderingResultsToCanvas() override;
- virtual PassRefPtr<ImageData> paintRenderingResultsToImageData();
+ PassRefPtr<ImageData> paintRenderingResultsToImageData();
void removeSharedObject(WebGLSharedObject*);
void removeContextObject(WebGLContextObject*);
namespace WebCore {
-class WebGLShader : public WebGLSharedObject {
+class WebGLShader final : public WebGLSharedObject {
public:
virtual ~WebGLShader();
WebGLContextGroup* contextGroup() const { return m_contextGroup; }
virtual bool isBuffer() const { return false; }
- virtual bool isFramebuffer() const { return false; }
virtual bool isProgram() const { return false; }
virtual bool isRenderbuffer() const { return false; }
virtual bool isShader() const { return false; }
namespace WebCore {
-class WebGLTexture : public WebGLSharedObject {
+class WebGLTexture final : public WebGLSharedObject {
public:
enum TextureExtensionFlag {
static GC3Dint computeLevelCount(GC3Dsizei width, GC3Dsizei height);
-protected:
+private:
WebGLTexture(WebGLRenderingContext*);
virtual void deleteObjectImpl(GraphicsContext3D*, Platform3DObject) override;
-private:
class LevelInfo {
public:
LevelInfo()
namespace WebCore {
-class WebGLVertexArrayObjectOES : public WebGLContextObject {
+class WebGLVertexArrayObjectOES final : public WebGLContextObject {
public:
enum VaoType {
VaoTypeDefault,
WebGLVertexArrayObjectOES(WebGLRenderingContext*, VaoType);
virtual void deleteObjectImpl(GraphicsContext3D*, Platform3DObject) override;
-
- virtual bool isVertexArray() const { return true; }
VaoType m_type;
bool m_hasEverBeenBound;
explicit ImageControlsRootElement(Document&);
private:
- virtual bool isImageControlsRootElement() const override { return true; }
+ virtual bool isImageControlsRootElement() const override final { return true; }
};
} // namespace WebCore
virtual void childrenChanged(const ChildChange&) override;
virtual InsertionNotificationRequest insertedInto(ContainerNode&) override;
virtual void removedFrom(ContainerNode&) override;
- virtual bool isInsertionPointNode() const override { return true; }
private:
+ virtual bool isInsertionPointNode() const override final { return true; }
bool m_hasDistribution;
};
class MediaControlDivElement : public HTMLDivElement, public MediaControlElement {
protected:
- virtual bool isMediaControlElement() const override { return MediaControlElement::isMediaControlElement(); }
explicit MediaControlDivElement(Document&, MediaControlElementType);
+
+private:
+ virtual bool isMediaControlElement() const override final { return MediaControlElement::isMediaControlElement(); }
};
// ----------------------------
class MediaControlInputElement : public HTMLInputElement, public MediaControlElement {
protected:
- virtual bool isMediaControlElement() const override { return MediaControlElement::isMediaControlElement(); }
explicit MediaControlInputElement(Document&, MediaControlElementType);
private:
+ virtual bool isMediaControlElement() const override final { return MediaControlElement::isMediaControlElement(); }
virtual void updateDisplayType() { }
};
// ----------------------------
-class MediaControlTimelineContainerElement : public MediaControlDivElement {
+class MediaControlTimelineContainerElement final : public MediaControlDivElement {
public:
static PassRefPtr<MediaControlTimelineContainerElement> create(Document&);
// ----------------------------
-class MediaControlVolumeSliderContainerElement : public MediaControlDivElement {
+class MediaControlVolumeSliderContainerElement final : public MediaControlDivElement {
public:
static PassRefPtr<MediaControlVolumeSliderContainerElement> create(Document&);
// ----------------------------
-class MediaControlStatusDisplayElement : public MediaControlDivElement {
+class MediaControlStatusDisplayElement final : public MediaControlDivElement {
public:
static PassRefPtr<MediaControlStatusDisplayElement> create(Document&);
// ----------------------------
-class MediaControlSeekForwardButtonElement : public MediaControlSeekButtonElement {
+class MediaControlSeekForwardButtonElement final : public MediaControlSeekButtonElement {
public:
static PassRefPtr<MediaControlSeekForwardButtonElement> create(Document&);
// ----------------------------
-class MediaControlSeekBackButtonElement : public MediaControlSeekButtonElement {
+class MediaControlSeekBackButtonElement final : public MediaControlSeekButtonElement {
public:
static PassRefPtr<MediaControlSeekBackButtonElement> create(Document&);
// ----------------------------
-class MediaControlRewindButtonElement : public MediaControlInputElement {
+class MediaControlRewindButtonElement final : public MediaControlInputElement {
public:
static PassRefPtr<MediaControlRewindButtonElement> create(Document&);
// ----------------------------
-class MediaControlReturnToRealtimeButtonElement : public MediaControlInputElement {
+class MediaControlReturnToRealtimeButtonElement final : public MediaControlInputElement {
public:
static PassRefPtr<MediaControlReturnToRealtimeButtonElement> create(Document&);
virtual bool willRespondToMouseClickEvents() override { return true; }
#endif
- virtual void setIsFullscreen(bool);
+ void setIsFullscreen(bool);
private:
explicit MediaControlFullscreenButtonElement(Document&);
};
// ----------------------------
-class MediaControlFullscreenVolumeSliderElement : public MediaControlVolumeSliderElement {
+class MediaControlFullscreenVolumeSliderElement final : public MediaControlVolumeSliderElement {
public:
static PassRefPtr<MediaControlFullscreenVolumeSliderElement> create(Document&);
// ----------------------------
-class MediaControlFullscreenVolumeMinButtonElement : public MediaControlInputElement {
+class MediaControlFullscreenVolumeMinButtonElement final : public MediaControlInputElement {
public:
static PassRefPtr<MediaControlFullscreenVolumeMinButtonElement> create(Document&);
// ----------------------------
-class MediaControlFullscreenVolumeMaxButtonElement : public MediaControlInputElement {
+class MediaControlFullscreenVolumeMaxButtonElement final : public MediaControlInputElement {
public:
static PassRefPtr<MediaControlFullscreenVolumeMaxButtonElement> create(Document&);
bool m_isMouseOverControls;
private:
- virtual bool isMediaControls() const override { return true; }
+ virtual bool isMediaControls() const override final { return true; }
};
inline MediaControls* toMediaControls(Node* node)
MediaControlsApple* m_mediaControls;
};
-class MediaControlsApple : public MediaControls {
+class MediaControlsApple final : public MediaControls {
public:
static PassRefPtr<MediaControlsApple> createControls(Document&);
// implementation, e.g. during event handling.
static PassRefPtr<SpinButtonElement> create(Document&, SpinButtonOwner&);
UpDownState upDownState() const { return m_upDownState; }
- virtual void releaseCapture();
+ void releaseCapture();
void removeSpinButtonOwner() { m_spinButtonOwner = 0; }
void step(int amount);
virtual void audioTrackEnabledChanged(AudioTrack*) = 0;
};
-class AudioTrack : public TrackBase, public AudioTrackPrivateClient {
+class AudioTrack final : public TrackBase, public AudioTrackPrivateClient {
public:
static PassRefPtr<AudioTrack> create(AudioTrackClient* client, PassRefPtr<AudioTrackPrivate> trackPrivate)
{
virtual const AtomicString& defaultKindKeyword() const override { return emptyAtom; }
virtual bool enabled() const override { return m_enabled; }
- virtual void setEnabled(const bool);
+ void setEnabled(const bool);
- virtual void clearClient() override { m_client = 0; }
+ virtual void clearClient() override { m_client = nullptr; }
AudioTrackClient* client() const { return m_client; }
size_t inbandTrackIndex();
class AudioTrack;
-class AudioTrackList : public TrackListBase {
+class AudioTrackList final : public TrackListBase {
public:
static PassRefPtr<AudioTrackList> create(HTMLMediaElement* owner, ScriptExecutionContext* context)
{
class ScriptExecutionContext;
-class DataCue : public TextTrackCue {
+class DataCue final : public TextTrackCue {
public:
static PassRefPtr<DataCue> create(ScriptExecutionContext& context, const MediaTime& start, const MediaTime& end, ArrayBuffer* data, ExceptionCode& ec)
{
#endif
virtual ~DataCue();
- virtual CueType cueType() const { return Data; }
+ virtual CueType cueType() const override { return Data; }
PassRefPtr<ArrayBuffer> data() const;
void setData(ArrayBuffer*, ExceptionCode&);
class SerializedPlatformRepresentation;
#endif
-class InbandDataTextTrack : public InbandTextTrack {
+class InbandDataTextTrack final : public InbandTextTrack {
public:
static PassRefPtr<InbandDataTextTrack> create(ScriptExecutionContext*, TextTrackClient*, PassRefPtr<InbandTextTrackPrivate>);
virtual ~InbandDataTextTrack();
class InbandTextTrackPrivate;
class TextTrackCue;
-class GenericTextTrackCueMap {
+class GenericTextTrackCueMap final {
public:
GenericTextTrackCueMap();
- virtual ~GenericTextTrackCueMap();
+ ~GenericTextTrackCueMap();
void add(GenericCueData*, TextTrackCueGeneric*);
CueDataToCueMap m_dataToCueMap;
};
-class InbandGenericTextTrack : public InbandTextTrack, private WebVTTParserClient {
+class InbandGenericTextTrack final : public InbandTextTrack, private WebVTTParserClient {
public:
static PassRefPtr<InbandGenericTextTrack> create(ScriptExecutionContext*, TextTrackClient*, PassRefPtr<InbandTextTrackPrivate>);
virtual ~InbandGenericTextTrack();
void setPrivate(PassRefPtr<InbandTextTrackPrivate>);
- virtual bool isInband() const override { return true; }
-
protected:
InbandTextTrack(ScriptExecutionContext*, TextTrackClient*, PassRefPtr<InbandTextTrackPrivate>);
RefPtr<InbandTextTrackPrivate> m_private;
private:
-
+ virtual bool isInband() const override final { return true; }
virtual void idChanged(TrackPrivateBase*, const AtomicString&) override;
virtual void labelChanged(TrackPrivateBase*, const AtomicString&) override;
virtual void languageChanged(TrackPrivateBase*, const AtomicString&) override;
namespace WebCore {
-class InbandWebVTTTextTrack : public InbandTextTrack, private WebVTTParserClient {
+class InbandWebVTTTextTrack final : public InbandTextTrack, private WebVTTParserClient {
public:
static PassRefPtr<InbandTextTrack> create(ScriptExecutionContext*, TextTrackClient*, PassRefPtr<InbandTextTrackPrivate>);
virtual ~InbandWebVTTTextTrack();
class HTMLTrackElement;
class LoadableTextTrack;
-class LoadableTextTrack : public TextTrack, private TextTrackLoaderClient {
+class LoadableTextTrack final : public TextTrack, private TextTrackLoaderClient {
public:
static PassRefPtr<LoadableTextTrack> create(HTMLTrackElement* track, const String& kind, const String& label, const String& language)
{
virtual void newCuesAvailable(TextTrackLoader*) override;
virtual void cueLoadingCompleted(TextTrackLoader*, bool loadingFailed) override;
#if ENABLE(WEBVTT_REGIONS)
- virtual void newRegionsAvailable(TextTrackLoader*);
+ virtual void newRegionsAvailable(TextTrackLoader*) override;
#endif
LoadableTextTrack(HTMLTrackElement*, const String& kind, const String& label, const String& language);
class TextTrack;
-class TextTrackList : public TrackListBase {
+class TextTrackList final : public TrackListBase {
public:
static PassRefPtr<TextTrackList> create(HTMLMediaElement* element, ScriptExecutionContext* context)
{
RefPtr<TrackBase> track;
};
-class TrackEvent : public Event {
+class TrackEvent final : public Event {
public:
virtual ~TrackEvent();
virtual void applyCSSProperties(const IntSize& videoSize);
static const AtomicString& vttCueBoxShadowPseudoId();
- virtual void setFontSizeFromCaptionUserPrefs(int fontSize) { m_fontSizeFromCaptionUserPrefs = fontSize; }
+ void setFontSizeFromCaptionUserPrefs(int fontSize) { m_fontSizeFromCaptionUserPrefs = fontSize; }
protected:
VTTCueBox(Document&, VTTCue&);
- virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) override;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) override final;
VTTCue& m_cue;
int m_fontSizeFromCaptionUserPrefs;
class VTTCueBox;
class VTTScanner;
-class VTTRegion : public RefCounted<VTTRegion>, public ContextDestructionObserver {
+class VTTRegion final : public RefCounted<VTTRegion>, public ContextDestructionObserver {
public:
static PassRefPtr<VTTRegion> create(ScriptExecutionContext& context)
{
virtual void videoTrackSelectedChanged(VideoTrack*) = 0;
};
-class VideoTrack : public TrackBase, public VideoTrackPrivateClient {
+class VideoTrack final : public TrackBase, public VideoTrackPrivateClient {
public:
static PassRefPtr<VideoTrack> create(VideoTrackClient* client, PassRefPtr<VideoTrackPrivate> trackPrivate)
{
class VideoTrack;
-class VideoTrackList : public TrackListBase {
+class VideoTrackList final : public TrackListBase {
public:
static PassRefPtr<VideoTrackList> create(HTMLMediaElement* owner, ScriptExecutionContext* context)
{
return adoptRef(new VideoTrackList(owner, context));
}
- ~VideoTrackList();
+ virtual ~VideoTrackList();
VideoTrack* getTrackById(const AtomicString&) const;
long selectedIndex() const;
virtual void fileFailedToParse() = 0;
};
-class WebVTTCueData : public RefCounted<WebVTTCueData> {
+class WebVTTCueData final : public RefCounted<WebVTTCueData> {
public:
static PassRefPtr<WebVTTCueData> create() { return adoptRef(new WebVTTCueData()); }
- virtual ~WebVTTCueData() { }
+ ~WebVTTCueData() { }
MediaTime startTime() const { return m_startTime; }
void setStartTime(const MediaTime& startTime) { m_startTime = startTime; }
git://git.webkit.org / WebKit-https.git / commitdiff