Fix python scripts in src/tools/

tools/symsrc/source_index.py

 #!/usr/bin/env python
-
-# Copyright (c) 2008 The Chromium Authors. All rights reserved.
+# 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.
 
 """Usage: <win-path-to-pdb.pdb>
 This tool will take a PDB on the command line, extract the source files that
 were used in building the PDB, query SVN for which repository and revision
 these files are at, and then finally write this information back into the PDB
 in a format that the debugging tools understand.  This allows for automatic
 source debugging, as all of the information is contained in the PDB, and the
 debugger can go out and fetch the source files via SVN.
@@ skipping 24 matching lines @@
 REPO_MAP = {
   "svn://chrome-svn/chrome": "http://src.chromium.org/svn",
   "svn://chrome-svn.corp.google.com/chrome": "http://src.chromium.org/svn",
   "http://v8.googlecode.com/svn": None,
   "http://google-breakpad.googlecode.com/svn": None,
   "http://googletest.googlecode.com/svn": None,
   "http://open-vcdiff.googlecode.com/svn": None,
   "http://google-url.googlecode.com/svn": None,
 }
 
+
 def FindFile(filename):
   """Return the full windows path to a file in the same dir as this code."""
   thisdir = os.path.dirname(os.path.join(os.path.curdir, __file__))
   return os.path.abspath(os.path.join(thisdir, filename))
 
 
 def ExtractSourceFiles(pdb_filename):
   """Extract a list of local paths of the source files from a PDB."""
   srctool = subprocess.Popen([FindFile('srctool.exe'), '-r', pdb_filename],
                              stdout=subprocess.PIPE, stderr=subprocess.PIPE)
   filelist = srctool.stdout.read()
   res = srctool.wait()
   if res != 0 or filelist.startswith("srctool: "):
     raise "srctool failed: " + filelist
   return [x for x in filelist.split('\r\n') if len(x) != 0]
 
+
 def ReadSourceStream(pdb_filename):
   """Read the contents of the source information stream from a PDB."""
   srctool = subprocess.Popen([FindFile('pdbstr.exe'),
                               '-r', '-s:srcsrv',
                               '-p:%s' % pdb_filename],
                              stdout=subprocess.PIPE, stderr=subprocess.PIPE)
   data = srctool.stdout.read()
   res = srctool.wait()
 
   if (res != 0 and res != -1) or data.startswith("pdbstr: "):
     raise "pdbstr failed: " + data
   return data
 
+
 def WriteSourceStream(pdb_filename, data):
   """Write the contents of the source information stream to a PDB."""
   # Write out the data to a temporary filename that we can pass to pdbstr.
   (f, fname) = tempfile.mkstemp()
   f = os.fdopen(f, "wb")
   f.write(data)
   f.close()
 
   srctool = subprocess.Popen([FindFile('pdbstr.exe'),
                               '-w', '-s:srcsrv',
                               '-i:%s' % fname,
                               '-p:%s' % pdb_filename],
                              stdout=subprocess.PIPE, stderr=subprocess.PIPE)
   data = srctool.stdout.read()
   res = srctool.wait()
 
   if (res != 0 and res != -1) or data.startswith("pdbstr: "):
     raise "pdbstr failed: " + data
 
   os.unlink(fname)
 
+
 # TODO for performance, we should probably work in directories instead of
 # files.  I'm scared of DEPS and generated files, so for now we query each
 # individual file, and don't make assumptions that all files in the same
 # directory are part of the same repository or at the same revision number.
 def ExtractSvnInfo(local_filename):
   """Calls svn info to extract the repository, path, and revision."""
   # We call svn.bat to make sure and get the depot tools SVN and not cygwin.
   srctool = subprocess.Popen(['svn.bat', 'info', local_filename],
                              stdout=subprocess.PIPE, stderr=subprocess.PIPE)
   info = srctool.stdout.read()
   res = srctool.wait()
   if res != 0:
     return None
   # Hack up into a dictionary of the fields printed by svn info.
   vals = dict((y.split(': ', 2) for y in info.split('\r\n') if y))
 
   root = vals['Repository Root']
   if not vals['URL'].startswith(root):
     raise "URL is not inside of the repository root?!?"
   path = vals['URL'][len(root):]
   rev  = int(vals['Revision'])
 
   return [root, path, rev]
 
+
 def UpdatePDB(pdb_filename, verbose=False):
   """Update a pdb file with source information."""
   dir_blacklist = { }
   # TODO(deanm) look into "compressing" our output, by making use of vars
   # and other things, so we don't need to duplicate the repo path and revs.
   lines = [
     'SRCSRV: ini ------------------------------------------------',
     'VERSION=1',
     'INDEXVERSION=2',
     'VERCTRL=Subversion',
@@ skipping 51 matching lines @@
       root = REPO_MAP[root]
 
     lines.append('%s*%s*%s*%s' % (filename, root, path, rev))
     if verbose:
       print "  indexed file."
 
   lines.append('SRCSRV: end ------------------------------------------------')
 
   WriteSourceStream(pdb_filename, '\r\n'.join(lines))
 
-if __name__ == '__main__':
+
+def main():
   if len(sys.argv) < 2 or len(sys.argv) > 3:
     print "usage: file.pdb [-v]"
-    sys.exit(1)
+    return 1
 
   verbose = False
   if len(sys.argv) == 3:
     verbose = (sys.argv[2] == '-v')
 
   UpdatePDB(sys.argv[1], verbose=verbose)
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())