[Telemetry] Kill PageTest.DidRunActions hook.

tools/perf/measurements/task_execution_time_unittest.py

 # Copyright 2014 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.
 
 from telemetry.core import wpr_modes
 from telemetry import decorators
 from telemetry.page import page as page_module
 from telemetry.results import page_test_results
 from telemetry.timeline import model as model_module
 from telemetry.timeline import slice as slice_data
@@ skipping 143 matching lines @@
     # Add too many increasing-durtation tasks and confirm we only get the
     # slowest _NUMBER_OF_RESULTS_TO_DISPLAY tasks reported back.
     duration = 0
     extra = 5
     for duration in xrange(
         task_execution_time.TaskExecutionTime._NUMBER_OF_RESULTS_TO_DISPLAY +
         extra):
       data.AddSlice('task' + str(duration), 0, duration)
 
     # Run the code we are testing.
-    self._measurement.ValidateAndMeasurePage(None, None, data.results)
+    self._measurement._AddResults(data.results)
 
     # Check that the last (i.e. biggest) _NUMBER_OF_RESULTS_TO_DISPLAY get
     # returned in the results.
     for duration in xrange(
         extra,
         extra +
         task_execution_time.TaskExecutionTime._NUMBER_OF_RESULTS_TO_DISPLAY):
       self._findResultFromName(
           'process 1:%s:task%s' % (self._first_thread_name, str(duration)),
           data)
 
   def _findResultFromName(self, name, data):
     for result in data.results.all_page_specific_values:
       if result.name == name:
         return result
     self.fail('Expected result "%s" missing.' % (name))
 
   def _GenerateResultsFromMockedData(self):
     data = self._GenerateDataForEmptyPageSet()
 
     data.AddSlice('fast', 0, 1)
     data.AddSlice('medium', 0, 500)
     data.AddSlice('slow', 0, 1000)
 
     # Run the code we are testing and return results.
-    self._measurement.ValidateAndMeasurePage(None, None, data.results)
+    self._measurement._AddResults(data.results)
     return data
 
   def _GenerateResultsFromMockedIdleData(self):
     data = self._GenerateDataForEmptyPageSet()
 
     # Make a slice that looks like an idle task parent.
     slice_start_time = 0
     slow_slice_duration = 1000
     fast_slice_duration = 250
     parent_slice = data.AddSlice(
         task_execution_time.TaskExecutionTime.IDLE_SECTION_TRIGGER,
         slice_start_time,
         slow_slice_duration)
     # Add a sub-slice, this should be reported back as occuring in idle time.
     sub_slice = slice_data.Slice(
         None,
         'category',
         'slow_sub_slice',
         slice_start_time,
         slow_slice_duration,
         slice_start_time,
         slow_slice_duration,
         [])
     parent_slice.sub_slices.append(sub_slice)
 
     # Add a non-idle task.
     data.AddSlice('not_idle', slice_start_time, fast_slice_duration)
 
     # Run the code we are testing.
-    self._measurement.ValidateAndMeasurePage(None, None, data.results)
+    self._measurement._AddResults(data.results)
 
     return data
 
   def _GenerateDataForEmptyPageSet(self):
     self._measurement = task_execution_time.TaskExecutionTime()
     self._page_set = self.CreateEmptyPageSet()
     page = TestTaskExecutionTimePage(self._page_set, self._page_set.base_dir)
     self._page_set.AddUserStory(page)
 
     # Get the name of a thread used by task_execution_time metric and set up
@@ skipping 34 matching lines @@
         None,
         'category',
         name,
         timestamp,
         duration,
         timestamp,
         duration,
         [])
     self._renderer_thread.all_slices.append(new_slice)
     return new_slice