for discussion: add tools/roll_pdfium.py

tools/roll_pdfium.py

 #!/usr/bin/env python
 # Copyright 2015 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.
 
 import argparse
 import collections
 import logging
 import os
 import re
 import subprocess
 import sys
 import time
 
 
 SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
 SRC_DIR = os.path.abspath(os.path.join(SCRIPT_DIR, os.pardir))
 import find_depot_tools
 find_depot_tools.add_depot_tools_to_path()
 import roll_dep_svn
 from gclient import GClientKeywords
 from third_party import upload
 
 # Avoid depot_tools/third_party/upload.py print verbose messages.
 upload.verbosity = 0  # Errors only.
 
 CHROMIUM_GIT_URL = 'https://chromium.googlesource.com/chromium/src.git'
 CL_ISSUE_RE = re.compile('^Issue number: ([0-9]+) \((.*)\)$')
 RIETVELD_URL_RE = re.compile('^https?://(.*)/(.*)')
-ROLL_BRANCH_NAME = 'special_angle_roll_branch'
+ROLL_BRANCH_NAME = 'special_pdfium_roll_branch'
 TRYJOB_STATUS_SLEEP_SECONDS = 30
 
 # Use a shell for subcommands on Windows to get a PATH search.
 IS_WIN = sys.platform.startswith('win')
-ANGLE_PATH = os.path.join('third_party', 'angle')
+PDFIUM_PATH = os.path.join('third_party', 'pdfium')
 
 CommitInfo = collections.namedtuple('CommitInfo', ['git_commit',
                                                    'git_repo_url'])
 CLInfo = collections.namedtuple('CLInfo', ['issue', 'url', 'rietveld_server'])
 
 def _PosixPath(path):
   """Convert a possibly-Windows path to a posix-style path."""
   (_, path) = os.path.splitdrive(path)
   return path.replace(os.sep, '/')
 
@@ skipping 18 matching lines @@
   global_scope = {
     'File': GClientKeywords.FileImpl,
     'From': GClientKeywords.FromImpl,
     'Var': var.Lookup,
     'deps_os': {},
   }
   exec(deps_content, global_scope, local_scope)
   return local_scope
 
 
-def _GenerateCLDescriptionCommand(angle_current, angle_new, bugs):
+def _GenerateCLDescriptionCommand(pdfium_current, pdfium_new, bugs):
   def GetChangeString(current_hash, new_hash):
     return '%s..%s' % (current_hash[0:7], new_hash[0:7]);
 
   def GetChangeLogURL(git_repo_url, change_string):
     return '%s/+log/%s' % (git_repo_url, change_string)
 
   def GetBugString(bugs):
     bug_str = 'BUG='
     for bug in bugs:
       bug_str += str(bug) + ','
     return bug_str.rstrip(',')
 
-  if angle_current.git_commit != angle_new.git_commit:
-    change_str = GetChangeString(angle_current.git_commit,
-                                 angle_new.git_commit)
-    changelog_url = GetChangeLogURL(angle_current.git_repo_url,
+  if pdfium_current.git_commit != pdfium_new.git_commit:
+    change_str = GetChangeString(pdfium_current.git_commit,
+                                 pdfium_new.git_commit)
+    changelog_url = GetChangeLogURL(pdfium_current.git_repo_url,
                                     change_str)
 
   return [
-    '-m', 'Roll ANGLE ' + change_str,
+    '-m', 'Roll PDFium ' + change_str,
     '-m', '%s' % changelog_url,
     '-m', GetBugString(bugs),
     '-m', 'TEST=bots',
   ]
 
 
 class AutoRoller(object):
   def __init__(self, chromium_src):
     self._chromium_src = chromium_src
 
@@ skipping 61 matching lines @@
 
   def _IsTreeClean(self):
     lines = self._RunCommand(
       ['git', 'status', '--porcelain', '-uno']).splitlines()
     if len(lines) == 0:
       return True
 
     logging.debug('Dirty/unversioned files:\n%s', '\n'.join(lines))
     return False
 
-  def _GetBugList(self, path_below_src, angle_current, angle_new):
+  def _GetBugList(self, path_below_src, pdfium_current, pdfium_new):
     working_dir = os.path.join(self._chromium_src, path_below_src)
     lines = self._RunCommand(
         ['git','log',
-            '%s..%s' % (angle_current.git_commit, angle_new.git_commit)],
+            '%s..%s' % (pdfium_current.git_commit, pdfium_new.git_commit)],
         working_dir=working_dir).split('\n')
     bugs = set()
     for line in lines:
       line = line.strip()
       bug_prefix = 'BUG='
       if line.startswith(bug_prefix):
         bugs_strings = line[len(bug_prefix):].split(',')
         for bug_string in bugs_strings:
           try:
             bugs.add(int(bug_string))
           except:
             # skip this, it may be a project specific bug such as
