Support automatically resolving dependencies in javascript tests.

chrome/test/base/js2gtest.js

 // 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.
 
 /**
  * @fileoverview Generator script for creating gtest-style JavaScript
  *     tests for WebUI and unit tests. Generates C++ gtest wrappers
  *     which will invoke the appropriate JavaScript for each test.
  * @author scr@chromium.org (Sheridan Rawlins)
  * @see WebUI testing: http://goo.gl/ZWFXF
  * @see gtest documentation: http://goo.gl/Ujj3H
  * @see chrome/chrome_tests.gypi
  * @see tools/gypv8sh.py
  */
 
 // Arguments from rules in chrome_tests.gypi are passed in through
 // python script gypv8sh.py.
-if (arguments.length < 4) {
+if (arguments.length != 6) {
   print('usage: ' +
-        arguments[0] + ' path-to-testfile.js testfile.js output.cc test-type');
+        arguments[0] +
+        ' path-to-testfile.js testfile.js path_to_deps.js output.cc test-type');
   quit(-1);
 }
 
 /**
  * Full path to the test input file.
  * @type {string}
  */
 var jsFile = arguments[1];
 
 /**
  * Relative path to the test input file appropriate for use in the
  * C++ TestFixture's addLibrary method.
  * @type {string}
  */
 var jsFileBase = arguments[2];
 
 /**
+ * Path to Closure library style deps.js file.
+ * @type {string?}
+ */
+var depsFile = arguments[3];
+
+/**
  * Path to C++ file generation is outputting to.
  * @type {string}
  */
-var outputFile = arguments[3];
+var outputFile = arguments[4];
 
 /**
  * Type of this test.
  * @type {string} ('unit'| 'webui')
  */
-var testType = arguments[4];
+var testType = arguments[5];
 
 /**
  * C++ gtest macro to use for TEST_F depending on |testType|.
  * @type {string} ('TEST_F'|'IN_PROC_BROWSER_TEST_F')
  */
 var testF;
 
 /**
  * Keeps track of whether a typedef has been generated for each test
  * fixture.
@@ skipping 26 matching lines @@
 //
 // Currently supports:
 // 'unit' - unit_tests harness, js2unit rule, V8UnitTest superclass.
 // 'webui' - browser_tests harness, js2webui rule, WebUIBrowserTest superclass.
 if (testType === 'unit') {
   print('#include "chrome/test/base/v8_unit_test.h"');
   testing.Test.prototype.typedefCppFixture = 'V8UnitTest';
   testF = 'TEST_F';
   addSetPreloadInfo = false;
 } else {
-  print('#include "chrome/test/base/web_ui_browsertest.h"');
+  print('#include "chrome/test/base/web_ui_browser_test.h"');
   testing.Test.prototype.typedefCppFixture = 'WebUIBrowserTest';
   testF = 'IN_PROC_BROWSER_TEST_F';
   addSetPreloadInfo = true;
 }
 print('#include "url/gurl.h"');
 print('#include "testing/gtest/include/gtest/gtest.h"');
 print();
 
 /**
  * Convert the |includeFile| to paths appropriate for immediate
  * inclusion (path) and runtime inclusion (base).
  * @param {string} includeFile The file to include.
  * @return {{path: string, base: string}} Object describing the paths
  *     for |includeFile|.
  */
 function includeFileToPaths(includeFile) {
   return {
     path: jsFile.replace(/[^\/\\]+$/, includeFile),
     base: jsFileBase.replace(/[^\/\\]+$/, includeFile),
   };
 }
 
