libv8 7.8.279.23.0beta1 → 8.4.255.0

data/vendor/depot_tools/gclient_eval.py

@@ -11,26 +11,44 @@ import tokenize
 import gclient_utils
 
 from third_party import schema
+from third_party import six
 
-if sys.version_info.major == 2:
+if six.PY2:
   # We use cStringIO.StringIO because it is equivalent to Py3's io.StringIO.
   from cStringIO import StringIO
+  import collections as collections_abc
 else:
+  from collections import abc as collections_abc
   from io import StringIO
-
-
-# TODO(crbug.com/953884): Remove this when python3 migration is done.
-try:
-  basestring
-except NameError:
   # pylint: disable=redefined-builtin
   basestring = str
 
 
-class _NodeDict(collections.MutableMapping):
+class ConstantString(object):
+  def __init__(self, value):
+    self.value = value
+
+  def __format__(self, format_spec):
+    del format_spec
+    return self.value
+
+  def __repr__(self):
+    return "Str('" + self.value + "')"
+
+  def __eq__(self, other):
+    if isinstance(other, ConstantString):
+      return self.value == other.value
+    else:
+      return self.value == other
+
+  def __hash__(self):
+      return self.value.__hash__()
+
+
+class _NodeDict(collections_abc.MutableMapping):
   """Dict-like type that also stores information on AST nodes and tokens."""
-  def __init__(self, data, tokens=None):
-    self.data = collections.OrderedDict(data)
+  def __init__(self, data=None, tokens=None):
+    self.data = collections.OrderedDict(data or [])
     self.tokens = tokens
 
   def __str__(self):
@@ -57,7 +75,7 @@ class _NodeDict(collections.MutableMapping):
   def MoveTokens(self, origin, delta):
     if self.tokens:
       new_tokens = {}
-      for pos, token in self.tokens.iteritems():
+      for pos, token in self.tokens.items():
         if pos[0] >= origin:
           pos = (pos[0] + delta, pos[1])
           token = token[:2] + (pos,) + token[3:]
