Handle corrupted data in Telemetry WebRtcRendering

tools/telemetry/telemetry/web_perf/metrics/webrtc_rendering_stats_unittest.py

 # Copyright 2015 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 import unittest
 
 from telemetry.web_perf.metrics import webrtc_rendering_stats as stats_helper
 
 
 class FakeEvent(object):
   """Fake event class to mock rendering events."""
@@ skipping 96 matching lines @@
             ideal_instant=1663780361998, serial=self.remote_stream),
         FakeEvent(actual_begin=1663780395575, actual_end=1663780412241,
             ideal_instant=1663780361998, serial=self.remote_stream),
         FakeEvent(actual_begin=1663780412241, actual_end=1663780428907,
             ideal_instant=1663780361998, serial=self.remote_stream),
         FakeEvent(actual_begin=1663780428907, actual_end=1663780445573,
             ideal_instant=1663780412998, serial=self.remote_stream)]
 
     return fake_events
 
+  def _GetCorruptEvents(self):
+    # The events below are corrupt data because the |ideal_instant|
+    # parameter is zero, which makes all computation meaningless.
+    # Indeed, the ideal_instant (aka Ideal Render Instant) indicates
+    # when the frame should be rendered ideally.
+    corrupt_events = [
+        FakeEvent(actual_begin=1663780195583, actual_end=1663780212249,
+            ideal_instant=0, serial=self.remote_stream),
+        FakeEvent(actual_begin=1663780212249, actual_end=1663780228915,
+            ideal_instant=0, serial=self.remote_stream),
+        FakeEvent(actual_begin=1663780228915, actual_end=1663780245581,
+            ideal_instant=0, serial=self.remote_stream),
+        FakeEvent(actual_begin=1663780245581, actual_end=1663780262247,
+            ideal_instant=0, serial=self.remote_stream)]
+    return corrupt_events
+
   def testGetCadence(self):
     fake_events = self._GetFakeEvents()
     stats_parser = stats_helper.WebMediaPlayerMsRenderingStats(fake_events)
     # The events defined in _GetFakeEvents above show that the first source
     # framee of ideal_instant=1663780179998 is rendered twice, then
     # the second source frame of ideal_instant=1663780197998 is rendered once
     # the third source frame of  ideal_instant=1663780215998 is rendered twice
     # and so on. The expected cadence will therefore be [2 1 2 etc..]
     expected_cadence = [2, 1, 2, 3, 3, 3, 1]
     self.assertEqual(expected_cadence, stats_parser._GetCadence(fake_events))
@@ skipping 105 matching lines @@
         stats.percent_badly_out_of_sync)
     self.assertEqual(expected_stats.percent_out_of_sync,
         stats.percent_out_of_sync)
     self.assertEqual(expected_stats.smoothness_score, stats.smoothness_score)
     self.assertEqual(expected_stats.freezing_score, stats.freezing_score)
     self.assertEqual(expected_stats.rendering_length_error,
         stats.rendering_length_error)
     self.assertEqual(expected_stats.fps, stats.fps)
     self.assertEqual(expected_stats.frame_distribution,
         stats.frame_distribution)
+
+  def testCorruptData(self):
+    corrupt_events = self._GetCorruptEvents()
+    stats_parser = stats_helper.WebMediaPlayerMsRenderingStats(corrupt_events)
+    stats = stats_parser.GetTimeStats()
+    self.assertTrue(stats.invalid_data)
+    self.assertIsNone(stats.drift_time)
+    self.assertIsNone(stats.percent_badly_out_of_sync)
+    self.assertIsNone(stats.percent_out_of_sync)
+    self.assertIsNone(stats.smoothness_score)
+    self.assertIsNone(stats.freezing_score)
+    self.assertIsNone(stats.rendering_length_error)
+    self.assertIsNone(stats.fps)
+    self.assertIsNone(stats.frame_distribution)