golden/app/js/logic.js - buildbot - Git at Google

 'use strict';


 /* Add this to the skia namespace */
 var skia = skia || {};
 (function (ns) {
   // c contains all constants. Primarily relating to backend resources.
   // They need to match the definitions in go/skiacorrectness/main.go
   ns.c = {
     // PREFIX_URL is the prefix to all backend request to JSON resources.
     PREFIX_URL: '/rest',

     // URLs exposed by the backend to retrieve JSON data.
     URL_COUNTS: '/counts',
     URL_TRIAGE: '/triage',
     URL_STATUS: '/status',

     URL_LOGIN_STATUS: '/loginstatus',
     URL_LOGOUT: '/logout',

     // The triage labels need to match the values in golden/go/types/types.go
     UNTRIAGED: 0,
     POSITIVE: 1,
     NEGATIVE: 2,

     // Key in parameters that identifies a test.
     PRIMARY_KEY_FIELD: 'name',

     CORPUS_FIELD: 'source_type',

     // Param fields to filter.
     PARAMS_FILTER: {
       'source_type': true
     },

     // Query parameters (that are not automatically available via parameters).
     QUERY_COMMIT_START: 'cs',
     QUERY_COMMIT_END: 'ce',

     // Miscellaneous query flags.
     QUERY_HEAD: 'head',
   };

   // List of states - used to cycle through via nextState.
   ns.c.ALL_STATES = [ns.c.UNTRIAGED, ns.c.POSITIVE, ns.c.NEGATIVE];

   // Set of query flags that are not related to parameters or commits.
   ns.c.QUERY_FLAGS = [ns.c.QUERY_HEAD];

     /**
      * Plot is a class that wraps the flot object and exposes draw functions.
      *
      * @param {jQueryElement} element This a jquery element to which the
                                       flot instance to attach to.
      *
      * @return {Plot} instance of Plot class.
      **/

   ns.Plot = function (element) {
     this.element = element;

     // initialize the flot element with empty data.
     this.flotObj = element.plot([], {
       legend: {
         show: true
       },
       xaxis: {
         show: true
       }
     }).data('plot');
   };


   /**
    * setData sets the data that the plot needs to draw and forces a redraw.
    * If ticks is not null it will also set the ticks and reset the x-axis.
    *
      * @param {array} data Array of series understood by Flot. See
      *           https://github.com/flot/flot/blob/master/API.md#data-format
      *
      * @param {array} ticks Array or function that defines the ticks for the
      *                      x-axis.
   */
   ns.Plot.prototype.setData = function(data, ticks) {
     this.flotObj.setData(data);

     // Set the ticks on the x axis if necessary.
     if (ticks) {
       var opt = this.flotObj.getOptions();
       opt.xaxes.forEach(function(axis) {
         axis.ticks = ticks;
       });
     }

     this.redraw();
   };

   /**
   * redraw forces a resize and redraw of the canvas.
   */
   ns.Plot.prototype.redraw = function () {
     // redraw the graph
     this.flotObj.resize();
     this.flotObj.setupGrid();
     this.flotObj.draw();
   }

   /**
    * PlotData is a class that used as the return value of processAllCounts and
    * contains the processed data.
    *  */
   ns.PlotData = function (data, ticks, allAggregates, testDetails) {
     this.plotData = data;
     this.ticks = ticks;
     this.testDetails = testDetails;
     this.allAggregates = allAggregates;
   };

   /**
    * getTicks returns the ticks for the PlotData object at hand.
    */
   ns.PlotData.prototype.getTicks = function (axis) {
     return this.ticks;
   };

   /**
   * TestDetails is a class that contails the aggregated information about
   * a single tests. It is derived from the data returned by the server.
   */
   ns.TestDetails = function (name, counts) {
     this.name = name;
     this.counts = counts;
     this.aggregates = aggregateCounts(counts);
   };

   /**
   * DiffDigestInfo is a helper class to store information about a
   * digest (usually positive) and how it differs from the a given
   * untriaged digest.
   */
   ns.DiffDigestInfo = function (digest, imgUrl, count, paramCounts, diff) {
     this.digest = digest;
     this.imgUrl = imgUrl;
     this.count = count;
     this.paramCounts = paramCounts;
     this.diff = diff;
   };

   /**
   * isIdentical returns true if the current digest is identical
   *             to the untriaged digest.
   */
   ns.DiffDigestInfo.prototype.isIdentical = function () {
     return this.diff.numDiffPixels === 0;
   }

   /**
   * addIndexAsX adds takes an array of numbers and returns an array of
   * datapoints (x,y) where x is the index of the input element y.
   */
   function addIndexAsX(arr) {
     var result = [];
     for(var i=0, len=arr.length; i<len; i++) {
       result.push([i, arr[i]])
     }
     return result;
   }

   /**
   * aggregateCounts sums over the counts contained in an object.
   * Each member in the object is assumed to be an array of numbers.
   *
   * @param { object } countsObj contains attributes where each attribute
   *                   is an array of numbers.
   * @return {object} an array with the same attributes as the input object.
   *                  Each attribute contains the sum of the corresponding
   *                  array.
   */
   function aggregateCounts(countsObj) {
     var result = {};
     var arr;
     for(var k in countsObj) {
       if (countsObj.hasOwnProperty(k)) {
         result[k] = 0;
         arr = countsObj[k];
         for(var i=0,len=arr.length; i < len; i++) {
           result[k] += arr[i];
         }
       }
     }
     return result;
   }

   /**
   * processAllCounts converts the data returned by the server to
   *  an instance of PlotData that can then be used to render the UI
   *  and also serve as input to the Plot class.
   *
   * @param {object} serverData returned from the server containing the
   *                 aggregated values over all tests.
   *
   * @param {string} testName specifies whether we want to get the data
   *                 for a specific test. If null all data are returned.
   *
   * @return {object} instance of PlotData.
   *
   */
   ns.processCounts = function (serverData, testName) {
     // get the counts from the tests.
     var testCounts = [];
     if (testName && serverData.counts.hasOwnProperty(testName)) {
       testCounts.push(new ns.TestDetails(testName, serverData.counts[testName]))
     }
     else {
       for(var tName in serverData.counts) {
         if (serverData.counts.hasOwnProperty(tName)) {
           testCounts.push(new ns.TestDetails(tName, serverData.counts[tName]));
         }
       }
     }

     // assemble the plot data.
     var targetData = testName ? serverData.counts[testName] : serverData.aggregated;
     var data = [];
     for(var k in targetData) {
       if (targetData.hasOwnProperty(k)) {
         data.push({
           label: k,
           lines: {
             show: true,
             steps: true
           },
           data: addIndexAsX(targetData[k])
         });
       }
     }

     return new ns.PlotData(data,
                            serverData.ticks,
                            aggregateCounts(serverData.aggregated),
                            testCounts);
   };


   /**
     getAutoCommitRanges returns a list of decreasing commit ranges
     that can be used to render a simple selection on the screen.
     TODO: Make this adaptive on the backend so that the minimum is not
     5 but whatever number of commits cover all traces aka constitute
     out current knowledge of HEAD.
   */
   var COMMIT_INTERVALS = [100, 50, 20, 15, 10, 5];
   ns.getAutoCommitRanges = function(serverData) {
     var commits = serverData.commits;
     var result = [{ start: commits[0], name: commits.length }];
     for(var i=0, len=COMMIT_INTERVALS.length; i < len; i++) {
       if (commits.length > COMMIT_INTERVALS[i]) {
         result.push({ start: commits[COMMIT_INTERVALS[i]-1], name: COMMIT_INTERVALS[i] });
       }
     }

     return result;
   };

   /**
   * extractTriageData is the central function to pre-process data coming
   *                   from the server.
   */
   ns.extractTriageData = function (serverData, filterParams) {
     var result = [];
     var triageState = {};
     var totalUnt = new Stats(),
         totalPos = new Stats(),
         totalNeg = new Stats();

     for (var i = 0, len = serverData.tests.length; i < len; i++) {
       var untStats = new Stats();
       var posStats = new Stats();
       var negStats = new Stats();
       var positive = ns.getSortedDigests(serverData, 'positive', posStats, i);
       var negative = ns.getSortedDigests(serverData, 'negative', negStats, i);
       var untriaged = ns.getUntriagedSorted(serverData, i, untStats);
       var testName = serverData.tests[i].name;

       // Set the triage state for each digest.
       var add = function(arr, state) {
         for (var i=0, len=arr.length; i<len; i++) {
           triageState[testName][arr[i].digest] = state;
         }
       };

       triageState[testName] = {};
       add(positive[0], ns.c.POSITIVE);
       add(negative[0], ns.c.NEGATIVE);
       add(untriaged, ns.c.UNTRIAGED);

       result.push({
         name: testName,
         untriaged: untriaged,
         positive:  positive[0],
         positiveMap: positive[1],
         negative:  negative[0],
         negativeMap: negative[1],
         untStats:  untStats,
         posStats:  posStats,
         negStats:  negStats
       });

       totalPos.add(posStats);
       totalNeg.add(negStats);
       totalUnt.add(untStats);
     }

     return {
       tests: result,
       allParams: ns.getSortedParams(serverData, filterParams),
       triageState: triageState,
       commitRanges: ns.getAutoCommitRanges(serverData),
       untStats: totalUnt,
       posStats: totalPos,
       negStats: totalNeg
     };
   };

   /**
   * extractTriageListData returns test data across tests from data returned
   * by the server. Currently shows number of unques digests for each test.
   */
   ns.extractTriageListData = function (serverData) {
     var result = [];
     var tests = serverData.tests;
     for (var i=0, len=tests.length; i < len; i++) {
       var t = tests[i];
       var  posK = ns.keys(t.positive);
       var  negK = ns.keys(t.negative);
       var  untK = ns.keys(t.untriaged);
       var showPos = (posK.length > 0) && t.positive[posK[0]];
       var showUnt = (untK.length > 0) && t.untriaged[untK[0]];
       var showDif = (posK.length > 0) && (untK.length > 0);

       var untStats = new Stats();
       var untriaged = ns.getUntriagedSorted(serverData, i, untStats);

       // Return the stats element and the list of untriaged Digests.
       result.push({
         name: t.name,
         posLen: posK.length,
         negLen: negK.length,
         untLen: untK.length,
         showPos: showPos,
         showUnt: showUnt,
         showDif: showDif,
         untriaged: untriaged
       });
     }

     result.sort(function(a,b) {
       return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
     });

     return {
       tests: result,
       allParams: ns.getSortedParams(serverData, false),
       commitRanges: ns.getAutoCommitRanges(serverData)
     };
   };

   /**
   * Stats is a helper class to hold counts about a set of digests.
   */
   function Stats(total, unique) {
     this.total = total || 0;
     this.unique = unique || 0;
   }

   Stats.prototype.set = function (total, unique) {
     this.total = total;
     this.unique = unique;
   };

   Stats.prototype.add = function (statsObj) {
     this.total += statsObj.total;
     this.unique += statsObj.unique;
   };

   /**
   *  getUntriagedSorted returns the untriaged digests sorted by largest
   *  deviation from a positively labeled digest. It processes the data
   *  directly returned by the backend.
   *  It also resolves the references to the positive digests contained in
   *  the diff metrics.
   */
   ns.getUntriagedSorted = function(serverData, testIdx, stats) {
     var unt = robust_get(serverData, ['tests', testIdx, 'untriaged']);
     if (!unt) {
       return [];
     }

     var posd, d;
     var result = [];
     var positive = serverData.tests[testIdx].positive;
     var hasPos = false;
     var total = 0;

     for (var digest in unt) {
       if (unt.hasOwnProperty(digest)) {
         total += unt[digest].count;
         var posDiffs = [];
         var useDiffs = robust_get(unt, [digest, 'diffs']);
         if (useDiffs) {
           for(var i=0, len=useDiffs.length; i < len; i++) {
             // TODO (stephana): Fill in expanding the diff information.
             // This will be done once triaging works. So we can test it
             // with real data.
             d = useDiffs[i];
             if (d) {
               posd = positive[d.posDigest];
               posDiffs.push(new ns.DiffDigestInfo(d.posDigest, posd.imgUrl,
                                              posd.count, posd.paramCounts, d));
             }
           }
         }
         hasPos = hasPos || (posDiffs.length > 0);

         // Inject the digest and the augmented positive diffs.
         unt[digest].digest = digest;
         unt[digest].positiveDiffs = posDiffs;
         unt[digest].paramCounts = ns.filterObject(unt[digest].paramCounts, ns.c.PARAMS_FILTER);
         result.push(unt[digest]);
       }
     }


     if (hasPos) {
       result = result.filter(function(a) {
         return a.positiveDiffs.length > 0;
       });
     }
     stats.set(total, result.length);

     // Sort the result increasing by pixel difference or
     // decreasing by counts if there are no positives.
     var sortFn;
     if (hasPos) {
       sortFn = function (a,b) {
         return a.positiveDiffs[0].diff.numDiffPixels - b.positiveDiffs[0].diff.numDiffPixels;
       };
     } else {
       sortFn = function (a,b) { return b.count - a.count; };
     }
     result.sort(sortFn);

     return result;
   };

   /**
   * getSortedPositivesFromUntriaged returns the list of positively labeled
   * digests. It assumes that 'untriagedRec' was generated by a call to
   * getUntriagedSorted(...).
   */
   ns.getSortedPositivesFromUntriaged = function (untriagedRec) {
     if (untriagedRec && untriagedRec.positiveDiffs && untriagedRec.positiveDiffs.length > 0) {
       return untriagedRec.positiveDiffs;
     }

     return [];
   };

   /**
   * getSortedDigests returns a list of digests with the given digestClass
   * from the data returnded by the backend. This is to be used when there are no
   * untriaged digests.
   */
   ns.getSortedDigests= function (serverData, digestClass, stats, idx) {
     var targetDigests = robust_get(serverData, ['tests', idx, digestClass]);
     if (!targetDigests)  {
       return [[], {}];
     }

     var result = [];
     var total = 0;
     for (var digest in targetDigests) {
       if (targetDigests.hasOwnProperty(digest)) {
         total += targetDigests[digest].count;
         // Inject the digest into the object.
         targetDigests[digest].digest = digest;
         targetDigests[digest].paramCounts = ns.filterObject(
                         targetDigests[digest].paramCounts, ns.c.PARAMS_FILTER);
         result.push(targetDigests[digest]);
       }
     }

     stats.set(total, result.length);

     // Sort the result in decreasing order of their occurences.
     result.sort(function (a,b) {
       a.count - b.count;
     });

     return [result, targetDigests];
   };

   /**
   * getSortedParams returns all parameters and the union of their values as a
   * (nested) sorted Array in the format:
   *       [[param1, [val1, val2, ...],
            [param2, [val3, val4, ...], ... ]]]
   */
   ns.getSortedParams = function (serverData, filter) {
     var result = [];
     for(var k in serverData.allParams) {
       if (serverData.allParams.hasOwnProperty(k) && (!filter || !ns.c.PARAMS_FILTER[k])) {
           serverData.allParams[k].sort();
           result.push([k, serverData.allParams[k]]);
       }
     }

     result.sort(function(a,b){
       return (a[0] < b[0]) ? -1 : (a[0] > b[0]) ? 1 : 0;
     });

     return result;
   };

   /**
   * filterQueryByParams returns a suboject of query only containing
   * the members that are in sortedParams. sortedParams is assumed to be
   * the same format as returned by the getSortedParams function.
   */

   ns.filterQueryByParams = function (query, sortedParams) {
     if  (!sortedParams || !query) {
       return {};
     }

     var result = {};
     for (var i=0, len=sortedParams.length; i<len; i++) {
       if (query.hasOwnProperty(sortedParams[i][0])) {
         result[sortedParams[i][0]] = query[sortedParams[i][0]];
       }
     }
     return result;
   }

   function robustArrayOrStr(obj, key, idx) {
     if (!obj) {
       return obj;
     }

     if (!obj[key]) {
       return obj[key];
     }

     if (Array.isArray(obj[key])) {
       return obj[key][idx];
     }
     return obj[key];
   }

   ns.splitQuery = function (query, allParams) {
     var paramQuery = ns.filterQueryByParams(query, allParams);
     var flagsQuery = ns.subObject(query, ns.c.QUERY_FLAGS);

     var crq = {};
     crq[ns.c.QUERY_COMMIT_START] = robustArrayOrStr(query, ns.c.QUERY_COMMIT_START, 0) || "";
     crq[ns.c.QUERY_COMMIT_END] = robustArrayOrStr(query, ns.c.QUERY_COMMIT_END, 0) || "";

     return {
       paramQuery: paramQuery,
       commitRangeQuery: crq,
       flagsQuery: flagsQuery,
     };
   }

   // flatQueryValueOr returns the value in query identified by
   // key. If that value is an array it will return the first element
   // in the array. If the value is a string it will return the string.
   // If key doesn't exist or the array is empty the defaultValue will be
   // returned.
   ns.flatQueryValueOr = function(query, key, defaultVal) {
     var val = query[key];

     if (!val) {
       return defaultVal;
     }

     if (Array.isArray(val)) {
       if (val.length > 0) {
         return val[0];
       }
       return defaultVal;
     }
     return val;
   };

   // sortedKeys returns the keys of the object in sorted order.
   ns.sortedKeys = function(obj) {
     var result = ns.keys(obj);
     result.sort();
     return result;
   };

   // keys returns the keys of an object.
   ns.keys = function(obj) {
     if (obj.keys) {
       return keys();
     }
     var result = [];
     for(var k in obj) {
       if (obj.hasOwnProperty(k)) {
         result.push(k);
       }
     }
     return result;
   };

   // Returns an object as an array sorted by keys. This assumes that the keys
   // are strings.
   ns.getSortedObject = function(obj) {
     var result = [];
     for(var k in obj) {
       if (obj.hasOwnProperty(k)) {
         result.push([k, obj[k]]);
       }
     }

     result.sort(function(a,b) {
       return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0;
     });

     return result;
   };

   /**
   * getCombinedParamsTable takes a variable number of paramCounts and
   * combines them into a multi dimensional array to be displayed as a
   * table. The output format is:
   *    [
   *     { p: 'paramName1', c: [['val1','val2'],['val3', 'val4']] },
   *     { p: 'paramName2', c: [['valx','valy'],['val3', 'val4']] },
   *     { p: 'paramName3', c: [['val1','val2'],['val3', 'val4']] },
   *     { p: 'paramName4', c: [['val1','val2'],['val3', 'val4']] }
   *    ]
   * The array is sorted by values of 'p'.
   */
   ns.getCombinedParamsTable = function ( _ ) {
     var combined = {};
     for(var i=0, len=arguments.length; (i<len) && arguments[i]; i++) {
       var params = arguments[i];
       for(var k in params) {
         if (params.hasOwnProperty(k)) {
           if (!combined[k]) {
             combined[k] = [];
           }
           combined[k][i] = ns.sortedKeys(params[k]);
         }
       }
     }

     var result = [];
     for(var k in combined) {
       if (combined.hasOwnProperty(k)) {
         result.push({p: k, c: combined[k]});
       }
     }

     result.sort(function(a,b) {
       return (a.p < b.p) ? -1 : (a.p > b.p) ? 1 : 0;
     });

     return result;
   };

   /**
   * nextState returns the next state in the order defined by ALL_STATES.
   */
   ns.nextState = function(state) {
     var idx = (ns.c.ALL_STATES.indexOf(state) + 1) % ns.c.ALL_STATES.length;
     return ns.c.ALL_STATES[idx];
   };

   /**
   * getNumArray returns an array of numbers of the given length and each
   * element is initialized with initVal. If initVal is omitted, 0 (zero)
   * is used instead.
   */
   ns.getNumArray = function(len, initVal) {
     if (!initVal) {
       initVal = 0;
     }

     var result = [];
     for(var i =0; i < len; i++) {
       result.push(initVal);
     }

     return result;
   };

   /**
   * updateDelta updates the given delta between changed and original for the
   * given testname. If testName evaluates to false the deltas for all tests
   * are calculated. It returns the number of changes this delta would result
   * in.
   */
   ns.updateDelta = function (changed, original, delta, testName) {
     var useTestNames = (testName) ? [testName] : ns.keys(changed);
     var testDelta, testCount, tn;

     for (var i = 0, len = useTestNames.length; i < len; i++) {
       tn = useTestNames[i];
       if (changed.hasOwnProperty(tn)) {
         testDelta = {};
         testCount = 0;

         for (var k in changed[tn]) {
           if (changed[tn].hasOwnProperty(k) &&
               original[tn].hasOwnProperty(k) &&
               (changed[tn][k] !== original[tn][k])) {
             testDelta[k] = changed[tn][k];
             testCount++;
           }
         }

         delta[tn] = {
           delta: testDelta,
           count: testCount
         };
       }
     }

     var pendingCount = 0;
     for(var k in delta) {
       if (delta.hasOwnProperty(k)) {
         pendingCount += delta[k].count;
       }
     }

     return pendingCount;
   };

   /**
   * filterObject returns a copy of 'obj' without the members that
   *              are also members in 'exclude'.
   */
   ns.filterObject = function(obj, exclude) {
     var result = {};
     for(var k in obj) {
       if (obj.hasOwnProperty(k) && !exclude[k]) {
         result[k] = obj[k];
       }
     }

     return result;
   };

   /**
   * subObject returns a new object with only the members that are
   * also in include which is expected to be an array of strings.
   */
   ns.subObject = function(obj, include) {
     var result = {};
     for (var i=0, len=include.length; i<len; i++) {
       if (obj.hasOwnProperty(include[i])) {
         result[include[i]] = obj[include[i]];
       }
     }
     return result;
   };

   /**
   * unionObject returns a new object with the union of all the members
   * of the arbibrary number of objects that are supplied.
   */
   ns.unionObject = function( _ ) {
     var result = {};
     for(var i=0, len=arguments.length; i<len; i++) {
       for(var k in arguments[i]) {
         if (arguments[i].hasOwnProperty(k)) {
           result[k] = arguments[i][k];
         }
       }
     }
     return result;
   }

   /**
   * TriageDigestReq is a container type for sending labeled digests to the
   * backend. It matches the input parameters of the triageDigestsHandler in
   * 'go/skiacorrectness/main.go'.
   */

   ns.TriageDigestReq = function () {
   };

   /**
   * addDigestLabel is a convenience method to add digests and their label to the
   * the instance.
   */
   ns.TriageDigestReq.prototype.add = function (testName, digest, label) {
     this[testName] = this[testName] || {};
     this[testName][digest] = label;
   };

   /////////////////////////////////////////////////////////////////
   // Generic utility functions.
   /////////////////////////////////////////////////////////////////
   /*
   * isEmpty returns true if the provided object is empty and false
   *         otherwise.
   */
   ns.isEmpty = function (obj) {
     for (var k in obj) {
       if (obj.hasOwnProperty(k)) {
         return false;
       }
     }
     return true;
   };

   /*
   */
   ns.extractQueryString = function (url) {
     var idx = url.indexOf('?');
     return (idx === -1) ? '' : url.substring(idx);
   };

   /////////////////////////////////////////////////////////////////
   // Utility functions that are not exposed in the namespace.
   /////////////////////////////////////////////////////////////////

   /**
    * robust_get finds a sub object within 'obj' by following the path
    * in 'idx'. It will not throw an error if any sub object is missing
    * but instead return 'undefined'.
    **/
   function robust_get(obj, idx) {
     if (!idx) {
       return;
     }

     for(var i=0, len=idx.length; i<len; i++) {
       if ((typeof obj === 'undefined') || (typeof idx[i] === 'undefined')) {
         return;  // returns 'undefined'
       }

       obj = obj[idx[i]];
     }

     return obj;
   }


 })(skia);
	'use strict';


	/* Add this to the skia namespace */
	var skia = skia \|\| {};
	(function (ns) {
	// c contains all constants. Primarily relating to backend resources.
	// They need to match the definitions in go/skiacorrectness/main.go
	ns.c = {
	// PREFIX_URL is the prefix to all backend request to JSON resources.
	PREFIX_URL: '/rest',

	// URLs exposed by the backend to retrieve JSON data.
	URL_COUNTS: '/counts',
	URL_TRIAGE: '/triage',
	URL_STATUS: '/status',

	URL_LOGIN_STATUS: '/loginstatus',
	URL_LOGOUT: '/logout',

	// The triage labels need to match the values in golden/go/types/types.go
	UNTRIAGED: 0,
	POSITIVE: 1,
	NEGATIVE: 2,

	// Key in parameters that identifies a test.
	PRIMARY_KEY_FIELD: 'name',

	CORPUS_FIELD: 'source_type',

	// Param fields to filter.
	PARAMS_FILTER: {
	'source_type': true
	},

	// Query parameters (that are not automatically available via parameters).
	QUERY_COMMIT_START: 'cs',
	QUERY_COMMIT_END: 'ce',

	// Miscellaneous query flags.
	QUERY_HEAD: 'head',
	};

	// List of states - used to cycle through via nextState.
	ns.c.ALL_STATES = [ns.c.UNTRIAGED, ns.c.POSITIVE, ns.c.NEGATIVE];

	// Set of query flags that are not related to parameters or commits.
	ns.c.QUERY_FLAGS = [ns.c.QUERY_HEAD];

	/**
	* Plot is a class that wraps the flot object and exposes draw functions.
	*
	* @param {jQueryElement} element This a jquery element to which the
	flot instance to attach to.
	*
	* @return {Plot} instance of Plot class.
	**/

	ns.Plot = function (element) {
	this.element = element;

	// initialize the flot element with empty data.
	this.flotObj = element.plot([], {
	legend: {
	show: true
	},
	xaxis: {
	show: true
	}
	}).data('plot');
	};


	/**
	* setData sets the data that the plot needs to draw and forces a redraw.
	* If ticks is not null it will also set the ticks and reset the x-axis.
	*
	* @param {array} data Array of series understood by Flot. See
	* https://github.com/flot/flot/blob/master/API.md#data-format
	*
	* @param {array} ticks Array or function that defines the ticks for the
	* x-axis.
	*/
	ns.Plot.prototype.setData = function(data, ticks) {
	this.flotObj.setData(data);

	// Set the ticks on the x axis if necessary.
	if (ticks) {
	var opt = this.flotObj.getOptions();
	opt.xaxes.forEach(function(axis) {
	axis.ticks = ticks;
	});
	}

	this.redraw();
	};

	/**
	* redraw forces a resize and redraw of the canvas.
	*/
	ns.Plot.prototype.redraw = function () {
	// redraw the graph
	this.flotObj.resize();
	this.flotObj.setupGrid();
	this.flotObj.draw();
	}

	/**
	* PlotData is a class that used as the return value of processAllCounts and
	* contains the processed data.
	* */
	ns.PlotData = function (data, ticks, allAggregates, testDetails) {
	this.plotData = data;
	this.ticks = ticks;
	this.testDetails = testDetails;
	this.allAggregates = allAggregates;
	};

	/**
	* getTicks returns the ticks for the PlotData object at hand.
	*/
	ns.PlotData.prototype.getTicks = function (axis) {
	return this.ticks;
	};

	/**
	* TestDetails is a class that contails the aggregated information about
	* a single tests. It is derived from the data returned by the server.
	*/
	ns.TestDetails = function (name, counts) {
	this.name = name;
	this.counts = counts;
	this.aggregates = aggregateCounts(counts);
	};

	/**
	* DiffDigestInfo is a helper class to store information about a
	* digest (usually positive) and how it differs from the a given
	* untriaged digest.
	*/
	ns.DiffDigestInfo = function (digest, imgUrl, count, paramCounts, diff) {
	this.digest = digest;
	this.imgUrl = imgUrl;
	this.count = count;
	this.paramCounts = paramCounts;
	this.diff = diff;
	};

	/**
	* isIdentical returns true if the current digest is identical
	* to the untriaged digest.
	*/
	ns.DiffDigestInfo.prototype.isIdentical = function () {
	return this.diff.numDiffPixels === 0;
	}

	/**
	* addIndexAsX adds takes an array of numbers and returns an array of
	* datapoints (x,y) where x is the index of the input element y.
	*/
	function addIndexAsX(arr) {
	var result = [];
	for(var i=0, len=arr.length; i<len; i++) {
	result.push([i, arr[i]])
	}
	return result;
	}

	/**
	* aggregateCounts sums over the counts contained in an object.
	* Each member in the object is assumed to be an array of numbers.
	*
	* @param { object } countsObj contains attributes where each attribute
	* is an array of numbers.
	* @return {object} an array with the same attributes as the input object.
	* Each attribute contains the sum of the corresponding
	* array.
	*/
	function aggregateCounts(countsObj) {
	var result = {};
	var arr;
	for(var k in countsObj) {
	if (countsObj.hasOwnProperty(k)) {
	result[k] = 0;
	arr = countsObj[k];
	for(var i=0,len=arr.length; i < len; i++) {
	result[k] += arr[i];
	}
	}
	}
	return result;
	}

	/**
	* processAllCounts converts the data returned by the server to
	* an instance of PlotData that can then be used to render the UI
	* and also serve as input to the Plot class.
	*
	* @param {object} serverData returned from the server containing the
	* aggregated values over all tests.
	*
	* @param {string} testName specifies whether we want to get the data
	* for a specific test. If null all data are returned.
	*
	* @return {object} instance of PlotData.
	*
	*/
	ns.processCounts = function (serverData, testName) {
	// get the counts from the tests.
	var testCounts = [];
	if (testName && serverData.counts.hasOwnProperty(testName)) {
	testCounts.push(new ns.TestDetails(testName, serverData.counts[testName]))
	}
	else {
	for(var tName in serverData.counts) {
	if (serverData.counts.hasOwnProperty(tName)) {
	testCounts.push(new ns.TestDetails(tName, serverData.counts[tName]));
	}
	}
	}

	// assemble the plot data.
	var targetData = testName ? serverData.counts[testName] : serverData.aggregated;
	var data = [];
	for(var k in targetData) {
	if (targetData.hasOwnProperty(k)) {
	data.push({
	label: k,
	lines: {
	show: true,
	steps: true
	},
	data: addIndexAsX(targetData[k])
	});
	}
	}

	return new ns.PlotData(data,
	serverData.ticks,
	aggregateCounts(serverData.aggregated),
	testCounts);
	};



	/**
	getAutoCommitRanges returns a list of decreasing commit ranges
	that can be used to render a simple selection on the screen.
	TODO: Make this adaptive on the backend so that the minimum is not
	5 but whatever number of commits cover all traces aka constitute
	out current knowledge of HEAD.
	*/
	var COMMIT_INTERVALS = [100, 50, 20, 15, 10, 5];
	ns.getAutoCommitRanges = function(serverData) {
	var commits = serverData.commits;
	var result = [{ start: commits[0], name: commits.length }];
	for(var i=0, len=COMMIT_INTERVALS.length; i < len; i++) {
	if (commits.length > COMMIT_INTERVALS[i]) {
	result.push({ start: commits[COMMIT_INTERVALS[i]-1], name: COMMIT_INTERVALS[i] });
	}
	}

	return result;
	};

	/**
	* extractTriageData is the central function to pre-process data coming
	* from the server.
	*/
	ns.extractTriageData = function (serverData, filterParams) {
	var result = [];
	var triageState = {};
	var totalUnt = new Stats(),
	totalPos = new Stats(),
	totalNeg = new Stats();

	for (var i = 0, len = serverData.tests.length; i < len; i++) {
	var untStats = new Stats();
	var posStats = new Stats();
	var negStats = new Stats();
	var positive = ns.getSortedDigests(serverData, 'positive', posStats, i);
	var negative = ns.getSortedDigests(serverData, 'negative', negStats, i);
	var untriaged = ns.getUntriagedSorted(serverData, i, untStats);
	var testName = serverData.tests[i].name;

	// Set the triage state for each digest.
	var add = function(arr, state) {
	for (var i=0, len=arr.length; i<len; i++) {
	triageState[testName][arr[i].digest] = state;
	}
	};

	triageState[testName] = {};
	add(positive[0], ns.c.POSITIVE);
	add(negative[0], ns.c.NEGATIVE);
	add(untriaged, ns.c.UNTRIAGED);

	result.push({
	name: testName,
	untriaged: untriaged,
	positive: positive[0],
	positiveMap: positive[1],
	negative: negative[0],
	negativeMap: negative[1],
	untStats: untStats,
	posStats: posStats,
	negStats: negStats
	});

	totalPos.add(posStats);
	totalNeg.add(negStats);
	totalUnt.add(untStats);
	}

	return {
	tests: result,
	allParams: ns.getSortedParams(serverData, filterParams),
	triageState: triageState,
	commitRanges: ns.getAutoCommitRanges(serverData),
	untStats: totalUnt,
	posStats: totalPos,
	negStats: totalNeg
	};
	};

	/**
	* extractTriageListData returns test data across tests from data returned
	* by the server. Currently shows number of unques digests for each test.
	*/
	ns.extractTriageListData = function (serverData) {
	var result = [];
	var tests = serverData.tests;
	for (var i=0, len=tests.length; i < len; i++) {
	var t = tests[i];
	var posK = ns.keys(t.positive);
	var negK = ns.keys(t.negative);
	var untK = ns.keys(t.untriaged);
	var showPos = (posK.length > 0) && t.positive[posK[0]];
	var showUnt = (untK.length > 0) && t.untriaged[untK[0]];
	var showDif = (posK.length > 0) && (untK.length > 0);

	var untStats = new Stats();
	var untriaged = ns.getUntriagedSorted(serverData, i, untStats);

	// Return the stats element and the list of untriaged Digests.
	result.push({
	name: t.name,
	posLen: posK.length,
	negLen: negK.length,
	untLen: untK.length,
	showPos: showPos,
	showUnt: showUnt,
	showDif: showDif,
	untriaged: untriaged
	});
	}

	result.sort(function(a,b) {
	return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
	});

	return {
	tests: result,
	allParams: ns.getSortedParams(serverData, false),
	commitRanges: ns.getAutoCommitRanges(serverData)
	};
	};

	/**
	* Stats is a helper class to hold counts about a set of digests.
	*/
	function Stats(total, unique) {
	this.total = total \|\| 0;
	this.unique = unique \|\| 0;
	}

	Stats.prototype.set = function (total, unique) {
	this.total = total;
	this.unique = unique;
	};

	Stats.prototype.add = function (statsObj) {
	this.total += statsObj.total;
	this.unique += statsObj.unique;
	};

	/**
	* getUntriagedSorted returns the untriaged digests sorted by largest
	* deviation from a positively labeled digest. It processes the data
	* directly returned by the backend.
	* It also resolves the references to the positive digests contained in
	* the diff metrics.
	*/
	ns.getUntriagedSorted = function(serverData, testIdx, stats) {
	var unt = robust_get(serverData, ['tests', testIdx, 'untriaged']);
	if (!unt) {
	return [];
	}

	var posd, d;
	var result = [];
	var positive = serverData.tests[testIdx].positive;
	var hasPos = false;
	var total = 0;

	for (var digest in unt) {
	if (unt.hasOwnProperty(digest)) {
	total += unt[digest].count;
	var posDiffs = [];
	var useDiffs = robust_get(unt, [digest, 'diffs']);
	if (useDiffs) {
	for(var i=0, len=useDiffs.length; i < len; i++) {
	// TODO (stephana): Fill in expanding the diff information.
	// This will be done once triaging works. So we can test it
	// with real data.
	d = useDiffs[i];
	if (d) {
	posd = positive[d.posDigest];
	posDiffs.push(new ns.DiffDigestInfo(d.posDigest, posd.imgUrl,
	posd.count, posd.paramCounts, d));
	}
	}
	}
	hasPos = hasPos \|\| (posDiffs.length > 0);

	// Inject the digest and the augmented positive diffs.
	unt[digest].digest = digest;
	unt[digest].positiveDiffs = posDiffs;
	unt[digest].paramCounts = ns.filterObject(unt[digest].paramCounts, ns.c.PARAMS_FILTER);
	result.push(unt[digest]);
	}
	}


	if (hasPos) {
	result = result.filter(function(a) {
	return a.positiveDiffs.length > 0;
	});
	}
	stats.set(total, result.length);

	// Sort the result increasing by pixel difference or
	// decreasing by counts if there are no positives.
	var sortFn;
	if (hasPos) {
	sortFn = function (a,b) {
	return a.positiveDiffs[0].diff.numDiffPixels - b.positiveDiffs[0].diff.numDiffPixels;
	};
	} else {
	sortFn = function (a,b) { return b.count - a.count; };
	}
	result.sort(sortFn);

	return result;
	};

	/**
	* getSortedPositivesFromUntriaged returns the list of positively labeled
	* digests. It assumes that 'untriagedRec' was generated by a call to
	* getUntriagedSorted(...).
	*/
	ns.getSortedPositivesFromUntriaged = function (untriagedRec) {
	if (untriagedRec && untriagedRec.positiveDiffs && untriagedRec.positiveDiffs.length > 0) {
	return untriagedRec.positiveDiffs;
	}

	return [];
	};

	/**
	* getSortedDigests returns a list of digests with the given digestClass
	* from the data returnded by the backend. This is to be used when there are no
	* untriaged digests.
	*/
	ns.getSortedDigests= function (serverData, digestClass, stats, idx) {
	var targetDigests = robust_get(serverData, ['tests', idx, digestClass]);
	if (!targetDigests) {
	return [[], {}];
	}

	var result = [];
	var total = 0;
	for (var digest in targetDigests) {
	if (targetDigests.hasOwnProperty(digest)) {
	total += targetDigests[digest].count;
	// Inject the digest into the object.
	targetDigests[digest].digest = digest;
	targetDigests[digest].paramCounts = ns.filterObject(
	targetDigests[digest].paramCounts, ns.c.PARAMS_FILTER);
	result.push(targetDigests[digest]);
	}
	}

	stats.set(total, result.length);

	// Sort the result in decreasing order of their occurences.
	result.sort(function (a,b) {
	a.count - b.count;
	});

	return [result, targetDigests];
	};

	/**
	* getSortedParams returns all parameters and the union of their values as a
	* (nested) sorted Array in the format:
	* [[param1, [val1, val2, ...],
	[param2, [val3, val4, ...], ... ]]]
	*/
	ns.getSortedParams = function (serverData, filter) {
	var result = [];
	for(var k in serverData.allParams) {
	if (serverData.allParams.hasOwnProperty(k) && (!filter \|\| !ns.c.PARAMS_FILTER[k])) {
	serverData.allParams[k].sort();
	result.push([k, serverData.allParams[k]]);
	}
	}

	result.sort(function(a,b){
	return (a[0] < b[0]) ? -1 : (a[0] > b[0]) ? 1 : 0;
	});

	return result;
	};

	/**
	* filterQueryByParams returns a suboject of query only containing
	* the members that are in sortedParams. sortedParams is assumed to be
	* the same format as returned by the getSortedParams function.
	*/

	ns.filterQueryByParams = function (query, sortedParams) {
	if (!sortedParams \|\| !query) {
	return {};
	}

	var result = {};
	for (var i=0, len=sortedParams.length; i<len; i++) {
	if (query.hasOwnProperty(sortedParams[i][0])) {
	result[sortedParams[i][0]] = query[sortedParams[i][0]];
	}
	}
	return result;
	}

	function robustArrayOrStr(obj, key, idx) {
	if (!obj) {
	return obj;
	}

	if (!obj[key]) {
	return obj[key];
	}

	if (Array.isArray(obj[key])) {
	return obj[key][idx];
	}
	return obj[key];
	}

	ns.splitQuery = function (query, allParams) {
	var paramQuery = ns.filterQueryByParams(query, allParams);
	var flagsQuery = ns.subObject(query, ns.c.QUERY_FLAGS);

	var crq = {};
	crq[ns.c.QUERY_COMMIT_START] = robustArrayOrStr(query, ns.c.QUERY_COMMIT_START, 0) \|\| "";
	crq[ns.c.QUERY_COMMIT_END] = robustArrayOrStr(query, ns.c.QUERY_COMMIT_END, 0) \|\| "";

	return {
	paramQuery: paramQuery,
	commitRangeQuery: crq,
	flagsQuery: flagsQuery,
	};
	}

	// flatQueryValueOr returns the value in query identified by
	// key. If that value is an array it will return the first element
	// in the array. If the value is a string it will return the string.
	// If key doesn't exist or the array is empty the defaultValue will be
	// returned.
	ns.flatQueryValueOr = function(query, key, defaultVal) {
	var val = query[key];

	if (!val) {
	return defaultVal;
	}

	if (Array.isArray(val)) {
	if (val.length > 0) {
	return val[0];
	}
	return defaultVal;
	}
	return val;
	};

	// sortedKeys returns the keys of the object in sorted order.
	ns.sortedKeys = function(obj) {
	var result = ns.keys(obj);
	result.sort();
	return result;
	};

	// keys returns the keys of an object.
	ns.keys = function(obj) {
	if (obj.keys) {
	return keys();
	}
	var result = [];
	for(var k in obj) {
	if (obj.hasOwnProperty(k)) {
	result.push(k);
	}
	}
	return result;
	};

	// Returns an object as an array sorted by keys. This assumes that the keys
	// are strings.
	ns.getSortedObject = function(obj) {
	var result = [];
	for(var k in obj) {
	if (obj.hasOwnProperty(k)) {
	result.push([k, obj[k]]);
	}
	}

	result.sort(function(a,b) {
	return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0;
	});

	return result;
	};

	/**
	* getCombinedParamsTable takes a variable number of paramCounts and
	* combines them into a multi dimensional array to be displayed as a
	* table. The output format is:
	* [
	* { p: 'paramName1', c: [['val1','val2'],['val3', 'val4']] },
	* { p: 'paramName2', c: [['valx','valy'],['val3', 'val4']] },
	* { p: 'paramName3', c: [['val1','val2'],['val3', 'val4']] },
	* { p: 'paramName4', c: [['val1','val2'],['val3', 'val4']] }
	* ]
	* The array is sorted by values of 'p'.
	*/
	ns.getCombinedParamsTable = function ( _ ) {
	var combined = {};
	for(var i=0, len=arguments.length; (i<len) && arguments[i]; i++) {
	var params = arguments[i];
	for(var k in params) {
	if (params.hasOwnProperty(k)) {
	if (!combined[k]) {
	combined[k] = [];
	}
	combined[k][i] = ns.sortedKeys(params[k]);
	}
	}
	}

	var result = [];
	for(var k in combined) {
	if (combined.hasOwnProperty(k)) {
	result.push({p: k, c: combined[k]});
	}
	}

	result.sort(function(a,b) {
	return (a.p < b.p) ? -1 : (a.p > b.p) ? 1 : 0;
	});

	return result;
	};

	/**
	* nextState returns the next state in the order defined by ALL_STATES.
	*/
	ns.nextState = function(state) {
	var idx = (ns.c.ALL_STATES.indexOf(state) + 1) % ns.c.ALL_STATES.length;
	return ns.c.ALL_STATES[idx];
	};

	/**
	* getNumArray returns an array of numbers of the given length and each
	* element is initialized with initVal. If initVal is omitted, 0 (zero)
	* is used instead.
	*/
	ns.getNumArray = function(len, initVal) {
	if (!initVal) {
	initVal = 0;
	}

	var result = [];
	for(var i =0; i < len; i++) {
	result.push(initVal);
	}

	return result;
	};

	/**
	* updateDelta updates the given delta between changed and original for the
	* given testname. If testName evaluates to false the deltas for all tests
	* are calculated. It returns the number of changes this delta would result
	* in.
	*/
	ns.updateDelta = function (changed, original, delta, testName) {
	var useTestNames = (testName) ? [testName] : ns.keys(changed);
	var testDelta, testCount, tn;

	for (var i = 0, len = useTestNames.length; i < len; i++) {
	tn = useTestNames[i];
	if (changed.hasOwnProperty(tn)) {
	testDelta = {};
	testCount = 0;

	for (var k in changed[tn]) {
	if (changed[tn].hasOwnProperty(k) &&
	original[tn].hasOwnProperty(k) &&
	(changed[tn][k] !== original[tn][k])) {
	testDelta[k] = changed[tn][k];
	testCount++;
	}
	}

	delta[tn] = {
	delta: testDelta,
	count: testCount
	};
	}
	}

	var pendingCount = 0;
	for(var k in delta) {
	if (delta.hasOwnProperty(k)) {
	pendingCount += delta[k].count;
	}
	}

	return pendingCount;
	};

	/**
	* filterObject returns a copy of 'obj' without the members that
	* are also members in 'exclude'.
	*/
	ns.filterObject = function(obj, exclude) {
	var result = {};
	for(var k in obj) {
	if (obj.hasOwnProperty(k) && !exclude[k]) {
	result[k] = obj[k];
	}
	}

	return result;
	};

	/**
	* subObject returns a new object with only the members that are
	* also in include which is expected to be an array of strings.
	*/
	ns.subObject = function(obj, include) {
	var result = {};
	for (var i=0, len=include.length; i<len; i++) {
	if (obj.hasOwnProperty(include[i])) {
	result[include[i]] = obj[include[i]];
	}
	}
	return result;
	};

	/**
	* unionObject returns a new object with the union of all the members
	* of the arbibrary number of objects that are supplied.
	*/
	ns.unionObject = function( _ ) {
	var result = {};
	for(var i=0, len=arguments.length; i<len; i++) {
	for(var k in arguments[i]) {
	if (arguments[i].hasOwnProperty(k)) {
	result[k] = arguments[i][k];
	}
	}
	}
	return result;
	}

	/**
	* TriageDigestReq is a container type for sending labeled digests to the
	* backend. It matches the input parameters of the triageDigestsHandler in
	* 'go/skiacorrectness/main.go'.
	*/

	ns.TriageDigestReq = function () {
	};

	/**
	* addDigestLabel is a convenience method to add digests and their label to the
	* the instance.
	*/
	ns.TriageDigestReq.prototype.add = function (testName, digest, label) {
	this[testName] = this[testName] \|\| {};
	this[testName][digest] = label;
	};

	/////////////////////////////////////////////////////////////////
	// Generic utility functions.
	/////////////////////////////////////////////////////////////////
	/*
	* isEmpty returns true if the provided object is empty and false
	* otherwise.
	*/
	ns.isEmpty = function (obj) {
	for (var k in obj) {
	if (obj.hasOwnProperty(k)) {
	return false;
	}
	}
	return true;
	};

	/*
	*/
	ns.extractQueryString = function (url) {
	var idx = url.indexOf('?');
	return (idx === -1) ? '' : url.substring(idx);
	};

	/////////////////////////////////////////////////////////////////
	// Utility functions that are not exposed in the namespace.
	/////////////////////////////////////////////////////////////////

	/**
	* robust_get finds a sub object within 'obj' by following the path
	* in 'idx'. It will not throw an error if any sub object is missing
	* but instead return 'undefined'.
	**/
	function robust_get(obj, idx) {
	if (!idx) {
	return;
	}

	for(var i=0, len=idx.length; i<len; i++) {
	if ((typeof obj === 'undefined') \|\| (typeof idx[i] === 'undefined')) {
	return; // returns 'undefined'
	}

	obj = obj[idx[i]];
	}

	return obj;
	}


	})(skia);