telemetry: Add thread time to telmetry timeline.

tools/telemetry/telemetry/core/timeline/trace_event_importer_unittest.py

Index: tools/telemetry/telemetry/core/timeline/trace_event_importer_unittest.py
diff --git a/tools/telemetry/telemetry/core/timeline/trace_event_importer_unittest.py b/tools/telemetry/telemetry/core/timeline/trace_event_importer_unittest.py
index 2467913b61e8788dd796d69eaf9cb276664a9f3c..25ac993dcf28e952f512ba47f6ad66e1d05b1939 100644
--- a/tools/telemetry/telemetry/core/timeline/trace_event_importer_unittest.py
+++ b/tools/telemetry/telemetry/core/timeline/trace_event_importer_unittest.py
@@ -24,13 +24,17 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
 
   def testBasicSingleThreadNonnestedParsing(self):
     events = [
-      {'name': 'a', 'args': {}, 'pid': 52, 'ts': 520, 'cat': 'foo',
+      {'name': 'a', 'args': {}, 'pid': 52, 'ts': 520, 'tts': 280, 'cat': 'foo',
        'tid': 53, 'ph': 'B'},
-      {'name': 'a', 'args': {}, 'pid': 52, 'ts': 560, 'cat': 'foo',
+      {'name': 'a', 'args': {}, 'pid': 52, 'ts': 560, 'tts': 310, 'cat': 'foo',
        'tid': 53, 'ph': 'E'},
-      {'name': 'b', 'args': {}, 'pid': 52, 'ts': 629, 'cat': 'bar',
+      {'name': 'b', 'args': {}, 'pid': 52, 'ts': 629, 'tts': 356, 'cat': 'bar',
        'tid': 53, 'ph': 'B'},
-      {'name': 'b', 'args': {}, 'pid': 52, 'ts': 631, 'cat': 'bar',
+      {'name': 'b', 'args': {}, 'pid': 52, 'ts': 631, 'tts': 357, 'cat': 'bar',
+       'tid': 53, 'ph': 'E'},
+      {'name': 'c', 'args': {}, 'pid': 52, 'ts': 633, 'cat': 'baz',
+       'tid': 53, 'ph': 'B'},
+      {'name': 'c', 'args': {}, 'pid': 52, 'ts': 637, 'cat': 'baz',
        'tid': 53, 'ph': 'E'}
     ]
 
@@ -42,13 +46,17 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
 
     self.assertEqual(1, len(p.threads))
     t = p.threads[53]
-    self.assertEqual(2, len(t.all_slices))
+    self.assertEqual(3, len(t.all_slices))
     self.assertEqual(53, t.tid)
     slice_event = t.all_slices[0]
     self.assertEqual('a', slice_event.name)
     self.assertEqual('foo', slice_event.category)
     self.assertAlmostEqual(0, slice_event.start)
     self.assertAlmostEqual((560 - 520) / 1000.0, slice_event.duration)
+    self.assertAlmostEqual((560 - 520) / 1000.0, slice_event.end)
+    self.assertAlmostEqual(0, slice_event.thread_start)
+    self.assertAlmostEqual((310 - 280) / 1000.0, slice_event.thread_duration)
+    self.assertAlmostEqual((310 - 280) / 1000.0, slice_event.thread_end)
     self.assertEqual(0, len(slice_event.sub_slices))
 
     slice_event = t.all_slices[1]
@@ -56,8 +64,23 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
     self.assertEqual('bar', slice_event.category)
     self.assertAlmostEqual((629 - 520) / 1000.0, slice_event.start)
     self.assertAlmostEqual((631 - 629) / 1000.0, slice_event.duration)
+    self.assertAlmostEqual((631 - 520) / 1000.0, slice_event.end)
+    self.assertAlmostEqual((356 - 280) / 1000.0, slice_event.thread_start)
+    self.assertAlmostEqual((357 - 356) / 1000.0, slice_event.thread_duration)
+    self.assertAlmostEqual((357 - 280) / 1000.0, slice_event.thread_end)
+    self.assertEqual(0, len(slice_event.sub_slices))
+
+    slice_event = t.all_slices[2]
+    self.assertEqual('c', slice_event.name)
+    self.assertEqual('baz', slice_event.category)
+    self.assertAlmostEqual((633 - 520) / 1000.0, slice_event.start)
+    self.assertAlmostEqual((637 - 633) / 1000.0, slice_event.duration)
+    self.assertEqual(None, slice_event.thread_start)
+    self.assertEqual(None, slice_event.thread_duration)
+    self.assertEqual(None, slice_event.thread_end)
     self.assertEqual(0, len(slice_event.sub_slices))
 
+
   def testArgumentDupeCreatesNonFailingImportError(self):
     events = [
       {'name': 'a', 'args': {'x': 1}, 'pid': 1, 'ts': 520, 'cat': 'foo',
@@ -98,13 +121,13 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
 
   def testNestedParsing(self):
     events = [
-      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 1, 'cat': 'foo',
+      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 1, 'tts': 2, 'cat': 'foo',
        'tid': 1, 'ph': 'B'},
-      {'name': 'b', 'args': {}, 'pid': 1, 'ts': 2, 'cat': 'bar',
+      {'name': 'b', 'args': {}, 'pid': 1, 'ts': 3, 'tts': 3, 'cat': 'bar',
        'tid': 1, 'ph': 'B'},
-      {'name': 'b', 'args': {}, 'pid': 1, 'ts': 3, 'cat': 'bar',
+      {'name': 'b', 'args': {}, 'pid': 1, 'ts': 5, 'tts': 4, 'cat': 'bar',
        'tid': 1, 'ph': 'E'},
-      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 4, 'cat': 'foo',
+      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 7, 'tts': 5, 'cat': 'foo',
        'tid': 1, 'ph': 'E'}
     ]
     m = timeline_model.TimelineModel(event_data=events,
@@ -117,23 +140,27 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
     self.assertEqual('a', slice_a.name)
     self.assertEqual('foo', slice_a.category)
     self.assertAlmostEqual(0.001, slice_a.start)
-    self.assertAlmostEqual(0.003, slice_a.duration)
+    self.assertAlmostEqual(0.006, slice_a.duration)
+    self.assertAlmostEqual(0.002, slice_a.thread_start)
+    self.assertAlmostEqual(0.003, slice_a.thread_duration)
 
     self.assertEqual('b', slice_b.name)
     self.assertEqual('bar', slice_b.category)
-    self.assertAlmostEqual(0.002, slice_b.start)
-    self.assertAlmostEqual(0.001, slice_b.duration)
+    self.assertAlmostEqual(0.003, slice_b.start)
+    self.assertAlmostEqual(0.002, slice_b.duration)
+    self.assertAlmostEqual(0.003, slice_b.thread_start)
+    self.assertAlmostEqual(0.001, slice_b.thread_duration)
 
   def testAutoclosing(self):
     events = [
       # Slice that doesn't finish.
-      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 1, 'cat': 'foo',
+      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 1, 'tts': 1, 'cat': 'foo',
        'tid': 1, 'ph': 'B'},
 
       # Slice that does finish to give an 'end time' to make autoclosing work.
-      {'name': 'b', 'args': {}, 'pid': 1, 'ts': 1, 'cat': 'bar',
+      {'name': 'b', 'args': {}, 'pid': 1, 'ts': 2, 'tts': 2, 'cat': 'bar',
        'tid': 2, 'ph': 'B'},
-      {'name': 'b', 'args': {}, 'pid': 1, 'ts': 2, 'cat': 'bar',
+      {'name': 'b', 'args': {}, 'pid': 1, 'ts': 4, 'tts': 3, 'cat': 'bar',
        'tid': 2, 'ph': 'E'}
     ]
     m = timeline_model.TimelineModel(event_data=events)
@@ -144,12 +171,14 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
     self.assertEqual('foo', slice_event.category)
     self.assertTrue(slice_event.did_not_finish)
     self.assertAlmostEqual(0, slice_event.start)
-    self.assertAlmostEqual((2 - 1) / 1000.0, slice_event.duration)
+    self.assertAlmostEqual((4 - 1) / 1000.0, slice_event.duration)
+    self.assertAlmostEqual(0, slice_event.thread_start)
+    self.assertAlmostEqual((3 - 1) / 1000.0, slice_event.thread_duration)
 
   def testAutoclosingLoneBegin(self):
     events = [
       # Slice that doesn't finish.
-      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 1, 'cat': 'foo',
+      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 1, 'tts': 1, 'cat': 'foo',
        'tid': 1, 'ph': 'B'}
     ]
     m = timeline_model.TimelineModel(event_data=events)
@@ -161,6 +190,8 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
     self.assertTrue(slice_event.did_not_finish)
     self.assertAlmostEqual(0, slice_event.start)
     self.assertAlmostEqual(0, slice_event.duration)
+    self.assertAlmostEqual(0, slice_event.thread_start)
+    self.assertAlmostEqual(0, slice_event.thread_duration)
 
   def testAutoclosingWithSubTasks(self):
     events = [
@@ -188,15 +219,15 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
   def testAutoclosingWithEventsOutsideBounds(self):
     events = [
       # Slice that begins before min and ends after max of the other threads.
-      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 0, 'cat': 'foo',
+      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 0, 'tts': 0, 'cat': 'foo',
        'tid': 1, 'ph': 'B'},
-      {'name': 'b', 'args': {}, 'pid': 1, 'ts': 3, 'cat': 'foo',
+      {'name': 'b', 'args': {}, 'pid': 1, 'ts': 6, 'tts': 3, 'cat': 'foo',
        'tid': 1, 'ph': 'B'},
 
       # Slice that does finish to give an 'end time' to establish a basis
-      {'name': 'c', 'args': {}, 'pid': 1, 'ts': 1, 'cat': 'bar',
+      {'name': 'c', 'args': {}, 'pid': 1, 'ts': 2, 'tts': 1, 'cat': 'bar',
        'tid': 2, 'ph': 'B'},
-      {'name': 'c', 'args': {}, 'pid': 1, 'ts': 2, 'cat': 'bar',
+      {'name': 'c', 'args': {}, 'pid': 1, 'ts': 4, 'tts': 2, 'cat': 'bar',
        'tid': 2, 'ph': 'E'}
     ]
     m = timeline_model.TimelineModel(event_data=events,
@@ -209,17 +240,24 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
     self.assertEqual('a', slice_event.name)
     self.assertEqual('foo', slice_event.category)
     self.assertAlmostEqual(0, slice_event.start)
-    self.assertAlmostEqual(0.003, slice_event.duration)
+    self.assertAlmostEqual(0.006, slice_event.duration)
+    self.assertAlmostEqual(0, slice_event.thread_start)
+    self.assertAlmostEqual(0.003, slice_event.thread_duration)
 
     t2 = p.threads[2]
     slice2 = FindEventNamed(t2.all_slices, 'c')
     self.assertEqual('c', slice2.name)
     self.assertEqual('bar', slice2.category)
-    self.assertAlmostEqual(0.001, slice2.start)
-    self.assertAlmostEqual(0.001, slice2.duration)
+    self.assertAlmostEqual(0.002, slice2.start)
+    self.assertAlmostEqual(0.002, slice2.duration)
+    self.assertAlmostEqual(0.001, slice2.thread_start)
+    self.assertAlmostEqual(0.001, slice2.thread_duration)
 
     self.assertAlmostEqual(0.000, m.bounds.min)
-    self.assertAlmostEqual(0.003, m.bounds.max)
+    self.assertAlmostEqual(0.006, m.bounds.max)
+    self.assertAlmostEqual(0.000, m.thread_time_bounds.min)
+    self.assertAlmostEqual(0.003, m.thread_time_bounds.max)
+
 
   def testNestedAutoclosing(self):
     events = [
@@ -249,13 +287,13 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
 
   def testMultipleThreadParsing(self):
     events = [
-      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 1, 'cat': 'foo',
+      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 2, 'tts': 1, 'cat': 'foo',
        'tid': 1, 'ph': 'B'},
-      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 2, 'cat': 'foo',
+      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 4, 'tts': 2, 'cat': 'foo',
        'tid': 1, 'ph': 'E'},
-      {'name': 'b', 'args': {}, 'pid': 1, 'ts': 3, 'cat': 'bar',
+      {'name': 'b', 'args': {}, 'pid': 1, 'ts': 6, 'tts': 3, 'cat': 'bar',
        'tid': 2, 'ph': 'B'},
-      {'name': 'b', 'args': {}, 'pid': 1, 'ts': 4, 'cat': 'bar',
+      {'name': 'b', 'args': {}, 'pid': 1, 'ts': 8, 'tts': 4, 'cat': 'bar',
        'tid': 2, 'ph': 'E'}
     ]
     m = timeline_model.TimelineModel(event_data=events)
@@ -274,7 +312,9 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
     self.assertEqual('a', slice_event.name)
     self.assertEqual('foo', slice_event.category)
     self.assertAlmostEqual(0, slice_event.start)
-    self.assertAlmostEqual((2 - 1) / 1000.0, slice_event.duration)
+    self.assertAlmostEqual((4 - 2) / 1000.0, slice_event.duration)
+    self.assertAlmostEqual(0, slice_event.thread_start)
+    self.assertAlmostEqual((2 - 1) / 1000.0, slice_event.thread_duration)
 
     # Check thread 2.
     t = p.threads[2]
@@ -284,18 +324,20 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
     slice_event = t.all_slices[0]
     self.assertEqual('b', slice_event.name)
     self.assertEqual('bar', slice_event.category)
-    self.assertAlmostEqual((3 - 1) / 1000.0, slice_event.start)
-    self.assertAlmostEqual((4 - 3) / 1000.0, slice_event.duration)
+    self.assertAlmostEqual((6 - 2) / 1000.0, slice_event.start)
+    self.assertAlmostEqual((8 - 6) / 1000.0, slice_event.duration)
+    self.assertAlmostEqual((3 - 1) / 1000.0, slice_event.thread_start)
+    self.assertAlmostEqual((4 - 3) / 1000.0, slice_event.thread_duration)
 
   def testMultiplePidParsing(self):
     events = [
-      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 1, 'cat': 'foo',
+      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 2, 'tts': 1, 'cat': 'foo',
        'tid': 1, 'ph': 'B'},
-      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 2, 'cat': 'foo',
+      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 4, 'tts': 2, 'cat': 'foo',
        'tid': 1, 'ph': 'E'},
-      {'name': 'b', 'args': {}, 'pid': 2, 'ts': 3, 'cat': 'bar',
+      {'name': 'b', 'args': {}, 'pid': 2, 'ts': 6, 'tts': 3, 'cat': 'bar',
        'tid': 2, 'ph': 'B'},
-      {'name': 'b', 'args': {}, 'pid': 2, 'ts': 4, 'cat': 'bar',
+      {'name': 'b', 'args': {}, 'pid': 2, 'ts': 8, 'tts': 4, 'cat': 'bar',
        'tid': 2, 'ph': 'E'}
     ]
 
@@ -316,7 +358,9 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
     self.assertEqual('a', slice_event.name)
     self.assertEqual('foo', slice_event.category)
     self.assertAlmostEqual(0, slice_event.start)
-    self.assertAlmostEqual((2 - 1) / 1000.0, slice_event.duration)
+    self.assertAlmostEqual((4 - 2) / 1000.0, slice_event.duration)
+    self.assertAlmostEqual(0, slice_event.thread_start)
+    self.assertAlmostEqual((2 - 1) / 1000.0, slice_event.thread_duration)
 
     # Check process 2 thread 2.
     # TODO: will this be in deterministic order?
@@ -330,8 +374,10 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
     slice_event = t.all_slices[0]
     self.assertEqual('b', slice_event.name)
     self.assertEqual('bar', slice_event.category)
-    self.assertAlmostEqual((3 - 1) / 1000.0, slice_event.start)
-    self.assertAlmostEqual((4 - 3) / 1000.0, slice_event.duration)
+    self.assertAlmostEqual((6 - 2) / 1000.0, slice_event.start)
+    self.assertAlmostEqual((8 - 6) / 1000.0, slice_event.duration)
+    self.assertAlmostEqual((3 - 1) / 1000.0, slice_event.thread_start)
+    self.assertAlmostEqual((4 - 3) / 1000.0, slice_event.thread_duration)
 
     # Check getAllThreads.
     self.assertEqual([processes[0].threads[1],
@@ -360,11 +406,11 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
 
   def testParsingWhenEndComesFirst(self):
     events = [
-      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 1, 'cat': 'foo',
+      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 1, 'tts': 1, 'cat': 'foo',
        'tid': 1, 'ph': 'E'},
-      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 4, 'cat': 'foo',
+      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 4, 'tts': 4, 'cat': 'foo',
        'tid': 1, 'ph': 'B'},
-      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 5, 'cat': 'foo',
+      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 5, 'tts': 5, 'cat': 'foo',
        'tid': 1, 'ph': 'E'}
     ]
     m = timeline_model.TimelineModel(event_data=events,
@@ -376,19 +422,21 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
     self.assertEqual('foo', t.all_slices[0].category)
     self.assertEqual(0.004, t.all_slices[0].start)
     self.assertEqual(0.001, t.all_slices[0].duration)
+    self.assertEqual(0.004, t.all_slices[0].thread_start)
+    self.assertEqual(0.001, t.all_slices[0].thread_duration)
     self.assertEqual(1, len(m.import_errors))
 
   def testImmediateParsing(self):
     events = [
       # Need to include immediates inside a task so the timeline
       # recentering/zeroing doesn't clobber their timestamp.
-      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 1, 'cat': 'foo',
+      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 2, 'tts': 1, 'cat': 'foo',
        'tid': 1, 'ph': 'B'},
-      {'name': 'immediate', 'args': {}, 'pid': 1, 'ts': 2, 'cat': 'bar',
+      {'name': 'immediate', 'args': {}, 'pid': 1, 'ts': 4, 'cat': 'bar',
        'tid': 1, 'ph': 'I'},
-      {'name': 'slower', 'args': {}, 'pid': 1, 'ts': 4, 'cat': 'baz',
+      {'name': 'slower', 'args': {}, 'pid': 1, 'ts': 8, 'cat': 'baz',
        'tid': 1, 'ph': 'i'},
-      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 4, 'cat': 'foo',
+      {'name': 'a', 'args': {}, 'pid': 1, 'ts': 8, 'tts': 4, 'cat': 'foo',
        'tid': 1, 'ph': 'E'}
     ]
     m = timeline_model.TimelineModel(event_data=events,
@@ -398,29 +446,25 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
     self.assertEqual(3, len(t.all_slices))
 
     i = m.GetAllEventsOfName('immediate')[0]
-    self.assertAlmostEqual(0.002, i.start)
+    self.assertEqual('immediate', i.name)
+    self.assertEqual('bar', i.category)
+    self.assertAlmostEqual(0.004, i.start)
     self.assertAlmostEqual(0, i.duration)
 
     slower = m.GetAllEventsOfName('slower')[0]
-    self.assertAlmostEqual(0.004, slower.start)
+    self.assertEqual('slower', slower.name)
+    self.assertEqual('baz', slower.category)
+    self.assertAlmostEqual(0.008, slower.start)
+    self.assertAlmostEqual(0, slower.duration)
 
     a = m.GetAllEventsOfName('a')[0]
-    self.assertAlmostEqual(0.001, a.start)
-    self.assertAlmostEqual(0.003, a.duration)
-
     self.assertEqual('a', a.name)
     self.assertEqual('foo', a.category)
-    self.assertEqual(0.003, a.duration)
+    self.assertAlmostEqual(0.002, a.start)
+    self.assertAlmostEqual(0.006, a.duration)
+    self.assertAlmostEqual(0.001, a.thread_start)
+    self.assertAlmostEqual(0.003, a.thread_duration)
 
-    self.assertEqual('immediate', i.name)
-    self.assertEqual('bar', i.category)
-    self.assertAlmostEqual(0.002, i.start)
-    self.assertAlmostEqual(0, i.duration)
-
-    self.assertEqual('slower', slower.name)
-    self.assertEqual('baz', slower.category)
-    self.assertAlmostEqual(0.004, slower.start)
-    self.assertAlmostEqual(0, slower.duration)
 
   def testSimpleCounter(self):
     events = [
@@ -922,11 +966,11 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
 
   def testImportCompleteEvent(self):
     events = [
-      {'name': 'a', 'args': {}, 'pid': 52, 'ts': 629, 'dur': 1, 'cat': 'baz',
-       'tid': 53, 'ph': 'X'},
-      {'name': 'b', 'args': {}, 'pid': 52, 'ts': 730, 'dur': 20, 'cat': 'foo',
-       'tid': 53, 'ph': 'X'},
-      {'name': 'c', 'args': {}, 'pid': 52, 'ts': 740, 'cat': 'baz',
+      {'name': 'a', 'args': {}, 'pid': 52, 'ts': 629, 'tts': 538, 'dur': 1,
+       'tdur': 1, 'cat': 'baz', 'tid': 53, 'ph': 'X'},
+      {'name': 'b', 'args': {}, 'pid': 52, 'ts': 730, 'tts': 620, 'dur': 20,
+       'tdur': 14, 'cat': 'foo', 'tid': 53, 'ph': 'X'},
+      {'name': 'c', 'args': {}, 'pid': 52, 'ts': 740, 'tts': 625, 'cat': 'baz',
        'tid': 53, 'ph': 'X'},
     ]
     m = timeline_model.TimelineModel(event_data=events)
@@ -938,6 +982,8 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
     self.assertEqual('a', slice_event.name)
     self.assertAlmostEqual(0.0, slice_event.start)
     self.assertAlmostEqual(1 / 1000.0, slice_event.duration)
+    self.assertAlmostEqual(0.0, slice_event.thread_start)
+    self.assertAlmostEqual(1 / 1000.0, slice_event.thread_duration)
     self.assertFalse(slice_event.did_not_finish)
     self.assertEqual(0, len(slice_event.sub_slices))
 
@@ -945,6 +991,8 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
     self.assertEqual('b', slice_event.name)
     self.assertAlmostEqual((730 - 629) / 1000.0, slice_event.start)
     self.assertAlmostEqual(20 / 1000.0, slice_event.duration)
+    self.assertAlmostEqual((620 - 538) / 1000.0, slice_event.thread_start)
+    self.assertAlmostEqual(14 / 1000.0, slice_event.thread_duration)
     self.assertFalse(slice_event.did_not_finish)
     self.assertEqual(1, len(slice_event.sub_slices))
     self.assertEqual(t.all_slices[2], slice_event.sub_slices[0])
@@ -953,5 +1001,7 @@ class TraceEventTimelineImporterTest(unittest.TestCase):
     self.assertEqual('c', slice_event.name)
     self.assertAlmostEqual((740 - 629) / 1000.0, slice_event.start)
     self.assertAlmostEqual(10 / 1000.0, slice_event.duration)
+    self.assertAlmostEqual((625 - 538) / 1000.0, slice_event.thread_start)
+    self.assertAlmostEqual(9 / 1000.0, slice_event.thread_duration)
     self.assertTrue(slice_event.did_not_finish)
     self.assertEqual(0, len(slice_event.sub_slices))