@@ -117,7 +135,7 @@ _GCLIENT_DEPS_SCHEMA = _NodeDictSchema({
 _GCLIENT_HOOKS_SCHEMA = [
     _NodeDictSchema({
         # Hook action: list of command-line arguments to invoke.
-        'action': [basestring],
+        'action': [schema.Or(basestring)],
 
         # Name of the hook. Doesn't affect operation.
         schema.Optional('name'): basestring,
@@ -138,7 +156,7 @@ _GCLIENT_HOOKS_SCHEMA = [
 
 _GCLIENT_SCHEMA = schema.Schema(
     _NodeDictSchema({
-        # List of host names from which dependencies are allowed (whitelist).
+        # List of host names from which dependencies are allowed (allowlist).
         # NOTE: when not present, all hosts are allowed.
         # NOTE: scoped to current DEPS file, not recursive.
         schema.Optional('allowed_hosts'): [schema.Optional(basestring)],
@@ -190,7 +208,7 @@ _GCLIENT_SCHEMA = schema.Schema(
         # Recursion limit for nested DEPS.
         schema.Optional('recursion'): int,
 
-        # Whitelists deps for which recursion should be enabled.
+        # Allowlists deps for which recursion should be enabled.
         schema.Optional('recursedeps'): [
             schema.Optional(schema.Or(
                 basestring,
@@ -199,7 +217,7 @@ _GCLIENT_SCHEMA = schema.Schema(
             )),
         ],
 
-        # Blacklists directories for checking 'include_rules'.
+        # Blocklists directories for checking 'include_rules'.
         schema.Optional('skip_child_includes'): [schema.Optional(basestring)],
 
         # Mapping from paths to include rules specific for that path.
@@ -223,7 +241,9 @@ _GCLIENT_SCHEMA = schema.Schema(
 
         # Variables that can be referenced using Var() - see 'deps'.
         schema.Optional('vars'): _NodeDictSchema({
-            schema.Optional(basestring): schema.Or(basestring, bool),
+            schema.Optional(basestring): schema.Or(ConstantString,
+                                                   basestring,
+                                                   bool),
         }),
     }))
 
@@ -231,6 +251,8 @@ _GCLIENT_SCHEMA = schema.Schema(
 def _gclient_eval(node_or_string, filename='<unknown>', vars_dict=None):
   """Safely evaluates a single expression. Returns the result."""
   _allowed_names = {'None': None, 'True': True, 'False': False}
+  if isinstance(node_or_string, ConstantString):
+    return node_or_string.value
   if isinstance(node_or_string, basestring):
     node_or_string = ast.parse(node_or_string, filename=filename, mode='eval')
   if isinstance(node_or_string, ast.Expression):
@@ -245,7 +267,7 @@ def _gclient_eval(node_or_string, filename='', vars_dict=None):
         raise KeyError(
             '%s was used as a variable, but was not declared in the vars dict '
             '(file %r, line %s)' % (
-                e.message, filename, getattr(node, 'lineno', '<unknown>')))
+                e.args[0], filename, getattr(node, 'lineno', '<unknown>')))
     elif isinstance(node, ast.Num):
       return node.n
     elif isinstance(node, ast.Tuple):
@@ -253,8 +275,15 @@ def _gclient_eval(node_or_string, filename='', vars_dict=None):
     elif isinstance(node, ast.List):
       return list(map(_convert, node.elts))
     elif isinstance(node, ast.Dict):
-      return _NodeDict((_convert(k), (_convert(v), v))
-          for k, v in zip(node.keys, node.values))
+      node_dict = _NodeDict()
+      for key_node, value_node in zip(node.keys, node.values):
+        key = _convert(key_node)
+        if key in node_dict:
+          raise ValueError(
+              'duplicate key in dictionary: %s (file %r, line %s)' % (
+                  key, filename, getattr(key_node, 'lineno', '<unknown>')))
+        node_dict.SetNode(key, _convert(value_node), value_node)
+      return node_dict
     elif isinstance(node, ast.Name):
       if node.id not in _allowed_names:
         raise ValueError(
@@ -265,16 +294,23 @@ def _gclient_eval(node_or_string, filename='', vars_dict=None):
         node, ast.NameConstant):  # Since Python 3.4
       return node.value
     elif isinstance(node, ast.Call):
-      if not isinstance(node.func, ast.Name) or node.func.id != 'Var':
+      if (not isinstance(node.func, ast.Name) or
+          (node.func.id not in ('Str', 'Var'))):
         raise ValueError(
-            'Var is the only allowed function (file %r, line %s)' % (
+            'Str and Var are the only allowed functions (file %r, line %s)' % (
                 filename, getattr(node, 'lineno', '<unknown>')))
       if node.keywords or getattr(node, 'starargs', None) or getattr(
           node, 'kwargs', None) or len(node.args) != 1:
         raise ValueError(
-            'Var takes exactly one argument (file %r, line %s)' % (
-                filename, getattr(node, 'lineno', '<unknown>')))
-      arg = _convert(node.args[0])
+            '%s takes exactly one argument (file %r, line %s)' % (
+                node.func.id, filename, getattr(node, 'lineno', '<unknown>')))
+      if node.func.id == 'Str':
+        if isinstance(node.args[0], ast.Str):
+          return ConstantString(node.args[0].s)
+        raise ValueError('Passed a non-string to Str() (file %r, line%s)' % (
+            filename, getattr(node, 'lineno', '<unknown>')))
+      else:
+        arg = _convert(node.args[0])
       if not isinstance(arg, basestring):
         raise ValueError(
             'Var\'s argument must be a variable name (file %r, line %s)' % (
@@ -286,7 +322,10 @@ def _gclient_eval(node_or_string, filename='', vars_dict=None):
             '%s was used as a variable, but was not declared in the vars dict '
             '(file %r, line %s)' % (
                 arg, filename, getattr(node, 'lineno', '<unknown>')))
-      return vars_dict[arg]
+      val = vars_dict[arg]
+      if isinstance(val, ConstantString):
+        val = val.value
+      return val
     elif isinstance(node, ast.BinOp) and isinstance(node.op, ast.Add):
       return _convert(node.left) + _convert(node.right)
     elif isinstance(node, ast.BinOp) and isinstance(node.op, ast.Mod):
@@ -375,44 +414,10 @@ def Exec(content, filename='', vars_override=None, builtin_vars=None):
     value = _gclient_eval(node, filename, vars_dict)
     local_scope.SetNode(name, value, node)
 
-  return _GCLIENT_SCHEMA.validate(local_scope)
-
-
-def ExecLegacy(content, filename='<unknown>', vars_override=None,
-               builtin_vars=None):
-  """Executes a DEPS file |content| using exec."""
-  local_scope = {}
-  global_scope = {'Var': lambda var_name: '{%s}' % var_name}
-
-  # If we use 'exec' directly, it complains that 'Parse' contains a nested
-  # function with free variables.
-  # This is because on versions of Python < 2.7.9, "exec(a, b, c)" not the same
-  # as "exec a in b, c" (See https://bugs.python.org/issue21591).
-  eval(compile(content, filename, 'exec'), global_scope, local_scope)
-
-  vars_dict = {}
-  vars_dict.update(local_scope.get('vars', {}))
-  if builtin_vars:
-    vars_dict.update(builtin_vars)
-  if vars_override:
-    vars_dict.update({k: v for k, v in vars_override.items() if k in vars_dict})
-
-  if not vars_dict:
-    return local_scope
-
-  def _DeepFormat(node):
-    if isinstance(node, basestring):
-      return node.format(**vars_dict)
-    elif isinstance(node, dict):
-      return {k.format(**vars_dict): _DeepFormat(v) for k, v in node.items()}
-    elif isinstance(node, list):
-      return [_DeepFormat(elem) for elem in node]
-    elif isinstance(node, tuple):
-      return tuple(_DeepFormat(elem) for elem in node)
-    else:
-      return node
-
-  return _DeepFormat(local_scope)
+  try:
+    return _GCLIENT_SCHEMA.validate(local_scope)
+  except schema.SchemaError as e:
+    raise gclient_utils.Error(str(e))
 
 
 def _StandardizeDeps(deps_dict, vars_dict):
@@ -426,7 +431,7 @@ def _StandardizeDeps(deps_dict, vars_dict):
   new_deps_dict = {}
   for dep_name, dep_info in deps_dict.items():
     dep_name = dep_name.format(**vars_dict)
-    if not isinstance(dep_info, collections.Mapping):
+    if not isinstance(dep_info, collections_abc.Mapping):
       dep_info = {'url': dep_info}
     dep_info.setdefault('dep_type', 'git')
     new_deps_dict[dep_name] = dep_info
@@ -480,18 +485,15 @@ def UpdateCondition(info_dict, op, new_condition):
     del info_dict['condition']
 
 
-def Parse(content, validate_syntax, filename, vars_override=None,
-          builtin_vars=None):
+def Parse(content, filename, vars_override=None, builtin_vars=None):
   """Parses DEPS strings.
 
   Executes the Python-like string stored in content, resulting in a Python
-  dictionary specifyied by the schema above. Supports syntax validation and
+  dictionary specified by the schema above. Supports syntax validation and
   variable expansion.
 
   Args:
     content: str. DEPS file stored as a string.
-    validate_syntax: bool. Whether syntax should be validated using the schema
-      defined above.
     filename: str. The name of the DEPS file, or a string describing the source
       of the content, e.g. '<string>', '<unknown>'.
     vars_override: dict, optional. A dictionary with overrides for the variables
@@ -503,10 +505,7 @@ def Parse(content, validate_syntax, filename, vars_override=None,
     A Python dict with the parsed contents of the DEPS file, as specified by the
     schema above.
   """
-  if validate_syntax:
-    result = Exec(content, filename, vars_override, builtin_vars)
-  else:
-    result = ExecLegacy(content, filename, vars_override, builtin_vars)
+  result = Exec(content, filename, vars_override, builtin_vars)
 
   vars_dict = result.get('vars', {})
   if 'deps' in result:
@@ -514,14 +513,14 @@ def Parse(content, validate_syntax, filename, vars_override=None,
 
   if 'deps_os' in result:
     deps = result.setdefault('deps', {})
-    for os_name, os_deps in result['deps_os'].iteritems():
+    for os_name, os_deps in result['deps_os'].items():
       os_deps = _StandardizeDeps(os_deps, vars_dict)
       _MergeDepsOs(deps, os_deps, os_name)
     del result['deps_os']
 
   if 'hooks_os' in result:
     hooks = result.setdefault('hooks', [])
-    for os_name, os_hooks in result['hooks_os'].iteritems():
+    for os_name, os_hooks in result['hooks_os'].items():
       for hook in os_hooks:
         UpdateCondition(hook, 'and', 'checkout_' + os_name)
       hooks.extend(os_hooks)
@@ -538,9 +537,11 @@ def EvaluateCondition(condition, variables, referenced_variables=None):
   main_node = ast.parse(condition, mode='eval')
   if isinstance(main_node, ast.Expression):
     main_node = main_node.body
-  def _convert(node):
+  def _convert(node, allow_tuple=False):
     if isinstance(node, ast.Str):
       return node.s
+    elif isinstance(node, ast.Tuple) and allow_tuple:
+      return tuple(map(_convert, node.elts))
     elif isinstance(node, ast.Name):
       if node.id in referenced_variables:
         raise ValueError(
@@ -567,34 +568,27 @@ def EvaluateCondition(condition, variables, referenced_variables=None):
         # between arguments for GN to be passed verbatim, and ones to
         # be evaluated.
         return node.id
+    elif not sys.version_info[:2] < (3, 4) and isinstance(
+        node, ast.NameConstant):  # Since Python 3.4
+      return node.value
     elif isinstance(node, ast.BoolOp) and isinstance(node.op, ast.Or):
-      if len(node.values) != 2:
-        raise ValueError(
-            'invalid "or": exactly 2 operands required (inside %r)' % (
-                condition))
-      left = _convert(node.values[0])
-      right = _convert(node.values[1])
-      if not isinstance(left, bool):
-        raise ValueError(
-            'invalid "or" operand %r (inside %r)' % (left, condition))
-      if not isinstance(right, bool):
-        raise ValueError(
-            'invalid "or" operand %r (inside %r)' % (right, condition))
-      return left or right
+      bool_values = []
+      for value in node.values:
+        bool_values.append(_convert(value))
+        if not isinstance(bool_values[-1], bool):
+          raise ValueError(
+              'invalid "or" operand %r (inside %r)' % (
+                  bool_values[-1], condition))
+      return any(bool_values)
     elif isinstance(node, ast.BoolOp) and isinstance(node.op, ast.And):
-      if len(node.values) != 2:
-        raise ValueError(
-            'invalid "and": exactly 2 operands required (inside %r)' % (
-                condition))
-      left = _convert(node.values[0])
-      right = _convert(node.values[1])
-      if not isinstance(left, bool):
-        raise ValueError(
-            'invalid "and" operand %r (inside %r)' % (left, condition))
-      if not isinstance(right, bool):
-        raise ValueError(
-            'invalid "and" operand %r (inside %r)' % (right, condition))
-      return left and right
+      bool_values = []
+      for value in node.values:
+        bool_values.append(_convert(value))
+        if not isinstance(bool_values[-1], bool):
+          raise ValueError(
+              'invalid "and" operand %r (inside %r)' % (
+                  bool_values[-1], condition))
+      return all(bool_values)
     elif isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.Not):
       value = _convert(node.operand)
       if not isinstance(value, bool):
@@ -612,12 +606,15 @@ def EvaluateCondition(condition, variables, referenced_variables=None):
                 condition))
 
       left = _convert(node.left)
-      right = _convert(node.comparators[0])
+      right = _convert(
+          node.comparators[0], allow_tuple=isinstance(node.ops[0], ast.In))
 
       if isinstance(node.ops[0], ast.Eq):
         return left == right
       if isinstance(node.ops[0], ast.NotEq):
         return left != right
+      if isinstance(node.ops[0], ast.In):
+        return left in right
 
       raise ValueError(
           'unexpected operator: %s %s (inside %r)' % (
@@ -639,10 +636,13 @@ def RenderDEPSFile(gclient_dict):
 
 
 def _UpdateAstString(tokens, node, value):
+  if isinstance(node, ast.Call):
+    node = node.args[0]
   position = node.lineno, node.col_offset
   quote_char = ''
   if isinstance(node, ast.Str):
     quote_char = tokens[position][1][0]
+    value = value.encode('unicode_escape').decode('utf-8')
   tokens[position][1] = quote_char + value + quote_char
   node.s = value
 
@@ -685,7 +685,7 @@ def AddVar(gclient_dict, var_name, value):
   col = node.keys[0].col_offset
 
   # We use a minimal Python dictionary, so that ast can parse it.
-  var_content = '{\n%s"%s": "%s",\n}' % (' ' * col, var_name, value)
+  var_content = '{\n%s"%s": "%s",\n}\n' % (' ' * col, var_name, value)
   var_ast = ast.parse(var_content).body[0].value
 
   # Set the ast nodes for the key and value.
@@ -704,7 +704,7 @@ def AddVar(gclient_dict, var_name, value):
   var_tokens = {
       token[2]: list(token)
       # Ignore the tokens corresponding to braces and new lines.
-      for token in var_tokens[2:-2]
+      for token in var_tokens[2:-3]
   }
 
   gclient_dict.tokens = _ShiftLinesInTokens(gclient_dict.tokens, 1, line)
@@ -797,6 +797,15 @@ def SetRevision(gclient_dict, dep_name, new_revision):
     if isinstance(node, ast.BinOp):
       node = node.right
 
+    if isinstance(node, ast.Str):
+      token = _gclient_eval(tokens[node.lineno, node.col_offset][1])
+      if token != node.s:
+        raise ValueError(
+            'Can\'t update value for %s. Multiline strings and implicitly '
+            'concatenated strings are not supported.\n'
+            'Consider reformatting the DEPS file.' % dep_key)
+
+
     if not isinstance(node, ast.Call) and not isinstance(node, ast.Str):
       raise ValueError(
           "Unsupported dependency revision format. Please file a bug to the "
@@ -838,7 +847,10 @@ def GetVar(gclient_dict, var_name):
     raise KeyError(
         "Could not find any variable called %s." % var_name)
 
-  return gclient_dict['vars'][var_name]
+  val = gclient_dict['vars'][var_name]
+  if isinstance(val, ConstantString):
+    return val.value
+  return val
 
 
 def GetCIPD(gclient_dict, dep_name, package_name):
@@ -871,7 +883,7 @@ def GetRevision(gclient_dict, dep_name):
   elif isinstance(dep, basestring):
     _, _, revision = dep.partition('@')
     return revision or None
-  elif isinstance(dep, collections.Mapping) and 'url' in dep:
+  elif isinstance(dep, collections_abc.Mapping) and 'url' in dep:
     _, _, revision = dep['url'].partition('@')
     return revision or None
   else:

data/vendor/depot_tools/gclient_paths.py

@@ -10,7 +10,10 @@
 
 from __future__ import print_function
 
+import gclient_utils
+import logging
 import os
+import subprocess2
 import sys
 
 
@@ -24,65 +27,66 @@ def FindGclientRoot(from_dir, filename='.gclient'):
       return None
     path = split_path[0]
 
+  logging.info('Found gclient root at ' + path)
+
+  if path == real_from_dir:
+    return path
+
   # If we did not find the file in the current directory, make sure we are in a
   # sub directory that is controlled by this configuration.
-  if path != real_from_dir:
-    entries_filename = os.path.join(path, filename + '_entries')
-    if not os.path.exists(entries_filename):
-      # If .gclient_entries does not exist, a previous call to gclient sync
-      # might have failed. In that case, we cannot verify that the .gclient
-      # is the one we want to use. In order to not to cause too much trouble,
-      # just issue a warning and return the path anyway.
-      print(
-          "%s missing, %s file in parent directory %s might not be the file "
-          "you want to use." % (entries_filename, filename, path),
-          file=sys.stderr)
+  entries_filename = os.path.join(path, filename + '_entries')
+  if not os.path.exists(entries_filename):
+    # If .gclient_entries does not exist, a previous call to gclient sync
+    # might have failed. In that case, we cannot verify that the .gclient
+    # is the one we want to use. In order to not to cause too much trouble,
+    # just issue a warning and return the path anyway.
+    print(
+        "%s missing, %s file in parent directory %s might not be the file "
+        "you want to use." % (entries_filename, filename, path),
+        file=sys.stderr)
+    return path
+
+  entries_content = gclient_utils.FileRead(entries_filename)
+  scope = {}
+  try:
+    exec(entries_content, scope)
+  except (SyntaxError, Exception) as e:
+    gclient_utils.SyntaxErrorToError(filename, e)
+
+  all_directories = scope['entries'].keys()
+  path_to_check = os.path.relpath(real_from_dir, path)
+  while path_to_check:
+    if path_to_check in all_directories:
       return path
-    scope = {}
-    try:
-      import io
-      with io.open(entries_filename, encoding='utf-8') as f:
-        exec(f.read(), scope)
-    except SyntaxError as e:
-      SyntaxErrorToError(filename, e)
-    all_directories = scope['entries'].keys()
-    path_to_check = real_from_dir[len(path)+1:]
-    while path_to_check:
-      if path_to_check in all_directories:
-        return path
-      path_to_check = os.path.dirname(path_to_check)
-    return None
+    path_to_check = os.path.dirname(path_to_check)
 
-  import logging
-  logging.info('Found gclient root at ' + path)
-  return path
+  return None
 
 
 def GetPrimarySolutionPath():
   """Returns the full path to the primary solution. (gclient_root + src)"""
 
   gclient_root = FindGclientRoot(os.getcwd())
-  if not gclient_root:
-    # Some projects might not use .gclient. Try to see whether we're in a git
-    # checkout.
-    top_dir = [os.getcwd()]
-    def filter_fn(line):
-      repo_root_path = os.path.normpath(line.rstrip('\n'))
-      if os.path.exists(repo_root_path):
-        top_dir[0] = repo_root_path
-    try:
-      CheckCallAndFilter(["git", "rev-parse", "--show-toplevel"],
-                         print_stdout=False, filter_fn=filter_fn)
-    except Exception:
-      pass
-    top_dir = top_dir[0]
-    if os.path.exists(os.path.join(top_dir, 'buildtools')):
-      return top_dir
-    return None
-
-  # Some projects' top directory is not named 'src'.
-  source_dir_name = GetGClientPrimarySolutionName(gclient_root) or 'src'
-  return os.path.join(gclient_root, source_dir_name)
+  if gclient_root:
+    # Some projects' top directory is not named 'src'.
+    source_dir_name = GetGClientPrimarySolutionName(gclient_root) or 'src'
+    return os.path.join(gclient_root, source_dir_name)
+
+  # Some projects might not use .gclient. Try to see whether we're in a git
+  # checkout that contains a 'buildtools' subdir.
+  top_dir = os.getcwd()
+  try:
+    top_dir = subprocess2.check_output(
+        ['git', 'rev-parse', '--show-toplevel'])
+    if sys.version_info.major == 3:
+      top_dir = top_dir.decode('utf-8', 'replace')
+    top_dir = os.path.normpath(top_dir.strip())
+  except subprocess2.CalledProcessError:
+    pass
+
+  if os.path.exists(os.path.join(top_dir, 'buildtools')):
+    return top_dir
+  return None
 
 
 def GetBuildtoolsPath():
@@ -98,12 +102,18 @@ def GetBuildtoolsPath():
   primary_solution = GetPrimarySolutionPath()
   if not primary_solution:
     return None
+
   buildtools_path = os.path.join(primary_solution, 'buildtools')
-  if not os.path.exists(buildtools_path):
-    # Buildtools may be in the gclient root.
-    gclient_root = FindGclientRoot(os.getcwd())
-    buildtools_path = os.path.join(gclient_root, 'buildtools')
-  return buildtools_path
+  if os.path.exists(buildtools_path):
+    return buildtools_path
+
+  # buildtools may be in the gclient root.
+  gclient_root = FindGclientRoot(os.getcwd())
+  buildtools_path = os.path.join(gclient_root, 'buildtools')
+  if os.path.exists(buildtools_path):
+    return buildtools_path
+
+  return None
 
 
 def GetBuildtoolsPlatformBinaryPath():
@@ -119,7 +129,7 @@ def GetBuildtoolsPlatformBinaryPath():
   elif sys.platform.startswith('linux'):
     subdir = 'linux64'
   else:
-    raise Error('Unknown platform: ' + sys.platform)
+    raise gclient_utils.Error('Unknown platform: ' + sys.platform)
   return os.path.join(buildtools_path, subdir)
 
 
@@ -133,9 +143,9 @@ def GetExeSuffix():
 def GetGClientPrimarySolutionName(gclient_root_dir_path):
   """Returns the name of the primary solution in the .gclient file specified."""
   gclient_config_file = os.path.join(gclient_root_dir_path, '.gclient')
+  gclient_config_contents = gclient_utils.FileRead(gclient_config_file)
   env = {}
-  exec(compile(open(gclient_config_file).read(), gclient_config_file, 'exec'),
-       env)
+  exec(gclient_config_contents, env)
   solutions = env.get('solutions', [])
   if solutions:
     return solutions[0].get('name')