android-7.0.0_r1/s

<!DOCTYPE html>
<!--
Copyright (c) 2013 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.
-->

<link rel="import" href="/tracing/base/iteration_helpers.html">
<link rel="import" href="/tracing/base/range_utils.html">
<link rel="import" href="/tracing/base/statistics.html">
<link rel="import" href="/tracing/core/auditor.html">
<link rel="import" href="/tracing/model/alert.html">
<link rel="import" href="/tracing/model/frame.html">
<link rel="import" href="/tracing/model/helpers/android_model_helper.html">
<link rel="import" href="/tracing/model/thread_time_slice.html">
<link rel="import" href="/tracing/model/user_model/response_expectation.html">
<link rel="import" href="/tracing/value/numeric.html">
<link rel="import" href="/tracing/value/unit.html">

<script>
'use strict';

/**
 * @fileoverview Class for Android-specific Auditing.
 */
tr.exportTo('tr.e.audits', function() {
  var SCHEDULING_STATE = tr.model.SCHEDULING_STATE;
  var Auditor = tr.c.Auditor;
  var AndroidModelHelper = tr.model.helpers.AndroidModelHelper;
  var ColorScheme = tr.b.ColorScheme;
  var Statistics = tr.b.Statistics;
  var FRAME_PERF_CLASS = tr.model.FRAME_PERF_CLASS;
  var Alert = tr.model.Alert;
  var EventInfo = tr.model.EventInfo;
  var ScalarNumeric = tr.v.ScalarNumeric;
  var timeDurationInMs = tr.v.Unit.byName.timeDurationInMs;

  // TODO: extract from VSYNC, since not all devices have vsync near 60fps
  var EXPECTED_FRAME_TIME_MS = 16.67;

  function getStart(e) { return e.start; }
  function getDuration(e) { return e.duration; }
  // used for general UI thread responsiveness alerts, falls back to duration
  function getCpuDuration(e) {
    return (e.cpuDuration !== undefined) ? e.cpuDuration : e.duration;
  }

  function frameIsActivityStart(frame) {
    for (var i = 0; i < frame.associatedEvents.length; i++) {
      if (frame.associatedEvents[i].title == 'activityStart')
        return true;
    }
    return false;
  }

  function frameMissedDeadline(frame) {
    return frame.args['deadline'] && frame.args['deadline'] < frame.end;
  }

  /** Builder object for EventInfo docLink structures */
  function DocLinkBuilder() {
    this.docLinks = [];
  }
  DocLinkBuilder.prototype = {
    addAppVideo: function(name, videoId) {
      this.docLinks.push({
        label: 'Video Link',
        textContent: ('Android Performance Patterns: ' + name),
        href: 'https://www.youtube.com/watch?list=PLWz5rJ2EKKc9CBxr3BVjPTPoDPLdPIFCE&v=' + videoId // @suppress longLineCheck
      });
      return this;
    },
    addDacRef: function(name, link) {
      this.docLinks.push({
          label: 'Doc Link',
          textContent: (name + ' documentation'),
          href: 'https://developer.android.com/reference/' + link
      });
      return this;
    },
    build: function() {
      return this.docLinks;
    }
  };

  /**
   * Auditor for Android-specific traces.
   * @constructor
   */
  function AndroidAuditor(model) {
    Auditor.call(this, model);

    var helper = model.getOrCreateHelper(AndroidModelHelper);
    if (helper.apps.length || helper.surfaceFlinger)
      this.helper = helper;
  };

  //////////////////////////////////////////////////////////////////////////////
  // Rendering / RenderThread alerts - only available on SDK 22+
  //////////////////////////////////////////////////////////////////////////////

  AndroidAuditor.viewAlphaAlertInfo_ = new EventInfo(
      'Inefficient View alpha usage',
      'Setting an alpha between 0 and 1 has significant performance costs, if one of the fast alpha paths is not used.', // @suppress longLineCheck
      new DocLinkBuilder()
          .addAppVideo('Hidden Cost of Transparency', 'wIy8g8yNhNk')
          .addDacRef('View#setAlpha()', 'android/view/View.html#setAlpha(float)') // @suppress longLineCheck
          .build());
  AndroidAuditor.saveLayerAlertInfo_ = new EventInfo(
      'Expensive rendering with Canvas#saveLayer()',
      'Canvas#saveLayer() incurs extremely high rendering cost. They disrupt the rendering pipeline when drawn, forcing a flush of drawing content. Instead use View hardware layers, or static Bitmaps. This enables the offscreen buffers to be reused in between frames, and avoids the disruptive render target switch.', // @suppress longLineCheck
      new DocLinkBuilder()
          .addAppVideo('Hidden Cost of Transparency', 'wIy8g8yNhNk')
          .addDacRef('Canvas#saveLayerAlpha()', 'android/graphics/Canvas.html#saveLayerAlpha(android.graphics.RectF, int, int)') // @suppress longLineCheck
          .build());
  AndroidAuditor.getSaveLayerAlerts_ = function(frame) {
    var badAlphaRegEx =
        /^(.+) alpha caused (unclipped )?saveLayer (\d+)x(\d+)$/;
    var saveLayerRegEx = /^(unclipped )?saveLayer (\d+)x(\d+)$/;

    var ret = [];
    var events = [];

    frame.associatedEvents.forEach(function(slice) {
      var match = badAlphaRegEx.exec(slice.title);
      if (match) {
        // due to bug in tracing code on SDK 22, ignore
        // presence of 'unclipped' string in View alpha slices
        var args = { 'view name': match[1],
                     width: parseInt(match[3]),
                     height: parseInt(match[4]) };
        ret.push(new Alert(AndroidAuditor.viewAlphaAlertInfo_,
                           slice.start, [slice], args));
      } else if (saveLayerRegEx.test(slice.title))
        events.push(slice);
    }, this);

    if (events.length > ret.length) {
      // more saveLayers than bad alpha can account for - add another alert

      var unclippedSeen = Statistics.sum(events, function(slice) {
        return saveLayerRegEx.exec(slice.title)[1] ? 1 : 0;
      });
      var clippedSeen = events.length - unclippedSeen;
      var earliestStart = Statistics.min(events, function(slice) {
        return slice.start;
      });

      var args = {
        'Unclipped saveLayer count (especially bad!)': unclippedSeen,
        'Clipped saveLayer count': clippedSeen
      };

      events.push(frame);
      ret.push(new Alert(AndroidAuditor.saveLayerAlertInfo_,
                         earliestStart, events, args));
    }

    return ret;
  };


  AndroidAuditor.pathAlertInfo_ = new EventInfo(
      'Path texture churn',
      'Paths are drawn with a mask texture, so when a path is modified / newly drawn, that texture must be generated and uploaded to the GPU. Ensure that you cache paths between frames and do not unnecessarily call Path#reset(). You can cut down on this cost by sharing Path object instances between drawables/views.'); // @suppress longLineCheck
  AndroidAuditor.getPathAlert_ = function(frame) {
    var uploadRegEx = /^Generate Path Texture$/;

    var events = frame.associatedEvents.filter(function(event) {
      return event.title == 'Generate Path Texture';
    });
    var start = Statistics.min(events, getStart);
    var duration = Statistics.sum(events, getDuration);

    if (duration < 3)
      return undefined;

    events.push(frame);
    return new Alert(AndroidAuditor.pathAlertInfo_, start, events,
        { 'Time spent': new ScalarNumeric(timeDurationInMs, duration) });
  };


  AndroidAuditor.uploadAlertInfo_ = new EventInfo(
      'Expensive Bitmap uploads',
      'Bitmaps that have been modified / newly drawn must be uploaded to the GPU. Since this is expensive if the total number of pixels uploaded is large, reduce the amount of Bitmap churn in this animation/context, per frame.'); // @suppress longLineCheck
  AndroidAuditor.getUploadAlert_ = function(frame) {
    var uploadRegEx = /^Upload (\d+)x(\d+) Texture$/;

    var events = [];
    var start = Number.POSITIVE_INFINITY;
    var duration = 0;
    var pixelsUploaded = 0;
    frame.associatedEvents.forEach(function(event) {
      var match = uploadRegEx.exec(event.title);
      if (match) {
        events.push(event);
        start = Math.min(start, event.start);
        duration += event.duration;
        pixelsUploaded += parseInt(match[1]) * parseInt(match[2]);
      }
    });
    if (events.length == 0 || duration < 3)
      return undefined;

    var mPixels = (pixelsUploaded / 1000000).toFixed(2) + ' million';
    var args = { 'Pixels uploaded': mPixels,
                 'Time spent': new ScalarNumeric(timeDurationInMs, duration) };
    events.push(frame);
    return new Alert(AndroidAuditor.uploadAlertInfo_, start, events, args);
  };

  //////////////////////////////////////////////////////////////////////////////
  // UI responsiveness alerts
  //////////////////////////////////////////////////////////////////////////////

  AndroidAuditor.ListViewInflateAlertInfo_ = new EventInfo(
      'Inflation during ListView recycling',
      'ListView item recycling involved inflating views. Ensure your Adapter#getView() recycles the incoming View, instead of constructing a new one.'); // @suppress longLineCheck
  AndroidAuditor.ListViewBindAlertInfo_ = new EventInfo(
      'Inefficient ListView recycling/rebinding',
      'ListView recycling taking too much time per frame. Ensure your Adapter#getView() binds data efficiently.'); // @suppress longLineCheck
  AndroidAuditor.getListViewAlert_ = function(frame) {
    var events = frame.associatedEvents.filter(function(event) {
      return event.title == 'obtainView' || event.title == 'setupListItem';
    });
    var duration = Statistics.sum(events, getCpuDuration);

    if (events.length == 0 || duration < 3)
      return undefined;

    // simplifying assumption - check for *any* inflation.
    // TODO(ccraik): make 'inflate' slices associated events.
    var hasInflation = false;
    for (var i = 0; i < events.length; i++) {
      if (events[i] instanceof tr.model.Slice &&
          events[i].findDescendentSlice('inflate')) {
        hasInflation = true;
        break;
      }
    }

    var start = Statistics.min(events, getStart);
    var args = { 'Time spent': new ScalarNumeric(timeDurationInMs, duration) };
    args['ListView items ' + (hasInflation ? 'inflated' : 'rebound')] =
        events.length / 2;
    var eventInfo = hasInflation ? AndroidAuditor.ListViewInflateAlertInfo_ :
        AndroidAuditor.ListViewBindAlertInfo_;
    events.push(frame);
    return new Alert(eventInfo, start, events, args);
  };


  AndroidAuditor.measureLayoutAlertInfo_ = new EventInfo(
      'Expensive measure/layout pass',
      'Measure/Layout took a significant time, contributing to jank. Avoid triggering layout during animations.', // @suppress longLineCheck
      new DocLinkBuilder()
          .addAppVideo('Invalidations, Layouts, and Performance', 'we6poP0kw6E')
          .build());
  AndroidAuditor.getMeasureLayoutAlert_ = function(frame) {
    var events = frame.associatedEvents.filter(function(event) {
      return event.title == 'measure' || event.title == 'layout';
    });
    var duration = Statistics.sum(events, getCpuDuration);

    if (events.length == 0 || duration < 3)
      return undefined;

    var start = Statistics.min(events, getStart);
    events.push(frame);
    return new Alert(AndroidAuditor.measureLayoutAlertInfo_, start, events,
        { 'Time spent': new ScalarNumeric(timeDurationInMs, duration) });
  };


  AndroidAuditor.viewDrawAlertInfo_ = new EventInfo(
      'Long View#draw()',
      'Recording the drawing commands of invalidated Views took a long time. Avoid significant work in View or Drawable custom drawing, especially allocations or drawing to Bitmaps.', // @suppress longLineCheck
      new DocLinkBuilder()
          .addAppVideo('Invalidations, Layouts, and Performance', 'we6poP0kw6E')
          .addAppVideo('Avoiding Allocations in onDraw()', 'HAK5acHQ53E')
          .build());
  AndroidAuditor.getViewDrawAlert_ = function(frame) {
    var slice = undefined;
    for (var i = 0; i < frame.associatedEvents.length; i++) {
      if (frame.associatedEvents[i].title == 'getDisplayList' ||
          frame.associatedEvents[i].title == 'Record View#draw()') {
        slice = frame.associatedEvents[i];
        break;
      }
    }

    if (!slice || getCpuDuration(slice) < 3)
      return undefined;
    return new Alert(AndroidAuditor.viewDrawAlertInfo_, slice.start,
        [slice, frame],
        { 'Time spent': new ScalarNumeric(
            timeDurationInMs, getCpuDuration(slice)) });
  };


  //////////////////////////////////////////////////////////////////////////////
  // Runtime alerts
  //////////////////////////////////////////////////////////////////////////////

  AndroidAuditor.blockingGcAlertInfo_ = new EventInfo(
      'Blocking Garbage Collection',
      'Blocking GCs are caused by object churn, and made worse by having large numbers of objects in the heap. Avoid allocating objects during animations/scrolling, and recycle Bitmaps to avoid triggering garbage collection.', // @suppress longLineCheck
      new DocLinkBuilder()
          .addAppVideo('Garbage Collection in Android', 'pzfzz50W5Uo')
          .addAppVideo('Avoiding Allocations in onDraw()', 'HAK5acHQ53E')
          .build());
  AndroidAuditor.getBlockingGcAlert_ = function(frame) {
    var events = frame.associatedEvents.filter(function(event) {
      return event.title == 'DVM Suspend' ||
          event.title == 'GC: Wait For Concurrent';
    });
    var blockedDuration = Statistics.sum(events, getDuration);
    if (blockedDuration < 3)
      return undefined;

    var start = Statistics.min(events, getStart);
    events.push(frame);
    return new Alert(AndroidAuditor.blockingGcAlertInfo_, start, events,
        { 'Blocked duration': new ScalarNumeric(
            timeDurationInMs, blockedDuration) });
  };


  AndroidAuditor.lockContentionAlertInfo_ = new EventInfo(
      'Lock contention',
      'UI thread lock contention is caused when another thread holds a lock that the UI thread is trying to use. UI thread progress is blocked until the lock is released. Inspect locking done within the UI thread, and ensure critical sections are short.'); // @suppress longLineCheck
  AndroidAuditor.getLockContentionAlert_ = function(frame) {
    var events = frame.associatedEvents.filter(function(event) {
      return /^Lock Contention on /.test(event.title);
    });

    var blockedDuration = Statistics.sum(events, getDuration);
    if (blockedDuration < 1)
      return undefined;

    var start = Statistics.min(events, getStart);
    events.push(frame);
    return new Alert(AndroidAuditor.lockContentionAlertInfo_, start, events,
        { 'Blocked duration': new ScalarNumeric(
            timeDurationInMs, blockedDuration) });
  };

  AndroidAuditor.schedulingAlertInfo_ = new EventInfo(
      'Scheduling delay',
      'Work to produce this frame was descheduled for several milliseconds, contributing to jank. Ensure that code on the UI thread doesn\'t block on work being done on other threads, and that background threads (doing e.g. network or bitmap loading) are running at android.os.Process#THREAD_PRIORITY_BACKGROUND or lower so they are less likely to interrupt the UI thread. These background threads should show up with a priority number of 130 or higher in the scheduling section under the Kernel process.'); // @suppress longLineCheck
  AndroidAuditor.getSchedulingAlert_ = function(frame) {
    var totalDuration = 0;
    var totalStats = {};
    frame.threadTimeRanges.forEach(function(ttr) {
      var stats = ttr.thread.getSchedulingStatsForRange(ttr.start, ttr.end);
      tr.b.iterItems(stats, function(key, value) {
        if (!(key in totalStats))
          totalStats[key] = 0;
        totalStats[key] += value;
        totalDuration += value;
      });
    });

    // only alert if frame not running for > 3ms. Note that we expect a frame
    // to never describe intentionally idle time.
    if (!(SCHEDULING_STATE.RUNNING in totalStats) ||
        totalDuration == 0 ||
        totalDuration - totalStats[SCHEDULING_STATE.RUNNING] < 3)
      return;

    var args = {};
    tr.b.iterItems(totalStats, function(key, value) {
      if (key === SCHEDULING_STATE.RUNNABLE)
        key = 'Not scheduled, but runnable';
      else if (key === SCHEDULING_STATE.UNINTR_SLEEP)
        key = 'Blocking I/O delay';
      args[key] = new ScalarNumeric(timeDurationInMs, value);
    });

    return new Alert(AndroidAuditor.schedulingAlertInfo_, frame.start, [frame],
                     args);
  };

  AndroidAuditor.prototype = {
    __proto__: Auditor.prototype,

    renameAndSort_: function() {
      this.model.kernel.important = false;// auto collapse
      // SurfaceFlinger first, other processes sorted by slice count
      this.model.getAllProcesses().forEach(function(process) {
        if (this.helper.surfaceFlinger &&
            process == this.helper.surfaceFlinger.process) {
          if (!process.name)
            process.name = 'SurfaceFlinger';
          process.sortIndex = Number.NEGATIVE_INFINITY;
          process.important = false; // auto collapse
          return;
        }

        var uiThread = process.getThread(process.pid);
        if (!process.name && uiThread && uiThread.name) {
          if (/^ndroid\./.test(uiThread.name))
            uiThread.name = 'a' + uiThread.name;
          process.name = uiThread.name;

          uiThread.name = 'UI Thread';
        }

        process.sortIndex = 0;
        for (var tid in process.threads) {
          process.sortIndex -= process.threads[tid].sliceGroup.slices.length;
        }
      }, this);

      // ensure sequential, relative order for UI/Render/Worker threads
      this.model.getAllThreads().forEach(function(thread) {
        if (thread.tid == thread.parent.pid)
          thread.sortIndex = -3;
        if (thread.name == 'RenderThread')
          thread.sortIndex = -2;
        if (/^hwuiTask/.test(thread.name))
          thread.sortIndex = -1;
      });
    },

    pushFramesAndJudgeJank_: function() {
      var badFramesObserved = 0;
      var framesObserved = 0;
      var surfaceFlinger = this.helper.surfaceFlinger;

      this.helper.apps.forEach(function(app) {
        // override frame list
        app.process.frames = app.getFrames();

        app.process.frames.forEach(function(frame) {
          if (frame.totalDuration > EXPECTED_FRAME_TIME_MS * 2) {
            badFramesObserved += 2;
            frame.perfClass = FRAME_PERF_CLASS.TERRIBLE;
          } else if (frame.totalDuration > EXPECTED_FRAME_TIME_MS ||
              frameMissedDeadline(frame)) {
            badFramesObserved++;
            frame.perfClass = FRAME_PERF_CLASS.BAD;
          } else {
            frame.perfClass = FRAME_PERF_CLASS.GOOD;
          }
        });
        framesObserved += app.process.frames.length;
      });

      if (framesObserved) {
        var portionBad = badFramesObserved / framesObserved;
        if (portionBad > 0.3)
          this.model.faviconHue = 'red';
        else if (portionBad > 0.05)
          this.model.faviconHue = 'yellow';
        else
          this.model.faviconHue = 'green';
      }
    },

    pushEventInfo_: function() {
      var appAnnotator = new AppAnnotator();
      this.helper.apps.forEach(function(app) {
        if (app.uiThread)
          appAnnotator.applyEventInfos(app.uiThread.sliceGroup);
        if (app.renderThread)
          appAnnotator.applyEventInfos(app.renderThread.sliceGroup);
      });
    },

    runAnnotate: function() {
      if (!this.helper)
        return;

      this.renameAndSort_();
      this.pushFramesAndJudgeJank_();
      this.pushEventInfo_();

      this.helper.iterateImportantSlices(function(slice) {
        slice.important = true;
      });
    },

    runAudit: function() {
      if (!this.helper)
        return;

      var alerts = this.model.alerts;
      this.helper.apps.forEach(function(app) {
        app.getFrames().forEach(function(frame) {
          alerts.push.apply(alerts, AndroidAuditor.getSaveLayerAlerts_(frame));

          // skip most alerts for neutral or good frames
          if (frame.perfClass == FRAME_PERF_CLASS.NEUTRAL ||
              frame.perfClass == FRAME_PERF_CLASS.GOOD)
            return;

          var alert = AndroidAuditor.getPathAlert_(frame);
          if (alert)
            alerts.push(alert);
          var alert = AndroidAuditor.getUploadAlert_(frame);
          if (alert)
            alerts.push(alert);
          var alert = AndroidAuditor.getListViewAlert_(frame);
          if (alert)
            alerts.push(alert);
          var alert = AndroidAuditor.getMeasureLayoutAlert_(frame);
          if (alert)
            alerts.push(alert);
          var alert = AndroidAuditor.getViewDrawAlert_(frame);
          if (alert)
            alerts.push(alert);
          var alert = AndroidAuditor.getBlockingGcAlert_(frame);
          if (alert)
            alerts.push(alert);
          var alert = AndroidAuditor.getLockContentionAlert_(frame);
          if (alert)
            alerts.push(alert);
          var alert = AndroidAuditor.getSchedulingAlert_(frame);
          if (alert)
            alerts.push(alert);
        });
      }, this);

      this.addRenderingInteractionRecords();
      this.addInputInteractionRecords();
    },

    addRenderingInteractionRecords: function() {
      var events = [];
      this.helper.apps.forEach(function(app) {
        events.push.apply(events, app.getAnimationAsyncSlices());
        events.push.apply(events, app.getFrames());
      });

      var mergerFunction = function(events) {
        var ir = new tr.model.um.ResponseExpectation(
            this.model, 'Rendering',
            events[0].min,
            events[events.length - 1].max - events[0].min);
        this.model.userModel.expectations.push(ir);
      }.bind(this);
      tr.b.mergeRanges(tr.b.convertEventsToRanges(events), 30, mergerFunction);
    },

    addInputInteractionRecords: function() {
      var inputSamples = [];
      this.helper.apps.forEach(function(app) {
        inputSamples.push.apply(inputSamples, app.getInputSamples());
      });

      var mergerFunction = function(events) {
        var ir = new tr.model.um.ResponseExpectation(
            this.model, 'Input',
            events[0].min,
            events[events.length - 1].max - events[0].min);
        this.model.userModel.expectations.push(ir);
      }.bind(this);
      var inputRanges = inputSamples.map(function(sample) {
        return tr.b.Range.fromExplicitRange(sample.timestamp, sample.timestamp);
      });
      tr.b.mergeRanges(inputRanges, 30, mergerFunction);
    }
  };

  Auditor.register(AndroidAuditor);

  function AppAnnotator() {
    this.titleInfoLookup = {};
    this.titleParentLookup = {};
    this.build_();
  }

  AppAnnotator.prototype = {
    build_: function() {
      var registerEventInfo = function(dict) {
        this.titleInfoLookup[dict.title] = new EventInfo(
            dict.title, dict.description, dict.docLinks);
        if (dict.parents)
          this.titleParentLookup[dict.title] = dict.parents;
      }.bind(this);

      registerEventInfo({
          title: 'inflate',
          description: 'Constructing a View hierarchy from pre-processed XML via LayoutInflater#layout. This includes constructing all of the View objects in the hierarchy, and applying styled attributes.'}); // @suppress longLineCheck

      //////////////////////////////////////////////////////////////////////////
      // Adapter view
      //////////////////////////////////////////////////////////////////////////
      registerEventInfo({
          title: 'obtainView',
          description: 'Adapter#getView() called to bind content to a recycled View that is being presented.'}); // @suppress longLineCheck
      registerEventInfo({
          title: 'setupListItem',
          description: 'Attached a newly-bound, recycled View to its parent ListView.'}); // @suppress longLineCheck
      registerEventInfo({
          title: 'setupGridItem',
          description: 'Attached a newly-bound, recycled View to its parent GridView.'}); // @suppress longLineCheck

      //////////////////////////////////////////////////////////////////////////
      // Choreographer (tracing enabled on M+)
      //////////////////////////////////////////////////////////////////////////
      var choreographerLinks = new DocLinkBuilder()
          .addDacRef('Choreographer', 'android/view/Choreographer.html') // @suppress longLineCheck
          .build();
      registerEventInfo({
          title: 'Choreographer#doFrame',
          docLinks: choreographerLinks,
          description: 'Choreographer executes frame callbacks for inputs, animations, and rendering traversals. When this work is done, a frame will be presented to the user.'}); // @suppress longLineCheck
      registerEventInfo({
          title: 'input',
          parents: ['Choreographer#doFrame'],
          docLinks: choreographerLinks,
          description: 'Input callbacks are processed. This generally encompasses dispatching input to Views, as well as any work the Views do to process this input/gesture.'}); // @suppress longLineCheck
      registerEventInfo({
          title: 'animation',
          parents: ['Choreographer#doFrame'],
          docLinks: choreographerLinks,
          description: 'Animation callbacks are processed. This is generally minimal work, as animations determine progress for the frame, and push new state to animated objects (such as setting View properties).'}); // @suppress longLineCheck
      registerEventInfo({
          title: 'traversals',
          parents: ['Choreographer#doFrame'],
          docLinks: choreographerLinks,
          description: 'Primary draw traversals. This is the primary traversal of the View hierarchy, including layout and draw passes.'}); // @suppress longLineCheck

      //////////////////////////////////////////////////////////////////////////
      // performTraversals + sub methods
      //////////////////////////////////////////////////////////////////////////
      var traversalParents = ['Choreographer#doFrame', 'performTraversals'];
      var layoutLinks = new DocLinkBuilder()
          .addDacRef('View#Layout', 'android/view/View.html#Layout')
          .build();
      registerEventInfo({
          title: 'performTraversals',
          description: 'A drawing traversal of the View hierarchy, comprised of all layout and drawing needed to produce the frame.'}); // @suppress longLineCheck
      registerEventInfo({
          title: 'measure',
          parents: traversalParents,
          docLinks: layoutLinks,
          description: 'First of two phases in view hierarchy layout. Views are asked to size themselves according to constraints supplied by their parent. Some ViewGroups may measure a child more than once to help satisfy their own constraints. Nesting ViewGroups that measure children more than once can lead to excessive and repeated work.'}); // @suppress longLineCheck
      registerEventInfo({
          title: 'layout',
          parents: traversalParents,
          docLinks: layoutLinks,
          description: 'Second of two phases in view hierarchy layout, repositioning content and child Views into their new locations.'}); // @suppress longLineCheck
      var drawString = 'Draw pass over the View hierarchy. Every invalidated View will have its drawing commands recorded. On Android versions prior to Lollipop, this would also include the issuing of draw commands to the GPU. Starting with Lollipop, it only includes the recording of commands, and syncing that information to the RenderThread.'; // @suppress longLineCheck
      registerEventInfo({
          title: 'draw',
          parents: traversalParents,
          description: drawString});

      var recordString = 'Every invalidated View\'s drawing commands are recorded. Each will have View#draw() called, and is passed a Canvas that will record and store its drawing commands until it is next invalidated/rerecorded.'; // @suppress longLineCheck
      registerEventInfo({
          title: 'getDisplayList', // Legacy name for compatibility.
          parents: ['draw'],
          description: recordString});
      registerEventInfo({
          title: 'Record View#draw()',
          parents: ['draw'],
          description: recordString});

      registerEventInfo({
          title: 'drawDisplayList',
          parents: ['draw'],
          description: 'Execution of recorded draw commands to generate a frame. This represents the actual formation and issuing of drawing commands to the GPU. On Android L and higher devices, this work is done on a dedicated RenderThread, instead of on the UI Thread.'}); // @suppress longLineCheck

      //////////////////////////////////////////////////////////////////////////
      // RenderThread
      //////////////////////////////////////////////////////////////////////////
      registerEventInfo({
          title: 'DrawFrame',
          description: 'RenderThread portion of the standard UI/RenderThread split frame. This represents the actual formation and issuing of drawing commands to the GPU.'}); // @suppress longLineCheck
      registerEventInfo({
          title: 'doFrame',
          description: 'RenderThread animation frame. Represents drawing work done by the RenderThread on a frame where the UI thread did not produce new drawing content.'}); // @suppress longLineCheck
      registerEventInfo({
          title: 'syncFrameState',
          description: 'Sync stage between the UI thread and the RenderThread, where the UI thread hands off a frame (including information about modified Views). Time in this method primarily consists of uploading modified Bitmaps to the GPU. After this sync is completed, the UI thread is unblocked, and the RenderThread starts to render the frame.'}); // @suppress longLineCheck
      registerEventInfo({
          title: 'flush drawing commands',
          description: 'Issuing the now complete drawing commands to the GPU.'}); // @suppress longLineCheck
      registerEventInfo({
          title: 'eglSwapBuffers',
          description: 'Complete GPU rendering of the frame.'}); // @suppress longLineCheck

      //////////////////////////////////////////////////////////////////////////
      // RecyclerView
      //////////////////////////////////////////////////////////////////////////
      registerEventInfo({
          title: 'RV Scroll',
          description: 'RecyclerView is calculating a scroll. If there are too many of these in Systrace, some Views inside RecyclerView might be causing it. Try to avoid using EditText, focusable views or handle them with care.'}); // @suppress longLineCheck
      registerEventInfo({
          title: 'RV OnLayout',
          description: 'OnLayout has been called by the View system. If this shows up too many times in Systrace, make sure the children of RecyclerView do not update themselves directly. This will cause a full re-layout but when it happens via the Adapter notifyItemChanged, RecyclerView can avoid full layout calculation.'}); // @suppress longLineCheck
      registerEventInfo({
          title: 'RV FullInvalidate',
          description: 'NotifyDataSetChanged or equal has been called. If this is taking a long time, try sending granular notify adapter changes instead of just calling notifyDataSetChanged or setAdapter / swapAdapter. Adding stable ids to your adapter might help.'}); // @suppress longLineCheck
      registerEventInfo({
          title: 'RV PartialInvalidate',
          description: 'RecyclerView is rebinding a View. If this is taking a lot of time, consider optimizing your layout or make sure you are not doing extra operations in onBindViewHolder call.'}); // @suppress longLineCheck
      registerEventInfo({
          title: 'RV OnBindView',
          description: 'RecyclerView is rebinding a View. If this is taking a lot of time, consider optimizing your layout or make sure you are not doing extra operations in onBindViewHolder call.'}); // @suppress longLineCheck
      registerEventInfo({
          title: 'RV CreateView',
          description: 'RecyclerView is creating a new View. If too many of these are present: 1) There might be a problem in Recycling (e.g. custom Animations that set transient state and prevent recycling or ItemAnimator not implementing the contract properly. See Adapter#onFailedToRecycleView(ViewHolder). 2) There may be too many item view types. Try merging them. 3) There might be too many itemChange animations and not enough space in RecyclerPool. Try increasing your pool size and item cache size.'}); // @suppress longLineCheck

      //////////////////////////////////////////////////////////////////////////
      // Graphics + Composition
      //////////////////////////////////////////////////////////////////////////
      // TODO(ccraik): SurfaceFlinger work
      registerEventInfo({
          title: 'eglSwapBuffers',
          description: 'The CPU has finished producing drawing commands, and is flushing drawing work to the GPU, and posting that buffer to the consumer (which is often SurfaceFlinger window composition). Once this is completed, the GPU can produce the frame content without any involvement from the CPU.'}); // @suppress longLineCheck
    },

    applyEventInfosRecursive_: function(parentNames, slice) {
      var checkExpectedParentNames = function(expectedParentNames) {
        if (!expectedParentNames)
          return true;
        return expectedParentNames.some(function(name) {
          return name in parentNames;
        });
      };


      // Set EventInfo on the slice if it matches title, and parent.
      if (slice.title in this.titleInfoLookup) {
        if (checkExpectedParentNames(this.titleParentLookup[slice.title]))
          slice.info = this.titleInfoLookup[slice.title];
      }

      // Push slice into parentNames, and recurse over subSlices.
      if (slice.subSlices.length > 0) {
        // Increment title in parentName dict.
        if (!(slice.title in parentNames))
          parentNames[slice.title] = 0;
        parentNames[slice.title]++;

        // Recurse over subSlices.
        slice.subSlices.forEach(function(subSlice) {
          this.applyEventInfosRecursive_(parentNames, subSlice);
        }, this);

        // Decrement title in parentName dict.
        parentNames[slice.title]--;
        if (parentNames[slice.title] == 0)
          delete parentNames[slice.title];
      }
    },

    applyEventInfos: function(sliceGroup) {
      sliceGroup.topLevelSlices.forEach(function(slice) {
        this.applyEventInfosRecursive_({}, slice);
      }, this);
    }
  };

  return {
    AndroidAuditor: AndroidAuditor
  };
});
</script>