Integration test for minidump paths, adding in wait time to make sure the

tools/perf/core/minidump_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 logging
 
 from telemetry.testing import tab_test_case
 from telemetry import decorators
 from telemetry.core import util
 
 class BrowserMinidumpTest(tab_test_case.TabTestCase):
   @decorators.Isolated
   @decorators.Enabled('mac')
   def testSymbolizeMinidump(self):
+    # Wait for the browser to restart fully before crashing
+    self._loadPageAndWait('var sam = "car";', 'sam')
     self._browser.tabs.New().Navigate('chrome://gpucrash', timeout=5)
     crash_minidump_path = self._browser.GetMostRecentMinidumpPath()
     self.assertIsNotNone(crash_minidump_path)
 
     logging.info('testSymbolizeMinidump: most recent path = '
         + crash_minidump_path)
     all_paths = self._browser.GetAllMinidumpPaths()
     logging.info('testSymbolizeMinidump: all paths ' + ''.join(all_paths))
     all_unsymbolized_paths = self._browser.GetAllUnsymbolizedMinidumpPaths()
     logging.info('testSymbolizeMinidump: all unsymbolized paths '
         + ''.join(all_unsymbolized_paths))
     #self.assertTrue(len(all_unsymbolized_paths) == 1)
 
     # Now symbolize that minidump and make sure there are no longer any present
     self._browser.SymbolizeMinidump(crash_minidump_path)
 
     all_unsymbolized_after_symbolize_paths = \
         self._browser.GetAllUnsymbolizedMinidumpPaths()
     logging.info('testSymbolizeMinidump: after symbolize all '
         + 'unsymbolized paths: '
         + ''.join(all_unsymbolized_after_symbolize_paths))
     #self.assertTrue(len(all_unsymbolized_after_symbolize_paths) == 0)
 
 
   @decorators.Isolated
   @decorators.Enabled('mac')
   def testMultipleCrashMinidumps(self):
+    # Wait for the browser to restart fully before crashing
+    self._loadPageAndWait('var cat = "dog";', 'cat')
     self._browser.tabs.New().Navigate('chrome://gpucrash', timeout=5)
     first_crash_path = self._browser.GetMostRecentMinidumpPath()
 
     self.assertIsNotNone(first_crash_path)
     logging.info('testMultipleCrashMinidumps: first crash most recent path'
         + first_crash_path)
     all_paths = self._browser.GetAllMinidumpPaths()
     logging.info('testMultipleCrashMinidumps: first crash all paths: '
         + ''.join(all_paths))
     #self.assertEquals(len(all_paths), 1)
     #self.assertEqual(all_paths[0], first_crash_path)
     all_unsymbolized_paths = self._browser.GetAllUnsymbolizedMinidumpPaths()
     #self.assertTrue(len(all_unsymbolized_paths) == 1)
     logging.info('testMultipleCrashMinidumps: first crash all unsymbolized '
         'paths: ' + ''.join(all_unsymbolized_paths))
 
     # Restart the browser and then crash a second time
     self._RestartBrowser()
 
     # Start a new tab in the restarted browser
-    new_tab = self._browser.tabs.New()
-    new_tab.Navigate('http://www.google.com/',
-        script_to_evaluate_on_commit='var foo = "bar";')
-    # Wait until the javascript has run ensuring that
-    # the new browser has restarted before we crash it again
-    util.WaitFor(lambda: new_tab.EvaluateJavaScript('foo'), 60)
+    self._loadPageAndWait('var foo = "bar";', 'foo')
 
     self._browser.tabs.New().Navigate('chrome://gpucrash', timeout=5)
     second_crash_path = self._browser.GetMostRecentMinidumpPath()
     self.assertIsNotNone(second_crash_path)
     logging.info('testMultipleCrashMinidumps: second crash most recent path'
         + second_crash_path)
     second_crash_all_paths = self._browser.GetAllMinidumpPaths()
     logging.info('testMultipleCrashMinidumps: second crash all paths: '
         + ''.join(second_crash_all_paths))
     second_crash_all_unsymbolized_paths = \
@@ skipping 15 matching lines @@
     logging.info('testMultipleCrashMinidumps: after symbolize all paths: '
         + ''.join(after_symbolize_all_paths))
     #self.assertEquals(len(after_symbolize_all_paths), 2)
     after_symbolize_all_unsymbolized_paths = \
         self._browser.GetAllUnsymbolizedMinidumpPaths()
     logging.info('testMultipleCrashMinidumps: after symbolize all '
         + 'unsymbolized paths: '
         + ''.join(after_symbolize_all_unsymbolized_paths))
     #self.assertEquals(after_symbolize_all_unsymbolized_paths,
      #   [first_crash_path])
+
+  def _loadPageAndWait(self, script, value):

[nednguyen, 2016/07/28 15:44:47]

nits: _LoadPageThenWait(self, script, value):

Our convention for method names in python is "DoThisOperation."

[eyaich, 2016/07/28 15:55:52]

Done.

+    new_tab = self._browser.tabs.New()
+    new_tab.Navigate('http://www.google.com/',

[nednguyen, 2016/07/28 15:44:48]

http://www.google.com would probably hit real network. You probably wants to use
"about:blank" or static page instead.

[eyaich, 2016/07/28 15:55:52]

I think we actually want to hit a real web page and not just about:blank.  We
want the browser to fully load and therefore establish all tmp dirs.  

I have a hunch, that may be way off, but I was seeing that the browser was
sometimes flaky on the first crash and we couldn't find the first minidump path.
  I was wondering if it was because the browser was crashed before everything
was setup, hence why I am waiting for at least one full page to load first.

[eyaich, 2016/07/28 16:59:02]

Talked offline, I have changed this now.  Done.

+        script_to_evaluate_on_commit=script)
+    # Wait until the javascript has run ensuring that
+    # the new browser has restarted before we crash it again
+    util.WaitFor(lambda: new_tab.EvaluateJavaScript(value), 60)