# Copyright (c) 2012 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.

"""The page cycler measurement.

This measurement registers a window load handler in which is forces a layout and
then records the value of performance.now(). This call to now() measures the
time from navigationStart (immediately after the previous page's beforeunload
event) until after the layout in the page's load event. In addition, two garbage
collections are performed in between the page loads (in the beforeunload event).
This extra garbage collection time is not included in the measurement times.

Finally, various memory and IO statistics are gathered at the very end of
cycling all pages.
"""

import collections
import os

from metrics import cpu
from metrics import io
from metrics import memory
from metrics import speedindex
from metrics import v8_object_stats
from telemetry.core import util
from telemetry.page import page_measurement

class PageCycler(page_measurement.PageMeasurement):
  def __init__(self, *args, **kwargs):
    super(PageCycler, self).__init__(*args, **kwargs)

    with open(os.path.join(os.path.dirname(__file__),
                           'page_cycler.js'), 'r') as f:
      self._page_cycler_js = f.read()

    self._record_v8_object_stats = False
    self._report_speed_index = False
    self._speedindex_metric = speedindex.SpeedIndexMetric()
    self._memory_metric = None
    self._cpu_metric = None
    self._v8_object_stats_metric = None
    self._cold_run_start_index = None
    self._has_loaded_page = collections.defaultdict(int)

  def AddCommandLineOptions(self, parser):
    # The page cyclers should default to 10 iterations. In order to change the
    # default of an option, we must remove and re-add it.
    # TODO: Remove this after transition to run_benchmark.
    pageset_repeat_option = parser.get_option('--pageset-repeat')
    pageset_repeat_option.default = 10
    parser.remove_option('--pageset-repeat')
    parser.add_option(pageset_repeat_option)

    parser.add_option('--v8-object-stats',
        action='store_true',
        help='Enable detailed V8 object statistics.')

    parser.add_option('--report-speed-index',
        action='store_true',
        help='Enable the speed index metric.')

    parser.add_option('--cold-load-percent', type='int',
                      help='%d of page visits for which a cold load is forced')

  def DidStartBrowser(self, browser):
    """Initialize metrics once right after the browser has been launched."""
    self._memory_metric = memory.MemoryMetric(browser)
    self._cpu_metric = cpu.CpuMetric(browser)
    if self._record_v8_object_stats:
      self._v8_object_stats_metric = v8_object_stats.V8ObjectStatsMetric()

  def DidStartHTTPServer(self, tab):
    # Avoid paying for a cross-renderer navigation on the first page on legacy
    # page cyclers which use the filesystem.
    tab.Navigate(tab.browser.http_server.UrlOf('nonexistent.html'))

  def WillNavigateToPage(self, page, tab):
    page.script_to_evaluate_on_commit = self._page_cycler_js
    if self.ShouldRunCold(page.url):
      tab.ClearCache()
    if self._report_speed_index:
      self._speedindex_metric.Start(page, tab)

  def DidNavigateToPage(self, page, tab):
    self._memory_metric.Start(page, tab)
    # TODO(qyearsley): Uncomment the following line and move it to
    # WillNavigateToPage once the cpu metric has been changed.
    # This is being temporarily commented out to let the page cycler
    # results return to how they were before the cpu metric was added.
    # self._cpu_metric.Start(page, tab) See crbug.com/301714.
    if self._record_v8_object_stats:
      self._v8_object_stats_metric.Start(page, tab)

  def CustomizeBrowserOptions(self, options):
    memory.MemoryMetric.CustomizeBrowserOptions(options)
    io.IOMetric.CustomizeBrowserOptions(options)
    options.AppendExtraBrowserArgs('--js-flags=--expose_gc')

    if options.v8_object_stats:
      self._record_v8_object_stats = True
      v8_object_stats.V8ObjectStatsMetric.CustomizeBrowserOptions(options)

    if options.report_speed_index:
      self._report_speed_index = True

    cold_runs_percent_set = (options.cold_load_percent != None)
    # Handle requests for cold cache runs
    if (cold_runs_percent_set and
        (options.repeat_options.page_repeat_secs or
         options.repeat_options.pageset_repeat_secs)):
      raise Exception('--cold-load-percent is incompatible with timed repeat')

    if (cold_runs_percent_set and
        (options.cold_load_percent < 0 or options.cold_load_percent > 100)):
      raise Exception('--cold-load-percent must be in the range [0-100]')

    # Make sure _cold_run_start_index is an integer multiple of page_repeat.
    # Without this, --pageset_shuffle + --page_repeat could lead to
    # assertion failures on _started_warm in WillNavigateToPage.
    if cold_runs_percent_set:
      number_warm_pageset_runs = int(
          (int(options.repeat_options.pageset_repeat_iters) - 1) *
          (100 - options.cold_load_percent) / 100)
      number_warm_runs = (number_warm_pageset_runs *
                          options.repeat_options.page_repeat_iters)
      self._cold_run_start_index = (number_warm_runs +
          options.repeat_options.page_repeat_iters)
      self.discard_first_result = (not options.cold_load_percent or
                                   self.discard_first_result)
    else:
      self._cold_run_start_index = (
          options.repeat_options.pageset_repeat_iters *
          options.repeat_options.page_repeat_iters)

  def MeasurePage(self, page, tab, results):
    tab.WaitForJavaScriptExpression('__pc_load_time', 60)

    chart_name_prefix = ('cold_' if self.IsRunCold(page.url) else
                         'warm_')

    results.Add('page_load_time', 'ms',
                int(float(tab.EvaluateJavaScript('__pc_load_time'))),
                chart_name=chart_name_prefix+'times')

    self._has_loaded_page[page.url] += 1

    self._memory_metric.Stop(page, tab)
    self._memory_metric.AddResults(tab, results)
    # TODO(qyearsley): Uncomment the following line when CPU metric is
    # changed. See crbug.com/301714.
    # self._cpu_metric.Stop(page, tab)
    # self._cpu_metric.AddResults(tab, results)
    if self._record_v8_object_stats:
      self._v8_object_stats_metric.Stop(page, tab)
      self._v8_object_stats_metric.AddResults(tab, results)

    if self._report_speed_index:
      def SpeedIndexIsFinished():
        return self._speedindex_metric.IsFinished(tab)
      util.WaitFor(SpeedIndexIsFinished, 60)
      self._speedindex_metric.Stop(page, tab)
      self._speedindex_metric.AddResults(
          tab, results, chart_name=chart_name_prefix+'speed_index')

  def DidRunTest(self, browser, results):
    self._memory_metric.AddSummaryResults(results)
    io.IOMetric().AddSummaryResults(browser, results)

  def IsRunCold(self, url):
    return (self.ShouldRunCold(url) or
            self._has_loaded_page[url] == 0)

  def ShouldRunCold(self, url):
    # We do the warm runs first for two reasons.  The first is so we can
    # preserve any initial profile cache for as long as possible.
    # The second is that, if we did cold runs first, we'd have a transition
    # page set during which we wanted the run for each URL to both
    # contribute to the cold data and warm the catch for the following
    # warm run, and clearing the cache before the load of the following
    # URL would eliminate the intended warmup for the previous URL.
    return (self._has_loaded_page[url] >= self._cold_run_start_index)

  def results_are_the_same_on_every_page(self):
    return False