-Date: Fri Apr 24 18:38:26 2015 -0400
-
- fix bad merge
diff --git a/dom/canvas/test/webgl-conf/checkout/closure-library/README.md b/dom/canvas/test/webgl-conf/checkout/closure-library/README.md
deleted file mode 100644
index d794d1b9b2..0000000000
--- a/dom/canvas/test/webgl-conf/checkout/closure-library/README.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# Closure Library
-
-Closure Library is a powerful, low-level JavaScript library designed
-for building complex and scalable web applications. It is used by many
-Google web applications, such as Gmail and Google Docs.
-
-For more information, visit the
-[Google Developers](https://developers.google.com/closure/library) or
-[GitHub](https://github.com/google/closure-library) sites.
diff --git a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/closurebuilder.py b/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/closurebuilder.py
deleted file mode 100644
index 9e4e2eb339..0000000000
--- a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/closurebuilder.py
+++ /dev/null
@@ -1,287 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2009 The Closure Library Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS-IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Utility for Closure Library dependency calculation.
-
-ClosureBuilder scans source files to build dependency info. From the
-dependencies, the script can produce a manifest in dependency order,
-a concatenated script, or compiled output from the Closure Compiler.
-
-Paths to files can be expressed as individual arguments to the tool (intended
-for use with find and xargs). As a convenience, --root can be used to specify
-all JS files below a directory.
-
-usage: %prog [options] [file1.js file2.js ...]
-"""
-
-__author__ = 'nnaze@google.com (Nathan Naze)'
-
-
-import logging
-import optparse
-import os
-import sys
-
-import depstree
-import jscompiler
-import source
-import treescan
-
-
-def _GetOptionsParser():
- """Get the options parser."""
-
- parser = optparse.OptionParser(__doc__)
- parser.add_option('-i',
- '--input',
- dest='inputs',
- action='append',
- default=[],
- help='One or more input files to calculate dependencies '
- 'for. The namespaces in this file will be combined with '
- 'those given with the -n flag to form the set of '
- 'namespaces to find dependencies for.')
- parser.add_option('-n',
- '--namespace',
- dest='namespaces',
- action='append',
- default=[],
- help='One or more namespaces to calculate dependencies '
- 'for. These namespaces will be combined with those given '
- 'with the -i flag to form the set of namespaces to find '
- 'dependencies for. A Closure namespace is a '
- 'dot-delimited path expression declared with a call to '
- 'goog.provide() (e.g. "goog.array" or "foo.bar").')
- parser.add_option('--root',
- dest='roots',
- action='append',
- default=[],
- help='The paths that should be traversed to build the '
- 'dependencies.')
- parser.add_option('-o',
- '--output_mode',
- dest='output_mode',
- type='choice',
- action='store',
- choices=['list', 'script', 'compiled'],
- default='list',
- help='The type of output to generate from this script. '
- 'Options are "list" for a list of filenames, "script" '
- 'for a single script containing the contents of all the '
- 'files, or "compiled" to produce compiled output with '
- 'the Closure Compiler. Default is "list".')
- parser.add_option('-c',
- '--compiler_jar',
- dest='compiler_jar',
- action='store',
- help='The location of the Closure compiler .jar file.')
- parser.add_option('-f',
- '--compiler_flags',
- dest='compiler_flags',
- default=[],
- action='append',
- help='Additional flags to pass to the Closure compiler. '
- 'To pass multiple flags, --compiler_flags has to be '
- 'specified multiple times.')
- parser.add_option('-j',
- '--jvm_flags',
- dest='jvm_flags',
- default=[],
- action='append',
- help='Additional flags to pass to the JVM compiler. '
- 'To pass multiple flags, --jvm_flags has to be '
- 'specified multiple times.')
- parser.add_option('--output_file',
- dest='output_file',
- action='store',
- help=('If specified, write output to this path instead of '
- 'writing to standard output.'))
-
- return parser
-
-
-def _GetInputByPath(path, sources):
- """Get the source identified by a path.
-
- Args:
- path: str, A path to a file that identifies a source.
- sources: An iterable collection of source objects.
-
- Returns:
- The source from sources identified by path, if found. Converts to
- real paths for comparison.
- """
- for js_source in sources:
- # Convert both to real paths for comparison.
- if os.path.realpath(path) == os.path.realpath(js_source.GetPath()):
- return js_source
-
-
-def _GetClosureBaseFile(sources):
- """Given a set of sources, returns the one base.js file.
-
- Note that if zero or two or more base.js files are found, an error message
- will be written and the program will be exited.
-
- Args:
- sources: An iterable of _PathSource objects.
-
- Returns:
- The _PathSource representing the base Closure file.
- """
- base_files = [
- js_source for js_source in sources if _IsClosureBaseFile(js_source)]
-
- if not base_files:
- logging.error('No Closure base.js file found.')
- sys.exit(1)
- if len(base_files) > 1:
- logging.error('More than one Closure base.js files found at these paths:')
- for base_file in base_files:
- logging.error(base_file.GetPath())
- sys.exit(1)
- return base_files[0]
-
-
-def _IsClosureBaseFile(js_source):
- """Returns true if the given _PathSource is the Closure base.js source."""
- return (os.path.basename(js_source.GetPath()) == 'base.js' and
- js_source.provides == set(['goog']))
-
-
-class _PathSource(source.Source):
- """Source file subclass that remembers its file path."""
-
- def __init__(self, path):
- """Initialize a source.
-
- Args:
- path: str, Path to a JavaScript file. The source string will be read
- from this file.
- """
- super(_PathSource, self).__init__(source.GetFileContents(path))
-
- self._path = path
-
- def __str__(self):
- return 'PathSource %s' % self._path
-
- def GetPath(self):
- """Returns the path."""
- return self._path
-
-
-def _WrapGoogModuleSource(src):
- return ('goog.loadModule(function(exports) {{'
- '"use strict";'
- '{0}'
- '\n' # terminate any trailing single line comment.
- ';return exports'
- '}});\n').format(src)
-
-
-def main():
- logging.basicConfig(format=(sys.argv[0] + ': %(message)s'),
- level=logging.INFO)
- options, args = _GetOptionsParser().parse_args()
-
- # Make our output pipe.
- if options.output_file:
- out = open(options.output_file, 'w')
- else:
- out = sys.stdout
-
- sources = set()
-
- logging.info('Scanning paths...')
- for path in options.roots:
- for js_path in treescan.ScanTreeForJsFiles(path):
- sources.add(_PathSource(js_path))
-
- # Add scripts specified on the command line.
- for js_path in args:
- sources.add(_PathSource(js_path))
-
- logging.info('%s sources scanned.', len(sources))
-
- # Though deps output doesn't need to query the tree, we still build it
- # to validate dependencies.
- logging.info('Building dependency tree..')
- tree = depstree.DepsTree(sources)
-
- input_namespaces = set()
- inputs = options.inputs or []
- for input_path in inputs:
- js_input = _GetInputByPath(input_path, sources)
- if not js_input:
- logging.error('No source matched input %s', input_path)
- sys.exit(1)
- input_namespaces.update(js_input.provides)
-
- input_namespaces.update(options.namespaces)
-
- if not input_namespaces:
- logging.error('No namespaces found. At least one namespace must be '
- 'specified with the --namespace or --input flags.')
- sys.exit(2)
-
- # The Closure Library base file must go first.
- base = _GetClosureBaseFile(sources)
- deps = [base] + tree.GetDependencies(input_namespaces)
-
- output_mode = options.output_mode
- if output_mode == 'list':
- out.writelines([js_source.GetPath() + '\n' for js_source in deps])
- elif output_mode == 'script':
- for js_source in deps:
- src = js_source.GetSource()
- if js_source.is_goog_module:
- src = _WrapGoogModuleSource(src)
- out.write(src + '\n')
- elif output_mode == 'compiled':
- logging.warning("""\
-Closure Compiler now natively understands and orders Closure dependencies and
-is prefererred over using this script for performing JavaScript compilation.
-
-Please migrate your codebase.
-
-See:
-https://github.com/google/closure-compiler/wiki/Manage-Closure-Dependencies
-""")
-
- # Make sure a .jar is specified.
- if not options.compiler_jar:
- logging.error('--compiler_jar flag must be specified if --output is '
- '"compiled"')
- sys.exit(2)
-
- # Will throw an error if the compilation fails.
- compiled_source = jscompiler.Compile(
- options.compiler_jar,
- [js_source.GetPath() for js_source in deps],
- jvm_flags=options.jvm_flags,
- compiler_flags=options.compiler_flags)
-
- logging.info('JavaScript compilation succeeded.')
- out.write(compiled_source)
-
- else:
- logging.error('Invalid value for --output flag.')
- sys.exit(2)
-
-
-if __name__ == '__main__':
- main()
diff --git a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/depstree.py b/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/depstree.py
deleted file mode 100644
index f288dd3aa6..0000000000
--- a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/depstree.py
+++ /dev/null
@@ -1,189 +0,0 @@
-# Copyright 2009 The Closure Library Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS-IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-"""Class to represent a full Closure Library dependency tree.
-
-Offers a queryable tree of dependencies of a given set of sources. The tree
-will also do logical validation to prevent duplicate provides and circular
-dependencies.
-"""
-
-__author__ = 'nnaze@google.com (Nathan Naze)'
-
-
-class DepsTree(object):
- """Represents the set of dependencies between source files."""
-
- def __init__(self, sources):
- """Initializes the tree with a set of sources.
-
- Args:
- sources: A set of JavaScript sources.
-
- Raises:
- MultipleProvideError: A namespace is provided by muplitple sources.
- NamespaceNotFoundError: A namespace is required but never provided.
- """
-
- self._sources = sources
- self._provides_map = dict()
-
- # Ensure nothing was provided twice.
- for source in sources:
- for provide in source.provides:
- if provide in self._provides_map:
- raise MultipleProvideError(
- provide, [self._provides_map[provide], source])
-
- self._provides_map[provide] = source
-
- # Check that all required namespaces are provided.
- for source in sources:
- for require in source.requires:
- if require not in self._provides_map:
- raise NamespaceNotFoundError(require, source)
-
- def GetDependencies(self, required_namespaces):
- """Get source dependencies, in order, for the given namespaces.
-
- Args:
- required_namespaces: A string (for one) or list (for one or more) of
- namespaces.
-
- Returns:
- A list of source objects that provide those namespaces and all
- requirements, in dependency order.
-
- Raises:
- NamespaceNotFoundError: A namespace is requested but doesn't exist.
- CircularDependencyError: A cycle is detected in the dependency tree.
- """
- if isinstance(required_namespaces, str):
- required_namespaces = [required_namespaces]
-
- deps_sources = []
-
- for namespace in required_namespaces:
- for source in DepsTree._ResolveDependencies(
- namespace, [], self._provides_map, []):
- if source not in deps_sources:
- deps_sources.append(source)
-
- return deps_sources
-
- @staticmethod
- def _ResolveDependencies(required_namespace, deps_list, provides_map,
- traversal_path):
- """Resolve dependencies for Closure source files.
-
- Follows the dependency tree down and builds a list of sources in dependency
- order. This function will recursively call itself to fill all dependencies
- below the requested namespaces, and then append its sources at the end of
- the list.
-
- Args:
- required_namespace: String of required namespace.
- deps_list: List of sources in dependency order. This function will append
- the required source once all of its dependencies are satisfied.
- provides_map: Map from namespace to source that provides it.
- traversal_path: List of namespaces of our path from the root down the
- dependency/recursion tree. Used to identify cyclical dependencies.
- This is a list used as a stack -- when the function is entered, the
- current namespace is pushed and popped right before returning.
- Each recursive call will check that the current namespace does not
- appear in the list, throwing a CircularDependencyError if it does.
-
- Returns:
- The given deps_list object filled with sources in dependency order.
-
- Raises:
- NamespaceNotFoundError: A namespace is requested but doesn't exist.
- CircularDependencyError: A cycle is detected in the dependency tree.
- """
-
- source = provides_map.get(required_namespace)
- if not source:
- raise NamespaceNotFoundError(required_namespace)
-
- if required_namespace in traversal_path:
- traversal_path.append(required_namespace) # do this *after* the test
-
- # This must be a cycle.
- raise CircularDependencyError(traversal_path)
-
- # If we don't have the source yet, we'll have to visit this namespace and
- # add the required dependencies to deps_list.
- if source not in deps_list:
- traversal_path.append(required_namespace)
-
- for require in source.requires:
-
- # Append all other dependencies before we append our own.
- DepsTree._ResolveDependencies(require, deps_list, provides_map,
- traversal_path)
- deps_list.append(source)
-
- traversal_path.pop()
-
- return deps_list
-
-
-class BaseDepsTreeError(Exception):
- """Base DepsTree error."""
-
- def __init__(self):
- Exception.__init__(self)
-
-
-class CircularDependencyError(BaseDepsTreeError):
- """Raised when a dependency cycle is encountered."""
-
- def __init__(self, dependency_list):
- BaseDepsTreeError.__init__(self)
- self._dependency_list = dependency_list
-
- def __str__(self):
- return ('Encountered circular dependency:\n%s\n' %
- '\n'.join(self._dependency_list))
-
-
-class MultipleProvideError(BaseDepsTreeError):
- """Raised when a namespace is provided more than once."""
-
- def __init__(self, namespace, sources):
- BaseDepsTreeError.__init__(self)
- self._namespace = namespace
- self._sources = sources
-
- def __str__(self):
- source_strs = map(str, self._sources)
-
- return ('Namespace "%s" provided more than once in sources:\n%s\n' %
- (self._namespace, '\n'.join(source_strs)))
-
-
-class NamespaceNotFoundError(BaseDepsTreeError):
- """Raised when a namespace is requested but not provided."""
-
- def __init__(self, namespace, source=None):
- BaseDepsTreeError.__init__(self)
- self._namespace = namespace
- self._source = source
-
- def __str__(self):
- msg = 'Namespace "%s" never provided.' % self._namespace
- if self._source:
- msg += ' Required in %s' % self._source
- return msg
diff --git a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/depswriter.py b/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/depswriter.py
deleted file mode 100644
index bc3be88a35..0000000000
--- a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/depswriter.py
+++ /dev/null
@@ -1,204 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2009 The Closure Library Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS-IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-"""Generates out a Closure deps.js file given a list of JavaScript sources.
-
-Paths can be specified as arguments or (more commonly) specifying trees
-with the flags (call with --help for descriptions).
-
-Usage: depswriter.py [path/to/js1.js [path/to/js2.js] ...]
-"""
-
-import logging
-import optparse
-import os
-import posixpath
-import shlex
-import sys
-
-import source
-import treescan
-
-
-__author__ = 'nnaze@google.com (Nathan Naze)'
-
-
-def MakeDepsFile(source_map):
- """Make a generated deps file.
-
- Args:
- source_map: A dict map of the source path to source.Source object.
-
- Returns:
- str, A generated deps file source.
- """
-
- # Write in path alphabetical order
- paths = sorted(source_map.keys())
-
- lines = []
-
- for path in paths:
- js_source = source_map[path]
-
- # We don't need to add entries that don't provide anything.
- if js_source.provides:
- lines.append(_GetDepsLine(path, js_source))
-
- return ''.join(lines)
-
-
-def _GetDepsLine(path, js_source):
- """Get a deps.js file string for a source."""
-
- provides = sorted(js_source.provides)
- requires = sorted(js_source.requires)
- module = 'true' if js_source.is_goog_module else 'false'
-
- return 'goog.addDependency(\'%s\', %s, %s, %s);\n' % (
- path, provides, requires, module)
-
-
-def _GetOptionsParser():
- """Get the options parser."""
-
- parser = optparse.OptionParser(__doc__)
-
- parser.add_option('--output_file',
- dest='output_file',
- action='store',
- help=('If specified, write output to this path instead of '
- 'writing to standard output.'))
- parser.add_option('--root',
- dest='roots',
- default=[],
- action='append',
- help='A root directory to scan for JS source files. '
- 'Paths of JS files in generated deps file will be '
- 'relative to this path. This flag may be specified '
- 'multiple times.')
- parser.add_option('--root_with_prefix',
- dest='roots_with_prefix',
- default=[],
- action='append',
- help='A root directory to scan for JS source files, plus '
- 'a prefix (if either contains a space, surround with '
- 'quotes). Paths in generated deps file will be relative '
- 'to the root, but preceded by the prefix. This flag '
- 'may be specified multiple times.')
- parser.add_option('--path_with_depspath',
- dest='paths_with_depspath',
- default=[],
- action='append',
- help='A path to a source file and an alternate path to '
- 'the file in the generated deps file (if either contains '
- 'a space, surround with whitespace). This flag may be '
- 'specified multiple times.')
- return parser
-
-
-def _NormalizePathSeparators(path):
- """Replaces OS-specific path separators with POSIX-style slashes.
-
- Args:
- path: str, A file path.
-
- Returns:
- str, The path with any OS-specific path separators (such as backslash on
- Windows) replaced with URL-compatible forward slashes. A no-op on systems
- that use POSIX paths.
- """
- return path.replace(os.sep, posixpath.sep)
-
-
-def _GetRelativePathToSourceDict(root, prefix=''):
- """Scans a top root directory for .js sources.
-
- Args:
- root: str, Root directory.
- prefix: str, Prefix for returned paths.
-
- Returns:
- dict, A map of relative paths (with prefix, if given), to source.Source
- objects.
- """
- # Remember and restore the cwd when we're done. We work from the root so
- # that paths are relative from the root.
- start_wd = os.getcwd()
- os.chdir(root)
-
- path_to_source = {}
- for path in treescan.ScanTreeForJsFiles('.'):
- prefixed_path = _NormalizePathSeparators(os.path.join(prefix, path))
- path_to_source[prefixed_path] = source.Source(source.GetFileContents(path))
-
- os.chdir(start_wd)
-
- return path_to_source
-
-
-def _GetPair(s):
- """Return a string as a shell-parsed tuple. Two values expected."""
- try:
- # shlex uses '\' as an escape character, so they must be escaped.
- s = s.replace('\\', '\\\\')
- first, second = shlex.split(s)
- return (first, second)
- except:
- raise Exception('Unable to parse input line as a pair: %s' % s)
-
-
-def main():
- """CLI frontend to MakeDepsFile."""
- logging.basicConfig(format=(sys.argv[0] + ': %(message)s'),
- level=logging.INFO)
- options, args = _GetOptionsParser().parse_args()
-
- path_to_source = {}
-
- # Roots without prefixes
- for root in options.roots:
- path_to_source.update(_GetRelativePathToSourceDict(root))
-
- # Roots with prefixes
- for root_and_prefix in options.roots_with_prefix:
- root, prefix = _GetPair(root_and_prefix)
- path_to_source.update(_GetRelativePathToSourceDict(root, prefix=prefix))
-
- # Source paths
- for path in args:
- path_to_source[path] = source.Source(source.GetFileContents(path))
-
- # Source paths with alternate deps paths
- for path_with_depspath in options.paths_with_depspath:
- srcpath, depspath = _GetPair(path_with_depspath)
- path_to_source[depspath] = source.Source(source.GetFileContents(srcpath))
-
- # Make our output pipe.
- if options.output_file:
- out = open(options.output_file, 'w')
- else:
- out = sys.stdout
-
- out.write('// This file was autogenerated by %s.\n' % sys.argv[0])
- out.write('// Please do not edit.\n')
-
- out.write(MakeDepsFile(path_to_source))
-
-
-if __name__ == '__main__':
- main()
diff --git a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/jscompiler.py b/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/jscompiler.py
deleted file mode 100644
index cc6eb55f9e..0000000000
--- a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/jscompiler.py
+++ /dev/null
@@ -1,135 +0,0 @@
-# Copyright 2010 The Closure Library Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS-IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Utility to use the Closure Compiler CLI from Python."""
-
-
-import logging
-import os
-import re
-import subprocess
-
-
-# Pulls just the major and minor version numbers from the first line of
-# 'java -version'. Versions are in the format of [0-9]+\.[0-9]+\..* See:
-# http://www.oracle.com/technetwork/java/javase/versioning-naming-139433.html
-_VERSION_REGEX = re.compile(r'"([0-9]+)\.([0-9]+)')
-
-
-class JsCompilerError(Exception):
- """Raised if there's an error in calling the compiler."""
- pass
-
-
-def _GetJavaVersionString():
- """Get the version string from the Java VM."""
- return subprocess.check_output(['java', '-version'], stderr=subprocess.STDOUT)
-
-
-def _ParseJavaVersion(version_string):
- """Returns a 2-tuple for the current version of Java installed.
-
- Args:
- version_string: String of the Java version (e.g. '1.7.2-ea').
-
- Returns:
- The major and minor versions, as a 2-tuple (e.g. (1, 7)).
- """
- match = _VERSION_REGEX.search(version_string)
- if match:
- version = tuple(int(x, 10) for x in match.groups())
- assert len(version) == 2
- return version
-
-
-def _JavaSupports32BitMode():
- """Determines whether the JVM supports 32-bit mode on the platform."""
- # Suppresses process output to stderr and stdout from showing up in the
- # console as we're only trying to determine 32-bit JVM support.
- supported = False
- try:
- devnull = open(os.devnull, 'wb')
- return subprocess.call(
- ['java', '-d32', '-version'], stdout=devnull, stderr=devnull) == 0
- except IOError:
- pass
- else:
- devnull.close()
- return supported
-
-
-def _GetJsCompilerArgs(compiler_jar_path, java_version, source_paths,
- jvm_flags, compiler_flags):
- """Assembles arguments for call to JsCompiler."""
-
- if java_version < (1, 7):
- raise JsCompilerError('Closure Compiler requires Java 1.7 or higher. '
- 'Please visit http://www.java.com/getjava')
-
- args = ['java']
-
- # Add JVM flags we believe will produce the best performance. See
- # https://groups.google.com/forum/#!topic/closure-library-discuss/7w_O9-vzlj4
-
- # Attempt 32-bit mode if available (Java 7 on Mac OS X does not support 32-bit
- # mode, for example).
- if _JavaSupports32BitMode():
- args += ['-d32']
-
- # Prefer the "client" VM.
- args += ['-client']
-
- # Add JVM flags, if any
- if jvm_flags:
- args += jvm_flags
-
- # Add the application JAR.
- args += ['-jar', compiler_jar_path]
-
- for path in source_paths:
- args += ['--js', path]
-
- # Add compiler flags, if any.
- if compiler_flags:
- args += compiler_flags
-
- return args
-
-
-def Compile(compiler_jar_path, source_paths,
- jvm_flags=None,
- compiler_flags=None):
- """Prepares command-line call to Closure Compiler.
-
- Args:
- compiler_jar_path: Path to the Closure compiler .jar file.
- source_paths: Source paths to build, in order.
- jvm_flags: A list of additional flags to pass on to JVM.
- compiler_flags: A list of additional flags to pass on to Closure Compiler.
-
- Returns:
- The compiled source, as a string, or None if compilation failed.
- """
-
- java_version = _ParseJavaVersion(_GetJavaVersionString())
-
- args = _GetJsCompilerArgs(
- compiler_jar_path, java_version, source_paths, jvm_flags, compiler_flags)
-
- logging.info('Compiling with the following command: %s', ' '.join(args))
-
- try:
- return subprocess.check_output(args)
- except subprocess.CalledProcessError:
- raise JsCompilerError('JavaScript compilation failed.')
diff --git a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/source.py b/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/source.py
deleted file mode 100644
index be5e0d8ad6..0000000000
--- a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/source.py
+++ /dev/null
@@ -1,127 +0,0 @@
-# Copyright 2009 The Closure Library Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS-IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-"""Scans a source JS file for its provided and required namespaces.
-
-Simple class to scan a JavaScript file and express its dependencies.
-"""
-
-__author__ = 'nnaze@google.com'
-
-
-import re
-
-_BASE_REGEX_STRING = r'^\s*goog\.%s\(\s*[\'"](.+)[\'"]\s*\)'
-_MODULE_REGEX = re.compile(_BASE_REGEX_STRING % 'module')
-_PROVIDE_REGEX = re.compile(_BASE_REGEX_STRING % 'provide')
-
-_REQUIRE_REGEX_STRING = (r'^\s*(?:(?:var|let|const)\s+[a-zA-Z_$][a-zA-Z0-9$_]*'
- r'\s*=\s*)?goog\.require\(\s*[\'"](.+)[\'"]\s*\)')
-_REQUIRES_REGEX = re.compile(_REQUIRE_REGEX_STRING)
-
-
-class Source(object):
- """Scans a JavaScript source for its provided and required namespaces."""
-
- # Matches a "/* ... */" comment.
- # Note: We can't definitively distinguish a "/*" in a string literal without a
- # state machine tokenizer. We'll assume that a line starting with whitespace
- # and "/*" is a comment.
- _COMMENT_REGEX = re.compile(
- r"""
- ^\s* # Start of a new line and whitespace
- /\* # Opening "/*"
- .*? # Non greedy match of any characters (including newlines)
- \*/ # Closing "*/""",
- re.MULTILINE | re.DOTALL | re.VERBOSE)
-
- def __init__(self, source):
- """Initialize a source.
-
- Args:
- source: str, The JavaScript source.
- """
-
- self.provides = set()
- self.requires = set()
- self.is_goog_module = False
-
- self._source = source
- self._ScanSource()
-
- def GetSource(self):
- """Get the source as a string."""
- return self._source
-
- @classmethod
- def _StripComments(cls, source):
- return cls._COMMENT_REGEX.sub('', source)
-
- @classmethod
- def _HasProvideGoogFlag(cls, source):
- """Determines whether the @provideGoog flag is in a comment."""
- for comment_content in cls._COMMENT_REGEX.findall(source):
- if '@provideGoog' in comment_content:
- return True
-
- return False
-
- def _ScanSource(self):
- """Fill in provides and requires by scanning the source."""
-
- stripped_source = self._StripComments(self.GetSource())
-
- source_lines = stripped_source.splitlines()
- for line in source_lines:
- match = _PROVIDE_REGEX.match(line)
- if match:
- self.provides.add(match.group(1))
- match = _MODULE_REGEX.match(line)
- if match:
- self.provides.add(match.group(1))
- self.is_goog_module = True
- match = _REQUIRES_REGEX.match(line)
- if match:
- self.requires.add(match.group(1))
-
- # Closure's base file implicitly provides 'goog'.
- # This is indicated with the @provideGoog flag.
- if self._HasProvideGoogFlag(self.GetSource()):
-
- if len(self.provides) or len(self.requires):
- raise Exception(
- 'Base file should not provide or require namespaces.')
-
- self.provides.add('goog')
-
-
-def GetFileContents(path):
- """Get a file's contents as a string.
-
- Args:
- path: str, Path to file.
-
- Returns:
- str, Contents of file.
-
- Raises:
- IOError: An error occurred opening or reading the file.
-
- """
- fileobj = open(path)
- try:
- return fileobj.read()
- finally:
- fileobj.close()
diff --git a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/treescan.py b/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/treescan.py
deleted file mode 100644
index 6694593aab..0000000000
--- a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/build/treescan.py
+++ /dev/null
@@ -1,78 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2010 The Closure Library Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS-IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-"""Shared utility functions for scanning directory trees."""
-
-import os
-import re
-
-
-__author__ = 'nnaze@google.com (Nathan Naze)'
-
-
-# Matches a .js file path.
-_JS_FILE_REGEX = re.compile(r'^.+\.js$')
-
-
-def ScanTreeForJsFiles(root):
- """Scans a directory tree for JavaScript files.
-
- Args:
- root: str, Path to a root directory.
-
- Returns:
- An iterable of paths to JS files, relative to cwd.
- """
- return ScanTree(root, path_filter=_JS_FILE_REGEX)
-
-
-def ScanTree(root, path_filter=None, ignore_hidden=True):
- """Scans a directory tree for files.
-
- Args:
- root: str, Path to a root directory.
- path_filter: A regular expression filter. If set, only paths matching
- the path_filter are returned.
- ignore_hidden: If True, do not follow or return hidden directories or files
- (those starting with a '.' character).
-
- Yields:
- A string path to files, relative to cwd.
- """
-
- def OnError(os_error):
- raise os_error
-
- for dirpath, dirnames, filenames in os.walk(root, onerror=OnError):
- # os.walk allows us to modify dirnames to prevent decent into particular
- # directories. Avoid hidden directories.
- for dirname in dirnames:
- if ignore_hidden and dirname.startswith('.'):
- dirnames.remove(dirname)
-
- for filename in filenames:
-
- # nothing that starts with '.'
- if ignore_hidden and filename.startswith('.'):
- continue
-
- fullpath = os.path.join(dirpath, filename)
-
- if path_filter and not path_filter.match(fullpath):
- continue
-
- yield os.path.normpath(fullpath)
diff --git a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/calcdeps.py b/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/calcdeps.py
deleted file mode 100644
index 9cb1a6db06..0000000000
--- a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/calcdeps.py
+++ /dev/null
@@ -1,590 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2006 The Closure Library Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS-IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-"""Calculates JavaScript dependencies without requiring Google's build system.
-
-This tool is deprecated and is provided for legacy users.
-See build/closurebuilder.py and build/depswriter.py for the current tools.
-
-It iterates over a number of search paths and builds a dependency tree. With
-the inputs provided, it walks the dependency tree and outputs all the files
-required for compilation.
-"""
-
-
-
-
-
-try:
- import distutils.version
-except ImportError:
- # distutils is not available in all environments
- distutils = None
-
-import logging
-import optparse
-import os
-import re
-import subprocess
-import sys
-
-
-_BASE_REGEX_STRING = '^\s*goog\.%s\(\s*[\'"](.+)[\'"]\s*\)'
-req_regex = re.compile(_BASE_REGEX_STRING % 'require')
-prov_regex = re.compile(_BASE_REGEX_STRING % 'provide')
-ns_regex = re.compile('^ns:((\w+\.)*(\w+))$')
-version_regex = re.compile('[\.0-9]+')
-
-
-def IsValidFile(ref):
- """Returns true if the provided reference is a file and exists."""
- return os.path.isfile(ref)
-
-
-def IsJsFile(ref):
- """Returns true if the provided reference is a Javascript file."""
- return ref.endswith('.js')
-
-
-def IsNamespace(ref):
- """Returns true if the provided reference is a namespace."""
- return re.match(ns_regex, ref) is not None
-
-
-def IsDirectory(ref):
- """Returns true if the provided reference is a directory."""
- return os.path.isdir(ref)
-
-
-def ExpandDirectories(refs):
- """Expands any directory references into inputs.
-
- Description:
- Looks for any directories in the provided references. Found directories
- are recursively searched for .js files, which are then added to the result
- list.
-
- Args:
- refs: a list of references such as files, directories, and namespaces
-
- Returns:
- A list of references with directories removed and replaced by any
- .js files that are found in them. Also, the paths will be normalized.
- """
- result = []
- for ref in refs:
- if IsDirectory(ref):
- # Disable 'Unused variable' for subdirs
- # pylint: disable=unused-variable
- for (directory, subdirs, filenames) in os.walk(ref):
- for filename in filenames:
- if IsJsFile(filename):
- result.append(os.path.join(directory, filename))
- else:
- result.append(ref)
- return map(os.path.normpath, result)
-
-
-class DependencyInfo(object):
- """Represents a dependency that is used to build and walk a tree."""
-
- def __init__(self, filename):
- self.filename = filename
- self.provides = []
- self.requires = []
-
- def __str__(self):
- return '%s Provides: %s Requires: %s' % (self.filename,
- repr(self.provides),
- repr(self.requires))
-
-
-def BuildDependenciesFromFiles(files):
- """Build a list of dependencies from a list of files.
-
- Description:
- Takes a list of files, extracts their provides and requires, and builds
- out a list of dependency objects.
-
- Args:
- files: a list of files to be parsed for goog.provides and goog.requires.
-
- Returns:
- A list of dependency objects, one for each file in the files argument.
- """
- result = []
- filenames = set()
- for filename in files:
- if filename in filenames:
- continue
-
- # Python 3 requires the file encoding to be specified
- if (sys.version_info[0] < 3):
- file_handle = open(filename, 'r')
- else:
- file_handle = open(filename, 'r', encoding='utf8')
-
- try:
- dep = CreateDependencyInfo(filename, file_handle)
- result.append(dep)
- finally:
- file_handle.close()
-
- filenames.add(filename)
-
- return result
-
-
-def CreateDependencyInfo(filename, source):
- """Create dependency info.
-
- Args:
- filename: Filename for source.
- source: File-like object containing source.
-
- Returns:
- A DependencyInfo object with provides and requires filled.
- """
- dep = DependencyInfo(filename)
- for line in source:
- if re.match(req_regex, line):
- dep.requires.append(re.search(req_regex, line).group(1))
- if re.match(prov_regex, line):
- dep.provides.append(re.search(prov_regex, line).group(1))
- return dep
-
-
-def BuildDependencyHashFromDependencies(deps):
- """Builds a hash for searching dependencies by the namespaces they provide.
-
- Description:
- Dependency objects can provide multiple namespaces. This method enumerates
- the provides of each dependency and adds them to a hash that can be used
- to easily resolve a given dependency by a namespace it provides.
-
- Args:
- deps: a list of dependency objects used to build the hash.
-
- Raises:
- Exception: If a multiple files try to provide the same namepace.
-
- Returns:
- A hash table { namespace: dependency } that can be used to resolve a
- dependency by a namespace it provides.
- """
- dep_hash = {}
- for dep in deps:
- for provide in dep.provides:
- if provide in dep_hash:
- raise Exception('Duplicate provide (%s) in (%s, %s)' % (
- provide,
- dep_hash[provide].filename,
- dep.filename))
- dep_hash[provide] = dep
- return dep_hash
-
-
-def CalculateDependencies(paths, inputs):
- """Calculates the dependencies for given inputs.
-
- Description:
- This method takes a list of paths (files, directories) and builds a
- searchable data structure based on the namespaces that each .js file
- provides. It then parses through each input, resolving dependencies
- against this data structure. The final output is a list of files,
- including the inputs, that represent all of the code that is needed to
- compile the given inputs.
-
- Args:
- paths: the references (files, directories) that are used to build the
- dependency hash.
- inputs: the inputs (files, directories, namespaces) that have dependencies
- that need to be calculated.
-
- Raises:
- Exception: if a provided input is invalid.
-
- Returns:
- A list of all files, including inputs, that are needed to compile the given
- inputs.
- """
- deps = BuildDependenciesFromFiles(paths + inputs)
- search_hash = BuildDependencyHashFromDependencies(deps)
- result_list = []
- seen_list = []
- for input_file in inputs:
- if IsNamespace(input_file):
- namespace = re.search(ns_regex, input_file).group(1)
- if namespace not in search_hash:
- raise Exception('Invalid namespace (%s)' % namespace)
- input_file = search_hash[namespace].filename
- if not IsValidFile(input_file) or not IsJsFile(input_file):
- raise Exception('Invalid file (%s)' % input_file)
- seen_list.append(input_file)
- file_handle = open(input_file, 'r')
- try:
- for line in file_handle:
- if re.match(req_regex, line):
- require = re.search(req_regex, line).group(1)
- ResolveDependencies(require, search_hash, result_list, seen_list)
- finally:
- file_handle.close()
- result_list.append(input_file)
-
- # All files depend on base.js, so put it first.
- base_js_path = FindClosureBasePath(paths)
- if base_js_path:
- result_list.insert(0, base_js_path)
- else:
- logging.warning('Closure Library base.js not found.')
-
- return result_list
-
-
-def FindClosureBasePath(paths):
- """Given a list of file paths, return Closure base.js path, if any.
-
- Args:
- paths: A list of paths.
-
- Returns:
- The path to Closure's base.js file including filename, if found.
- """
-
- for path in paths:
- pathname, filename = os.path.split(path)
-
- if filename == 'base.js':
- f = open(path)
-
- is_base = False
-
- # Sanity check that this is the Closure base file. Check that this
- # is where goog is defined. This is determined by the @provideGoog
- # flag.
- for line in f:
- if '@provideGoog' in line:
- is_base = True
- break
-
- f.close()
-
- if is_base:
- return path
-
-def ResolveDependencies(require, search_hash, result_list, seen_list):
- """Takes a given requirement and resolves all of the dependencies for it.
-
- Description:
- A given requirement may require other dependencies. This method
- recursively resolves all dependencies for the given requirement.
-
- Raises:
- Exception: when require does not exist in the search_hash.
-
- Args:
- require: the namespace to resolve dependencies for.
- search_hash: the data structure used for resolving dependencies.
- result_list: a list of filenames that have been calculated as dependencies.
- This variable is the output for this function.
- seen_list: a list of filenames that have been 'seen'. This is required
- for the dependency->dependant ordering.
- """
- if require not in search_hash:
- raise Exception('Missing provider for (%s)' % require)
-
- dep = search_hash[require]
- if not dep.filename in seen_list:
- seen_list.append(dep.filename)
- for sub_require in dep.requires:
- ResolveDependencies(sub_require, search_hash, result_list, seen_list)
- result_list.append(dep.filename)
-
-
-def GetDepsLine(dep, base_path):
- """Returns a JS string for a dependency statement in the deps.js file.
-
- Args:
- dep: The dependency that we're printing.
- base_path: The path to Closure's base.js including filename.
- """
- return 'goog.addDependency("%s", %s, %s);' % (
- GetRelpath(dep.filename, base_path), dep.provides, dep.requires)
-
-
-def GetRelpath(path, start):
- """Return a relative path to |path| from |start|."""
- # NOTE: Python 2.6 provides os.path.relpath, which has almost the same
- # functionality as this function. Since we want to support 2.4, we have
- # to implement it manually. :(
- path_list = os.path.abspath(os.path.normpath(path)).split(os.sep)
- start_list = os.path.abspath(
- os.path.normpath(os.path.dirname(start))).split(os.sep)
-
- common_prefix_count = 0
- for i in range(0, min(len(path_list), len(start_list))):
- if path_list[i] != start_list[i]:
- break
- common_prefix_count += 1
-
- # Always use forward slashes, because this will get expanded to a url,
- # not a file path.
- return '/'.join(['..'] * (len(start_list) - common_prefix_count) +
- path_list[common_prefix_count:])
-
-
-def PrintLine(msg, out):
- out.write(msg)
- out.write('\n')
-
-
-def PrintDeps(source_paths, deps, out):
- """Print out a deps.js file from a list of source paths.
-
- Args:
- source_paths: Paths that we should generate dependency info for.
- deps: Paths that provide dependency info. Their dependency info should
- not appear in the deps file.
- out: The output file.
-
- Returns:
- True on success, false if it was unable to find the base path
- to generate deps relative to.
- """
- base_path = FindClosureBasePath(source_paths + deps)
- if not base_path:
- return False
-
- PrintLine('// This file was autogenerated by calcdeps.py', out)
- excludesSet = set(deps)
-
- for dep in BuildDependenciesFromFiles(source_paths + deps):
- if not dep.filename in excludesSet:
- PrintLine(GetDepsLine(dep, base_path), out)
-
- return True
-
-
-def PrintScript(source_paths, out):
- for index, dep in enumerate(source_paths):
- PrintLine('// Input %d' % index, out)
- f = open(dep, 'r')
- PrintLine(f.read(), out)
- f.close()
-
-
-def GetJavaVersion():
- """Returns the string for the current version of Java installed."""
- proc = subprocess.Popen(['java', '-version'], stderr=subprocess.PIPE)
- proc.wait()
- version_line = proc.stderr.read().splitlines()[0]
- return version_regex.search(version_line).group()
-
-
-def FilterByExcludes(options, files):
- """Filters the given files by the exlusions specified at the command line.
-
- Args:
- options: The flags to calcdeps.
- files: The files to filter.
- Returns:
- A list of files.
- """
- excludes = []
- if options.excludes:
- excludes = ExpandDirectories(options.excludes)
-
- excludesSet = set(excludes)
- return [i for i in files if not i in excludesSet]
-
-
-def GetPathsFromOptions(options):
- """Generates the path files from flag options.
-
- Args:
- options: The flags to calcdeps.
- Returns:
- A list of files in the specified paths. (strings).
- """
-
- search_paths = options.paths
- if not search_paths:
- search_paths = ['.'] # Add default folder if no path is specified.
-
- search_paths = ExpandDirectories(search_paths)
- return FilterByExcludes(options, search_paths)
-
-
-def GetInputsFromOptions(options):
- """Generates the inputs from flag options.
-
- Args:
- options: The flags to calcdeps.
- Returns:
- A list of inputs (strings).
- """
- inputs = options.inputs
- if not inputs: # Parse stdin
- logging.info('No inputs specified. Reading from stdin...')
- inputs = filter(None, [line.strip('\n') for line in sys.stdin.readlines()])
-
- logging.info('Scanning files...')
- inputs = ExpandDirectories(inputs)
-
- return FilterByExcludes(options, inputs)
-
-
-def Compile(compiler_jar_path, source_paths, out, flags=None):
- """Prepares command-line call to Closure compiler.
-
- Args:
- compiler_jar_path: Path to the Closure compiler .jar file.
- source_paths: Source paths to build, in order.
- flags: A list of additional flags to pass on to Closure compiler.
- """
- args = ['java', '-jar', compiler_jar_path]
- for path in source_paths:
- args += ['--js', path]
-
- if flags:
- args += flags
-
- logging.info('Compiling with the following command: %s', ' '.join(args))
- proc = subprocess.Popen(args, stdout=subprocess.PIPE)
- (stdoutdata, stderrdata) = proc.communicate()
- if proc.returncode != 0:
- logging.error('JavaScript compilation failed.')
- sys.exit(1)
- else:
- out.write(stdoutdata)
-
-
-def main():
- """The entrypoint for this script."""
-
- logging.basicConfig(format='calcdeps.py: %(message)s', level=logging.INFO)
-
- usage = 'usage: %prog [options] arg'
- parser = optparse.OptionParser(usage)
- parser.add_option('-i',
- '--input',
- dest='inputs',
- action='append',
- help='The inputs to calculate dependencies for. Valid '
- 'values can be files, directories, or namespaces '
- '(ns:goog.net.XhrIo). Only relevant to "list" and '
- '"script" output.')
- parser.add_option('-p',
- '--path',
- dest='paths',
- action='append',
- help='The paths that should be traversed to build the '
- 'dependencies.')
- parser.add_option('-d',
- '--dep',
- dest='deps',
- action='append',
- help='Directories or files that should be traversed to '
- 'find required dependencies for the deps file. '
- 'Does not generate dependency information for names '
- 'provided by these files. Only useful in "deps" mode.')
- parser.add_option('-e',
- '--exclude',
- dest='excludes',
- action='append',
- help='Files or directories to exclude from the --path '
- 'and --input flags')
- parser.add_option('-o',
- '--output_mode',
- dest='output_mode',
- action='store',
- default='list',
- help='The type of output to generate from this script. '
- 'Options are "list" for a list of filenames, "script" '
- 'for a single script containing the contents of all the '
- 'file, "deps" to generate a deps.js file for all '
- 'paths, or "compiled" to produce compiled output with '
- 'the Closure compiler.')
- parser.add_option('-c',
- '--compiler_jar',
- dest='compiler_jar',
- action='store',
- help='The location of the Closure compiler .jar file.')
- parser.add_option('-f',
- '--compiler_flag',
- '--compiler_flags', # for backwards compatability
- dest='compiler_flags',
- action='append',
- help='Additional flag to pass to the Closure compiler. '
- 'May be specified multiple times to pass multiple flags.')
- parser.add_option('--output_file',
- dest='output_file',
- action='store',
- help=('If specified, write output to this path instead of '
- 'writing to standard output.'))
-
- (options, args) = parser.parse_args()
-
- search_paths = GetPathsFromOptions(options)
-
- if options.output_file:
- out = open(options.output_file, 'w')
- else:
- out = sys.stdout
-
- if options.output_mode == 'deps':
- result = PrintDeps(search_paths, ExpandDirectories(options.deps or []), out)
- if not result:
- logging.error('Could not find Closure Library in the specified paths')
- sys.exit(1)
-
- return
-
- inputs = GetInputsFromOptions(options)
-
- logging.info('Finding Closure dependencies...')
- deps = CalculateDependencies(search_paths, inputs)
- output_mode = options.output_mode
-
- if output_mode == 'script':
- PrintScript(deps, out)
- elif output_mode == 'list':
- # Just print out a dep per line
- for dep in deps:
- PrintLine(dep, out)
- elif output_mode == 'compiled':
- # Make sure a .jar is specified.
- if not options.compiler_jar:
- logging.error('--compiler_jar flag must be specified if --output is '
- '"compiled"')
- sys.exit(1)
-
- # User friendly version check.
- if distutils and not (distutils.version.LooseVersion(GetJavaVersion()) >
- distutils.version.LooseVersion('1.6')):
- logging.error('Closure Compiler requires Java 1.6 or higher.')
- logging.error('Please visit http://www.java.com/getjava')
- sys.exit(1)
-
- Compile(options.compiler_jar, deps, out, options.compiler_flags)
-
- else:
- logging.error('Invalid value for --output flag.')
- sys.exit(1)
-
-if __name__ == '__main__':
- main()
diff --git a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/scopify.py b/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/scopify.py
deleted file mode 100644
index d8057efbc9..0000000000
--- a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/bin/scopify.py
+++ /dev/null
@@ -1,221 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright 2010 The Closure Library Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS-IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-"""Automatically converts codebases over to goog.scope.
-
-Usage:
-cd path/to/my/dir;
-../../../../javascript/closure/bin/scopify.py
-
-Scans every file in this directory, recursively. Looks for existing
-goog.scope calls, and goog.require'd symbols. If it makes sense to
-generate a goog.scope call for the file, then we will do so, and
-try to auto-generate some aliases based on the goog.require'd symbols.
-
-Known Issues:
-
- When a file is goog.scope'd, the file contents will be indented +2.
- This may put some lines over 80 chars. These will need to be fixed manually.
-
- We will only try to create aliases for capitalized names. We do not check
- to see if those names will conflict with any existing locals.
-
- This creates merge conflicts for every line of every outstanding change.
- If you intend to run this on your codebase, make sure your team members
- know. Better yet, send them this script so that they can scopify their
- outstanding changes and "accept theirs".
-
- When an alias is "captured", it can no longer be stubbed out for testing.
- Run your tests.
-
-"""
-
-__author__ = 'nicksantos@google.com (Nick Santos)'
-
-import os.path
-import re
-import sys
-
-REQUIRES_RE = re.compile(r"goog.require\('([^']*)'\)")
-
-# Edit this manually if you want something to "always" be aliased.
-# TODO(nicksantos): Add a flag for this.
-DEFAULT_ALIASES = {}
-
-def Transform(lines):
- """Converts the contents of a file into javascript that uses goog.scope.
-
- Arguments:
- lines: A list of strings, corresponding to each line of the file.
- Returns:
- A new list of strings, or None if the file was not modified.
- """
- requires = []
-
- # Do an initial scan to be sure that this file can be processed.
- for line in lines:
- # Skip this file if it has already been scopified.
- if line.find('goog.scope') != -1:
- return None
-
- # If there are any global vars or functions, then we also have
- # to skip the whole file. We might be able to deal with this
- # more elegantly.
- if line.find('var ') == 0 or line.find('function ') == 0:
- return None
-
- for match in REQUIRES_RE.finditer(line):
- requires.append(match.group(1))
-
- if len(requires) == 0:
- return None
-
- # Backwards-sort the requires, so that when one is a substring of another,
- # we match the longer one first.
- for val in DEFAULT_ALIASES.values():
- if requires.count(val) == 0:
- requires.append(val)
-
- requires.sort()
- requires.reverse()
-
- # Generate a map of requires to their aliases
- aliases_to_globals = DEFAULT_ALIASES.copy()
- for req in requires:
- index = req.rfind('.')
- if index == -1:
- alias = req
- else:
- alias = req[(index + 1):]
-
- # Don't scopify lowercase namespaces, because they may conflict with
- # local variables.
- if alias[0].isupper():
- aliases_to_globals[alias] = req
-
- aliases_to_matchers = {}
- globals_to_aliases = {}
- for alias, symbol in aliases_to_globals.items():
- globals_to_aliases[symbol] = alias
- aliases_to_matchers[alias] = re.compile('\\b%s\\b' % symbol)
-
- # Insert a goog.scope that aliases all required symbols.
- result = []
-
- START = 0
- SEEN_REQUIRES = 1
- IN_SCOPE = 2
-
- mode = START
- aliases_used = set()
- insertion_index = None
- num_blank_lines = 0
- for line in lines:
- if mode == START:
- result.append(line)
-
- if re.search(REQUIRES_RE, line):
- mode = SEEN_REQUIRES
-
- elif mode == SEEN_REQUIRES:
- if (line and
- not re.search(REQUIRES_RE, line) and
- not line.isspace()):
- # There should be two blank lines before goog.scope
- result += ['\n'] * 2
- result.append('goog.scope(function() {\n')
- insertion_index = len(result)
- result += ['\n'] * num_blank_lines
- mode = IN_SCOPE
- elif line.isspace():
- # Keep track of the number of blank lines before each block of code so
- # that we can move them after the goog.scope line if necessary.
- num_blank_lines += 1
- else:
- # Print the blank lines we saw before this code block
- result += ['\n'] * num_blank_lines
- num_blank_lines = 0
- result.append(line)
-
- if mode == IN_SCOPE:
- for symbol in requires:
- if not symbol in globals_to_aliases:
- continue
-
- alias = globals_to_aliases[symbol]
- matcher = aliases_to_matchers[alias]
- for match in matcher.finditer(line):
- # Check to make sure we're not in a string.
- # We do this by being as conservative as possible:
- # if there are any quote or double quote characters
- # before the symbol on this line, then bail out.
- before_symbol = line[:match.start(0)]
- if before_symbol.count('"') > 0 or before_symbol.count("'") > 0:
- continue
-
- line = line.replace(match.group(0), alias)
- aliases_used.add(alias)
-
- if line.isspace():
- # Truncate all-whitespace lines
- result.append('\n')
- else:
- result.append(line)
-
- if len(aliases_used):
- aliases_used = [alias for alias in aliases_used]
- aliases_used.sort()
- aliases_used.reverse()
- for alias in aliases_used:
- symbol = aliases_to_globals[alias]
- result.insert(insertion_index,
- 'var %s = %s;\n' % (alias, symbol))
- result.append('}); // goog.scope\n')
- return result
- else:
- return None
-
-def TransformFileAt(path):
- """Converts a file into javascript that uses goog.scope.
-
- Arguments:
- path: A path to a file.
- """
- f = open(path)
- lines = Transform(f.readlines())
- if lines:
- f = open(path, 'w')
- for l in lines:
- f.write(l)
- f.close()
-
-if __name__ == '__main__':
- args = sys.argv[1:]
- if not len(args):
- args = '.'
-
- for file_name in args:
- if os.path.isdir(file_name):
- for root, dirs, files in os.walk(file_name):
- for name in files:
- if name.endswith('.js') and \
- not os.path.islink(os.path.join(root, name)):
- TransformFileAt(os.path.join(root, name))
- else:
- if file_name.endswith('.js') and \
- not os.path.islink(file_name):
- TransformFileAt(file_name)
diff --git a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/goog/base.js b/dom/canvas/test/webgl-conf/checkout/closure-library/closure/goog/base.js
deleted file mode 100644
index a96333017c..0000000000
--- a/dom/canvas/test/webgl-conf/checkout/closure-library/closure/goog/base.js
+++ /dev/null
@@ -1,2496 +0,0 @@
-// Copyright 2006 The Closure Library Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS-IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-/**
- * @fileoverview Bootstrap for the Google JS Library (Closure).
- *
- * In uncompiled mode base.js will write out Closure's deps file, unless the
- * global CLOSURE_NO_DEPS is set to true. This allows projects to
- * include their own deps file(s) from different locations.
- *
- * @author arv@google.com (Erik Arvidsson)
- *
- * @provideGoog
- */
-
-
-/**
- * @define {boolean} Overridden to true by the compiler when --closure_pass
- * or --mark_as_compiled is specified.
- */
-var COMPILED = false;
-
-
-/**
- * Base namespace for the Closure library. Checks to see goog is already
- * defined in the current scope before assigning to prevent clobbering if
- * base.js is loaded more than once.
- *
- * @const
- */
-var goog = goog || {};
-
-
-/**
- * Reference to the global context. In most cases this will be 'window'.
- */
-goog.global = this;
-
-
-/**
- * A hook for overriding the define values in uncompiled mode.
- *
- * In uncompiled mode, {@code CLOSURE_UNCOMPILED_DEFINES} may be defined before
- * loading base.js. If a key is defined in {@code CLOSURE_UNCOMPILED_DEFINES},
- * {@code goog.define} will use the value instead of the default value. This
- * allows flags to be overwritten without compilation (this is normally
- * accomplished with the compiler's "define" flag).
- *
- * Example:
- *
- * var CLOSURE_UNCOMPILED_DEFINES = {'goog.DEBUG': false};
- *
- *
- * @type {Object|undefined}
- */
-goog.global.CLOSURE_UNCOMPILED_DEFINES;
-
-
-/**
- * A hook for overriding the define values in uncompiled or compiled mode,
- * like CLOSURE_UNCOMPILED_DEFINES but effective in compiled code. In
- * uncompiled code CLOSURE_UNCOMPILED_DEFINES takes precedence.
- *
- * Also unlike CLOSURE_UNCOMPILED_DEFINES the values must be number, boolean or
- * string literals or the compiler will emit an error.
- *
- * While any @define value may be set, only those set with goog.define will be
- * effective for uncompiled code.
- *
- * Example:
- *
- * var CLOSURE_DEFINES = {'goog.DEBUG': false} ;
- *
- *
- * @type {Object|undefined}
- */
-goog.global.CLOSURE_DEFINES;
-
-
-/**
- * Returns true if the specified value is not undefined.
- * WARNING: Do not use this to test if an object has a property. Use the in
- * operator instead.
- *
- * @param {?} val Variable to test.
- * @return {boolean} Whether variable is defined.
- */
-goog.isDef = function(val) {
- // void 0 always evaluates to undefined and hence we do not need to depend on
- // the definition of the global variable named 'undefined'.
- return val !== void 0;
-};
-
-
-/**
- * Builds an object structure for the provided namespace path, ensuring that
- * names that already exist are not overwritten. For example:
- * "a.b.c" -> a = {};a.b={};a.b.c={};
- * Used by goog.provide and goog.exportSymbol.
- * @param {string} name name of the object that this file defines.
- * @param {*=} opt_object the object to expose at the end of the path.
- * @param {Object=} opt_objectToExportTo The object to add the path to; default
- * is |goog.global|.
- * @private
- */
-goog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {
- var parts = name.split('.');
- var cur = opt_objectToExportTo || goog.global;
-
- // Internet Explorer exhibits strange behavior when throwing errors from
- // methods externed in this manner. See the testExportSymbolExceptions in
- // base_test.html for an example.
- if (!(parts[0] in cur) && cur.execScript) {
- cur.execScript('var ' + parts[0]);
- }
-
- // Certain browsers cannot parse code in the form for((a in b); c;);
- // This pattern is produced by the JSCompiler when it collapses the
- // statement above into the conditional loop below. To prevent this from
- // happening, use a for-loop and reserve the init logic as below.
-
- // Parentheses added to eliminate strict JS warning in Firefox.
- for (var part; parts.length && (part = parts.shift());) {
- if (!parts.length && goog.isDef(opt_object)) {
- // last part and we have an object; use it
- cur[part] = opt_object;
- } else if (cur[part]) {
- cur = cur[part];
- } else {
- cur = cur[part] = {};
- }
- }
-};
-
-
-/**
- * Defines a named value. In uncompiled mode, the value is retrieved from
- * CLOSURE_DEFINES or CLOSURE_UNCOMPILED_DEFINES if the object is defined and
- * has the property specified, and otherwise used the defined defaultValue.
- * When compiled the default can be overridden using the compiler
- * options or the value set in the CLOSURE_DEFINES object.
- *
- * @param {string} name The distinguished name to provide.
- * @param {string|number|boolean} defaultValue
- */
-goog.define = function(name, defaultValue) {
- var value = defaultValue;
- if (!COMPILED) {
- if (goog.global.CLOSURE_UNCOMPILED_DEFINES &&
- Object.prototype.hasOwnProperty.call(
- goog.global.CLOSURE_UNCOMPILED_DEFINES, name)) {
- value = goog.global.CLOSURE_UNCOMPILED_DEFINES[name];
- } else if (goog.global.CLOSURE_DEFINES &&
- Object.prototype.hasOwnProperty.call(
- goog.global.CLOSURE_DEFINES, name)) {
- value = goog.global.CLOSURE_DEFINES[name];
- }
- }
- goog.exportPath_(name, value);
-};
-
-
-/**
- * @define {boolean} DEBUG is provided as a convenience so that debugging code
- * that should not be included in a production js_binary can be easily stripped
- * by specifying --define goog.DEBUG=false to the JSCompiler. For example, most
- * toString() methods should be declared inside an "if (goog.DEBUG)" conditional
- * because they are generally used for debugging purposes and it is difficult
- * for the JSCompiler to statically determine whether they are used.
- */
-goog.define('goog.DEBUG', true);
-
-
-/**
- * @define {string} LOCALE defines the locale being used for compilation. It is
- * used to select locale specific data to be compiled in js binary. BUILD rule
- * can specify this value by "--define goog.LOCALE=" as JSCompiler
- * option.
- *
- * Take into account that the locale code format is important. You should use
- * the canonical Unicode format with hyphen as a delimiter. Language must be
- * lowercase, Language Script - Capitalized, Region - UPPERCASE.
- * There are few examples: pt-BR, en, en-US, sr-Latin-BO, zh-Hans-CN.
- *
- * See more info about locale codes here:
- * http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers
- *
- * For language codes you should use values defined by ISO 693-1. See it here
- * http://www.w3.org/WAI/ER/IG/ert/iso639.htm. There is only one exception from
- * this rule: the Hebrew language. For legacy reasons the old code (iw) should
- * be used instead of the new code (he), see http://wiki/Main/IIISynonyms.
- */
-goog.define('goog.LOCALE', 'en'); // default to en
-
-
-/**
- * @define {boolean} Whether this code is running on trusted sites.
- *
- * On untrusted sites, several native functions can be defined or overridden by
- * external libraries like Prototype, Datejs, and JQuery and setting this flag
- * to false forces closure to use its own implementations when possible.
- *
- * If your JavaScript can be loaded by a third party site and you are wary about
- * relying on non-standard implementations, specify
- * "--define goog.TRUSTED_SITE=false" to the JSCompiler.
- */
-goog.define('goog.TRUSTED_SITE', true);
-
-
-/**
- * @define {boolean} Whether a project is expected to be running in strict mode.
- *
- * This define can be used to trigger alternate implementations compatible with
- * running in EcmaScript Strict mode or warn about unavailable functionality.
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode
- *
- */
-goog.define('goog.STRICT_MODE_COMPATIBLE', false);
-
-
-/**
- * @define {boolean} Whether code that calls {@link goog.setTestOnly} should
- * be disallowed in the compilation unit.
- */
-goog.define('goog.DISALLOW_TEST_ONLY_CODE', COMPILED && !goog.DEBUG);
-
-
-/**
- * Defines a namespace in Closure.
- *
- * A namespace may only be defined once in a codebase. It may be defined using
- * goog.provide() or goog.module().
- *
- * The presence of one or more goog.provide() calls in a file indicates
- * that the file defines the given objects/namespaces.
- * Provided symbols must not be null or undefined.
- *
- * In addition, goog.provide() creates the object stubs for a namespace
- * (for example, goog.provide("goog.foo.bar") will create the object
- * goog.foo.bar if it does not already exist).
- *
- * Build tools also scan for provide/require/module statements
- * to discern dependencies, build dependency files (see deps.js), etc.
- *
- * @see goog.require
- * @see goog.module
- * @param {string} name Namespace provided by this file in the form
- * "goog.package.part".
- */
-goog.provide = function(name) {
- if (!COMPILED) {
- // Ensure that the same namespace isn't provided twice.
- // A goog.module/goog.provide maps a goog.require to a specific file
- if (goog.isProvided_(name)) {
- throw Error('Namespace "' + name + '" already declared.');
- }
- }
-
- goog.constructNamespace_(name);
-};
-
-
-/**
- * @param {string} name Namespace provided by this file in the form
- * "goog.package.part".
- * @param {Object=} opt_obj The object to embed in the namespace.
- * @private
- */
-goog.constructNamespace_ = function(name, opt_obj) {
- if (!COMPILED) {
- delete goog.implicitNamespaces_[name];
-
- var namespace = name;
- while ((namespace = namespace.substring(0, namespace.lastIndexOf('.')))) {
- if (goog.getObjectByName(namespace)) {
- break;
- }
- goog.implicitNamespaces_[namespace] = true;
- }
- }
-
- goog.exportPath_(name, opt_obj);
-};
-
-
-/**
- * Module identifier validation regexp.
- * Note: This is a conservative check, it is very possible to be more lenient,
- * the primary exclusion here is "/" and "\" and a leading ".", these
- * restrictions are intended to leave the door open for using goog.require
- * with relative file paths rather than module identifiers.
- * @private
- */
-goog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;
-
-
-/**
- * Defines a module in Closure.
- *
- * Marks that this file must be loaded as a module and claims the namespace.
- *
- * A namespace may only be defined once in a codebase. It may be defined using
- * goog.provide() or goog.module().
- *
- * goog.module() has three requirements:
- * - goog.module may not be used in the same file as goog.provide.
- * - goog.module must be the first statement in the file.
- * - only one goog.module is allowed per file.
- *
- * When a goog.module annotated file is loaded, it is enclosed in
- * a strict function closure. This means that:
- * - any variables declared in a goog.module file are private to the file
- * (not global), though the compiler is expected to inline the module.
- * - The code must obey all the rules of "strict" JavaScript.
- * - the file will be marked as "use strict"
- *
- * NOTE: unlike goog.provide, goog.module does not declare any symbols by
- * itself. If declared symbols are desired, use
- * goog.module.declareLegacyNamespace().
- *
- *
- * See the public goog.module proposal: http://goo.gl/Va1hin
- *
- * @param {string} name Namespace provided by this file in the form
- * "goog.package.part", is expected but not required.
- */
-goog.module = function(name) {
- if (!goog.isString(name) ||
- !name ||
- name.search(goog.VALID_MODULE_RE_) == -1) {
- throw Error('Invalid module identifier');
- }
- if (!goog.isInModuleLoader_()) {
- throw Error('Module ' + name + ' has been loaded incorrectly.');
- }
- if (goog.moduleLoaderState_.moduleName) {
- throw Error('goog.module may only be called once per module.');
- }
-
- // Store the module name for the loader.
- goog.moduleLoaderState_.moduleName = name;
- if (!COMPILED) {
- // Ensure that the same namespace isn't provided twice.
- // A goog.module/goog.provide maps a goog.require to a specific file
- if (goog.isProvided_(name)) {
- throw Error('Namespace "' + name + '" already declared.');
- }
- delete goog.implicitNamespaces_[name];
- }
-};
-
-
-/**
- * @param {string} name The module identifier.
- * @return {?} The module exports for an already loaded module or null.
- *
- * Note: This is not an alternative to goog.require, it does not
- * indicate a hard dependency, instead it is used to indicate
- * an optional dependency or to access the exports of a module
- * that has already been loaded.
- * @suppress {missingProvide}
- */
-goog.module.get = function(name) {
- return goog.module.getInternal_(name);
-};
-
-
-/**
- * @param {string} name The module identifier.
- * @return {?} The module exports for an already loaded module or null.
- * @private
- */
-goog.module.getInternal_ = function(name) {
- if (!COMPILED) {
- if (goog.isProvided_(name)) {
- // goog.require only return a value with-in goog.module files.
- return name in goog.loadedModules_ ?
- goog.loadedModules_[name] :
- goog.getObjectByName(name);
- } else {
- return null;
- }
- }
-};
-
-
-/**
- * @private {?{
- * moduleName: (string|undefined),
- * declareTestMethods: boolean
- * }}
- */
-goog.moduleLoaderState_ = null;
-
-
-/**
- * @private
- * @return {boolean} Whether a goog.module is currently being initialized.
- */
-goog.isInModuleLoader_ = function() {
- return goog.moduleLoaderState_ != null;
-};
-
-
-/**
- * Indicate that a module's exports that are known test methods should
- * be copied to the global object. This makes the test methods visible to
- * test runners that inspect the global object.
- *
- * TODO(johnlenz): Make the test framework aware of goog.module so
- * that this isn't necessary. Alternately combine this with goog.setTestOnly
- * to minimize boiler plate.
- * @suppress {missingProvide}
- */
-goog.module.declareTestMethods = function() {
- if (!goog.isInModuleLoader_()) {
- throw new Error('goog.module.declareTestMethods must be called from ' +
- 'within a goog.module');
- }
- goog.moduleLoaderState_.declareTestMethods = true;
-};
-
-
-/**
- * Provide the module's exports as a globally accessible object under the
- * module's declared name. This is intended to ease migration to goog.module
- * for files that have existing usages.
- * @suppress {missingProvide}
- */
-goog.module.declareLegacyNamespace = function() {
- if (!COMPILED && !goog.isInModuleLoader_()) {
- throw new Error('goog.module.declareLegacyNamespace must be called from ' +
- 'within a goog.module');
- }
- if (!COMPILED && !goog.moduleLoaderState_.moduleName) {
- throw Error('goog.module must be called prior to ' +
- 'goog.module.declareLegacyNamespace.');
- }
- goog.moduleLoaderState_.declareLegacyNamespace = true;
-};
-
-
-/**
- * Marks that the current file should only be used for testing, and never for
- * live code in production.
- *
- * In the case of unit tests, the message may optionally be an exact namespace
- * for the test (e.g. 'goog.stringTest'). The linter will then ignore the extra
- * provide (if not explicitly defined in the code).
- *
- * @param {string=} opt_message Optional message to add to the error that's
- * raised when used in production code.
- */
-goog.setTestOnly = function(opt_message) {
- if (goog.DISALLOW_TEST_ONLY_CODE) {
- opt_message = opt_message || '';
- throw Error('Importing test-only code into non-debug environment' +
- (opt_message ? ': ' + opt_message : '.'));
- }
-};
-
-
-/**
- * Forward declares a symbol. This is an indication to the compiler that the
- * symbol may be used in the source yet is not required and may not be provided
- * in compilation.
- *
- * The most common usage of forward declaration is code that takes a type as a
- * function parameter but does not need to require it. By forward declaring
- * instead of requiring, no hard dependency is made, and (if not required
- * elsewhere) the namespace may never be required and thus, not be pulled
- * into the JavaScript binary. If it is required elsewhere, it will be type
- * checked as normal.
- *
- *
- * @param {string} name The namespace to forward declare in the form of
- * "goog.package.part".
- */
-goog.forwardDeclare = function(name) {};
-
-
-if (!COMPILED) {
-
- /**
- * Check if the given name has been goog.provided. This will return false for
- * names that are available only as implicit namespaces.
- * @param {string} name name of the object to look for.
- * @return {boolean} Whether the name has been provided.
- * @private
- */
- goog.isProvided_ = function(name) {
- return (name in goog.loadedModules_) ||
- (!goog.implicitNamespaces_[name] &&
- goog.isDefAndNotNull(goog.getObjectByName(name)));
- };
-
- /**
- * Namespaces implicitly defined by goog.provide. For example,
- * goog.provide('goog.events.Event') implicitly declares that 'goog' and
- * 'goog.events' must be namespaces.
- *
- * @type {!Object}
- * @private
- */
- goog.implicitNamespaces_ = {'goog.module': true};
-
- // NOTE: We add goog.module as an implicit namespace as goog.module is defined
- // here and because the existing module package has not been moved yet out of
- // the goog.module namespace. This satisifies both the debug loader and
- // ahead-of-time dependency management.
-}
-
-
-/**
- * Returns an object based on its fully qualified external name. The object
- * is not found if null or undefined. If you are using a compilation pass that
- * renames property names beware that using this function will not find renamed
- * properties.
- *
- * @param {string} name The fully qualified name.
- * @param {Object=} opt_obj The object within which to look; default is
- * |goog.global|.
- * @return {?} The value (object or primitive) or, if not found, null.
- */
-goog.getObjectByName = function(name, opt_obj) {
- var parts = name.split('.');
- var cur = opt_obj || goog.global;
- for (var part; part = parts.shift(); ) {
- if (goog.isDefAndNotNull(cur[part])) {
- cur = cur[part];
- } else {
- return null;
- }
- }
- return cur;
-};
-
-
-/**
- * Globalizes a whole namespace, such as goog or goog.lang.
- *
- * @param {!Object} obj The namespace to globalize.
- * @param {Object=} opt_global The object to add the properties to.
- * @deprecated Properties may be explicitly exported to the global scope, but
- * this should no longer be done in bulk.
- */
-goog.globalize = function(obj, opt_global) {
- var global = opt_global || goog.global;
- for (var x in obj) {
- global[x] = obj[x];
- }
-};
-
-
-/**
- * Adds a dependency from a file to the files it requires.
- * @param {string} relPath The path to the js file.
- * @param {!Array} provides An array of strings with
- * the names of the objects this file provides.
- * @param {!Array} requires An array of strings with
- * the names of the objects this file requires.
- * @param {boolean=} opt_isModule Whether this dependency must be loaded as
- * a module as declared by goog.module.
- */
-goog.addDependency = function(relPath, provides, requires, opt_isModule) {
- if (goog.DEPENDENCIES_ENABLED) {
- var provide, require;
- var path = relPath.replace(/\\/g, '/');
- var deps = goog.dependencies_;
- for (var i = 0; provide = provides[i]; i++) {
- deps.nameToPath[provide] = path;
- deps.pathIsModule[path] = !!opt_isModule;
- }
- for (var j = 0; require = requires[j]; j++) {
- if (!(path in deps.requires)) {
- deps.requires[path] = {};
- }
- deps.requires[path][require] = true;
- }
- }
-};
-
-
-
-
-// NOTE(nnaze): The debug DOM loader was included in base.js as an original way
-// to do "debug-mode" development. The dependency system can sometimes be
-// confusing, as can the debug DOM loader's asynchronous nature.
-//
-// With the DOM loader, a call to goog.require() is not blocking -- the script
-// will not load until some point after the current script. If a namespace is
-// needed at runtime, it needs to be defined in a previous script, or loaded via
-// require() with its registered dependencies.
-// User-defined namespaces may need their own deps file. See http://go/js_deps,
-// http://go/genjsdeps, or, externally, DepsWriter.
-// https://developers.google.com/closure/library/docs/depswriter
-//
-// Because of legacy clients, the DOM loader can't be easily removed from
-// base.js. Work is being done to make it disableable or replaceable for
-// different environments (DOM-less JavaScript interpreters like Rhino or V8,
-// for example). See bootstrap/ for more information.
-
-
-/**
- * @define {boolean} Whether to enable the debug loader.
- *
- * If enabled, a call to goog.require() will attempt to load the namespace by
- * appending a script tag to the DOM (if the namespace has been registered).
- *
- * If disabled, goog.require() will simply assert that the namespace has been
- * provided (and depend on the fact that some outside tool correctly ordered
- * the script).
- */
-goog.define('goog.ENABLE_DEBUG_LOADER', true);
-
-
-/**
- * @param {string} msg
- * @private
- */
-goog.logToConsole_ = function(msg) {
- if (goog.global.console) {
- goog.global.console['error'](msg);
- }
-};
-
-
-/**
- * Implements a system for the dynamic resolution of dependencies that works in
- * parallel with the BUILD system. Note that all calls to goog.require will be
- * stripped by the JSCompiler when the --closure_pass option is used.
- * @see goog.provide
- * @param {string} name Namespace to include (as was given in goog.provide()) in
- * the form "goog.package.part".
- * @return {?} If called within a goog.module file, the associated namespace or
- * module otherwise null.
- */
-goog.require = function(name) {
-
- // If the object already exists we do not need do do anything.
- if (!COMPILED) {
- if (goog.ENABLE_DEBUG_LOADER && goog.IS_OLD_IE_) {
- goog.maybeProcessDeferredDep_(name);
- }
-
- if (goog.isProvided_(name)) {
- if (goog.isInModuleLoader_()) {
- return goog.module.getInternal_(name);
- } else {
- return null;
- }
- }
-
- if (goog.ENABLE_DEBUG_LOADER) {
- var path = goog.getPathFromDeps_(name);
- if (path) {
- goog.included_[path] = true;
- goog.writeScripts_();
- return null;
- }
- }
-
- var errorMessage = 'goog.require could not find: ' + name;
- goog.logToConsole_(errorMessage);
-
- throw Error(errorMessage);
- }
-};
-
-
-/**
- * Path for included scripts.
- * @type {string}
- */
-goog.basePath = '';
-
-
-/**
- * A hook for overriding the base path.
- * @type {string|undefined}
- */
-goog.global.CLOSURE_BASE_PATH;
-
-
-/**
- * Whether to write out Closure's deps file. By default, the deps are written.
- * @type {boolean|undefined}
- */
-goog.global.CLOSURE_NO_DEPS;
-
-
-/**
- * A function to import a single script. This is meant to be overridden when
- * Closure is being run in non-HTML contexts, such as web workers. It's defined
- * in the global scope so that it can be set before base.js is loaded, which
- * allows deps.js to be imported properly.
- *
- * The function is passed the script source, which is a relative URI. It should
- * return true if the script was imported, false otherwise.
- * @type {(function(string): boolean)|undefined}
- */
-goog.global.CLOSURE_IMPORT_SCRIPT;
-
-
-/**
- * Null function used for default values of callbacks, etc.
- * @return {void} Nothing.
- */
-goog.nullFunction = function() {};
-
-
-/**
- * The identity function. Returns its first argument.
- *
- * @param {*=} opt_returnValue The single value that will be returned.
- * @param {...*} var_args Optional trailing arguments. These are ignored.
- * @return {?} The first argument. We can't know the type -- just pass it along
- * without type.
- * @deprecated Use goog.functions.identity instead.
- */
-goog.identityFunction = function(opt_returnValue, var_args) {
- return opt_returnValue;
-};
-
-
-/**
- * When defining a class Foo with an abstract method bar(), you can do:
- * Foo.prototype.bar = goog.abstractMethod
- *
- * Now if a subclass of Foo fails to override bar(), an error will be thrown
- * when bar() is invoked.
- *
- * Note: This does not take the name of the function to override as an argument
- * because that would make it more difficult to obfuscate our JavaScript code.
- *
- * @type {!Function}
- * @throws {Error} when invoked to indicate the method should be overridden.
- */
-goog.abstractMethod = function() {
- throw Error('unimplemented abstract method');
-};
-
-
-/**
- * Adds a {@code getInstance} static method that always returns the same
- * instance object.
- * @param {!Function} ctor The constructor for the class to add the static
- * method to.
- */
-goog.addSingletonGetter = function(ctor) {
- ctor.getInstance = function() {
- if (ctor.instance_) {
- return ctor.instance_;
- }
- if (goog.DEBUG) {
- // NOTE: JSCompiler can't optimize away Array#push.
- goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;
- }
- return ctor.instance_ = new ctor;
- };
-};
-
-
-/**
- * All singleton classes that have been instantiated, for testing. Don't read
- * it directly, use the {@code goog.testing.singleton} module. The compiler
- * removes this variable if unused.
- * @type {!Array}
- * @private
- */
-goog.instantiatedSingletons_ = [];
-
-
-/**
- * @define {boolean} Whether to load goog.modules using {@code eval} when using
- * the debug loader. This provides a better debugging experience as the
- * source is unmodified and can be edited using Chrome Workspaces or similar.
- * However in some environments the use of {@code eval} is banned
- * so we provide an alternative.
- */
-goog.define('goog.LOAD_MODULE_USING_EVAL', true);
-
-
-/**
- * @define {boolean} Whether the exports of goog.modules should be sealed when
- * possible.
- */
-goog.define('goog.SEAL_MODULE_EXPORTS', goog.DEBUG);
-
-
-/**
- * The registry of initialized modules:
- * the module identifier to module exports map.
- * @private @const {!Object}
- */
-goog.loadedModules_ = {};
-
-
-/**
- * True if goog.dependencies_ is available.
- * @const {boolean}
- */
-goog.DEPENDENCIES_ENABLED = !COMPILED && goog.ENABLE_DEBUG_LOADER;
-
-
-if (goog.DEPENDENCIES_ENABLED) {
- /**
- * Object used to keep track of urls that have already been added. This record
- * allows the prevention of circular dependencies.
- * @private {!Object}
- */
- goog.included_ = {};
-
-
- /**
- * This object is used to keep track of dependencies and other data that is
- * used for loading scripts.
- * @private
- * @type {{
- * pathIsModule: !Object,
- * nameToPath: !Object,
- * requires: !Object>,
- * visited: !Object,
- * written: !Object,
- * deferred: !Object
- * }}
- */
- goog.dependencies_ = {
- pathIsModule: {}, // 1 to 1
-
- nameToPath: {}, // 1 to 1
-
- requires: {}, // 1 to many
-
- // Used when resolving dependencies to prevent us from visiting file twice.
- visited: {},
-
- written: {}, // Used to keep track of script files we have written.
-
- deferred: {} // Used to track deferred module evaluations in old IEs
- };
-
-
- /**
- * Tries to detect whether is in the context of an HTML document.
- * @return {boolean} True if it looks like HTML document.
- * @private
- */
- goog.inHtmlDocument_ = function() {
- var doc = goog.global.document;
- return typeof doc != 'undefined' &&
- 'write' in doc; // XULDocument misses write.
- };
-
-
- /**
- * Tries to detect the base path of base.js script that bootstraps Closure.
- * @private
- */
- goog.findBasePath_ = function() {
- if (goog.isDef(goog.global.CLOSURE_BASE_PATH)) {
- goog.basePath = goog.global.CLOSURE_BASE_PATH;
- return;
- } else if (!goog.inHtmlDocument_()) {
- return;
- }
- var doc = goog.global.document;
- var scripts = doc.getElementsByTagName('SCRIPT');
- // Search backwards since the current script is in almost all cases the one
- // that has base.js.
- for (var i = scripts.length - 1; i >= 0; --i) {
- var script = /** @type {!HTMLScriptElement} */ (scripts[i]);
- var src = script.src;
- var qmark = src.lastIndexOf('?');
- var l = qmark == -1 ? src.length : qmark;
- if (src.substr(l - 7, 7) == 'base.js') {
- goog.basePath = src.substr(0, l - 7);
- return;
- }
- }
- };
-
-
- /**
- * Imports a script if, and only if, that script hasn't already been imported.
- * (Must be called at execution time)
- * @param {string} src Script source.
- * @param {string=} opt_sourceText The optionally source text to evaluate
- * @private
- */
- goog.importScript_ = function(src, opt_sourceText) {
- var importScript = goog.global.CLOSURE_IMPORT_SCRIPT ||
- goog.writeScriptTag_;
- if (importScript(src, opt_sourceText)) {
- goog.dependencies_.written[src] = true;
- }
- };
-
-
- /** @const @private {boolean} */
- goog.IS_OLD_IE_ = !!(!goog.global.atob && goog.global.document &&
- goog.global.document.all);
-
-
- /**
- * Given a URL initiate retrieval and execution of the module.
- * @param {string} src Script source URL.
- * @private
- */
- goog.importModule_ = function(src) {
- // In an attempt to keep browsers from timing out loading scripts using
- // synchronous XHRs, put each load in its own script block.
- var bootstrap = 'goog.retrieveAndExecModule_("' + src + '");';
-
- if (goog.importScript_('', bootstrap)) {
- goog.dependencies_.written[src] = true;
- }
- };
-
-
- /** @private {!Array} */
- goog.queuedModules_ = [];
-
-
- /**
- * Return an appropriate module text. Suitable to insert into
- * a script tag (that is unescaped).
- * @param {string} srcUrl
- * @param {string} scriptText
- * @return {string}
- * @private
- */
- goog.wrapModule_ = function(srcUrl, scriptText) {
- if (!goog.LOAD_MODULE_USING_EVAL || !goog.isDef(goog.global.JSON)) {
- return '' +
- 'goog.loadModule(function(exports) {' +
- '"use strict";' +
- scriptText +
- '\n' + // terminate any trailing single line comment.
- ';return exports' +
- '});' +
- '\n//# sourceURL=' + srcUrl + '\n';
- } else {
- return '' +
- 'goog.loadModule(' +
- goog.global.JSON.stringify(
- scriptText + '\n//# sourceURL=' + srcUrl + '\n') +
- ');';
- }
- };
-
- // On IE9 and earlier, it is necessary to handle
- // deferred module loads. In later browsers, the
- // code to be evaluated is simply inserted as a script
- // block in the correct order. To eval deferred
- // code at the right time, we piggy back on goog.require to call
- // goog.maybeProcessDeferredDep_.
- //
- // The goog.requires are used both to bootstrap
- // the loading process (when no deps are available) and
- // declare that they should be available.
- //
- // Here we eval the sources, if all the deps are available
- // either already eval'd or goog.require'd. This will
- // be the case when all the dependencies have already
- // been loaded, and the dependent module is loaded.
- //
- // But this alone isn't sufficient because it is also
- // necessary to handle the case where there is no root
- // that is not deferred. For that there we register for an event
- // and trigger goog.loadQueuedModules_ handle any remaining deferred
- // evaluations.
-
- /**
- * Handle any remaining deferred goog.module evals.
- * @private
- */
- goog.loadQueuedModules_ = function() {
- var count = goog.queuedModules_.length;
- if (count > 0) {
- var queue = goog.queuedModules_;
- goog.queuedModules_ = [];
- for (var i = 0; i < count; i++) {
- var path = queue[i];
- goog.maybeProcessDeferredPath_(path);
- }
- }
- };
-
-
- /**
- * Eval the named module if its dependencies are
- * available.
- * @param {string} name The module to load.
- * @private
- */
- goog.maybeProcessDeferredDep_ = function(name) {
- if (goog.isDeferredModule_(name) &&
- goog.allDepsAreAvailable_(name)) {
- var path = goog.getPathFromDeps_(name);
- goog.maybeProcessDeferredPath_(goog.basePath + path);
- }
- };
-
- /**
- * @param {string} name The module to check.
- * @return {boolean} Whether the name represents a
- * module whose evaluation has been deferred.
- * @private
- */
- goog.isDeferredModule_ = function(name) {
- var path = goog.getPathFromDeps_(name);
- if (path && goog.dependencies_.pathIsModule[path]) {
- var abspath = goog.basePath + path;
- return (abspath) in goog.dependencies_.deferred;
- }
- return false;
- };
-
- /**
- * @param {string} name The module to check.
- * @return {boolean} Whether the name represents a
- * module whose declared dependencies have all been loaded
- * (eval'd or a deferred module load)
- * @private
- */
- goog.allDepsAreAvailable_ = function(name) {
- var path = goog.getPathFromDeps_(name);
- if (path && (path in goog.dependencies_.requires)) {
- for (var requireName in goog.dependencies_.requires[path]) {
- if (!goog.isProvided_(requireName) &&
- !goog.isDeferredModule_(requireName)) {
- return false;
- }
- }
- }
- return true;
- };
-
-
- /**
- * @param {string} abspath
- * @private
- */
- goog.maybeProcessDeferredPath_ = function(abspath) {
- if (abspath in goog.dependencies_.deferred) {
- var src = goog.dependencies_.deferred[abspath];
- delete goog.dependencies_.deferred[abspath];
- goog.globalEval(src);
- }
- };
-
-
- /**
- * @param {function(?):?|string} moduleDef The module definition.
- */
- goog.loadModule = function(moduleDef) {
- // NOTE: we allow function definitions to be either in the from
- // of a string to eval (which keeps the original source intact) or
- // in a eval forbidden environment (CSP) we allow a function definition
- // which in its body must call {@code goog.module}, and return the exports
- // of the module.
- var previousState = goog.moduleLoaderState_;
- try {
- goog.moduleLoaderState_ = {
- moduleName: undefined, declareTestMethods: false};
- var exports;
- if (goog.isFunction(moduleDef)) {
- exports = moduleDef.call(goog.global, {});
- } else if (goog.isString(moduleDef)) {
- exports = goog.loadModuleFromSource_.call(goog.global, moduleDef);
- } else {
- throw Error('Invalid module definition');
- }
-
- var moduleName = goog.moduleLoaderState_.moduleName;
- if (!goog.isString(moduleName) || !moduleName) {
- throw Error('Invalid module name \"' + moduleName + '\"');
- }
-
- // Don't seal legacy namespaces as they may be uses as a parent of
- // another namespace
- if (goog.moduleLoaderState_.declareLegacyNamespace) {
- goog.constructNamespace_(moduleName, exports);
- } else if (goog.SEAL_MODULE_EXPORTS && Object.seal) {
- Object.seal(exports);
- }
-
- goog.loadedModules_[moduleName] = exports;
- if (goog.moduleLoaderState_.declareTestMethods) {
- for (var entry in exports) {
- if (entry.indexOf('test', 0) === 0 ||
- entry == 'tearDown' ||
- entry == 'setUp' ||
- entry == 'setUpPage' ||
- entry == 'tearDownPage') {
- goog.global[entry] = exports[entry];
- }
- }
- }
- } finally {
- goog.moduleLoaderState_ = previousState;
- }
- };
-
-
- /**
- * @param {string} source
- * @return {!Object}
- * @private
- */
- goog.loadModuleFromSource_ = function(source) {
- // NOTE: we avoid declaring parameters or local variables here to avoid
- // masking globals or leaking values into the module definition.
- 'use strict';
- var exports = {};
- eval(arguments[0]);
- return exports;
- };
-
-
- /**
- * The default implementation of the import function. Writes a script tag to
- * import the script.
- *
- * @param {string} src The script url.
- * @param {string=} opt_sourceText The optionally source text to evaluate
- * @return {boolean} True if the script was imported, false otherwise.
- * @private
- */
- goog.writeScriptTag_ = function(src, opt_sourceText) {
- if (goog.inHtmlDocument_()) {
- var doc = goog.global.document;
-
- // If the user tries to require a new symbol after document load,
- // something has gone terribly wrong. Doing a document.write would
- // wipe out the page.
- if (doc.readyState == 'complete') {
- // Certain test frameworks load base.js multiple times, which tries
- // to write deps.js each time. If that happens, just fail silently.
- // These frameworks wipe the page between each load of base.js, so this
- // is OK.
- var isDeps = /\bdeps.js$/.test(src);
- if (isDeps) {
- return false;
- } else {
- throw Error('Cannot write "' + src + '" after document load');
- }
- }
-
- var isOldIE = goog.IS_OLD_IE_;
-
- if (opt_sourceText === undefined) {
- if (!isOldIE) {
- doc.write(
- '
-
-bindAttribLocation with aliasing
-
-
-
-
-
-
-
-
-
-