| # Copyright 2014 The Chromium Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| from page_sets import press_story |
| from telemetry import story |
| |
| |
| class WebrtcPage(press_story.PressStory): |
| |
| def __init__(self, url, page_set, name, tags, extra_browser_args=None): |
| assert url.startswith('file://webrtc_cases/') |
| self.URL = url |
| self.NAME = name |
| super(WebrtcPage, self).__init__(page_set, |
| tags=tags, |
| extra_browser_args=extra_browser_args) |
| |
| |
| class GetUserMedia(WebrtcPage): |
| """Why: Acquires a high definition (720p) local stream.""" |
| |
| def __init__(self, page_set, tags): |
| super(GetUserMedia, self).__init__( |
| url='file://webrtc_cases/resolution.html', |
| name='hd_local_stream_10s', |
| page_set=page_set, tags=tags) |
| |
| def ExecuteTest(self, action_runner): |
| action_runner.ClickElement('button[id="hd"]') |
| action_runner.Wait(10) |
| |
| |
| class DataChannel(WebrtcPage): |
| """Why: Transfer as much data as possible through a data channel in 10s.""" |
| |
| def __init__(self, page_set, tags): |
| super(DataChannel, self).__init__( |
| url='file://webrtc_cases/datatransfer.html', |
| name='10s_datachannel_transfer', |
| page_set=page_set, tags=tags) |
| |
| def ExecuteTest(self, action_runner): |
| action_runner.ExecuteJavaScript('megsToSend.value = 100;') |
| action_runner.ClickElement('button[id="sendTheData"]') |
| action_runner.Wait(10) |
| |
| def ParseTestResults(self, action_runner): |
| self.AddJavaScriptMeasurement( |
| 'data_transferred', |
| 'sizeInBytes_biggerIsBetter', |
| 'receiveProgress.value', |
| description='Amount of data transferred by data channel in 10 seconds') |
| self.AddJavaScriptMeasurement( |
| 'data_throughput', |
| 'bytesPerSecond_biggerIsBetter', |
| 'currentThroughput', |
| description='Throughput of the data transfer.') |
| |
| |
| class CanvasCapturePeerConnection(WebrtcPage): |
| """Why: Sets up a canvas capture stream connection to a peer connection.""" |
| |
| def __init__(self, page_set, tags): |
| super(CanvasCapturePeerConnection, self).__init__( |
| url='file://webrtc_cases/canvas-capture.html', |
| name='canvas_capture_peer_connection', |
| page_set=page_set, tags=tags) |
| |
| def ExecuteTest(self, action_runner): |
| with action_runner.CreateInteraction('Action_Canvas_PeerConnection', |
| repeatable=False): |
| action_runner.ClickElement('button[id="startButton"]') |
| action_runner.Wait(10) |
| |
| |
| class VideoCodecConstraints(WebrtcPage): |
| """Why: Sets up a video codec to a peer connection.""" |
| |
| def __init__(self, page_set, video_codec, tags): |
| super(VideoCodecConstraints, self).__init__( |
| url='file://webrtc_cases/codec_constraints.html', |
| name='codec_constraints_%s' % video_codec.lower(), |
| page_set=page_set, tags=tags) |
| self.video_codec = video_codec |
| |
| def ExecuteTest(self, action_runner): |
| with action_runner.CreateInteraction('Action_Codec_Constraints', |
| repeatable=False): |
| action_runner.ClickElement('input[id="%s"]' % self.video_codec) |
| action_runner.ClickElement('button[id="startButton"]') |
| action_runner.WaitForElement('button[id="callButton"]:enabled') |
| action_runner.ClickElement('button[id="callButton"]') |
| action_runner.Wait(20) |
| action_runner.ClickElement('button[id="hangupButton"]') |
| |
| |
| class MultiplePeerConnections(WebrtcPage): |
| """Why: Sets up several peer connections in the same page.""" |
| |
| def __init__(self, page_set, tags): |
| super(MultiplePeerConnections, self).__init__( |
| url='file://webrtc_cases/multiple-peerconnections.html', |
| name='multiple_peerconnections', |
| page_set=page_set, tags=tags) |
| |
| def ExecuteTest(self, action_runner): |
| with action_runner.CreateInteraction('Action_Create_PeerConnection', |
| repeatable=False): |
| # Set the number of peer connections to create to 10. |
| action_runner.ExecuteJavaScript( |
| 'document.getElementById("num-peerconnections").value=10') |
| action_runner.ExecuteJavaScript( |
| 'document.getElementById("cpuoveruse-detection").checked=false') |
| action_runner.ClickElement('button[id="start-test"]') |
| action_runner.Wait(20) |
| |
| |
| class PausePlayPeerConnections(WebrtcPage): |
| """Why: Ensures frequent pause and plays of peer connection streams work.""" |
| |
| def __init__(self, page_set, tags): |
| super(PausePlayPeerConnections, self).__init__( |
| url='file://webrtc_cases/pause-play.html', |
| name='pause_play_peerconnections', |
| page_set=page_set, tags=tags) |
| |
| def ExecuteTest(self, action_runner): |
| action_runner.ExecuteJavaScript( |
| 'startTest({test_runtime_s}, {num_peerconnections},' |
| '{iteration_delay_ms}, "video");'.format( |
| test_runtime_s=20, num_peerconnections=10, iteration_delay_ms=20)) |
| action_runner.Wait(20) |
| |
| |
| class InsertableStreamsAudioProcessing(WebrtcPage): |
| """Why: processes/transforms audio using insertable streams.""" |
| |
| def __init__(self, page_set, tags): |
| super(InsertableStreamsAudioProcessing, self).__init__( |
| url='file://webrtc_cases/audio-processing.html', |
| name='insertable_streams_audio_processing', |
| page_set=page_set, |
| tags=tags, |
| extra_browser_args=( |
| '--enable-blink-features=WebCodecs,MediaStreamInsertableStreams')) |
| self.supported = None |
| |
| def RunNavigateSteps(self, action_runner): |
| self.supported = action_runner.EvaluateJavaScript('''(function () { |
| try { |
| new MediaStreamTrackGenerator('audio'); |
| return true; |
| } catch (e) { |
| return false; |
| } |
| })()''') |
| if self.supported: |
| super(InsertableStreamsAudioProcessing, |
| self).RunNavigateSteps(action_runner) |
| |
| def ExecuteTest(self, action_runner): |
| self.AddMeasurement( |
| 'supported', 'count_biggerIsBetter', 1 if self.supported else 0, |
| 'Boolean flag indicating if this benchmark is supported by the browser.' |
| ) |
| if not self.supported: |
| return |
| action_runner.WaitForJavaScriptCondition('!!audio') |
| action_runner.ExecuteJavaScript('start()') |
| action_runner.Wait(10) |
| |
| |
| class InsertableStreamsVideoProcessing(WebrtcPage): |
| """Why: processes/transforms video in various ways.""" |
| |
| def __init__(self, page_set, source, transform, sink, tags): |
| super(InsertableStreamsVideoProcessing, self).__init__( |
| url='file://webrtc_cases/video-processing.html', |
| name=('insertable_streams_video_processing_%s_%s_%s' % |
| (source, transform, sink)), |
| page_set=page_set, |
| tags=tags, |
| extra_browser_args=( |
| '--enable-blink-features=WebCodecs,MediaStreamInsertableStreams')) |
| self.source = source |
| self.transform = transform |
| self.sink = sink |
| self.supported = None |
| |
| def RunNavigateSteps(self, action_runner): |
| self.supported = action_runner.EvaluateJavaScript( |
| "typeof MediaStreamTrackProcessor !== 'undefined' &&" |
| "typeof MediaStreamTrackGenerator !== 'undefined'") |
| if self.supported: |
| super(InsertableStreamsVideoProcessing, |
| self).RunNavigateSteps(action_runner) |
| |
| def ExecuteTest(self, action_runner): |
| self.AddMeasurement( |
| 'supported', 'count_biggerIsBetter', 1 if self.supported else 0, |
| 'Boolean flag indicating if this benchmark is supported by the browser.' |
| ) |
| if not self.supported: |
| return |
| with action_runner.CreateInteraction('Start_Pipeline', repeatable=True): |
| action_runner.WaitForElement('select[id="sourceSelector"]:enabled') |
| action_runner.ExecuteJavaScript( |
| 'document.getElementById("sourceSelector").value="%s";' % self.source) |
| action_runner.WaitForElement('select[id="transformSelector"]:enabled') |
| action_runner.ExecuteJavaScript( |
| 'document.getElementById("transformSelector").value="%s";' % |
| self.transform) |
| action_runner.WaitForElement('select[id="sinkSelector"]:enabled') |
| action_runner.ExecuteJavaScript( |
| 'document.getElementById("sinkSelector").value="%s";' % self.sink) |
| action_runner.ExecuteJavaScript( |
| 'document.getElementById("sourceSelector").dispatchEvent(' |
| ' new InputEvent("input", {}));') |
| action_runner.WaitForElement('.sinkVideo') |
| action_runner.Wait(10) |
| self.AddJavaScriptMeasurement( |
| 'sink_decoded_frames', |
| 'count_biggerIsBetter', |
| 'document.querySelector(".sinkVideo").webkitDecodedFrameCount', |
| description='Number of frames received at the sink video.') |
| |
| |
| class NegotiateTiming(WebrtcPage): |
| """Why: Measure how long renegotiation takes with large SDP blobs.""" |
| |
| def __init__(self, page_set, tags): |
| super(NegotiateTiming, |
| self).__init__(url='file://webrtc_cases/negotiate-timing.html', |
| name='negotiate-timing', |
| page_set=page_set, |
| tags=tags) |
| |
| def ExecuteTest(self, action_runner): |
| action_runner.ExecuteJavaScript('start()') |
| action_runner.WaitForJavaScriptCondition('!callButton.disabled') |
| action_runner.ExecuteJavaScript('call()') |
| action_runner.WaitForJavaScriptCondition('!renegotiateButton.disabled') |
| # Due to suspicion of renegotiate activating too early: |
| action_runner.Wait(1) |
| # Negotiate 50 transceivers, then negotiate back to 1, simulating Meet "pin" |
| action_runner.ExecuteJavaScript('videoSectionsField.value = 50') |
| action_runner.ExecuteJavaScript('renegotiate()') |
| action_runner.WaitForJavaScriptCondition('!renegotiateButton.disabled') |
| action_runner.ExecuteJavaScript('videoSectionsField.value = 1') |
| action_runner.ExecuteJavaScript('renegotiate()') |
| action_runner.WaitForJavaScriptCondition('!renegotiateButton.disabled') |
| # Negotiate back up to 50, simulating Meet "unpin". This is what gets measured. |
| action_runner.ExecuteJavaScript('videoSectionsField.value = 50') |
| action_runner.ExecuteJavaScript('renegotiate()') |
| action_runner.WaitForJavaScriptCondition('!renegotiateButton.disabled') |
| result = action_runner.EvaluateJavaScript('result') |
| |
| self.AddMeasurement('callerSetLocalDescription', |
| 'ms', |
| result['callerSetLocalDescription'], |
| description='Time for caller SetLocalDescription') |
| self.AddMeasurement('calleeSetLocalDescription', |
| 'ms', |
| result['calleeSetLocalDescription'], |
| description='Time for callee SetLocalDescription') |
| self.AddMeasurement('callerSetRemoteDescription', |
| 'ms', |
| result['callerSetRemoteDescription'], |
| description='Time for caller SetRemoteDescription') |
| self.AddMeasurement('calleeSetRemoteDescription', |
| 'ms', |
| result['calleeSetRemoteDescription'], |
| description='Time for callee SetRemoteDescription') |
| self.AddMeasurement('callerCreateOffer', |
| 'ms', |
| result['callerCreateOffer'], |
| description='Time for overall offer/answer handshake') |
| self.AddMeasurement('calleeCreateAnswer', |
| 'ms', |
| result['calleeCreateAnswer'], |
| description='Time for overall offer/answer handshake') |
| self.AddMeasurement('elapsedTime', |
| 'ms', |
| result['elapsedTime'], |
| description='Time for overall offer/answer handshake') |
| self.AddMeasurement( |
| 'audioImpairment', |
| 'count', |
| result['audioImpairment'], |
| description='Number of late audio samples concealed during negotiation') |
| |
| |
| class EncodedInsertableStreams(WebrtcPage): |
| """Why: Performs encoded insertable streams.""" |
| def __init__(self, page_set, tags): |
| super(EncodedInsertableStreams, self).__init__( |
| url='file://webrtc_cases/encoded-insertable-streams.html', |
| name='encoded_insertable_streams', |
| page_set=page_set, |
| tags=tags) |
| |
| def ExecuteTest(self, action_runner): |
| with action_runner.CreateInteraction('Action_Create_PeerConnection', |
| repeatable=False): |
| # Set the number of peer connections to create to 10. |
| action_runner.ExecuteJavaScript( |
| 'document.getElementById("num-peerconnections").value=10') |
| action_runner.ClickElement('button[id="start-test"]') |
| action_runner.Wait(20) |
| |
| |
| class WebrtcPageSet(story.StorySet): |
| def __init__(self): |
| super(WebrtcPageSet, self).__init__( |
| cloud_storage_bucket=story.PUBLIC_BUCKET) |
| |
| self.AddStory(PausePlayPeerConnections(self, tags=['pauseplay'])) |
| self.AddStory(MultiplePeerConnections(self, tags=['stress'])) |
| self.AddStory(DataChannel(self, tags=['datachannel'])) |
| self.AddStory(GetUserMedia(self, tags=['getusermedia'])) |
| self.AddStory(CanvasCapturePeerConnection(self, tags=['smoothness'])) |
| self.AddStory(VideoCodecConstraints(self, 'H264', tags=['videoConstraints'])) |
| self.AddStory(VideoCodecConstraints(self, 'VP8', tags=['videoConstraints'])) |
| self.AddStory(VideoCodecConstraints(self, 'VP9', tags=['videoConstraints'])) |
| self.AddStory( |
| InsertableStreamsAudioProcessing(self, tags=['insertableStreams'])) |
| self.AddStory( |
| InsertableStreamsVideoProcessing(self, |
| 'camera', |
| 'webgl', |
| 'video', |
| tags=['insertableStreams'])) |
| self.AddStory( |
| InsertableStreamsVideoProcessing(self, |
| 'video', |
| 'webgl', |
| 'video', |
| tags=['insertableStreams'])) |
| self.AddStory( |
| InsertableStreamsVideoProcessing(self, |
| 'pc', |
| 'webgl', |
| 'video', |
| tags=['insertableStreams'])) |
| self.AddStory( |
| InsertableStreamsVideoProcessing(self, |
| 'camera', |
| 'canvas2d', |
| 'video', |
| tags=['insertableStreams'])) |
| self.AddStory( |
| InsertableStreamsVideoProcessing(self, |
| 'camera', |
| 'noop', |
| 'video', |
| tags=['insertableStreams'])) |
| self.AddStory( |
| InsertableStreamsVideoProcessing(self, |
| 'camera', |
| 'webgl', |
| 'pc', |
| tags=['insertableStreams'])) |
| self.AddStory(NegotiateTiming(self, tags=['sdp'])) |
| self.AddStory(EncodedInsertableStreams(self, tags=['stress'])) |