-            # "angleproject:X" or an ill-formed BUG= message
+            # "pdfium:X" or an ill-formed BUG= message
             pass
     return bugs
 
   def _UpdateReadmeFile(self, readme_path, new_revision):
     readme = open(os.path.join(self._chromium_src, readme_path), 'r+')
     txt = readme.read()
     m = re.sub(re.compile('.*^Revision\: ([0-9]*).*', re.MULTILINE),
         ('Revision: %s' % new_revision), txt)
     readme.seek(0)
     readme.write(m)
@@ skipping 18 matching lines @@
     if not ignore_checks:
       self._RunCommand(['git', 'pull'])
 
     self._RunCommand(['git', 'checkout', '-b', ROLL_BRANCH_NAME])
 
     # Modify Chromium's DEPS file.
 
     # Parse current hashes.
     deps_filename = os.path.join(self._chromium_src, 'DEPS')
     deps = _ParseDepsFile(deps_filename)
-    angle_current = self._GetDepsCommitInfo(deps, ANGLE_PATH)
+    pdfium_current = self._GetDepsCommitInfo(deps, PDFIUM_PATH)
 
     # Find ToT revisions.
-    angle_latest = self._GetCommitInfo(ANGLE_PATH)
+    pdfium_latest = self._GetCommitInfo(PDFIUM_PATH)
 
     if IS_WIN:
       # Make sure the roll script doesn't use windows line endings
       self._RunCommand(['git', 'config', 'core.autocrlf', 'true'])
 
-    self._UpdateDep(deps_filename, ANGLE_PATH, angle_latest)
+    self._UpdateDep(deps_filename, PDFIUM_PATH, pdfium_latest)
 
     if self._IsTreeClean():
       logging.debug('Tree is clean - no changes detected.')
       self._DeleteRollBranch()
     else:
-      bugs = self._GetBugList(ANGLE_PATH, angle_current, angle_latest)
+      bugs = self._GetBugList(PDFIUM_PATH, pdfium_current, pdfium_latest)
       description = _GenerateCLDescriptionCommand(
-          angle_current, angle_latest, bugs)
+          pdfium_current, pdfium_latest, bugs)
       logging.debug('Committing changes locally.')
       self._RunCommand(['git', 'add', '--update', '.'])
       self._RunCommand(['git', 'commit'] + description)
       logging.debug('Uploading changes...')
       self._RunCommand(['git', 'cl', 'upload'],
                        extra_env={'EDITOR': 'true'})
       self._RunCommand(['git', 'cl', 'try'])
       cl_info = self._GetCLInfo()
       print 'Issue: %d URL: %s' % (cl_info.issue, cl_info.url)
 
@@ skipping 48 matching lines @@
       self._RunCommand(['git', 'checkout', ROLL_BRANCH_NAME])
       # Ignore an error here in case an issue wasn't created for some reason.
       self._RunCommand(['git', 'cl', 'set_close'], ignore_exit_code=True)
       self._RunCommand(['git', 'checkout', active_branch])
       self._RunCommand(['git', 'branch', '-D', ROLL_BRANCH_NAME])
     return 0
 
 
 def main():
   parser = argparse.ArgumentParser(
-      description='Auto-generates a CL containing an ANGLE roll.')
+      description='Auto-generates a CL containing an PDFium roll.')
   parser.add_argument('--abort',
     help=('Aborts a previously prepared roll. '
           'Closes any associated issues and deletes the roll branches'),
     action='store_true')
   parser.add_argument('--ignore-checks', action='store_true', default=False,
       help=('Skips checks for being on the master branch, dirty workspaces and '
             'the updating of the checkout. Will still delete and create local '
             'Git branches.'))
   parser.add_argument('-v', '--verbose', action='store_true', default=False,
       help='Be extra verbose in printing of log messages.')
   args = parser.parse_args()
 
   if args.verbose:
     logging.basicConfig(level=logging.DEBUG)
   else:
     logging.basicConfig(level=logging.ERROR)
 
   autoroller = AutoRoller(SRC_DIR)
   if args.abort:
     return autoroller.Abort()
   else:
     return autoroller.PrepareRoll(args.ignore_checks)
 
 if __name__ == '__main__':
   sys.exit(main())