Remove base.* methods.

Tools/GardeningServer/scripts/results.js

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 112 matching lines @@
             break;
         default:
             // FIXME: Add support for the rest of the result types.
             // '-expected.html',
             // '-expected-mismatch.html',
             // ... and possibly more.
             break;
         }
     });
 
-    return base.uniquifyArray(suffixList);
+    return suffixList.unique();
 }
 
 function failureTypeList(failureBlob)
 {
     return failureBlob.split(' ');
 };
 
 function resultsDirectoryURL(builderName)
 {
     return config.layoutTestResultsURL + '/' + config.resultsDirectoryNameFromBuilderName(builderName) + '/results/layout-test-results/';
 }
 
 function resultsDirectoryURLForBuildNumber(builderName, buildNumber)
 {
     return config.layoutTestResultsURL + '/' + config.resultsDirectoryNameFromBuilderName(builderName) + '/' + buildNumber + '/' ;
 }
 
 function resultsSummaryURL(builderName)
 {
     return resultsDirectoryURL(builderName) + kResultsName;
 }
 
 var g_resultsCache = new base.AsynchronousCache(function(key) {
     return net.jsonp(key);
 });
 
-results.ResultAnalyzer = base.extends(Object, {
-    init: function(resultNode)
-    {
-        this._isUnexpected = resultNode.is_unexpected;
-        this._actual = resultNode ? failureTypeList(resultNode.actual) : [];
-        this._expected = resultNode ? this._addImpliedExpectations(failureTypeList(resultNode.expected)) : [];
-    },
+results.ResultAnalyzer = function(resultNode)
+{
+    this._isUnexpected = resultNode.is_unexpected;
+    this._actual = resultNode ? failureTypeList(resultNode.actual) : [];
+    this._expected = resultNode ? this._addImpliedExpectations(failureTypeList(resultNode.expected)) : [];
+};
+
+results.ResultAnalyzer.prototype = {
     _addImpliedExpectations: function(resultsList)
     {
         if (resultsList.indexOf('FAIL') == -1)
             return resultsList;
         return resultsList.concat(kFailingResults);
     },
     _hasPass: function(results)
     {
         return results.indexOf(PASS) != -1;
     },
@@ skipping 11 matching lines @@
     {
         return this._actual.length > 1;
     },
     wontfix: function()
     {
         return this._expected.indexOf('WONTFIX') != -1;
     },
     hasUnexpectedFailures: function()
     {
         return this._isUnexpected;
-    }
-});
+    },
+};
 
 function isUnexpectedFailure(resultNode)
 {
     var analyzer = new results.ResultAnalyzer(resultNode);
     return analyzer.hasUnexpectedFailures() && !analyzer.succeeded() && !analyzer.flaky() && !analyzer.wontfix();
 }
 
 function isResultNode(node)
 {
     return !!node.actual;
 }
 
+results._joinPath = function(parent, child)
+{
+    if (parent.length == 0)
+        return child;
+    return parent + '/' + child;
+};
+
+results._filterTree = function(tree, isLeaf, predicate)
+{
+    var filteredTree = {};
+
+    function walkSubtree(subtree, directory)
+    {
+        for (var childName in subtree) {
+            var child = subtree[childName];
+            var childPath = results._joinPath(directory, childName);
+            if (isLeaf(child)) {
+                if (predicate(child))
+                    filteredTree[childPath] = child;
+                continue;
+            }
+            walkSubtree(child, childPath);
+        }
+    }
+
+    walkSubtree(tree, '');
+    return filteredTree;
+};
+
 results.unexpectedFailures = function(resultsTree)
 {
-    return base.filterTree(resultsTree.tests, isResultNode, isUnexpectedFailure);
+    return results._filterTree(resultsTree.tests, isResultNode, isUnexpectedFailure);
 };
 
 function resultsByTest(resultsByBuilder, filter)
 {
     var resultsByTest = {};
 
     Object.keys(resultsByBuilder, function(builderName, resultsTree) {
         Object.keys(filter(resultsTree), function(testName, resultNode) {
             resultsByTest[testName] = resultsByTest[testName] || {};
             resultsByTest[testName][builderName] = resultNode;
@@ skipping 179 matching lines @@
     if (/\.wav$/.test(url))
         return results.kAudioType;
     return results.kTextType;
 }
 
 function sortResultURLsBySuffix(urls)
 {
     var sortedURLs = [];
     kPreferredSuffixOrder.forEach(function(suffix) {
         urls.forEach(function(url) {
-            if (!base.endsWith(url, suffix))
+            if (!url.endsWith(suffix))
                 return;
             sortedURLs.push(url);
         });
     });
     if (sortedURLs.length != urls.length)
         throw "sortResultURLsBySuffix failed to return the same number of URLs.";
     return sortedURLs;
 }
 
+results._trimExtension = function(url)
+{
+    var index = url.lastIndexOf('.');
+    if (index == -1)
+        return url;
+    return url.substr(0, index);
+}
+
 results.fetchResultsURLs = function(failureInfo)
 {
-    var testNameStem = base.trimExtension(failureInfo.testName);
+    var testNameStem = results._trimExtension(failureInfo.testName);
     var urlStem = resultsDirectoryURL(failureInfo.builderName);
 
     var suffixList = possibleSuffixListFor(failureInfo.failureTypeList);
     var resultURLs = [];
     var probePromises = [];
     suffixList.forEach(function(suffix) {
         var url = urlStem + testNameStem + suffix;
         probePromises.push(net.probe(url).then(
             function() {
                 resultURLs.push(url);
@@ skipping 14 matching lines @@
         fetchPromises.push(net.jsonp(resultsURL).then(function(resultsTree) {
             resultsByBuilder[builderName] = resultsTree;
         }));
     });
     return Promise.all(fetchPromises).then(function() {
         return resultsByBuilder;
     });
 };
 
 })();