Import chrome idl into third_party

third_party/chrome/tools/code.py

Index: third_party/chrome/tools/code.py
diff --git a/third_party/chrome/tools/code.py b/third_party/chrome/tools/code.py
new file mode 100644
index 0000000000000000000000000000000000000000..009eb12f16953c80616f29ab3d9d3d8df374ac58
--- /dev/null
+++ b/third_party/chrome/tools/code.py
@@ -0,0 +1,139 @@
+# Copyright (c) 2012 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+class Code(object):
+  """A convenience object for constructing code.
+
+  Logically each object should be a block of code. All methods except |Render|
+  and |IsEmpty| return self.
+  """
+  def __init__(self, indent_size=2, comment_length=80):
+    self._code = []
+    self._indent_level = 0
+    self._indent_size = indent_size
+    self._comment_length = comment_length
+
+  def Append(self, line='', substitute=True, indent_level=None):
+    """Appends a line of code at the current indent level or just a newline if
+    line is not specified. Trailing whitespace is stripped.
+
+    substitute: indicated whether this line should be affected by
+    code.Substitute().
+    """
+    if indent_level is None:
+      indent_level = self._indent_level
+    self._code.append(Line(((' ' * indent_level) + line).rstrip(),
+                      substitute=substitute))
+    return self
+
+  def IsEmpty(self):
+    """Returns True if the Code object is empty.
+    """
+    return not bool(self._code)
+
+  def Concat(self, obj):
+    """Concatenate another Code object onto this one. Trailing whitespace is
+    stripped.
+
+    Appends the code at the current indent level. Will fail if there are any
+    un-interpolated format specifiers eg %s, %(something)s which helps
+    isolate any strings that haven't been substituted.
+    """
+    if not isinstance(obj, Code):
+      raise TypeError(type(obj))
+    assert self is not obj
+    for line in obj._code:
+      try:
+        # line % () will fail if any substitution tokens are left in line
+        if line.substitute:
+          line.value %= ()
+      except TypeError:
+        raise TypeError('Unsubstituted value when concatting\n' + line)
+      except ValueError:
+        raise ValueError('Stray % character when concatting\n' + line)
+      self.Append(line.value, line.substitute)
+
+    return self
+
+  def Cblock(self, code):
+    """Concatenates another Code object |code| onto this one followed by a
+    blank line, if |code| is non-empty."""
+    if not code.IsEmpty():
+      self.Concat(code).Append()
+    return self
+
+  def Sblock(self, line=''):
+    """Starts a code block.
+
+    Appends a line of code and then increases the indent level.
+    """
+    self.Append(line)
+    self._indent_level += self._indent_size
+    return self
+
+  def Eblock(self, line=''):
+    """Ends a code block by decreasing and then appending a line (or a blank
+    line if not given).
+    """
+    # TODO(calamity): Decide if type checking is necessary
+    #if not isinstance(line, basestring):
+    #  raise TypeError
+    self._indent_level -= self._indent_size
+    self.Append(line)
+    return self
+
+  def Comment(self, comment, comment_prefix='// '):
+    """Adds the given string as a comment.
+
+    Will split the comment if it's too long. Use mainly for variable length
+    comments. Otherwise just use code.Append('// ...') for comments.
+
+    Unaffected by code.Substitute().
+    """
+    max_len = self._comment_length - self._indent_level - len(comment_prefix)
+    while len(comment) >= max_len:
+      line = comment[0:max_len]
+      last_space = line.rfind(' ')
+      if last_space != -1:
+        line = line[0:last_space]
+        comment = comment[last_space + 1:]
+      else:
+        comment = comment[max_len:]
+      self.Append(comment_prefix + line, substitute=False)
+    self.Append(comment_prefix + comment, substitute=False)
+    return self
+
+  def Substitute(self, d):
+    """Goes through each line and interpolates using the given dict.
+
+    Raises type error if passed something that isn't a dict
+
+    Use for long pieces of code using interpolation with the same variables
+    repeatedly. This will reduce code and allow for named placeholders which
+    are more clear.
+    """
+    if not isinstance(d, dict):
+      raise TypeError('Passed argument is not a dictionary: ' + d)
+    for i, line in enumerate(self._code):
+      if self._code[i].substitute:
+        # Only need to check %s because arg is a dict and python will allow
+        # '%s %(named)s' but just about nothing else
+        if '%s' in self._code[i].value or '%r' in self._code[i].value:
+          raise TypeError('"%s" or "%r" found in substitution. '
+                          'Named arguments only. Use "%" to escape')
+        self._code[i].value = line.value % d
+        self._code[i].substitute = False
+    return self
+
+  def Render(self):
+    """Renders Code as a string.
+    """
+    return '\n'.join([l.value for l in self._code])
+
+class Line(object):
+  """A line of code.
+  """
+  def __init__(self, value, substitute=True):
+    self.value = value
+    self.substitute = substitute