jenkins-bot has submitted this change and it was merged.

Change subject: Update videojs-ogvjs to 1.3.1
......................................................................


Update videojs-ogvjs to 1.3.1

Includes a fix for fullscreent to work on iOS.

Change-Id: I3b71d3f42df3e457662263a3f26eb5d0cba97903
---
M package.json
M resources/videojs-ogvjs/videojs-ogvjs.js
2 files changed, 557 insertions(+), 552 deletions(-)

Approvals:
  TheDJ: Looks good to me, approved
  jenkins-bot: Verified



diff --git a/package.json b/package.json
index 05eb6ef..86aa812 100644
--- a/package.json
+++ b/package.json
@@ -15,7 +15,7 @@
     "grunt-patch": "^0.1.7",
     "jscs-preset-wikimedia": "~1.0.0",
     "video.js": "^5.10.1",
-    "videojs-ogvjs": "^1.2.0",
+    "videojs-ogvjs": "^1.3.1",
     "videojs-resolution-switcher": "^0.4.2",
     "videojs-responsive-layout": "^1.1.0"
   },
diff --git a/resources/videojs-ogvjs/videojs-ogvjs.js 
b/resources/videojs-ogvjs/videojs-ogvjs.js
index 8b7e3e6..369d4d8 100644
--- a/resources/videojs-ogvjs/videojs-ogvjs.js
+++ b/resources/videojs-ogvjs/videojs-ogvjs.js
@@ -1,6 +1,6 @@
 /**
  * videojs-ogvjs
- * @version 1.2.0
+ * @version 1.3.1
  * @copyright 2016 Derk-Jan Hartman
  * @license (MIT OR Apache-2.0)
  */
