OLD | NEW |
| (Empty) |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 // The PlayerUtils provides utility functions to binding common media events | |
6 // to specific player functions. It also provides functions to load media source | |
7 // base on test configurations. | |
8 var PlayerUtils = new function() { | |
9 } | |
10 | |
11 // Prepares a video element for playback by setting default event handlers | |
12 // and source attribute. | |
13 PlayerUtils.registerDefaultEventListeners = function(player) { | |
14 Utils.timeLog('Registering video event handlers.'); | |
15 // Map from event name to event listener function name. It is common for | |
16 // event listeners to be named onEventName. | |
17 var eventListenerMap = { | |
18 'needkey': 'onNeedKey', | |
19 'webkitneedkey': 'onWebkitNeedKey', | |
20 'webkitkeymessage': 'onWebkitKeyMessage', | |
21 'webkitkeyadded': 'onWebkitKeyAdded', | |
22 'webkitkeyerror': 'onWebkitKeyError' | |
23 }; | |
24 for (eventName in eventListenerMap) { | |
25 var eventListenerFunction = player[eventListenerMap[eventName]]; | |
26 if (eventListenerFunction) { | |
27 player.video.addEventListener(eventName, function(e) { | |
28 player[eventListenerMap[e.type]](e); | |
29 }); | |
30 } | |
31 } | |
32 // List of events that fail tests. | |
33 var failingEvents = ['error', 'abort']; | |
34 for (var i = 0; i < failingEvents.length; i++) { | |
35 player.video.addEventListener(failingEvents[i], Utils.failTest); | |
36 } | |
37 }; | |
38 | |
39 PlayerUtils.registerEMEEventListeners = function(player) { | |
40 player.video.addEventListener('needkey', function(message) { | |
41 | |
42 function addMediaKeySessionListeners(mediaKeySession) { | |
43 mediaKeySession.addEventListener('message', function(message) { | |
44 player.video.receivedKeyMessage = true; | |
45 if (Utils.isHeartBeatMessage(message.message)) { | |
46 Utils.timeLog('MediaKeySession onMessage - heart beat', message); | |
47 player.video.receivedHeartbeat = true; | |
48 } | |
49 player.onMessage(message); | |
50 }); | |
51 mediaKeySession.addEventListener('error', function(error) { | |
52 Utils.failTest(error, KEY_ERROR); | |
53 }); | |
54 } | |
55 | |
56 Utils.timeLog('Creating new media key session for contentType: ' + | |
57 message.contentType + ', initData: ' + | |
58 Utils.getHexString(message.initData)); | |
59 try { | |
60 var session = message.target.mediaKeys.createSession( | |
61 message.contentType, message.initData); | |
62 if (PROMISES_SUPPORTED) { | |
63 session.then(addMediaKeySessionListeners) | |
64 .catch (function(error) { | |
65 Utils.failTest(error, KEY_ERROR); | |
66 }); | |
67 } else { | |
68 addMediaKeySessionListeners(session); | |
69 } | |
70 } catch (e) { | |
71 Utils.failTest(e); | |
72 } | |
73 }); | |
74 this.registerDefaultEventListeners(player); | |
75 try { | |
76 Utils.timeLog('Setting video media keys: ' + player.testConfig.keySystem); | |
77 if (PROMISES_SUPPORTED) { | |
78 MediaKeys.create(player.testConfig.keySystem).then(function(mediaKeys) { | |
79 player.video.setMediaKeys(mediaKeys); | |
80 }).catch(function(error) { | |
81 Utils.failTest(error, NOTSUPPORTEDERROR); | |
82 }); | |
83 } else { | |
84 player.video.setMediaKeys(new MediaKeys(player.testConfig.keySystem)); | |
85 } | |
86 } catch (e) { | |
87 Utils.failTest(e); | |
88 } | |
89 }; | |
90 | |
91 PlayerUtils.registerPrefixedEMEEventListeners = function(player) { | |
92 player.video.addEventListener('webkitneedkey', function(message) { | |
93 var initData = message.initData; | |
94 if (player.testConfig.sessionToLoad) { | |
95 Utils.timeLog('Loading session: ' + player.testConfig.sessionToLoad); | |
96 initData = Utils.convertToUint8Array( | |
97 PREFIXED_API_LOAD_SESSION_HEADER + player.testConfig.sessionToLoad); | |
98 } | |
99 Utils.timeLog(player.testConfig.keySystem + | |
100 ' Generate key request, initData: ' + | |
101 Utils.getHexString(initData)); | |
102 try { | |
103 message.target.webkitGenerateKeyRequest(player.testConfig.keySystem, | |
104 initData); | |
105 } catch (e) { | |
106 Utils.failTest(e); | |
107 } | |
108 }); | |
109 | |
110 player.video.addEventListener('webkitkeyadded', function(message) { | |
111 Utils.timeLog('onWebkitKeyAdded', message); | |
112 message.target.receivedKeyAdded = true; | |
113 }); | |
114 | |
115 player.video.addEventListener('webkitkeyerror', function(error) { | |
116 Utils.timeLog('onWebkitKeyError', error); | |
117 Utils.failTest(error, KEY_ERROR); | |
118 }); | |
119 | |
120 player.video.addEventListener('webkitkeymessage', function(message) { | |
121 Utils.timeLog('onWebkitKeyMessage', message); | |
122 message.target.receivedKeyMessage = true; | |
123 if (Utils.isHeartBeatMessage(message.message)) { | |
124 Utils.timeLog('onWebkitKeyMessage - heart beat', message); | |
125 message.target.receivedHeartbeat = true; | |
126 } | |
127 }); | |
128 this.registerDefaultEventListeners(player); | |
129 }; | |
130 | |
131 PlayerUtils.setVideoSource = function(player) { | |
132 if (player.testConfig.useMSE) { | |
133 Utils.timeLog('Loading media using MSE.'); | |
134 var mediaSource = | |
135 MediaSourceUtils.loadMediaSourceFromTestConfig(player.testConfig); | |
136 player.video.src = window.URL.createObjectURL(mediaSource); | |
137 } else { | |
138 Utils.timeLog('Loading media using src.'); | |
139 player.video.src = player.testConfig.mediaFile; | |
140 } | |
141 }; | |
142 | |
143 PlayerUtils.initEMEPlayer = function(player) { | |
144 this.registerEMEEventListeners(player); | |
145 this.setVideoSource(player); | |
146 }; | |
147 | |
148 PlayerUtils.initPrefixedEMEPlayer = function(player) { | |
149 this.registerPrefixedEMEEventListeners(player); | |
150 this.setVideoSource(player); | |
151 }; | |
152 | |
153 // Return the appropriate player based on test configuration. | |
154 PlayerUtils.createPlayer = function(video, testConfig) { | |
155 // Update keySystem if using prefixed Clear Key since it is not available as a | |
156 // separate key system to choose from; however it can be set in URL query. | |
157 var usePrefixedEME = testConfig.usePrefixedEME; | |
158 if (testConfig.keySystem == CLEARKEY && usePrefixedEME) | |
159 testConfig.keySystem = PREFIXED_CLEARKEY; | |
160 | |
161 function getPlayerType(keySystem) { | |
162 switch (keySystem) { | |
163 case WIDEVINE_KEYSYSTEM: | |
164 if (usePrefixedEME) | |
165 return PrefixedWidevinePlayer; | |
166 return WidevinePlayer; | |
167 case PREFIXED_CLEARKEY: | |
168 return PrefixedClearKeyPlayer; | |
169 case EXTERNAL_CLEARKEY: | |
170 case CLEARKEY: | |
171 if (usePrefixedEME) | |
172 return PrefixedClearKeyPlayer; | |
173 return ClearKeyPlayer; | |
174 case FILE_IO_TEST_KEYSYSTEM: | |
175 if (usePrefixedEME) | |
176 return FileIOTestPlayer; | |
177 default: | |
178 Utils.timeLog(keySystem + ' is not a known key system'); | |
179 if (usePrefixedEME) | |
180 return PrefixedClearKeyPlayer; | |
181 return ClearKeyPlayer; | |
182 } | |
183 } | |
184 var Player = getPlayerType(testConfig.keySystem); | |
185 return new Player(video, testConfig); | |
186 }; | |
OLD | NEW |