Fix python scripts in src/ppapi/

ppapi/generate_ppapi_size_checks.py

-#!/usr/bin/python
-
-# Copyright (c) 2010 The Chromium Authors. All rights reserved.
+#!/usr/bin/env python
+# Copyright (c) 2011 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.
 
 """This script should be run manually on occasion to make sure all PPAPI types
 have appropriate size checking.
-
 """
 
 import optparse
 import os
 import subprocess
 import sys
 
 
 # The string that the PrintNamesAndSizes plugin uses to indicate a type is
 # expected to have architecture-dependent size.
 ARCH_DEPENDENT_STRING = "ArchDependentSize"
 
 
+COPYRIGHT_STRING_C = (
+"""/* Copyright (c) %s 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.
+ *
+ * This file has compile assertions for the sizes of types that are dependent
+ * on the architecture for which they are compiled (i.e., 32-bit vs 64-bit).
+ */
 
-class SourceLocation:
+""") % datetime.date.today().year
 
+
+class SourceLocation(object):
   """A class representing the source location of a definiton."""
 
   def __init__(self, filename="", start_line=-1, end_line=-1):
     self.filename = os.path.normpath(filename)
     self.start_line = start_line
     self.end_line = end_line
 
 
-
-class TypeInfo:
-
+class TypeInfo(object):
   """A class representing information about a C++ type.  It contains the
   following fields:
    - kind:  The Clang TypeClassName (Record, Enum, Typedef, Union, etc)
    - name:  The unmangled string name of the type.
    - size:  The size in bytes of the type.
    - arch_dependent:  True if the type may have architecture dependent size
                       according to PrintNamesAndSizes.  False otherwise.  Types
                       which are considered architecture-dependent from 32-bit
                       to 64-bit are pointers, longs, unsigned longs, and any
                       type that contains an architecture-dependent type.
@@ skipping 26 matching lines @@
         start_line, end_line] = info_string.split(',')
     self.target = target
     self.parsed_line = info_string
     # Note that Clang counts line numbers from 1, but we want to count from 0.
     self.source_location = SourceLocation(source_file,
                                           int(start_line)-1,
                                           int(end_line)-1)
     self.arch_dependent = (arch_dependent_string == ARCH_DEPENDENT_STRING)
 
 
-class FilePatch:
-
+class FilePatch(object):
   """A class representing a set of line-by-line changes to a particular file.
   None of the changes are applied until Apply is called.  All line numbers are
   counted from 0.
   """
 
   def __init__(self, filename):
     self.filename = filename
     self.linenums_to_delete = set()
     # A dictionary from line number to an array of strings to be inserted at
     # that line number.
@@ skipping 117 matching lines @@
   line += typeinfo.size
   line += ");\n"
   return line
 
 
 def IsMacroDefinedName(typename):
   """Return true iff the given typename came from a PPAPI compile assertion."""
   return typename.find("PP_Dummy_Struct_For_") == 0
 
 
-COPYRIGHT_STRING_C = \
-"""/* Copyright (c) 2010 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.
- *
- * This file has compile assertions for the sizes of types that are dependent
- * on the architecture for which they are compiled (i.e., 32-bit vs 64-bit).
- */
-
-"""
-
-
 def WriteArchSpecificCode(types, root, filename):
   """Write a header file that contains a compile-time assertion for the size of
      each of the given typeinfos, in to a file named filename rooted at root.
   """
   assertion_lines = [ToAssertionCode(typeinfo) for typeinfo in types]
   assertion_lines.sort()
   outfile = open(os.path.join(root, filename), "w")
   header_guard = "PPAPI_TESTS_" + filename.upper().replace(".", "_") + "_"
   outfile.write(COPYRIGHT_STRING_C)
   outfile.write('#ifndef ' + header_guard + '\n')
@@ skipping 178 matching lines @@
                         "arch_dependent_sizes_32.h")
   WriteArchSpecificCode(types64.values(),
                         c_source_root,
                         "arch_dependent_sizes_64.h")
 
   return 0
 
 
 if __name__ == '__main__':
     sys.exit(main(sys.argv[1:]))
-