Adding frogium: a frog-chromium architecture that runs tests in chromium that

tools/testing/architecture.py

 # Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 #
 
 import os
 import platform
 import re
 import shutil
 import subprocess
@@ skipping 328 matching lines @@
     """Returns the name of the output .js file to create."""
     path = self.GetTestScriptFile()
     return os.path.abspath(os.path.join(self.temp_dir,
                                         os.path.basename(path) + '.js'))
 
   def GetHtmlName(self):
     """Returns the name of the output .html file to create."""
     relpath = os.path.relpath(self.test, self.root_path)
     return relpath.replace(os.sep, '_') + '.html'
 
+  def Compile(self):
+    return ExecuteCommand(self.GetCompileCommand())
+
+class DartcChromiumArchitecture(ChromiumArchitecture):
+  """ChromiumArchitecture that compiles code using dartc."""
+
+  def __init__(self, root_path, arch, mode, component, test):
+    super(DartcChromiumArchitecture, self).__init__(
+        root_path, arch, mode, component, test)
+
   def GetCompileCommand(self, fatal_static_type_errors=False):
     """Returns cmdline as an array to invoke the compiler on this test."""
 
     # We need an absolute path because the compilation will run
     # in a temporary directory.
     build_root = utils.GetBuildRoot(OS_GUESS, self.mode, 'ia32')
     dartc = os.path.abspath(os.path.join(build_root, 'compiler', 'bin',
                                          'dartc'))
     if utils.IsWindows(): dartc += '.exe'
     cmd = [dartc, '--work', self.temp_dir]
     if self.mode == 'release':
       cmd += ['--optimize']
     cmd += self.vm_options
     cmd += ['--out', self.GetScriptPath()]
     if fatal_static_type_errors:
       # TODO(zundel): update to --fatal_type_errors for both VM and Compiler
       cmd.append('-fatal-type-errors')
     cmd.append(self.GetTestScriptFile())
     return cmd
 
-  def Compile(self):
-    return ExecuteCommand(self.GetCompileCommand())
+
+class FrogChromiumArchitecture(ChromiumArchitecture):
+  """ChromiumArchitecture that compiles code using frog."""
+
+  def __init__(self, root_path, arch, mode, component, test):
+    super(FrogChromiumArchitecture, self).__init__(
+        root_path, arch, mode, component, test)
+
+  def GetCompileCommand(self, fatal_static_type_errors=False):
+    """Returns cmdline as an array to invoke the compiler on this test."""
+
+    # We need an absolute path because the compilation will run
+    # in a temporary directory.
+
+    frog = os.path.abspath(utils.GetDartRunner(self.mode, self.arch, 'frogsh'))
+    cmd = [frog, '--out=' + self.GetScriptPath(), '--compile-only',
+        '--libdir=' + os.path.abspath(
+            os.path.join(self.root_path, 'frog', 'lib'))]
+    cmd.extend(self.vm_options)
+    cmd.append(self.GetTestScriptFile())
+    return cmd
 
 
 class DartiumArchitecture(BrowserArchitecture):
   """Architecture that runs dart in an VM embedded in DumpRenderTree."""
 
   def __init__(self, root_path, arch, mode, component, test):
     super(DartiumArchitecture, self).__init__(root_path, arch, mode, component, test)
 
   def GetScriptType(self):
     return 'application/dart'
@@ skipping 104 matching lines @@
 
 def ExecuteCommand(cmd, verbose=False):
   """Execute a command in a subprocess."""
   if verbose: print 'Executing: ' + ' '.join(cmd)
   return subprocess.call(cmd)
 
 
 def GetArchitecture(arch, mode, component, test):
   root_path = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), '..'))
   if component == 'chromium':
-    return ChromiumArchitecture(root_path, arch, mode, component, test)
+    return DartcChromiumArchitecture(root_path, arch, mode, component, test)
 
   elif component == 'dartium':
     return DartiumArchitecture(root_path, arch, mode, component, test)
 
+  elif component == 'frogium':
+    return FrogChromiumArchitecture(root_path, arch, mode, component, test)
+
   elif component in ['vm', 'frog', 'frogsh']:
     return StandaloneArchitecture(root_path, arch, mode, component, test)
 
   elif component == 'leg':
     return LegArchitecture(root_path, arch, mode, component, test)
 
   elif component == 'dartc':
     return DartcArchitecture(root_path, arch, mode, component, test)