[telemetry] Add support for requesting memory dumps via DevTools API

tools/telemetry/telemetry/internal/backends/chrome_inspector/tracing_backend_unittest.py

Index: tools/telemetry/telemetry/internal/backends/chrome_inspector/tracing_backend_unittest.py
diff --git a/tools/telemetry/telemetry/internal/backends/chrome_inspector/tracing_backend_unittest.py b/tools/telemetry/telemetry/internal/backends/chrome_inspector/tracing_backend_unittest.py
index 073c11873fd454ab4501b81f54cf04dc0ea3574c..d5bc571b7b9f39b6093b96f78e2dd7128bf691bd 100644
--- a/tools/telemetry/telemetry/internal/backends/chrome_inspector/tracing_backend_unittest.py
+++ b/tools/telemetry/telemetry/internal/backends/chrome_inspector/tracing_backend_unittest.py
@@ -4,6 +4,7 @@
 
 import unittest
 
+from telemetry import decorators
 from telemetry.core import util
 from telemetry.internal.backends.chrome_inspector import tracing_backend
 from telemetry.internal.backends.chrome_inspector import websocket
@@ -27,35 +28,43 @@ class FakeInspectorWebsocket(object):
   """
   def __init__(self, mock_timer):
     self._mock_timer = mock_timer
-    self._responses = []
+    self._notifications = []
+    self._response_handlers = {}
     self._handler = None
 
   def RegisterDomain(self, _, handler):
     self._handler = handler
 
-  def AddResponse(self, method, value, time):
-    if self._responses:
-      assert self._responses[-1][1] < time, (
+  def AddNotification(self, method, value, time):
+    if self._notifications:
+      assert self._notifications[-1][1] < time, (
           'Current response is scheduled earlier than previous response.')
     params = {'value': value}
     response = {'method': method, 'params': params}
-    self._responses.append((response, time))
+    self._notifications.append((response, time))
+
+  def AddResponseHandler(self, method, handler):
+    self._response_handlers[method] = handler
+
+  def SyncRequest(self, request, *args, **kwargs):
+    handler = self._response_handlers[request['method']]
+    return handler(request) if handler else None
 
   def Connect(self, _):
     pass
 
   def DispatchNotifications(self, timeout):
     current_time = self._mock_timer.time()
-    if not self._responses:
+    if not self._notifications:
       self._mock_timer.SetTime(current_time + timeout + 1)
       raise websocket.WebSocketTimeoutException()
 
-    response, time = self._responses[0]
+    response, time = self._notifications[0]
     if time - current_time > timeout:
       self._mock_timer.SetTime(current_time + timeout + 1)
       raise websocket.WebSocketTimeoutException()
 
-    self._responses.pop(0)
+    self._notifications.pop(0)
     self._mock_timer.SetTime(time + 1)
     self._handler(response)
 
@@ -97,6 +106,34 @@ class TracingBackendTest(tab_test_case.TabTestCase):
     # Calling stop again will raise exception
     self.assertRaises(Exception, self._tracing_controller.Stop)
 
+  # This test will be enabled once the Tracing.DumpMemory method is added to the
+  # Chrome DevTools API. See crbug.com/505826
+  @decorators.Disabled
+  def testDumpMemory(self):
+    if not self._browser.supports_memory_dumping:
+      self.skipTest('Browser does not support memory dumping, skipping test.')
+
+    options = tracing_options.TracingOptions()
+    options.enable_chrome_trace = True
+    self._tracing_controller.Start(
+        options, tracing_category_filter.TracingCategoryFilter(
+            'disabled-by-default-memory-infra'))
+
+    # Request a memory dump and test that it was succesfully created.
+    dump_id = self._browser.DumpMemory()
+    self.assertIsNotNone(dump_id)
+
+    trace_data = self._tracing_controller.Stop()
+
+    # Test that trace data is parsable.
+    model = model_module.TimelineModel(trace_data)
+    self.assertGreater(len(model.processes), 0)
+
+    # Test that the resulting model contains the memory dump.
+    memory_dumps = list(model.IterGlobalMemoryDumps())
+    self.assertEqual(1, len(memory_dumps))
+    self.assertEqual(dump_id, memory_dumps[0].dump_id)
+
 
 class TracingBackendUnitTest(unittest.TestCase):
   def setUp(self):
@@ -107,9 +144,9 @@ class TracingBackendUnitTest(unittest.TestCase):
 
   def testCollectTracingDataTimeout(self):
     inspector = FakeInspectorWebsocket(self._mock_timer)
-    inspector.AddResponse('Tracing.dataCollected', 'asdf1', 9)
-    inspector.AddResponse('Tracing.dataCollected', 'asdf2', 19)
-    inspector.AddResponse('Tracing.tracingComplete', 'asdf3', 35)
+    inspector.AddNotification('Tracing.dataCollected', 'asdf1', 9)
+    inspector.AddNotification('Tracing.dataCollected', 'asdf2', 19)
+    inspector.AddNotification('Tracing.tracingComplete', 'asdf3', 35)
 
     with mock.patch('telemetry.internal.backends.chrome_inspector.'
                     'inspector_websocket.InspectorWebsocket') as mock_class:
@@ -125,9 +162,9 @@ class TracingBackendUnitTest(unittest.TestCase):
 
   def testCollectTracingDataNoTimeout(self):
     inspector = FakeInspectorWebsocket(self._mock_timer)
-    inspector.AddResponse('Tracing.dataCollected', 'asdf1', 9)
-    inspector.AddResponse('Tracing.dataCollected', 'asdf2', 14)
-    inspector.AddResponse('Tracing.tracingComplete', 'asdf3', 19)
+    inspector.AddNotification('Tracing.dataCollected', 'asdf1', 9)
+    inspector.AddNotification('Tracing.dataCollected', 'asdf2', 14)
+    inspector.AddNotification('Tracing.tracingComplete', 'asdf3', 19)
 
     with mock.patch('telemetry.internal.backends.chrome_inspector.'
                     'inspector_websocket.InspectorWebsocket') as mock_class:
@@ -137,3 +174,29 @@ class TracingBackendUnitTest(unittest.TestCase):
     backend._CollectTracingData(10)
     self.assertEqual(2, len(backend._trace_events))
     self.assertTrue(backend._has_received_all_tracing_data)
+
+  def testDumpMemorySuccess(self):
+    inspector = FakeInspectorWebsocket(self._mock_timer)
+    inspector.AddResponseHandler(
+        'Tracing.dumpMemory',
+        lambda req: {'result': {'success': True, 'dumpGuid': '42abc'}})
+
+    with mock.patch('telemetry.internal.backends.chrome_inspector.'
+                    'inspector_websocket.InspectorWebsocket') as mock_class:
+      mock_class.return_value = inspector
+      backend = tracing_backend.TracingBackend(devtools_port=65000)
+
+    self.assertEqual(backend.DumpMemory(), '42abc')
+
+  def testDumpMemoryFailure(self):
+    inspector = FakeInspectorWebsocket(self._mock_timer)
+    inspector.AddResponseHandler(
+        'Tracing.dumpMemory',
+        lambda req: {'result': {'success': False, 'dumpGuid': '42abc'}})
+
+    with mock.patch('telemetry.internal.backends.chrome_inspector.'
+                    'inspector_websocket.InspectorWebsocket') as mock_class:
+      mock_class.return_value = inspector
+      backend = tracing_backend.TracingBackend(devtools_port=65000)
+
+    self.assertIsNone(backend.DumpMemory())