Use ::-internal-media-controls* instead of ::-webkit-media-controls*

Source/core/html/shadow/MediaControlElements.cpp

 /*
  * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 82 matching lines @@
 {
 }
 
 PassRefPtrWillBeRawPtr<MediaControlPanelElement> MediaControlPanelElement::create(MediaControls& mediaControls)
 {
     return adoptRefWillBeNoop(new MediaControlPanelElement(mediaControls));
 }
 
 const AtomicString& MediaControlPanelElement::shadowPseudoId() const
 {
-    DEFINE_STATIC_LOCAL(AtomicString, id, ("-webkit-media-controls-panel", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, id, ("-internal-media-controls-panel", AtomicString::ConstructFromLiteral));
     return id;
 }
 
 void MediaControlPanelElement::defaultEventHandler(Event* event)
 {
     // Suppress the media element activation behavior (toggle play/pause) when
     // any part of the control panel is clicked.
     if (event->type() == EventTypeNames::click) {
         event->setDefaultHandled();
         return;
@@ skipping 67 matching lines @@
 {
 }
 
 PassRefPtrWillBeRawPtr<MediaControlPanelEnclosureElement> MediaControlPanelEnclosureElement::create(MediaControls& mediaControls)
 {
     return adoptRefWillBeNoop(new MediaControlPanelEnclosureElement(mediaControls));
 }
 
 const AtomicString& MediaControlPanelEnclosureElement::shadowPseudoId() const
 {
-    DEFINE_STATIC_LOCAL(AtomicString, id, ("-webkit-media-controls-enclosure", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, id, ("-internal-media-controls-enclosure", AtomicString::ConstructFromLiteral));
     return id;
 }
 
 // ----------------------------
 
 MediaControlOverlayEnclosureElement::MediaControlOverlayEnclosureElement(MediaControls& mediaControls)
     // Mapping onto same MediaControlElementType as panel element, since it has similar properties.
     : MediaControlDivElement(mediaControls, MediaControlsPanel)
 {
 }
 
 PassRefPtrWillBeRawPtr<MediaControlOverlayEnclosureElement> MediaControlOverlayEnclosureElement::create(MediaControls& mediaControls)
 {
     return adoptRefWillBeNoop(new MediaControlOverlayEnclosureElement(mediaControls));
 }
 
 const AtomicString& MediaControlOverlayEnclosureElement::shadowPseudoId() const
 {
-    DEFINE_STATIC_LOCAL(AtomicString, id, ("-webkit-media-controls-overlay-enclosure", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, id, ("-internal-media-controls-overlay-enclosure", AtomicString::ConstructFromLiteral));
     return id;
 }
 
 void* MediaControlOverlayEnclosureElement::preDispatchEventHandler(Event* event)
 {
     // When the media element is clicked or touched we want to make the overlay cast button visible
     // (if the other requirements are right) even if JavaScript is doing its own handling of the event.
     // Doing it in preDispatchEventHandler prevents any interference from JavaScript.
     // Note that we can't simply test for click, since JS handling of touch events can prevent their translation to click events.
     if (event && (event->type() == EventTypeNames::click || event->type() == EventTypeNames::touchstart) && mediaElement().hasRemoteRoutes() && !mediaElement().shouldShowControls())
@@ skipping 27 matching lines @@
     HTMLInputElement::defaultEventHandler(event);
 }
 
 void MediaControlMuteButtonElement::updateDisplayType()
 {
     setDisplayType(mediaElement().muted() ? MediaUnMuteButton : MediaMuteButton);
 }
 
 const AtomicString& MediaControlMuteButtonElement::shadowPseudoId() const
 {
-    DEFINE_STATIC_LOCAL(AtomicString, id, ("-webkit-media-controls-mute-button", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, id, ("-internal-media-controls-mute-button", AtomicString::ConstructFromLiteral));
     return id;
 }
 
 // ----------------------------
 
 MediaControlPlayButtonElement::MediaControlPlayButtonElement(MediaControls& mediaControls)
     : MediaControlInputElement(mediaControls, MediaPlayButton)
 {
 }
 
@@ skipping 15 matching lines @@
     HTMLInputElement::defaultEventHandler(event);
 }
 
 void MediaControlPlayButtonElement::updateDisplayType()
 {
     setDisplayType(mediaElement().togglePlayStateWillPlay() ? MediaPlayButton : MediaPauseButton);
 }
 
 const AtomicString& MediaControlPlayButtonElement::shadowPseudoId() const
 {
-    DEFINE_STATIC_LOCAL(AtomicString, id, ("-webkit-media-controls-play-button", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, id, ("-internal-media-controls-play-button", AtomicString::ConstructFromLiteral));
     return id;
 }
 
 // ----------------------------
 
 MediaControlOverlayPlayButtonElement::MediaControlOverlayPlayButtonElement(MediaControls& mediaControls)
     : MediaControlInputElement(mediaControls, MediaOverlayPlayButton)
 {
 }
 
@@ skipping 17 matching lines @@
 void MediaControlOverlayPlayButtonElement::updateDisplayType()
 {
     if (mediaElement().shouldShowControls() && mediaElement().togglePlayStateWillPlay())
         show();
     else
         hide();
 }
 
 const AtomicString& MediaControlOverlayPlayButtonElement::shadowPseudoId() const
 {
-    DEFINE_STATIC_LOCAL(AtomicString, id, ("-webkit-media-controls-overlay-play-button", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, id, ("-internal-media-controls-overlay-play-button", AtomicString::ConstructFromLiteral));
     return id;
 }
 
 bool MediaControlOverlayPlayButtonElement::keepEventInNode(Event* event)
 {
     return isUserInteractionEvent(event);
 }
 
 
 // ----------------------------
@@ skipping 26 matching lines @@
         setChecked(mediaElement().closedCaptionsVisible());
         updateDisplayType();
         event->setDefaultHandled();
     }
 
     HTMLInputElement::defaultEventHandler(event);
 }
 
 const AtomicString& MediaControlToggleClosedCaptionsButtonElement::shadowPseudoId() const
 {
-    DEFINE_STATIC_LOCAL(AtomicString, id, ("-webkit-media-controls-toggle-closed-captions-button", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, id, ("-internal-media-controls-toggle-closed-captions-button", AtomicString::ConstructFromLiteral));
     return id;
 }
 
 // ----------------------------
 
 MediaControlTimelineElement::MediaControlTimelineElement(MediaControls& mediaControls)
     : MediaControlInputElement(mediaControls, MediaSlider)
 {
 }
 
@@ skipping 52 matching lines @@
     setValue(String::number(currentTime));
 }
 
 void MediaControlTimelineElement::setDuration(double duration)
 {
     setFloatingPointAttribute(maxAttr, std::isfinite(duration) ? duration : 0);
 }
 
 const AtomicString& MediaControlTimelineElement::shadowPseudoId() const
 {
-    DEFINE_STATIC_LOCAL(AtomicString, id, ("-webkit-media-controls-timeline", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, id, ("-internal-media-controls-timeline", AtomicString::ConstructFromLiteral));
     return id;
 }
 
 bool MediaControlTimelineElement::keepEventInNode(Event* event)
 {
     return isUserInteractionEventForSlider(event);
 }
 
 // ----------------------------
 
@@ skipping 47 matching lines @@
 }
 
 void MediaControlVolumeSliderElement::setVolume(double volume)
 {
     if (value().toDouble() != volume)
         setValue(String::number(volume));
 }
 
 const AtomicString& MediaControlVolumeSliderElement::shadowPseudoId() const
 {
-    DEFINE_STATIC_LOCAL(AtomicString, id, ("-webkit-media-controls-volume-slider", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, id, ("-internal-media-controls-volume-slider", AtomicString::ConstructFromLiteral));
     return id;
 }
 
 bool MediaControlVolumeSliderElement::keepEventInNode(Event* event)
 {
     return isUserInteractionEventForSlider(event);
 }
 
 // ----------------------------
 
@@ skipping 18 matching lines @@
             mediaElement().exitFullscreen();
         else
             mediaElement().enterFullscreen();
         event->setDefaultHandled();
     }
     HTMLInputElement::defaultEventHandler(event);
 }
 
 const AtomicString& MediaControlFullscreenButtonElement::shadowPseudoId() const
 {
-    DEFINE_STATIC_LOCAL(AtomicString, id, ("-webkit-media-controls-fullscreen-button", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, id, ("-internal-media-controls-fullscreen-button", AtomicString::ConstructFromLiteral));
     return id;
 }
 
 void MediaControlFullscreenButtonElement::setIsFullscreen(bool isFullscreen)
 {
     setDisplayType(isFullscreen ? MediaExitFullscreenButton : MediaEnterFullscreenButton);
 }
 
 // ----------------------------
 
@@ skipping 46 matching lines @@
 {
 }
 
 PassRefPtrWillBeRawPtr<MediaControlTimeRemainingDisplayElement> MediaControlTimeRemainingDisplayElement::create(MediaControls& mediaControls)
 {
     return adoptRefWillBeNoop(new MediaControlTimeRemainingDisplayElement(mediaControls));
 }
 
 static const AtomicString& getMediaControlTimeRemainingDisplayElementShadowPseudoId()
 {
-    DEFINE_STATIC_LOCAL(AtomicString, id, ("-webkit-media-controls-time-remaining-display", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, id, ("-internal-media-controls-time-remaining-display", AtomicString::ConstructFromLiteral));
     return id;
 }
 
 const AtomicString& MediaControlTimeRemainingDisplayElement::shadowPseudoId() const
 {
     return getMediaControlTimeRemainingDisplayElementShadowPseudoId();
 }
 
 // ----------------------------
 
 MediaControlCurrentTimeDisplayElement::MediaControlCurrentTimeDisplayElement(MediaControls& mediaControls)
     : MediaControlTimeDisplayElement(mediaControls, MediaCurrentTimeDisplay)
 {
 }
 
 PassRefPtrWillBeRawPtr<MediaControlCurrentTimeDisplayElement> MediaControlCurrentTimeDisplayElement::create(MediaControls& mediaControls)
 {
     return adoptRefWillBeNoop(new MediaControlCurrentTimeDisplayElement(mediaControls));
 }
 
 static const AtomicString& getMediaControlCurrentTimeDisplayElementShadowPseudoId()
 {
-    DEFINE_STATIC_LOCAL(AtomicString, id, ("-webkit-media-controls-current-time-display", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, id, ("-internal-media-controls-current-time-display", AtomicString::ConstructFromLiteral));
     return id;
 }
 
 const AtomicString& MediaControlCurrentTimeDisplayElement::shadowPseudoId() const
 {
     return getMediaControlCurrentTimeDisplayElementShadowPseudoId();
 }
 
 // ----------------------------
 
@@ skipping 113 matching lines @@
     float fontSize = smallestDimension * 0.05f;
     if (fontSize != m_fontSize) {
         m_fontSize = fontSize;
         setInlineStyleProperty(CSSPropertyFontSize, fontSize, CSSPrimitiveValue::CSS_PX);
     }
 }
 
 // ----------------------------
 
 } // namespace blink