@@ -8,23 +8,11 @@
 (function (global){
 'use strict';
 
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
+exports.__esModule = true;
 
-var _createClass = (function () { function defineProperties(target, props) { 
for (var i = 0; i < props.length; i++) { var descriptor = props[i]; 
descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable 
= true; if ('value' in descriptor) descriptor.writable = true; 
Object.defineProperty(target, descriptor.key, descriptor); } } return function 
(Constructor, protoProps, staticProps) { if (protoProps) 
defineProperties(Constructor.prototype, protoProps); if (staticProps) 
defineProperties(Constructor, staticProps); return Constructor; }; })();
+var _video = (typeof window !== "undefined" ? window['videojs'] : typeof 
global !== "undefined" ? global['videojs'] : null);
 
-var _get = function get(_x, _x2, _x3) { var _again = true; _function: while 
(_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if 
(object === null) object = Function.prototype; var desc = 
Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { 
var parent = Object.getPrototypeOf(object); if (parent === null) { return 
undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; 
desc = parent = undefined; continue _function; } } else if ('value' in desc) { 
return desc.value; } else { var getter = desc.get; if (getter === undefined) { 
return undefined; } return getter.call(receiver); } } };
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 
'default': obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof 
Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== 
'function' && superClass !== null) { throw new TypeError('Super expression must 
either be null or a function, not ' + typeof superClass); } subClass.prototype 
= Object.create(superClass && superClass.prototype, { constructor: { value: 
subClass, enumerable: false, writable: true, configurable: true } }); if 
(superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, 
superClass) : subClass.__proto__ = superClass; }
-
-var _videoJs = (typeof window !== "undefined" ? window['videojs'] : typeof 
global !== "undefined" ? global['videojs'] : null);
-
-var _videoJs2 = _interopRequireDefault(_videoJs);
+var _video2 = _interopRequireDefault(_video);
 
 var _OGVCompat = (typeof window !== "undefined" ? window['OGVCompat'] : typeof 
global !== "undefined" ? global['OGVCompat'] : null);
 
@@ -38,7 +26,15 @@
 
 var _OGVPlayer2 = _interopRequireDefault(_OGVPlayer);
 
-var Tech = _videoJs2['default'].getComponent('Tech');
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 
'default': obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof 
Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new 
ReferenceError("this hasn't been initialised - super() hasn't been called"); } 
return call && (typeof call === "object" || typeof call === "function") ? call 
: self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== 
"function" && superClass !== null) { throw new TypeError("Super expression must 
either be null or a function, not " + typeof superClass); } subClass.prototype 
= Object.create(superClass && superClass.prototype, { constructor: { value: 
subClass, enumerable: false, writable: true, configurable: true } }); if 
(superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, 
superClass) : subClass.__proto__ = superClass; }
+
+var Tech = _video2['default'].getComponent('Tech');
 
 /**
  * Ogvjs Media Controller - Wrapper for Ogvjs Media API
@@ -49,31 +45,24 @@
  * @class Ogvjs
  */
 
-var Ogvjs = (function (_Tech) {
+var Ogvjs = function (_Tech) {
   _inherits(Ogvjs, _Tech);
 
   function Ogvjs(options, ready) {
     _classCallCheck(this, Ogvjs);
 
-    _get(Object.getPrototypeOf(Ogvjs.prototype), 'constructor', 
this).call(this, options, ready);
-
     // Set initial state of player
-    this.el_.src = options.source.src;
-    Ogvjs.setIfAvailable(this.el_, 'autoplay', options.autoplay);
-    Ogvjs.setIfAvailable(this.el_, 'loop', options.loop);
-    Ogvjs.setIfAvailable(this.el_, 'poster', options.poster);
-    Ogvjs.setIfAvailable(this.el_, 'preload', options.preload);
+    var _this = _possibleConstructorReturn(this, _Tech.call(this, options, 
ready));
 
-    this.triggerReady();
+    _this.el_.src = options.source.src;
+    Ogvjs.setIfAvailable(_this.el_, 'autoplay', options.autoplay);
+    Ogvjs.setIfAvailable(_this.el_, 'loop', options.loop);
+    Ogvjs.setIfAvailable(_this.el_, 'poster', options.poster);
+    Ogvjs.setIfAvailable(_this.el_, 'preload', options.preload);
+
+    _this.triggerReady();
+    return _this;
   }
-
-  /*
-   * Only set a value on an element if it has that property
-   *
-   * @param {Element} el
-   * @param {String} name
-   * @param value
-   */
 
   /**
    * Dispose of Ogvjs media element
@@ -81,571 +70,588 @@
    * @method dispose
    */
 
-  _createClass(Ogvjs, [{
-    key: 'dispose',
-    value: function dispose() {
-      this.el_.removeEventListener('framecallback', this.onFrameUpdate);
-      _get(Object.getPrototypeOf(Ogvjs.prototype), 'dispose', this).call(this);
+
+  Ogvjs.prototype.dispose = function dispose() {
+    this.el_.removeEventListener('framecallback', this.onFrameUpdate);
+    _Tech.prototype.dispose.call(this);
+  };
+
+  /**
+   * Create the component's DOM element
+   *
+   * @return {Element}
+   * @method createEl
+   */
+
+
+  Ogvjs.prototype.createEl = function createEl() {
+    var options = this.options_;
+
+    if (options.base) {
+      _OGVLoader2['default'].base = options.base;
+    } else {
+      throw new Error('Please specify the base for the ogv.js library');
     }
 
-    /**
-     * Create the component's DOM element
-     *
-     * @return {Element}
-     * @method createEl
-     */
-  }, {
-    key: 'createEl',
-    value: function createEl() {
-      var options = this.options_;
+    var el = new _OGVPlayer2['default'](options);
 
-      if (options.base) {
-        _OGVLoader2['default'].base = options.base;
-      } else {
-        throw new Error('Please specify the base for the ogv.js library');
-      }
-
-      var el = new _OGVPlayer2['default'](options);
-
-      if (!el.hasOwnProperty('preload')) {
-        // simulate timeupdate events for older ogv.js versions pre 1.1 
versions
-        // needed for subtitles. preload is only defined in 1.1 and later,
-        this.lastTime = 0;
-        el.addEventListener('framecallback', this.onFrameUpdate.bind(this));
-      }
-
-      el.className += ' vjs-tech';
-      options.tag = el;
-
-      return el;
-    }
-  }, {
-    key: 'onFrameUpdate',
-    value: function onFrameUpdate(event) {
-      var timeupdateInterval = 0.25;
-      var now = this.el_ ? this.el_.currentTime : this.lastTime;
-
-      // Don't spam time updates on every frame
-      if (Math.abs(now - this.lastTime) >= timeupdateInterval) {
-        this.lastTime = now;
-        this.trigger('timeupdate');
-        this.trigger('durationchange');
-      }
+    if (!el.hasOwnProperty('preload')) {
+      // simulate timeupdate events for older ogv.js versions pre 1.1 versions
+      // needed for subtitles. preload is only defined in 1.1 and later,
+      this.lastTime = 0;
+      el.addEventListener('framecallback', this.onFrameUpdate.bind(this));
     }
 
-    /**
-     * Play for Ogvjs tech
-     *
-     * @method play
-     */
-  }, {
-    key: 'play',
-    value: function play() {
-      this.el_.play();
-    }
+    el.className += ' vjs-tech';
+    options.tag = el;
 
-    /**
-     * Pause for Ogvjs tech
-     *
-     * @method pause
-     */
-  }, {
-    key: 'pause',
-    value: function pause() {
-      this.el_.pause();
-    }
+    return el;
+  };
 
-    /**
-     * Paused for Ogvjs tech
-     *
-     * @return {Boolean}
-     * @method paused
-     */
-  }, {
-    key: 'paused',
-    value: function paused() {
-      return this.el_.paused;
-    }
+  Ogvjs.prototype.onFrameUpdate = function onFrameUpdate(event) {
+    var timeupdateInterval = 0.25;
+    var now = this.el_ ? this.el_.currentTime : this.lastTime;
 
-    /**
-     * Get current time
-     *
-     * @return {Number}
-     * @method currentTime
-     */
-  }, {
-    key: 'currentTime',
-    value: function currentTime() {
-      return this.el_.currentTime;
+    // Don't spam time updates on every frame
+    if (Math.abs(now - this.lastTime) >= timeupdateInterval) {
+      this.lastTime = now;
+      this.trigger('timeupdate');
+      this.trigger('durationchange');
     }
+  };
 
-    /**
-     * Set current time
-     *
-     * @param {Number} seconds Current time of video
-     * @method setCurrentTime
-     */
-  }, {
-    key: 'setCurrentTime',
-    value: function setCurrentTime(seconds) {
-      try {
-        this.el_.currentTime = seconds;
-      } catch (e) {
-        _videoJs2['default'].log(e, 'Video is not ready. (Video.js)');
-      }
-    }
+  /**
+   * Play for Ogvjs tech
+   *
+   * @method play
+   */
 
-    /**
-     * Get duration
-     *
-     * @return {Number}
-     * @method duration
-     */
-  }, {
-    key: 'duration',
-    value: function duration() {
-      return this.el_.duration || 0;
-    }
 
-    /**
-     * Get a TimeRange object that represents the intersection
-     * of the time ranges for which the user agent has all
-     * relevant media
-     *
-     * @return {TimeRangeObject}
-     * @method buffered
-     */
-  }, {
-    key: 'buffered',
-    value: function buffered() {
-      return this.el_.buffered;
-    }
+  Ogvjs.prototype.play = function play() {
+    this.el_.play();
+  };
 
-    /**
-     * Get volume level
-     *
-     * @return {Number}
-     * @method volume
-     */
-  }, {
-    key: 'volume',
-    value: function volume() {
-      return this.el_.hasOwnProperty('volume') ? this.el_.volume : 1;
-    }
+  /**
+   * Pause for Ogvjs tech
+   *
+   * @method pause
+   */
 
-    /**
-     * Set volume level
-     *
-     * @param {Number} percentAsDecimal Volume percent as a decimal
-     * @method setVolume
-     */
-  }, {
-    key: 'setVolume',
-    value: function setVolume(percentAsDecimal) {
-      if (this.el_.hasOwnProperty('volume')) {
-        this.el_.volume = percentAsDecimal;
-      }
-    }
 
-    /**
-     * Get if muted
-     *
-     * @return {Boolean}
-     * @method muted
-     */
-  }, {
-    key: 'muted',
-    value: function muted() {
-      return this.el_.muted;
-    }
+  Ogvjs.prototype.pause = function pause() {
+    this.el_.pause();
+  };
 
-    /**
-     * Set muted
-     *
-     * @param {Boolean} If player is to be muted or note
-     * @method setMuted
-     */
-  }, {
-    key: 'setMuted',
-    value: function setMuted(muted) {
-      this.el_.muted = !!muted;
-    }
+  /**
+   * Paused for Ogvjs tech
+   *
+   * @return {Boolean}
+   * @method paused
+   */
 
-    /**
-     * Get player width
-     *
-     * @return {Number}
-     * @method width
-     */
-  }, {
-    key: 'width',
-    value: function width() {
-      return this.el_.offsetWidth;
-    }
 
-    /**
-     * Get player height
-     *
-     * @return {Number}
-     * @method height
-     */
-  }, {
-    key: 'height',
-    value: function height() {
-      return this.el_.offsetHeight;
-    }
+  Ogvjs.prototype.paused = function paused() {
+    return this.el_.paused;
+  };
 
-    /**
-     * Get/set video
-     *
-     * @param {Object=} src Source object
-     * @return {Object}
-     * @method src
-     */
-  }, {
-    key: 'src',
-    value: function src(_src) {
-      if (typeof _src === 'undefined') {
-        return this.el_.src;
-      }
-      // Setting src through `src` instead of `setSrc` will be deprecated
-      this.setSrc(_src);
-    }
+  /**
+   * Get current time
+   *
+   * @return {Number}
+   * @method currentTime
+   */
 
-    /**
-     * Set video
-     *
-     * @param {Object} src Source object
-     * @deprecated
-     * @method setSrc
-     */
-  }, {
-    key: 'setSrc',
-    value: function setSrc(src) {
-      this.el_.src = src;
-    }
 
-    /**
-     * Load media into player
-     *
-     * @method load
-     */
-  }, {
-    key: 'load',
-    value: function load() {
-      this.el_.load();
-    }
+  Ogvjs.prototype.currentTime = function currentTime() {
+    return this.el_.currentTime;
+  };
 
-    /**
-     * Get current source
-     *
-     * @return {Object}
-     * @method currentSrc
-     */
-  }, {
-    key: 'currentSrc',
-    value: function currentSrc() {
-      if (this.currentSource_) {
-        return this.currentSource_.src;
-      }
-      return this.el_.currentSrc;
-    }
+  /**
+   * Set current time
+   *
+   * @param {Number} seconds Current time of video
+   * @method setCurrentTime
+   */
 
-    /**
-     * Get poster
-     *
-     * @return {String}
-     * @method poster
-     */
-  }, {
-    key: 'poster',
-    value: function poster() {
-      return this.el_.poster;
-    }
 
-    /**
-     * Set poster
-     *
-     * @param {String} val URL to poster image
-     * @method
-     */
-  }, {
-    key: 'setPoster',
-    value: function setPoster(val) {
-      this.el_.poster = val;
+  Ogvjs.prototype.setCurrentTime = function setCurrentTime(seconds) {
+    try {
+      this.el_.currentTime = seconds;
+    } catch (e) {
+      _video2['default'].log(e, 'Video is not ready. (Video.js)');
     }
+  };
 
-    /**
-     * Get preload attribute
-     *
-     * @return {String}
-     * @method preload
-     */
-  }, {
-    key: 'preload',
-    value: function preload() {
-      return this.el_.preload || 'none';
-    }
+  /**
+   * Get duration
+   *
+   * @return {Number}
+   * @method duration
+   */
 
-    /**
-     * Set preload attribute
-     *
-     * @param {String} val Value for preload attribute
-     * @method setPreload
-     */
-  }, {
-    key: 'setPreload',
-    value: function setPreload(val) {
-      if (this.el_.hasOwnProperty('preload')) {
-        this.el_.preload = val;
-      }
-    }
 
-    /**
-     * Get autoplay attribute
-     *
-     * @return {Boolean}
-     * @method autoplay
-     */
-  }, {
-    key: 'autoplay',
-    value: function autoplay() {
-      return this.el_.autoplay || false;
-    }
+  Ogvjs.prototype.duration = function duration() {
+    return this.el_.duration || 0;
+  };
 
-    /**
-     * Set autoplay attribute
-     *
-     * @param {Boolean} val Value for preload attribute
-     * @method setAutoplay
-     */
-  }, {
-    key: 'setAutoplay',
-    value: function setAutoplay(val) {
-      if (this.el_.hasOwnProperty('autoplay')) {
-        this.el_.autoplay = !!val;
-        return;
-      }
-    }
+  /**
+   * Get a TimeRange object that represents the intersection
+   * of the time ranges for which the user agent has all
+   * relevant media
+   *
+   * @return {TimeRangeObject}
+   * @method buffered
+   */
 
-    /**
-     * Get controls attribute
-     *
-     * @return {Boolean}
-     * @method controls
-     */
-  }, {
-    key: 'controls',
-    value: function controls() {
-      return this.el_controls || false;
-    }
 
-    /**
-     * Set controls attribute
-     *
-     * @param {Boolean} val Value for controls attribute
-     * @method setControls
-     */
-  }, {
-    key: 'setControls',
-    value: function setControls(val) {
-      if (this.el_.hasOwnProperty('controls')) {
-        this.el_.controls = !!val;
-      }
-    }
+  Ogvjs.prototype.buffered = function buffered() {
+    return this.el_.buffered;
+  };
 
-    /**
-     * Get loop attribute
-     *
-     * @return {Boolean}
-     * @method loop
-     */
-  }, {
-    key: 'loop',
-    value: function loop() {
-      return this.el_.loop || false;
-    }
+  /**
+   * Get volume level
+   *
+   * @return {Number}
+   * @method volume
+   */
 
-    /**
-     * Set loop attribute
-     *
-     * @param {Boolean} val Value for loop attribute
-     * @method setLoop
-     */
-  }, {
-    key: 'setLoop',
-    value: function setLoop(val) {
-      if (this.el_.hasOwnProperty('loop')) {
-        this.el_.loop = !!val;
-      }
-    }
 
-    /**
-     * Get error value
-     *
-     * @return {String}
-     * @method error
-     */
-  }, {
-    key: 'error',
-    value: function error() {
-      return this.el_.error;
-    }
+  Ogvjs.prototype.volume = function volume() {
+    return this.el_.hasOwnProperty('volume') ? this.el_.volume : 1;
+  };
 
-    /**
-     * Get whether or not the player is in the "seeking" state
-     *
-     * @return {Boolean}
-     * @method seeking
-     */
-  }, {
-    key: 'seeking',
-    value: function seeking() {
-      return this.el_.seeking;
-    }
+  /**
+   * Set volume level
+   *
+   * @param {Number} percentAsDecimal Volume percent as a decimal
+   * @method setVolume
+   */
 
-    /**
-     * Get a TimeRanges object that represents the
-     * ranges of the media resource to which it is possible
-     * for the user agent to seek.
-     *
-     * @return {TimeRangeObject}
-     * @method seekable
-     */
-  }, {
-    key: 'seekable',
-    value: function seekable() {
-      return this.el_.seekable;
-    }
 
-    /**
-     * Get if video ended
-     *
-     * @return {Boolean}
-     * @method ended
-     */
-  }, {
-    key: 'ended',
-    value: function ended() {
-      return this.el_.ended;
+  Ogvjs.prototype.setVolume = function setVolume(percentAsDecimal) {
+    if (this.el_.hasOwnProperty('volume')) {
+      this.el_.volume = percentAsDecimal;
     }
+  };
 
-    /**
-     * Get the value of the muted content attribute
-     * This attribute has no dynamic effect, it only
-     * controls the default state of the element
-     *
-     * @return {Boolean}
-     * @method defaultMuted
-     */
-  }, {
-    key: 'defaultMuted',
-    value: function defaultMuted() {
-      return this.el_.defaultMuted || false;
-    }
+  /**
+   * Get if muted
+   *
+   * @return {Boolean}
+   * @method muted
+   */
 
-    /**
-     * Get desired speed at which the media resource is to play
-     *
-     * @return {Number}
-     * @method playbackRate
-     */
-  }, {
-    key: 'playbackRate',
-    value: function playbackRate() {
-      return this.el_.playbackRate || 1;
-    }
 
-    /**
-     * Returns a TimeRanges object that represents the ranges of the
-     * media resource that the user agent has played.
-     * @return {TimeRangeObject} the range of points on the media
-     * timeline that has been reached through normal playback
-     * @see 
https://html.spec.whatwg.org/multipage/embedded-content.html#dom-media-played
-     */
-  }, {
-    key: 'played',
-    value: function played() {
-      return this.el_.played;
-    }
+  Ogvjs.prototype.muted = function muted() {
+    return this.el_.muted;
+  };
 
-    /**
-     * Set desired speed at which the media resource is to play
-     *
-     * @param {Number} val Speed at which the media resource is to play
-     * @method setPlaybackRate
-     */
-  }, {
-    key: 'setPlaybackRate',
-    value: function setPlaybackRate(val) {
-      if (this.el_.hasOwnProperty('playbackRate')) {
-        this.el_.playbackRate = val;
-      }
-    }
+  /**
+   * Set muted
+   *
+   * @param {Boolean} If player is to be muted or note
+   * @method setMuted
+   */
 
-    /**
-     * Get the current state of network activity for the element, from
-     * the list below
-     * NETWORK_EMPTY (numeric value 0)
-     * NETWORK_IDLE (numeric value 1)
-     * NETWORK_LOADING (numeric value 2)
-     * NETWORK_NO_SOURCE (numeric value 3)
-     *
-     * @return {Number}
-     * @method networkState
-     */
-  }, {
-    key: 'networkState',
-    value: function networkState() {
-      return this.el_.networkState;
-    }
 
-    /**
-     * Get a value that expresses the current state of the element
-     * with respect to rendering the current playback position, from
-     * the codes in the list below
-     * HAVE_NOTHING (numeric value 0)
-     * HAVE_METADATA (numeric value 1)
-     * HAVE_CURRENT_DATA (numeric value 2)
-     * HAVE_FUTURE_DATA (numeric value 3)
-     * HAVE_ENOUGH_DATA (numeric value 4)
-     *
-     * @return {Number}
-     * @method readyState
-     */
-  }, {
-    key: 'readyState',
-    value: function readyState() {
-      return this.el_.readyState;
-    }
+  Ogvjs.prototype.setMuted = function setMuted(muted) {
+    this.el_.muted = !!muted;
+  };
 
-    /**
-     * Get width of video
-     *
-     * @return {Number}
-     * @method videoWidth
-     */
-  }, {
-    key: 'videoWidth',
-    value: function videoWidth() {
-      return this.el_.videoWidth;
-    }
+  /**
+   * Get player width
+   *
+   * @return {Number}
+   * @method width
+   */
 
-    /**
-     * Get height of video
-     *
-     * @return {Number}
-     * @method videoHeight
-     */
-  }, {
-    key: 'videoHeight',
-    value: function videoHeight() {
-      return this.el_.videoHeight;
+
+  Ogvjs.prototype.width = function width() {
+    return this.el_.offsetWidth;
+  };
+
+  /**
+   * Get player height
+   *
+   * @return {Number}
+   * @method height
+   */
+
+
+  Ogvjs.prototype.height = function height() {
+    return this.el_.offsetHeight;
+  };
+
+  /**
+   * Get/set video
+   *
+   * @param {Object=} src Source object
+   * @return {Object}
+   * @method src
+   */
+
+
+  Ogvjs.prototype.src = function src(_src) {
+    if (typeof _src === 'undefined') {
+      return this.el_.src;
     }
-  }]);
+    // Setting src through `src` instead of `setSrc` will be deprecated
+    this.setSrc(_src);
+  };
+
+  /**
+   * Set video
+   *
+   * @param {Object} src Source object
+   * @deprecated
+   * @method setSrc
+   */
+
+
+  Ogvjs.prototype.setSrc = function setSrc(src) {
+    this.el_.src = src;
+  };
+
+  /**
+   * Load media into player
+   *
+   * @method load
+   */
+
+
+  Ogvjs.prototype.load = function load() {
+    this.el_.load();
+  };
+
+  /**
+   * Get current source
+   *
+   * @return {Object}
+   * @method currentSrc
+   */
+
+
+  Ogvjs.prototype.currentSrc = function currentSrc() {
+    if (this.currentSource_) {
+      return this.currentSource_.src;
+    }
+    return this.el_.currentSrc;
+  };
+
+  /**
+   * Get poster
+   *
+   * @return {String}
+   * @method poster
+   */
+
+
+  Ogvjs.prototype.poster = function poster() {
+    return this.el_.poster;
+  };
+
+  /**
+   * Set poster
+   *
+   * @param {String} val URL to poster image
+   * @method
+   */
+
+
+  Ogvjs.prototype.setPoster = function setPoster(val) {
+    this.el_.poster = val;
+  };
+
+  /**
+   * Get preload attribute
+   *
+   * @return {String}
+   * @method preload
+   */
+
+
+  Ogvjs.prototype.preload = function preload() {
+    return this.el_.preload || 'none';
+  };
+
+  /**
+   * Set preload attribute
+   *
+   * @param {String} val Value for preload attribute
+   * @method setPreload
+   */
+
+
+  Ogvjs.prototype.setPreload = function setPreload(val) {
+    if (this.el_.hasOwnProperty('preload')) {
+      this.el_.preload = val;
+    }
+  };
+
+  /**
+   * Get autoplay attribute
+   *
+   * @return {Boolean}
+   * @method autoplay
+   */
+
+
+  Ogvjs.prototype.autoplay = function autoplay() {
+    return this.el_.autoplay || false;
+  };
+
+  /**
+   * Set autoplay attribute
+   *
+   * @param {Boolean} val Value for preload attribute
+   * @method setAutoplay
+   */
+
+
+  Ogvjs.prototype.setAutoplay = function setAutoplay(val) {
+    if (this.el_.hasOwnProperty('autoplay')) {
+      this.el_.autoplay = !!val;
+      return;
+    }
+  };
+
+  /**
+   * Get controls attribute
+   *
+   * @return {Boolean}
+   * @method controls
+   */
+
+
+  Ogvjs.prototype.controls = function controls() {
+    return this.el_controls || false;
+  };
+
+  /**
+   * Set controls attribute
+   *
+   * @param {Boolean} val Value for controls attribute
+   * @method setControls
+   */
+
+
+  Ogvjs.prototype.setControls = function setControls(val) {
+    if (this.el_.hasOwnProperty('controls')) {
+      this.el_.controls = !!val;
+    }
+  };
+
+  /**
+   * Get loop attribute
+   *
+   * @return {Boolean}
+   * @method loop
+   */
+
+
+  Ogvjs.prototype.loop = function loop() {
+    return this.el_.loop || false;
+  };
+
+  /**
+   * Set loop attribute
+   *
+   * @param {Boolean} val Value for loop attribute
+   * @method setLoop
+   */
+
+
+  Ogvjs.prototype.setLoop = function setLoop(val) {
+    if (this.el_.hasOwnProperty('loop')) {
+      this.el_.loop = !!val;
+    }
+  };
+
+  /**
+   * Get error value
+   *
+   * @return {String}
+   * @method error
+   */
+
+
+  Ogvjs.prototype.error = function error() {
+    return this.el_.error;
+  };
+
+  /**
+   * Get whether or not the player is in the "seeking" state
+   *
+   * @return {Boolean}
+   * @method seeking
+   */
+
+
+  Ogvjs.prototype.seeking = function seeking() {
+    return this.el_.seeking;
+  };
+
+  /**
+   * Get a TimeRanges object that represents the
+   * ranges of the media resource to which it is possible
+   * for the user agent to seek.
+   *
+   * @return {TimeRangeObject}
+   * @method seekable
+   */
+
+
+  Ogvjs.prototype.seekable = function seekable() {
+    return this.el_.seekable;
+  };
+
+  /**
+   * Get if video ended
+   *
+   * @return {Boolean}
+   * @method ended
+   */
+
+
+  Ogvjs.prototype.ended = function ended() {
+    return this.el_.ended;
+  };
+
+  /**
+   * Get the value of the muted content attribute
+   * This attribute has no dynamic effect, it only
+   * controls the default state of the element
+   *
+   * @return {Boolean}
+   * @method defaultMuted
+   */
+
+
+  Ogvjs.prototype.defaultMuted = function defaultMuted() {
+    return this.el_.defaultMuted || false;
+  };
+
+  /**
+   * Get desired speed at which the media resource is to play
+   *
+   * @return {Number}
+   * @method playbackRate
+   */
+
+
+  Ogvjs.prototype.playbackRate = function playbackRate() {
+    return this.el_.playbackRate || 1;
+  };
+
+  /**
+   * Returns a TimeRanges object that represents the ranges of the
+   * media resource that the user agent has played.
+   * @return {TimeRangeObject} the range of points on the media
+   * timeline that has been reached through normal playback
+   * @see 
https://html.spec.whatwg.org/multipage/embedded-content.html#dom-media-played
+   */
+
+
+  Ogvjs.prototype.played = function played() {
+    return this.el_.played;
+  };
+
+  /**
+   * Set desired speed at which the media resource is to play
+   *
+   * @param {Number} val Speed at which the media resource is to play
+   * @method setPlaybackRate
+   */
+
+
+  Ogvjs.prototype.setPlaybackRate = function setPlaybackRate(val) {
+    if (this.el_.hasOwnProperty('playbackRate')) {
+      this.el_.playbackRate = val;
+    }
+  };
+
+  /**
+   * Get the current state of network activity for the element, from
+   * the list below
+   * NETWORK_EMPTY (numeric value 0)
+   * NETWORK_IDLE (numeric value 1)
+   * NETWORK_LOADING (numeric value 2)
+   * NETWORK_NO_SOURCE (numeric value 3)
+   *
+   * @return {Number}
+   * @method networkState
+   */
+
+
+  Ogvjs.prototype.networkState = function networkState() {
+    return this.el_.networkState;
+  };
+
+  /**
+   * Get a value that expresses the current state of the element
+   * with respect to rendering the current playback position, from
+   * the codes in the list below
+   * HAVE_NOTHING (numeric value 0)
+   * HAVE_METADATA (numeric value 1)
+   * HAVE_CURRENT_DATA (numeric value 2)
+   * HAVE_FUTURE_DATA (numeric value 3)
+   * HAVE_ENOUGH_DATA (numeric value 4)
+   *
+   * @return {Number}
+   * @method readyState
+   */
+
+
+  Ogvjs.prototype.readyState = function readyState() {
+    return this.el_.readyState;
+  };
+
+  /**
+   * Get width of video
+   *
+   * @return {Number}
+   * @method videoWidth
+   */
+
+
+  Ogvjs.prototype.videoWidth = function videoWidth() {
+    return this.el_.videoWidth;
+  };
+
+  /**
+   * Get height of video
+   *
+   * @return {Number}
+   * @method videoHeight
+   */
+
+
+  Ogvjs.prototype.videoHeight = function videoHeight() {
+    return this.el_.videoHeight;
+  };
+
+  /**
+   * The technology has no native fullscreen
+   * This is important on iOS, where we have to fallback to
+   * fullWindow mode due to lack of HTML5 fullscreen api
+   */
+
+
+  Ogvjs.prototype.supportsFullScreen = function supportsFullScreen() {
+    return false;
+  };
 
   return Ogvjs;
-})(Tech);
+}(Tech);
+
+/*
+ * Only set a value on an element if it has that property
+ *
+ * @param {Element} el
+ * @param {String} name
+ * @param value
+ */
+
 
 Ogvjs.setIfAvailable = function (el, name, value) {
   if (el.hasOwnProperty(name)) {
@@ -757,7 +763,6 @@
 
 Tech.registerTech('Ogvjs', Ogvjs);
 exports['default'] = Ogvjs;
-module.exports = exports['default'];
 }).call(this,typeof global !== "undefined" ? global : typeof self !== 
"undefined" ? self : typeof window !== "undefined" ? window : {})
 },{}]},{},[1])(1)
 });
\ No newline at end of file

-- 
To view, visit https://gerrit.wikimedia.org/r/314728
To unsubscribe, visit https://gerrit.wikimedia.org/r/settings

Gerrit-MessageType: merged
Gerrit-Change-Id: I3b71d3f42df3e457662263a3f26eb5d0cba97903
Gerrit-PatchSet: 2
Gerrit-Project: mediawiki/extensions/TimedMediaHandler
Gerrit-Branch: master
Gerrit-Owner: Paladox <thomasmulhall...@yahoo.com>
Gerrit-Reviewer: Brion VIBBER <br...@wikimedia.org>
Gerrit-Reviewer: TheDJ <hartman.w...@gmail.com>
Gerrit-Reviewer: jenkins-bot <>

_______________________________________________
MediaWiki-commits mailing list
MediaWiki-commits@lists.wikimedia.org
https://lists.wikimedia.org/mailman/listinfo/mediawiki-commits

Reply via email to