+
+/**
+ * Maps object names to the path to the file that provides them.
+ * Populated from the |depsFile| if any.
+ * @type {Object.<string, string>}
+ */
+var dependencyProvidesToPaths = {};
+
+/**
+ * Maps dependency path names to object names required by the file.
+ * Populated from the |depsFile| if any.
+ * @type {Object.<string, Array.<string>>}
+ */
+var dependencyPathsToRequires = {};
+
+if (depsFile) {
+  var goog = goog || {};
+  /**
+   * Called by the javascript in the deps file to add modules and their
+   * dependencies.
+   * @param {string} path Relative path to the file.
+   * @param Array.<string> provides Objects provided by this file.
+   * @param Array.<string> requires Objects required by this file.
+   */
+  goog.addDependency = function(path, provides, requires) {
+    provides.forEach(function(provide) {
+      dependencyProvidesToPaths[provide] = path;
+    });
+    dependencyPathsToRequires[path] = requires;
+  };
+
+  // Read and eval the deps file.  It should only contain goog.addDependency
+  // calls.
+  eval(read(depsFile));
+}
+
+/**
+ * Resolves a list of libraries to an ordered list of paths to load by the
+ * generated C++.  The input should contain object names provided
+ * by the deps file.  Dependencies will be resolved and included in the
+ * correct order, meaning that the returned array may contain more entries
+ * than the input.
+ * @param {Array.<string>} deps List of dependencies.
+ * @return {Array.<string>} List of paths to load.
+ */
+function resolveClosureModuleDeps(deps) {
+  if (!depsFile && deps.length > 0) {
+    print('Can\'t have closure dependencies without a deps file.');
+    quit(-1);
+  }
+  var resultPaths = [];
+  var addedPaths = {};
+
+  function addPath(path) {
+    addedPaths[path] = true;
+    resultPaths.push(path);
+  }
+
+  function resolveAndAppend(path) {
+    if (addedPaths[path]) {
+      return;
+    }
+    // Set before recursing to catch cycles.
+    addedPaths[path] = true;
+    dependencyPathsToRequires[path].forEach(function(require) {
+      var providingPath = dependencyProvidesToPaths[require];
+      if (!providingPath) {
+        print('Unknown object', require, 'required by', path);
+        quit(-1);
+      }
+      resolveAndAppend(providingPath);
+    });
+    resultPaths.push(path);
+  }
+
+  // Always add closure library's base.js if provided by deps.
+  var basePath = dependencyProvidesToPaths['goog'];
+  if (basePath) {
+    addPath(basePath);
+  }
+
+  deps.forEach(function(dep) {
+    var providingPath = dependencyProvidesToPaths[dep];
+    if (providingPath) {
+      resolveAndAppend(providingPath);
+    } else {
+      print('Unknown dependency:', dep);
+      quit(-1);
+    }
+  });
+
+  return resultPaths;
+}
+
 /**
  * Output |code| verbatim.
  * @param {string} code The code to output.
  */
 function GEN(code) {
   print(code);
 }
 
 /**
  * Generate includes for the current |jsFile| by including them
@@ skipping 24 matching lines @@
   var testGenPostamble = this[testFixture].prototype.testGenPostamble;
   var typedefCppFixture = this[testFixture].prototype.typedefCppFixture;
   var isAsyncParam = testType === 'unit' ? '' :
       this[testFixture].prototype.isAsync + ', ';
   var testShouldFail = this[testFixture].prototype.testShouldFail;
   var testPredicate = testShouldFail ? 'ASSERT_FALSE' : 'ASSERT_TRUE';
   var extraLibraries = genIncludes.concat(
       this[testFixture].prototype.extraLibraries.map(
           function(includeFile) {
             return includeFileToPaths(includeFile).base;
-          }));
+          }),
+      resolveClosureModuleDeps(this[testFixture].prototype.closureModuleDeps));
 
   if (typedefCppFixture && !(testFixture in typedeffedCppFixtures)) {
     print('typedef ' + typedefCppFixture + ' ' + testFixture + ';');
     typedeffedCppFixtures[testFixture] = typedefCppFixture;
   }
 
   print(testF + '(' + testFixture + ', ' + testFunction + ') {');
   for (var i = 0; i < extraLibraries.length; i++) {
     print('  AddLibrary(base::FilePath(FILE_PATH_LITERAL("' +
         extraLibraries[i].replace(/\\/g, '/') + '")));');
@@ skipping 17 matching lines @@
         '"' + testFunction + '"));');
   if (testGenPostamble)
     testGenPostamble(testFixture, testFunction);
   print('}');
   print();
 }
 
 // Now that generation functions are defined, load in |jsFile|.
 var js = read(jsFile);
 eval(js);