Changeset 58023 in webkit


Ignore:
Timestamp:
Apr 21, 2010 4:22:15 PM (14 years ago)
Author:
eric@webkit.org
Message:

2010-04-21 Eric Seidel <​eric@webkit.org>

Unreviewed. Rolling out unicode() changes as they broke NRWT for chromium.
Rolling out:
​http://trac.webkit.org/changeset/58014
​http://trac.webkit.org/changeset/58016
​http://trac.webkit.org/changeset/58020

REGRESSION(57531): the commit-queue still hates Tor Arne Vestbo
​https://bugs.webkit.org/show_bug.cgi?id=37765

  • Scripts/webkitpy/common/checkout/api_unittest.py:
  • Scripts/webkitpy/common/checkout/changelog.py:
  • Scripts/webkitpy/common/checkout/changelog_unittest.py:
  • Scripts/webkitpy/common/checkout/commitinfo.py:
  • Scripts/webkitpy/common/checkout/scm.py:
  • Scripts/webkitpy/common/checkout/scm_unittest.py:
  • Scripts/webkitpy/common/config/committers.py:
  • Scripts/webkitpy/common/net/bugzilla.py:
  • Scripts/webkitpy/common/net/buildbot.py:
  • Scripts/webkitpy/common/net/buildbot_unittest.py:
  • Scripts/webkitpy/common/net/statusserver.py:
  • Scripts/webkitpy/common/prettypatch.py:
  • Scripts/webkitpy/common/system/autoinstall.py:
  • Scripts/webkitpy/common/system/deprecated_logging.py:
  • Scripts/webkitpy/common/system/executive.py:
  • Scripts/webkitpy/common/system/executive_unittest.py:
  • Scripts/webkitpy/layout_tests/layout_package/dump_render_tree_thread.py:
  • Scripts/webkitpy/layout_tests/layout_package/json_results_generator.py:
  • Scripts/webkitpy/layout_tests/port/apache_http_server.py:
  • Scripts/webkitpy/layout_tests/port/chromium.py:
  • Scripts/webkitpy/layout_tests/port/chromium_linux.py:
  • Scripts/webkitpy/layout_tests/port/chromium_mac.py:
  • Scripts/webkitpy/layout_tests/port/gtk.py:
  • Scripts/webkitpy/layout_tests/port/mac.py:
  • Scripts/webkitpy/layout_tests/port/mac_unittest.py:
  • Scripts/webkitpy/layout_tests/port/qt.py:
  • Scripts/webkitpy/layout_tests/port/server_process.py:
  • Scripts/webkitpy/layout_tests/port/webkit.py:
  • Scripts/webkitpy/layout_tests/port/websocket_server.py:
  • Scripts/webkitpy/layout_tests/rebaseline_chromium_webkit_tests.py:
  • Scripts/webkitpy/layout_tests/run_webkit_tests.py:
  • Scripts/webkitpy/layout_tests/test_types/image_diff.py:
  • Scripts/webkitpy/layout_tests/test_types/test_type_base.py:
  • Scripts/webkitpy/layout_tests/test_types/text_diff.py:
  • Scripts/webkitpy/style/filereader_unittest.py:
  • Scripts/webkitpy/thirdparty/init.py:
  • Scripts/webkitpy/tool/commands/earlywarningsystem.py:
  • Scripts/webkitpy/tool/commands/queues.py:
  • Scripts/webkitpy/tool/commands/queues_unittest.py:
  • Scripts/webkitpy/tool/commands/upload.py:
  • Scripts/webkitpy/tool/mocktool.py:
  • Scripts/webkitpy/tool/steps/abstractstep.py:
  • Scripts/webkitpy/tool/steps/postdiff.py:
  • Scripts/webkitpy/tool/steps/postdiffforcommit.py:
  • Scripts/webkitpy/tool/steps/postdiffforrevert.py:
  • Scripts/webkitpy/tool/steps/steps_unittest.py:
Location:
trunk/WebKitTools
Files:
47 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebKitTools/ChangeLog

    r58020 r58023  
     12010-04-21  Eric Seidel  <eric@webkit.org>
     2
     3        Unreviewed.  Rolling out unicode() changes as they broke NRWT for chromium.
     4        Rolling out:
     5        http://trac.webkit.org/changeset/58014
     6        http://trac.webkit.org/changeset/58016
     7        http://trac.webkit.org/changeset/58020
     8
     9        REGRESSION(57531): the commit-queue still hates Tor Arne Vestbo
     10        https://bugs.webkit.org/show_bug.cgi?id=37765
     11
     12        * Scripts/webkitpy/common/checkout/api_unittest.py:
     13        * Scripts/webkitpy/common/checkout/changelog.py:
     14        * Scripts/webkitpy/common/checkout/changelog_unittest.py:
     15        * Scripts/webkitpy/common/checkout/commitinfo.py:
     16        * Scripts/webkitpy/common/checkout/scm.py:
     17        * Scripts/webkitpy/common/checkout/scm_unittest.py:
     18        * Scripts/webkitpy/common/config/committers.py:
     19        * Scripts/webkitpy/common/net/bugzilla.py:
     20        * Scripts/webkitpy/common/net/buildbot.py:
     21        * Scripts/webkitpy/common/net/buildbot_unittest.py:
     22        * Scripts/webkitpy/common/net/statusserver.py:
     23        * Scripts/webkitpy/common/prettypatch.py:
     24        * Scripts/webkitpy/common/system/autoinstall.py:
     25        * Scripts/webkitpy/common/system/deprecated_logging.py:
     26        * Scripts/webkitpy/common/system/executive.py:
     27        * Scripts/webkitpy/common/system/executive_unittest.py:
     28        * Scripts/webkitpy/layout_tests/layout_package/dump_render_tree_thread.py:
     29        * Scripts/webkitpy/layout_tests/layout_package/json_results_generator.py:
     30        * Scripts/webkitpy/layout_tests/port/apache_http_server.py:
     31        * Scripts/webkitpy/layout_tests/port/chromium.py:
     32        * Scripts/webkitpy/layout_tests/port/chromium_linux.py:
     33        * Scripts/webkitpy/layout_tests/port/chromium_mac.py:
     34        * Scripts/webkitpy/layout_tests/port/gtk.py:
     35        * Scripts/webkitpy/layout_tests/port/mac.py:
     36        * Scripts/webkitpy/layout_tests/port/mac_unittest.py:
     37        * Scripts/webkitpy/layout_tests/port/qt.py:
     38        * Scripts/webkitpy/layout_tests/port/server_process.py:
     39        * Scripts/webkitpy/layout_tests/port/webkit.py:
     40        * Scripts/webkitpy/layout_tests/port/websocket_server.py:
     41        * Scripts/webkitpy/layout_tests/rebaseline_chromium_webkit_tests.py:
     42        * Scripts/webkitpy/layout_tests/run_webkit_tests.py:
     43        * Scripts/webkitpy/layout_tests/test_types/image_diff.py:
     44        * Scripts/webkitpy/layout_tests/test_types/test_type_base.py:
     45        * Scripts/webkitpy/layout_tests/test_types/text_diff.py:
     46        * Scripts/webkitpy/style/filereader_unittest.py:
     47        * Scripts/webkitpy/thirdparty/__init__.py:
     48        * Scripts/webkitpy/tool/commands/earlywarningsystem.py:
     49        * Scripts/webkitpy/tool/commands/queues.py:
     50        * Scripts/webkitpy/tool/commands/queues_unittest.py:
     51        * Scripts/webkitpy/tool/commands/upload.py:
     52        * Scripts/webkitpy/tool/mocktool.py:
     53        * Scripts/webkitpy/tool/steps/abstractstep.py:
     54        * Scripts/webkitpy/tool/steps/postdiff.py:
     55        * Scripts/webkitpy/tool/steps/postdiffforcommit.py:
     56        * Scripts/webkitpy/tool/steps/postdiffforrevert.py:
     57        * Scripts/webkitpy/tool/steps/steps_unittest.py:
     58
    1592010-04-21  Eric Seidel  <eric@webkit.org>
    260

  • trunk/WebKitTools/Scripts/webkitpy/common/checkout/api_unittest.py

    r58014 r58023  
    2727# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2828
    29 from __future__ import with_statement
    30 
    31 import codecs
    3229import os
    3330import shutil
    … …  
    4138from webkitpy.thirdparty.mock import Mock
    4239
    43 
    4440# FIXME: Copied from scm_unittest.py
    45 def write_into_file_at_path(file_path, contents, encoding="utf-8"):
    46     with codecs.open(file_path, "w", encoding) as file:
    47         file.write(contents)
     41def write_into_file_at_path(file_path, contents):
     42    new_file = open(file_path, 'w')
     43    new_file.write(contents)
     44    new_file.close()
    4845
    4946
    50 _changelog1entry1 = u"""2010-03-25  Tor Arne Vestb\u00f8  <vestbo@webkit.org>
     47_changelog1entry1 = """2010-03-25  Eric Seidel  <eric@webkit.org>
    5148
    5249        Unreviewed build fix to un-break webkit-patch land.
    … …  
    5754        * Scripts/webkitpy/common/checkout/api.py: import scm.CommitMessage
    5855"""
    59 _changelog1entry2 = u"""2010-03-25  Adam Barth  <abarth@webkit.org>
     56_changelog1entry2 = """2010-03-25  Adam Barth  <abarth@webkit.org>
    6057
    6158        Reviewed by Eric Seidel.
    … …  
    6663        * Scripts/webkitpy/common/checkout/api.py:
    6764"""
    68 _changelog1 = u"\n".join([_changelog1entry1, _changelog1entry2])
    69 _changelog2 = u"""2010-03-25  Tor Arne Vestb\u00f8  <vestbo@webkit.org>
     65_changelog1 = "\n".join([_changelog1entry1, _changelog1entry2])
     66_changelog2 = """2010-03-25  Eric Seidel  <eric@webkit.org>
    7067
    7168        Unreviewed build fix to un-break webkit-patch land.
    … …  
    8380
    8481class CommitMessageForThisCommitTest(unittest.TestCase):
    85     expected_commit_message = u"""2010-03-25  Tor Arne Vestb\u00f8  <vestbo@webkit.org>
     82    expected_commit_message = """2010-03-25  Eric Seidel  <eric@webkit.org>
    8683
    8784        Unreviewed build fix to un-break webkit-patch land.
    … …  
    9188
    9289        * Scripts/webkitpy/common/checkout/api.py: import scm.CommitMessage
    93 2010-03-25  Tor Arne Vestb\u00f8  <vestbo@webkit.org>
     902010-03-25  Eric Seidel  <eric@webkit.org>
    9491
    9592        Unreviewed build fix to un-break webkit-patch land.
    … …  
    141138        commitinfo = checkout.commit_info_for_revision(4)
    142139        self.assertEqual(commitinfo.bug_id(), 36629)
    143         self.assertEqual(commitinfo.author_name(), u"Tor Arne Vestb\u00f8")
    144         self.assertEqual(commitinfo.author_email(), "vestbo@webkit.org")
     140        self.assertEqual(commitinfo.author_name(), "Eric Seidel")
     141        self.assertEqual(commitinfo.author_email(), "eric@webkit.org")
    145142        self.assertEqual(commitinfo.reviewer_text(), None)
    146143        self.assertEqual(commitinfo.reviewer(), None)

  • trunk/WebKitTools/Scripts/webkitpy/common/checkout/changelog.py

    r58014 r58023  
    100100    @staticmethod
    101101    def parse_latest_entry_from_file(changelog_file):
    102         """changelog_file must be a file-like object which returns
    103         unicode strings.  Use codecs.open or StringIO(unicode())
    104         to pass file objects to this class."""
    105102        date_line_regexp = re.compile(ChangeLogEntry.date_line_regexp)
    106103        entry_lines = []
    107104        # The first line should be a date line.
    108105        first_line = changelog_file.readline()
    109         assert(isinstance(first_line, unicode))
    110106        if not date_line_regexp.match(first_line):
    111107            return None

  • trunk/WebKitTools/Scripts/webkitpy/common/checkout/changelog_unittest.py

    r58014 r58023  
    2727# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2828
    29 from __future__ import with_statement
    30 
    31 import codecs
     29import unittest
    3230import os
    3331import tempfile
    34 import unittest
    3532
    3633from StringIO import StringIO
    … …  
    5653
    5754    # More example text than we need.  Eventually we need to support parsing this all and write tests for the parsing.
    58     _example_changelog = u"""2009-08-17  Tor Arne Vestb\xf8  <vestbo@webkit.org>
     55    _example_changelog = '''2009-08-17  David Kilzer  <ddkilzer@apple.com>
    5956
    6057        <http://webkit.org/b/28393> check-webkit-style: add check for use of std::max()/std::min() instead of MAX()/MIN()
    … …  
    8885
    8986== Rolled over to ChangeLog-2009-06-16 ==
    90 """
     87'''
    9188
    9289    def test_latest_entry_parse(self):
    93         changelog_contents = u"%s\n%s" % (self._example_entry, self._example_changelog)
     90        changelog_contents = "%s\n%s" % (self._example_entry, self._example_changelog)
    9491        changelog_file = StringIO(changelog_contents)
    9592        latest_entry = ChangeLog.parse_latest_entry_from_file(changelog_file)
    … …  
    10198
    10299    @staticmethod
    103     def _write_tmp_file_with_contents(byte_array):
    104         assert(isinstance(byte_array, str))
     100    def _write_tmp_file_with_contents(contents):
    105101        (file_descriptor, file_path) = tempfile.mkstemp() # NamedTemporaryFile always deletes the file on close in python < 2.6
    106         with os.fdopen(file_descriptor, "w") as file:
    107             file.write(byte_array)
     102        file = os.fdopen(file_descriptor, 'w')
     103        file.write(contents)
     104        file.close()
    108105        return file_path
    109106
    110107    @staticmethod
    111     def _read_file_contents(file_path, encoding):
    112         with codecs.open(file_path, "r", encoding) as file:
    113             return file.read()
     108    def _read_file_contents(file_path):
     109        file = open(file_path)
     110        contents = file.read()
     111        file.close()
     112        return contents
    114113
    115114    _new_entry_boilerplate = '''2009-08-19  Eric Seidel  <eric@webkit.org>
    … …  
    123122
    124123    def test_set_reviewer(self):
    125         changelog_contents = u"%s\n%s" % (self._new_entry_boilerplate, self._example_changelog)
    126         changelog_path = self._write_tmp_file_with_contents(changelog_contents.encode("utf-8"))
     124        changelog_contents = "%s\n%s" % (self._new_entry_boilerplate, self._example_changelog)
     125        changelog_path = self._write_tmp_file_with_contents(changelog_contents)
    127126        reviewer_name = 'Test Reviewer'
    128127        ChangeLog(changelog_path).set_reviewer(reviewer_name)
    129         actual_contents = self._read_file_contents(changelog_path, "utf-8")
     128        actual_contents = self._read_file_contents(changelog_path)
    130129        expected_contents = changelog_contents.replace('NOBODY (OOPS!)', reviewer_name)
    131130        os.remove(changelog_path)
    … …  
    171170
    172171    def _assert_update_for_revert_output(self, args, expected_entry):
    173         changelog_contents = u"%s\n%s" % (self._new_entry_boilerplate, self._example_changelog)
    174         changelog_path = self._write_tmp_file_with_contents(changelog_contents.encode("utf-8"))
     172        changelog_contents = "%s\n%s" % (self._new_entry_boilerplate, self._example_changelog)
     173        changelog_path = self._write_tmp_file_with_contents(changelog_contents)
    175174        changelog = ChangeLog(changelog_path)
    176175        changelog.update_for_revert(*args)

  • trunk/WebKitTools/Scripts/webkitpy/common/checkout/commitinfo.py

    r58014 r58023  
    2828#
    2929# WebKit's python module for holding information on a commit
     30
     31import StringIO
    3032
    3133from webkitpy.common.checkout.changelog import view_source_url

  • trunk/WebKitTools/Scripts/webkitpy/common/checkout/scm.py

    r58014 r58023  
    146146
    147147    def strip_r_from_svn_revision(self, svn_revision):
    148         match = re.match("^r(?P<svn_revision>\d+)", unicode(svn_revision))
     148        match = re.match("^r(?P<svn_revision>\d+)", svn_revision)
    149149        if (match):
    150150            return match.group('svn_revision')
    … …  
    345345    def changed_files_for_revision(self, revision):
    346346        # As far as I can tell svn diff --summarize output looks just like svn status output.
    347         status_command = ["svn", "diff", "--summarize", "-c", revision]
     347        status_command = ["svn", "diff", "--summarize", "-c", str(revision)]
    348348        return self.run_status_and_extract_filenames(status_command, self._status_regexp("ACDMR"))
    349349
    … …  
    362362
    363363    def create_patch(self):
    364         return run_command([self.script_path("svn-create-patch")], cwd=self.checkout_root, return_stderr=False)
     364        return run_command(self.script_path("svn-create-patch"), cwd=self.checkout_root, return_stderr=False)
    365365
    366366    def committer_email_for_revision(self, revision):
    367         return run_command(["svn", "propget", "svn:author", "--revprop", "-r", revision]).rstrip()
     367        return run_command(["svn", "propget", "svn:author", "--revprop", "-r", str(revision)]).rstrip()
    368368
    369369    def contents_at_revision(self, path, revision):
    370370        remote_path = "%s/%s" % (self._repository_url(), path)
    371         return run_command(["svn", "cat", "-r", revision, remote_path])
     371        return run_command(["svn", "cat", "-r", str(revision), remote_path])
    372372
    373373    def diff_for_revision(self, revision):
    374374        # FIXME: This should probably use cwd=self.checkout_root
    375         return run_command(['svn', 'diff', '-c', revision])
     375        return run_command(['svn', 'diff', '-c', str(revision)])
    376376
    377377    def _repository_url(self):
    … …  
    406406
    407407    def svn_commit_log(self, svn_revision):
    408         svn_revision = self.strip_r_from_svn_revision(svn_revision)
     408        svn_revision = self.strip_r_from_svn_revision(str(svn_revision))
    409409        return run_command(['svn', 'log', '--non-interactive', '--revision', svn_revision]);
    410410

  • trunk/WebKitTools/Scripts/webkitpy/common/checkout/scm_unittest.py

    r58014 r58023  
    2828# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2929
    30 from __future__ import with_statement
    31 
    3230import base64
    33 import codecs
    3431import getpass
    3532import os
    … …  
    6057        raise ScriptError('Failed to run "%s"  exit_code: %d  cwd: %s' % (args, exit_code, cwd))
    6158
    62 
    63 def write_into_file_at_path(file_path, contents, encoding="utf-8"):
    64     with codecs.open(file_path, "w", encoding) as file:
    65         file.write(contents)
    66 
    67 
    68 def read_from_path(file_path, encoding="utf-8"):
    69     with codecs.open(file_path, "r", encoding) as file:
    70         return file.read()
    71 
     59def write_into_file_at_path(file_path, contents):
     60    file = open(file_path, 'w')
     61    file.write(contents)
     62    file.close()
     63
     64def read_from_path(file_path):
     65    file = open(file_path, 'r')
     66    contents = file.read()
     67    file.close()
     68    return contents
    7269
    7370# Exists to share svn repository creation code between the git and svn tests
    … …  
    312309"""
    313310        self.checkout.apply_patch(self._create_patch(git_binary_addition))
    314         added = read_from_path('fizzbuzz7.gif', encoding=None)
     311        added = read_from_path('fizzbuzz7.gif')
    315312        self.assertEqual(512, len(added))
    316313        self.assertTrue(added.startswith('GIF89a'))
    … …  
    340337"""
    341338        self.checkout.apply_patch(self._create_patch(git_binary_modification))
    342         modified = read_from_path('fizzbuzz7.gif', encoding=None)
     339        modified = read_from_path('fizzbuzz7.gif')
    343340        self.assertEqual('foobar\n', modified)
    344341        self.assertTrue('fizzbuzz7.gif' in self.scm.changed_files())
    … …  
    522519        patch_file = self._create_patch(patch_contents)
    523520        self.checkout.apply_patch(patch_file)
    524         actual_contents = read_from_path("test_file.swf", encoding=None)
     521        actual_contents = read_from_path("test_file.swf")
    525522        self.assertEqual(actual_contents, expected_contents)
    526523
    … …  
    743740        test_file_path = os.path.join(self.git_checkout_path, test_file_name)
    744741        file_contents = ''.join(map(chr, range(256)))
    745         write_into_file_at_path(test_file_path, file_contents, encoding=None)
     742        write_into_file_at_path(test_file_path, file_contents)
    746743        run_command(['git', 'add', test_file_name])
    747744        patch = scm.create_patch()
    … …  
    753750        self._setup_webkittools_scripts_symlink(scm)
    754751        self.checkout.apply_patch(self._create_patch(patch))
    755         self.assertEqual(file_contents, read_from_path(test_file_path, encoding=None))
     752        self.assertEqual(file_contents, read_from_path(test_file_path))
    756753
    757754        # Check if we can create a patch from a local commit.
    758         write_into_file_at_path(test_file_path, file_contents, encoding=None)
     755        write_into_file_at_path(test_file_path, file_contents)
    759756        run_command(['git', 'add', test_file_name])
    760757        run_command(['git', 'commit', '-m', 'binary diff'])

  • trunk/WebKitTools/Scripts/webkitpy/common/config/committers.py

    r58014 r58023  
    241241    Reviewer("Tim Omernick", "timo@apple.com"),
    242242    Reviewer("Timothy Hatcher", ["timothy@hatcher.name", "timothy@apple.com"], "xenon"),
    243     Reviewer(u"Tor Arne Vestb\u00f8", "vestbo@webkit.org", "torarne"),
     243    Reviewer(u'Tor Arne Vestb\xf8', "vestbo@webkit.org", "torarne"),
    244244    Reviewer("Vicki Murley", "vicki@apple.com"),
    245245    Reviewer("Xan Lopez", ["xan.lopez@gmail.com", "xan@gnome.org", "xan@webkit.org"], "xan"),

  • trunk/WebKitTools/Scripts/webkitpy/common/net/bugzilla.py

    r58014 r58023  
    3333import os.path
    3434import re
    35 import StringIO
    3635import subprocess
    3736
    … …  
    429428                attachment[result_key] = flag['setter']
    430429
    431     def _string_contents(self, soup):
    432         # WebKit's bugzilla instance uses UTF-8.
    433         # BeautifulSoup always returns Unicode strings, however
    434         # the .string method returns a (unicode) NavigableString.
    435         # NavigableString can confuse other parts of the code, so we
    436         # convert from NavigableString to a real unicode() object using unicode().
    437         return unicode(soup.string)
    438 
    439430    def _parse_attachment_element(self, element, bug_id):
    440 
    441431        attachment = {}
    442432        attachment['bug_id'] = bug_id
    … …  
    446436        # FIXME: No need to parse out the url here.
    447437        attachment['url'] = self.attachment_url_for_id(attachment['id'])
    448         attachment['name'] = self._string_contents(element.find('desc'))
    449         attachment['attacher_email'] = self._string_contents(element.find('attacher'))
    450         attachment['type'] = self._string_contents(element.find('type'))
     438        attachment['name'] = unicode(element.find('desc').string)
     439        attachment['attacher_email'] = str(element.find('attacher').string)
     440        attachment['type'] = str(element.find('type').string)
    451441        self._parse_attachment_flag(
    452442                element, 'review', attachment, 'reviewer_email')
    … …  
    459449        bug = {}
    460450        bug["id"] = int(soup.find("bug_id").string)
    461         bug["title"] = self._string_contents(soup.find("short_desc"))
    462         bug["reporter_email"] = self._string_contents(soup.find("reporter"))
    463         bug["assigned_to_email"] = self._string_contents(soup.find("assigned_to"))
    464         bug["cc_emails"] = [self._string_contents(element)
     451        bug["title"] = unicode(soup.find("short_desc").string)
     452        bug["reporter_email"] = str(soup.find("reporter").string)
     453        bug["assigned_to_email"] = str(soup.find("assigned_to").string)
     454        bug["cc_emails"] = [str(element.string)
    465455                            for element in soup.findAll('cc')]
    466456        bug["attachments"] = [self._parse_attachment_element(element, bug["id"]) for element in soup.findAll('attachment')]
    … …  
    559549    def _fill_attachment_form(self,
    560550                              description,
    561                               diff,
     551                              patch_file_object,
    562552                              comment_text=None,
    563553                              mark_for_review=False,
    … …  
    579569        else:
    580570            patch_name ="%s.patch" % timestamp()
    581 
    582         # ClientForm expects a file-like object
    583         patch_file_object = StringIO.StringIO(diff.encode("utf-8"))
    584571        self.browser.add_file(patch_file_object,
    585572                              "text/plain",
    … …  
    589576    def add_patch_to_bug(self,
    590577                         bug_id,
    591                          diff,
     578                         patch_file_object,
    592579                         description,
    593580                         comment_text=None,
    … …  
    608595                          self.bug_server_url, bug_id))
    609596        self.browser.select_form(name="entryform")
    610 
    611597        self._fill_attachment_form(description,
    612                                    diff,
     598                                   patch_file_object,
    613599                                   mark_for_review=mark_for_review,
    614600                                   mark_for_commit_queue=mark_for_commit_queue,
    … …  
    643629                   bug_description,
    644630                   component=None,
    645                    diff=None,
     631                   patch_file_object=None,
    646632                   patch_description=None,
    647633                   cc=None,
    … …  
    668654            self.browser["cc"] = cc
    669655        if blocked:
    670             self.browser["blocked"] = unicode(blocked)
     656            self.browser["blocked"] = str(blocked)
    671657        self.browser["short_desc"] = bug_title
    672658        self.browser["comment"] = bug_description
    673659
    674         if diff:
     660        if patch_file_object:
    675661            self._fill_attachment_form(
    676662                    patch_description,
    677                     diff,
     663                    patch_file_object,
    678664                    mark_for_review=mark_for_review,
    679665                    mark_for_commit_queue=mark_for_commit_queue)

  • trunk/WebKitTools/Scripts/webkitpy/common/net/buildbot.py

    r58014 r58023  
    4545class Builder(object):
    4646    def __init__(self, name, buildbot):
    47         self._name = name
     47        self._name = unicode(name)
    4848        self._buildbot = buildbot
    4949        self._builds_cache = {}
    … …  
    224224        tables = BeautifulSoup(page).findAll("table")
    225225        for table in tables:
    226             table_title = unicode(table.findPreviousSibling("p").string)
     226            table_title = table.findPreviousSibling("p").string
    227227            if table_title not in cls.expected_keys:
    228228                # This Exception should only ever be hit if run-webkit-tests changes its results.html format.
    229                 raise Exception("Unhandled title: %s" % table_title)
     229                raise Exception("Unhandled title: %s" % str(table_title))
    230230            # We might want to translate table titles into identifiers before storing.
    231             parsed_results[table_title] = [unicode(row.find("a").string) for row in table.findAll("tr")]
     231            parsed_results[table_title] = [row.find("a").string for row in table.findAll("tr")]
    232232
    233233        return parsed_results
    … …  
    362362        # First cell is the name
    363363        name_link = status_cells[0].find('a')
    364         builder["name"] = unicode(name_link.string)
     364        builder["name"] = name_link.string
    365365
    366366        self._parse_last_build_cell(builder, status_cells[1])
    … …  
    411411
    412412    def _parse_twisted_file_row(self, file_row):
    413         string_or_empty = lambda soup: unicode(soup.string) if soup.string else u""
     413        string_or_empty = lambda string: str(string) if string else ""
    414414        file_cells = file_row.findAll('td')
    415415        return {
    416             "filename": string_or_empty(file_cells[0].find("a")),
    417             "size": string_or_empty(file_cells[1]),
    418             "type": string_or_empty(file_cells[2]),
    419             "encoding": string_or_empty(file_cells[3]),
     416            "filename" : string_or_empty(file_cells[0].find("a").string),
     417            "size" : string_or_empty(file_cells[1].string),
     418            "type" : string_or_empty(file_cells[2].string),
     419            "encoding" : string_or_empty(file_cells[3].string),
    420420        }
    421421

  • trunk/WebKitTools/Scripts/webkitpy/common/net/buildbot_unittest.py

    r58014 r58023  
    5252    def setUp(self):
    5353        self.buildbot = BuildBot()
    54         self.builder = Builder(u"Test Builder \u2661", self.buildbot)
     54        self.builder = Builder("Test Builder", self.buildbot)
    5555        self._install_fetch_build(lambda build_number: ["test1", "test2"])
    5656

  • trunk/WebKitTools/Scripts/webkitpy/common/net/statusserver.py

    r58014 r58023  
    5353            return
    5454        if patch.bug_id():
    55             self.browser["bug_id"] = unicode(patch.bug_id())
     55            self.browser["bug_id"] = str(patch.bug_id())
    5656        if patch.id():
    57             self.browser["patch_id"] = unicode(patch.id())
     57            self.browser["patch_id"] = str(patch.id())
    5858
    5959    def _add_results_file(self, results_file):
    … …  
    8080        self.browser.open(update_svn_revision_url)
    8181        self.browser.select_form(name="update_svn_revision")
    82         self.browser["number"] = unicode(svn_revision_number)
     82        self.browser["number"] = str(svn_revision_number)
    8383        self.browser["broken_bot"] = broken_bot
    8484        return self.browser.submit().read()

  • trunk/WebKitTools/Scripts/webkitpy/common/prettypatch.py

    r58014 r58023  
    3939        pretty_diff = self.pretty_diff(diff)
    4040        diff_file = tempfile.NamedTemporaryFile(suffix=".html")
    41         diff_file.write(pretty_diff.encode("utf-8"))
     41        diff_file.write(pretty_diff)
    4242        diff_file.flush()
    4343        return diff_file

  • trunk/WebKitTools/Scripts/webkitpy/common/system/autoinstall.py

    r58014 r58023  
    3131"""Support for automatically downloading Python packages from an URL."""
    3232
    33 
    34 from __future__ import with_statement
    35 
    36 import codecs
    3733import logging
    3834import new
    … …  
    119115        os.makedirs(path)
    120116
    121     def _write_file(self, path, text, encoding):
     117    def _write_file(self, path, text):
    122118        """Create a file at the given path with given text.
    123119
    … …  
    127123        _log.debug("Creating file...")
    128124        _log.debug('    "%s"' % path)
    129         with codecs.open(path, "w", encoding) as file:
     125        file = open(path, "w")
     126        try:
    130127            file.write(text)
     128        finally:
     129            file.close()
    131130
    132131    def _set_up_target_dir(self, target_dir, append_to_search_path,
    … …  
    156155                text = ("# This file is required for Python to search this "
    157156                        "directory for modules.\n")
    158                 self._write_file(init_path, text, "ascii")
     157                self._write_file(init_path, text)
    159158
    160159    def _create_scratch_directory_inner(self, prefix):
    … …  
    218217            return False
    219218
    220         with codecs.open(version_path, "r", "utf-8") as file:
     219        file = open(version_path, "r")
     220        try:
    221221            version = file.read()
     222        finally:
     223            file.close()
    222224
    223225        return version.strip() == url.strip()
    … …  
    230232        _log.debug('     To: "%s"' % version_path)
    231233
    232         self._write_file(version_path, url, "utf-8")
     234        self._write_file(version_path, url)
    233235
    234236    def _extract_targz(self, path, scratch_dir):
    … …  
    283285
    284286            try:
    285                 # We open this file w/o encoding, as we're reading/writing
    286                 # the raw byte-stream from the zip file.
    287287                outfile = open(path, 'wb')
    288288            except IOError, err:

  • trunk/WebKitTools/Scripts/webkitpy/common/system/deprecated_logging.py

    r58014 r58023  
    3131# This module is now deprecated in favor of python's built-in logging.py.
    3232
    33 import codecs
    3433import os
    3534import sys
    36 
    3735
    3836def log(string):
    3937    print >> sys.stderr, string
    4038
    41 
    4239def error(string):
    4340    log("ERROR: %s" % string)
    4441    exit(1)
    45 
    4642
    4743# Simple class to split output between multiple destinations
    … …  
    5046        self.files = files
    5147
    52     # Callers should pass an already encoded string for writing.
    53     def write(self, bytes):
     48    def write(self, string):
    5449        for file in self.files:
    55             file.write(bytes)
    56 
     50            file.write(string)
    5751
    5852class OutputTee:
    … …  
    7872        if log_directory and not os.path.exists(log_directory):
    7973            os.makedirs(log_directory)
    80         return codecs.open(log_path, "a+", "utf-8")
     74        return open(log_path, 'a+')
    8175
    8276    def _tee_outputs_to_files(self, files):

  • trunk/WebKitTools/Scripts/webkitpy/common/system/executive.py

    r58014 r58023  
    8989
    9090    def _run_command_with_teed_output(self, args, teed_output):
    91         args = map(unicode, args)  # Popen will throw an exception if args are non-strings (like int())
    9291        child_process = subprocess.Popen(args,
    9392                                         stdout=subprocess.PIPE,
    … …  
    101100            if output_line == "" and child_process.poll() != None:
    102101                return child_process.poll()
    103             # We assume that the child process wrote to us in utf-8,
    104             # so no re-encoding is necessary before writing here.
    105102            teed_output.write(output_line)
    106103
    107     # FIXME: Remove this deprecated method and move callers to run_command.
    108     # FIXME: This method is a hack to allow running command which both
    109     # capture their output and print out to stdin.  Useful for things
    110     # like "build-webkit" where we want to display to the user that we're building
    111     # but still have the output to stuff into a log file.
    112     def run_and_throw_if_fail(self, args, quiet=False, decode_output=True):
     104    def run_and_throw_if_fail(self, args, quiet=False):
    113105        # Cache the child's output locally so it can be used for error reports.
    114106        child_out_file = StringIO.StringIO()
    115107        tee_stdout = sys.stdout
    116108        if quiet:
    117             dev_null = open(os.devnull, "w")  # FIXME: Does this need an encoding?
     109            dev_null = open(os.devnull, "w")
    118110            tee_stdout = dev_null
    119111        child_stdout = tee(child_out_file, tee_stdout)
    … …  
    124116        child_output = child_out_file.getvalue()
    125117        child_out_file.close()
    126 
    127         # We assume the child process output utf-8
    128         if decode_output:
    129             child_output = child_output.decode("utf-8")
    130118
    131119        if exit_code:
    … …  
    158146            # using Cygwin, it worked fine.  We should investigate whether
    159147            # we need this platform specific code here.
    160             subprocess.call(('taskkill.exe', '/f', '/pid', unicode(pid)),
     148            subprocess.call(('taskkill.exe', '/f', '/pid', str(pid)),
    161149                            stdin=open(os.devnull, 'r'),
    162150                            stdout=subprocess.PIPE,
    … …  
    176164        pass
    177165
    178     def _compute_stdin(self, input):
    179         """Returns (stdin, string_to_communicate)"""
    180         if not input:
    181             return (None, None)
    182         if hasattr(input, "read"):  # Check if the input is a file.
    183             return (input, None)  # Assume the file is in the right encoding.
    184 
    185         # Popen in Python 2.5 and before does not automatically encode unicode objects.
    186         # http://bugs.python.org/issue5290
    187         # See https://bugs.webkit.org/show_bug.cgi?id=37528
    188         # for an example of a regresion caused by passing a unicode string directly.
    189         # FIXME: We may need to encode differently on different platforms.
    190         if isinstance(input, unicode):
    191             input = input.encode("utf-8")
    192         return (subprocess.PIPE, input)
    193 
    194     # FIXME: run_and_throw_if_fail should be merged into this method.
     166    # FIXME: This should be merged with run_and_throw_if_fail
     167
    195168    def run_command(self,
    196169                    args,
    … …  
    199172                    error_handler=None,
    200173                    return_exit_code=False,
    201                     return_stderr=True,
    202                     decode_output=True):
    203         args = map(unicode, args)  # Popen will throw an exception if args are non-strings (like int())
    204         stdin, string_to_communicate = self._compute_stdin(input)
    205         stderr = subprocess.STDOUT if return_stderr else None
     174                    return_stderr=True):
     175        if hasattr(input, 'read'): # Check if the input is a file.
     176            stdin = input
     177            string_to_communicate = None
     178        else:
     179            stdin = None
     180            if input:
     181                stdin = subprocess.PIPE
     182            # string_to_communicate seems to need to be a str for proper
     183            # communication with shell commands.
     184            # See https://bugs.webkit.org/show_bug.cgi?id=37528
     185            # For an example of a regresion caused by passing a unicode string through.
     186            string_to_communicate = str(input)
     187        if return_stderr:
     188            stderr = subprocess.STDOUT
     189        else:
     190            stderr = None
    206191
    207192        process = subprocess.Popen(args,
    … …  
    211196                                   cwd=cwd)
    212197        output = process.communicate(string_to_communicate)[0]
    213         # run_command automatically decodes to unicode() unless explicitly told not to.
    214         if decode_output:
    215             output = output.decode("utf-8")
    216198        exit_code = process.wait()
    217199

  • trunk/WebKitTools/Scripts/webkitpy/common/system/executive_unittest.py

    r58014 r58023  
    1 # Copyright (C) 2010 Google Inc. All rights reserved.
     1# Copyright (C) 2009 Google Inc. All rights reserved.
    22# Copyright (C) 2009 Daniel Bates (dbates@intudata.com). All rights reserved.
    33#
    … …  
    3232from webkitpy.common.system.executive import Executive, run_command
    3333
    34 
    3534class ExecutiveTest(unittest.TestCase):
    3635
    … …  
    4039        self.failUnlessRaises(OSError, run_bad_command)
    4140
    42     def test_run_command_with_unicode(self):
    43         """Validate that it is safe to pass unicode() objects
    44         to Executive.run* methods, and they will return unicode()
    45         objects by default unless decode_output=False"""
    46         executive = Executive()
    47         unicode_tor = u"WebKit \u2661 Tor Arne Vestb\u00F8!"
    48         utf8_tor = unicode_tor.encode("utf-8")
    49 
    50         output = executive.run_command(["cat"], input=unicode_tor)
    51         self.assertEquals(output, unicode_tor)
    52 
    53         output = executive.run_command(["echo", "-n", unicode_tor])
    54         self.assertEquals(output, unicode_tor)
    55 
    56         output = executive.run_command(["echo", "-n", unicode_tor], decode_output=False)
    57         self.assertEquals(output, utf8_tor)
    58 
    59         # FIXME: We should only have one run* method to test
    60         output = executive.run_and_throw_if_fail(["echo", "-n", unicode_tor], quiet=True)
    61         self.assertEquals(output, unicode_tor)
    62 
    63         output = executive.run_and_throw_if_fail(["echo", "-n", unicode_tor], quiet=True, decode_output=False)
    64         self.assertEquals(output, utf8_tor)
     41if __name__ == '__main__':
     42    unittest.main()

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/layout_package/dump_render_tree_thread.py

    r58014 r58023  
    3636"""
    3737
    38 from __future__ import with_statement
    39 
    40 import codecs
    4138import copy
    4239import logging
    … …  
    9390        filename = os.path.splitext(filename)[0] + "-stack.txt"
    9491        port.maybe_make_directory(os.path.split(filename)[0])
    95         with codecs.open(filename, "wb", "utf-8") as file:
    96             file.write(error)
     92        open(filename, "wb").write(error)  # FIXME: This leaks a file handle.
    9793    elif error:
    9894        _log.debug("Previous test output extra lines after dump:\n%s" %
    … …  
    295291        tests_run_filename = os.path.join(self._options.results_directory,
    296292                                          "tests_run.txt")
    297         tests_run_file = codecs.open(tests_run_filename, "a", "utf-8")
     293        tests_run_file = open(tests_run_filename, "a")
    298294
    299295        while True:

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/layout_package/json_results_generator.py

    r58014 r58023  
    2828# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2929
    30 from __future__ import with_statement
    31 
    32 import codecs
    3330import logging
    3431import os
    … …  
    122119        json = self._get_json()
    123120        if json:
    124             results_file = codecs.open(self._results_file_path, "w", "utf-8")
     121            results_file = open(self._results_file_path, "w")
    125122            results_file.write(json)
    126123            results_file.close()
    … …  
    155152
    156153        if os.path.exists(self._results_file_path):
    157             with codecs.open(self._results_file_path, "r", "utf-8") as file:
    158                 old_results = file.read()
     154            old_results_file = open(self._results_file_path, "r")
     155            old_results = old_results_file.read()
    159156        elif self._builder_base_url:
    160157            # Check if we have the archived JSON file on the buildbot server.

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/port/apache_http_server.py

    r58014 r58023  
    3030"""A class to start/stop the apache http server used by layout tests."""
    3131
    32 
    33 from __future__ import with_statement
    34 
    35 import codecs
    3632import logging
    3733import optparse
    … …  
    156152        httpd_config = self._port_obj._path_to_apache_config_file()
    157153        httpd_config_copy = os.path.join(output_dir, "httpd.conf")
    158         # httpd.conf is always utf-8 according to http://archive.apache.org/gnats/10125
    159         with codecs.open(httpd_config, "r", "utf-8") as httpd_config_file:
    160             httpd_conf = httpd_config_file.read()
     154        httpd_conf = open(httpd_config).read()
    161155        if self._is_cygwin():
    162156            # This is a gross hack, but it lets us use the upstream .conf file
    … …  
    171165                'ServerRoot "%s"' % self._get_cygwin_path(cygusr))
    172166
    173         with codecs.open(httpd_config_copy, "w", "utf-8") as file:
    174             file.write(httpd_conf)
     167        f = open(httpd_config_copy, 'wb')
     168        f.write(httpd_conf)
     169        f.close()
    175170
    176171        if self._is_cygwin():

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/port/chromium.py

    r58014 r58023  
    390390                    _log.warning('stopping test driver timed out, '
    391391                                 'killing it')
    392                     # FIXME: This should use Executive.
    393                     null = open(os.devnull, "w")  # Does this need an encoding?
     392                    null = open(os.devnull, "w")
    394393                    subprocess.Popen(["kill", "-9",
    395394                                     str(self._proc.pid)], stderr=null)

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/port/chromium_linux.py

    r58014 r58023  
    127127
    128128    def _kill_all_process(self, process_name):
    129         # FIXME: This should use Executive.
    130129        null = open(os.devnull)
    131130        subprocess.call(['killall', '-TERM', '-u', os.getenv('USER'),

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/port/chromium_mac.py

    r58014 r58023  
    100100
    101101    def _check_wdiff_install(self):
    102         # FIXME: This should use Executive.
    103102        f = open(os.devnull, 'w')
    104103        rcode = 0
    … …  
    118117    def _kill_all_process(self, process_name):
    119118        """Kill any processes running under this name."""
    120         # FIXME: This should use Executive.
    121119        # On Mac OS X 10.6, killall has a new constraint: -SIGNALNAME or
    122120        # -SIGNALNUMBER must come first.  Example problem:

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/port/gtk.py

    r58014 r58023  
    6363
    6464    def _kill_all_process(self, process_name):
    65         # FIXME: This should use Executive.
    6665        null = open(os.devnull)
    6766        subprocess.call(['killall', '-TERM', '-u', os.getenv('USER'),

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/port/mac.py

    r58014 r58023  
    134134    # FIXME: This doesn't have anything to do with WebKit.
    135135    def _kill_all_process(self, process_name):
    136         # FIXME: This should use Executive.
    137136        # On Mac OS X 10.6, killall has a new constraint: -SIGNALNAME or
    138137        # -SIGNALNUMBER must come first.  Example problem:

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/port/mac_unittest.py

    r58014 r58023  
    4141        self.assertEqual(relative_paths, ['LayoutTests/platform/mac-leopard/Skipped', 'LayoutTests/platform/mac/Skipped'])
    4242
    43     example_skipped_file = u"""
     43    example_skipped_file = """
    4444# <rdar://problem/5647952> fast/events/mouseout-on-window.html needs mac DRT to issue mouse out events
    4545fast/events/mouseout-on-window.html

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/port/qt.py

    r58014 r58023  
    6464
    6565    def _kill_all_process(self, process_name):
    66         # FIXME: This should use Executive.
    6766        null = open(os.devnull)
    6867        subprocess.call(['killall', '-TERM', '-u', os.getenv('USER'),

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/port/server_process.py

    r58014 r58023  
    216216                _log.warning('stopping %s timed out, killing it' %
    217217                             self._name)
    218                 # FIXME: This should use Executive.
    219218                null = open(os.devnull, "w")
    220219                subprocess.Popen(["kill", "-9",

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/port/webkit.py

    r58014 r58023  
    3030"""WebKit implementations of the Port interface."""
    3131
    32 
    33 from __future__ import with_statement
    34 
    35 import codecs
    3632import logging
    3733import os
    … …  
    139135
    140136        actual_length = os.stat(actual_filename).st_size
    141         with open(actual_filename) as file:
    142             actual_file = file.read()
     137        actual_file = open(actual_filename).read()
    143138        expected_length = os.stat(expected_filename).st_size
    144         with open(expected_filename) as file:
    145             expected_file = file.read()
     139        expected_file = open(expected_filename).read()
    146140        sp.write('Content-Length: %d\n%sContent-Length: %d\n%s' %
    147141                 (actual_length, actual_file, expected_length, expected_file))
    … …  
    172166                result = False
    173167        elif output and diff_filename:
    174             with open(diff_filename, 'w') as file:
    175                 file.write(output)
     168            open(diff_filename, 'w').write(output)  # FIXME: This leaks a file handle.
    176169        elif sp.timed_out:
    177170            _log.error("ImageDiff timed out on %s" % expected_filename)

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/port/websocket_server.py

    r58014 r58023  
    3131
    3232
    33 from __future__ import with_statement
    34 
    35 import codecs
    3633import logging
    3734import optparse
    … …  
    155152
    156153        output_log = os.path.join(self._output_dir, log_file_name + "-out.txt")
    157         self._wsout = codecs.open(output_log, "w", "utf-8")
     154        self._wsout = open(output_log, "w")
    158155
    159156        python_interp = sys.executable
    … …  
    220217        url = url + '://127.0.0.1:%d/' % self._port
    221218        if not url_is_alive(url):
    222             fp = codecs.open(output_log, "utf-8")
     219            fp = open(output_log)
    223220            try:
    224221                for line in fp:
    … …  
    235232                'Failed to start %s server.' % self._server_name)
    236233        if self._pidfile:
    237             with codecs.open(self._pidfile, "w", "ascii") as file:
    238                 file.write("%d" % self._process.pid)
     234            f = open(self._pidfile, 'w')
     235            f.write("%d" % self._process.pid)
     236            f.close()
    239237
    240238    def stop(self, force=False):
    … …  
    246244            pid = self._process.pid
    247245        elif self._pidfile:
    248             with codecs.open(self._pidfile, "r", "ascii") as file:
    249                 pid = int(f.read().strip())
     246            f = open(self._pidfile)
     247            pid = int(f.read().strip())
     248            f.close()
    250249
    251250        if not pid:

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/rebaseline_chromium_webkit_tests.py

    r58014 r58023  
    4242"""
    4343
    44 from __future__ import with_statement
    45 
    46 import codecs
    4744import copy
    4845import logging
    … …  
    602599                _log.info('Saving original file to "%s"', backup_file)
    603600                os.rename(path, backup_file)
    604             # FIXME: What encoding are these files?
    605             # Or is new_expectations always a byte array?
    606             with open(path, "w") as file:
    607                 file.write(new_expectations)
     601            f = open(path, "w")
     602            f.write(new_expectations)
     603            f.close()
    608604        else:
    609605            _log.info('No test was rebaselined so nothing to remove.')
    … …  
    720716                                             baseline_filename, self._platform,
    721717                                             'old')
    722         # FIXME: This assumes run_shell returns a byte array.
    723         # We should be using an explicit encoding here.
    724         with open(base_file, "wb") as file:
    725             file.write(output)
     718        f = open(base_file, 'wb')
     719        f.write(output)
     720        f.close()
    726721        _log.info('  Html: created old baseline file: "%s".',
    727722                  base_file)
    … …  
    754749                    self._options.html_directory, baseline_filename,
    755750                    self._platform, 'diff')
    756                 # FIXME: This assumes run_shell returns a byte array, not unicode()
    757                 with open(diff_file, 'wb') as file:
    758                     file.write(output)
     751                f = open(diff_file, 'wb')
     752                f.write(output)
     753                f.close()
    759754                _log.info('  Html: created baseline diff file: "%s".',
    760755                          diff_file)
    … …  
    841836        _log.debug(html)
    842837
    843         with codecs.open(self._html_file, "w", "utf-8") as file:
    844             file.write(html)
     838        f = open(self._html_file, 'w')
     839        f.write(html)
     840        f.close()
    845841
    846842        _log.info('Baseline comparison html generated at "%s"',

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/run_webkit_tests.py

    r58014 r58023  
    368368            tests_run_filename = os.path.join(self._options.results_directory,
    369369                                              "tests_run.txt")
    370             with codecs.open(tests_run_filename, "w", "utf-8") as file:
    371                 file.write(tests_run_msg + "\n")
     370            tests_run_file = open(tests_run_filename, "w")
     371            tests_run_file.write(tests_run_msg + "\n")
     372            tests_run_file.close()
    372373
    373374            len_skip_chunk = int(len(files) * len(skipped) /
    … …  
    966967            dashboard).
    967968        """
    968         results_directory = self._options.results_directory
    969         _log.debug("Writing JSON files in %s." % results_directory)
    970         unexpected_json_path = os.path.join(results_directory, "unexpected_results.json")
    971         with codecs.open(unexpected_json_path, "w", "utf-8") as file:
    972             simplejson.dump(unexpected_results, file, sort_keys=True, indent=2)
     969        _log.debug("Writing JSON files in %s." %
     970                   self._options.results_directory)
     971        unexpected_file = open(os.path.join(self._options.results_directory,
     972            "unexpected_results.json"), "w")
     973        unexpected_file.write(simplejson.dumps(unexpected_results,
     974                              sort_keys=True, indent=2))
     975        unexpected_file.close()
    973976
    974977        # Write a json file of the test_expectations.txt file for the layout
    975978        # tests dashboard.
    976         expectations_path = os.path.join(results_directory, "expectations.json")
     979        expectations_file = open(os.path.join(self._options.results_directory,
     980            "expectations.json"), "w")
    977981        expectations_json = \
    978982            self._expectations.get_expectations_json_for_all_platforms()
    979         with codecs.open(expectations_path, "w", "utf-8") as file:
    980             file.write(u"ADD_EXPECTATIONS(%s);" % expectations_json)
     983        expectations_file.write("ADD_EXPECTATIONS(" + expectations_json + ");")
     984        expectations_file.close()
    981985
    982986        json_layout_results_generator.JSONLayoutResultsGenerator(
    … …  
    13891393        out_filename = os.path.join(self._options.results_directory,
    13901394                                    "results.html")
    1391         # FIXME: This should be re-written to prepare the string first
    1392         # so that the "open" call can be wrapped in a with statement.
    1393         out_file = codecs.open(out_filename, "w", "utf-8")
     1395        out_file = open(out_filename, 'w')
    13941396        # header
    13951397        if self._options.full_results_html:
    … …  
    14041406        for test_file in test_files:
    14051407            test_failures = result_summary.failures.get(test_file, [])
    1406             out_file.write(u"<p><a href='%s'>%s</a><br />\n"
     1408            out_file.write("<p><a href='%s'>%s</a><br />\n"
    14071409                           % (self._port.filename_to_uri(test_file),
    14081410                              self._port.relative_test_filename(test_file)))
    14091411            for failure in test_failures:
    1410                 out_file.write(u"&nbsp;&nbsp;%s<br/>"
     1412                out_file.write("&nbsp;&nbsp;%s<br/>"
    14111413                               % failure.result_html_output(
    14121414                                 self._port.relative_test_filename(test_file)))
    … …  
    14151417        # footer
    14161418        out_file.write("</body></html>\n")
    1417         out_file.close()
    14181419        return True
    14191420
    … …  
    14321433    tests = []
    14331434    for file in files:
    1434         # FIXME: This could be cleaner using a list comprehension.
    1435         for line in codecs.open(file, "r", "utf-8"):
     1435        for line in open(file):
    14361436            line = test_expectations.strip_comments(line)
    14371437            if line:

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/test_types/image_diff.py

    r58014 r58023  
    3535"""
    3636
    37 from __future__ import with_statement
    38 
    39 import codecs
    4037import errno
    4138import logging
    … …  
    8279          checksum: value of the actual checksum result
    8380        """
    84         with open(png_path, "rb") as png_file:
    85             png_data = png_file.read()
     81        png_file = open(png_path, "rb")
     82        png_data = png_file.read()
     83        png_file.close()
    8684        self._save_baseline_data(filename, png_data, ".png")
    8785        self._save_baseline_data(filename, checksum, ".checksum")
    … …  
    143141            _log.debug('Using %s' % expected_png_file)
    144142
    145         # FIXME: We repeat this pattern often, we should share code.
    146143        try:
    147             with codecs.open(expected_hash_file, "r", "ascii") as file:
    148                 expected_hash = file.read()
     144            expected_hash = open(expected_hash_file, "r").read()
    149145        except IOError, e:
    150146            if errno.ENOENT != e.errno:

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/test_types/test_type_base.py

    r58020 r58023  
    3333"""
    3434
    35 from __future__ import with_statement
    36 
    37 import codecs
    3835import cgi
    3936import errno
    … …  
    154151        raise NotImplemented
    155152
    156     def _write_into_file_at_path(self, file_path, contents, encoding=None):
    157         """Writes contents at file_path, using encoding."""
    158         if not encoding:
    159             # FIXME: This is a hack to handle binary data.  I thought
    160             # encoding=None worked, but I guess not.
    161             with open(file_path, "wb") as file:
    162                 file.write(contents)
    163             return
    164         with codecs.open(file_path, "w", encoding=encoding) as file:
    165             file.write(contents)
     153    def _write_into_file_at_path(self, file_path, contents):
     154        file = open(file_path, "wb")
     155        file.write(contents)
     156        file.close()
    166157
    167158    def write_output_files(self, port, filename, file_type,
    … …  
    185176        actual_filename = self.output_filename(filename, self.FILENAME_SUFFIX_ACTUAL + file_type)
    186177        expected_filename = self.output_filename(filename, self.FILENAME_SUFFIX_EXPECTED + file_type)
    187         # FIXME: The fact that this function can take many different
    188         # types of data is a total hack.
    189         encoding = "utf-8" if print_text_diffs else None
    190178        if output:
    191             self._write_into_file_at_path(actual_filename, output, encoding)
     179            self._write_into_file_at_path(actual_filename, output)
    192180        if expected:
    193             self._write_into_file_at_path(expected_filename, expected, encoding)
     181            self._write_into_file_at_path(expected_filename, expected)
    194182
    195183        if not output or not expected:
    … …  
    201189        diff = port.diff_text(expected, output, expected_filename, actual_filename)
    202190        diff_filename = self.output_filename(filename, self.FILENAME_SUFFIX_DIFF + file_type)
    203         self._write_into_file_at_path(diff_filename, diff, encoding="utf-8")
     191        self._write_into_file_at_path(diff_filename, diff)
    204192
    205193        # Shell out to wdiff to get colored inline diffs.
    206194        wdiff = port.wdiff_text(expected_filename, actual_filename)
    207195        wdiff_filename = self.output_filename(filename, self.FILENAME_SUFFIX_WDIFF)
    208         self._write_into_file_at_path(wdiff_filename, wdiff, encoding="utf-8")
     196        self._write_into_file_at_path(wdiff_filename, wdiff)
    209197
    210198        # Use WebKit's PrettyPatch.rb to get an HTML diff.
    211199        pretty_patch = port.pretty_patch_text(diff_filename)
    212200        pretty_patch_filename = self.output_filename(filename, self.FILENAME_SUFFIX_PRETTY_PATCH)
    213         self._write_into_file_at_path(pretty_patch_filename, pretty_patch, encoding="utf-8")
     201        self._write_into_file_at_path(pretty_patch_filename, pretty_patch)

  • trunk/WebKitTools/Scripts/webkitpy/layout_tests/test_types/text_diff.py

    r58014 r58023  
    3434"""
    3535
    36 from __future__ import with_statement
    37 
    38 import codecs
    3936import errno
    4037import logging
    … …  
    7471
    7572    def get_normalized_text(self, filename):
    76         # FIXME: We repeat this pattern often, we should share code.
    7773        try:
    78             with codecs.open(filename, "r", "utf-8") as file:
    79                 text = file.read()
     74            text = open(filename).read()
    8075        except IOError, e:
    8176            if errno.ENOENT != e.errno:

  • trunk/WebKitTools/Scripts/webkitpy/style/filereader_unittest.py

    r58014 r58023  
    2323"""Contains unit tests for filereader.py."""
    2424
    25 from __future__ import with_statement
    26 
    27 import codecs
    2825import os
    2926import shutil
    … …  
    7168        shutil.rmtree(self._temp_dir)
    7269
    73     def _create_file(self, rel_path, text, encoding="utf-8"):
     70    def _create_file(self, rel_path, text):
    7471        """Create a file with given text and return the path to the file."""
    75         # FIXME: There are better/more secure APIs for creatin tmp file paths.
    7672        file_path = os.path.join(self._temp_dir, rel_path)
    77         with codecs.open(file_path, "w", encoding) as file:
    78             file.write(text)
     73
     74        file = open(file_path, 'w')
     75        file.write(text)
     76        file.close()
     77
    7978        return file_path
    8079

  • trunk/WebKitTools/Scripts/webkitpy/thirdparty/__init__.py

    r58014 r58023  
    2525"""Autoinstalls third-party code required by WebKit."""
    2626
    27 from __future__ import with_statement
    28 
    29 import codecs
    3027import os
    3128
    … …  
    9289readme_path = os.path.join(autoinstalled_dir, "README")
    9390if not os.path.exists(readme_path):
    94     with codecs.open(readme_path, "w", "ascii") as file:
     91    file = open(readme_path, "w")
     92    try:
    9593        file.write("This directory is auto-generated by WebKit and is "
    9694                   "safe to delete.\nIt contains needed third-party Python "
    9795                   "packages automatically downloaded from the web.")
     96    finally:
     97        file.close()

  • trunk/WebKitTools/Scripts/webkitpy/tool/commands/earlywarningsystem.py

    r58014 r58023  
    2626# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    2727# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     28
     29from StringIO import StringIO
    2830
    2931from webkitpy.tool.commands.queues import AbstractReviewQueue

  • trunk/WebKitTools/Scripts/webkitpy/tool/commands/queues.py

    r58014 r58023  
    7272        webkit_patch_args = [self.tool.path()]
    7373        # FIXME: This is a hack, we should have a more general way to pass global options.
    74         # FIXME: We must always pass global options and their value in one argument
    75         # because our global option code looks for the first argument which does
    76         # not begin with "-" and assumes that is the command name.
    7774        webkit_patch_args += ["--status-host=%s" % self.tool.status_server.host]
    78         webkit_patch_args.extend(args)
     75        webkit_patch_args += map(str, args)
    7976        return self.tool.executive.run_and_throw_if_fail(webkit_patch_args)
    8077
    … …  
    127124            message = "Error: %s" % message
    128125        output = script_error.message_with_output(output_limit=1024*1024) # 1MB
    129         # We pre-encode the string to a byte array before passing it
    130         # to status_server, because ClientForm (part of mechanize)
    131         # wants a file-like object with pre-encoded data.
    132         return tool.status_server.update_status(cls.name, message, state["patch"], StringIO(output.encode("utf-8")))
     126        return tool.status_server.update_status(cls.name, message, state["patch"], StringIO(output))
    133127
    134128

  • trunk/WebKitTools/Scripts/webkitpy/tool/commands/queues_unittest.py

    r58014 r58023  
    7676
    7777        queue.run_webkit_patch(run_args)
    78         expected_run_args = ["echo", "--status-host=example.com"] + run_args
     78        expected_run_args = ["echo", "--status-host=example.com"] + map(str, run_args)
    7979        tool.executive.run_and_throw_if_fail.assert_called_with(expected_run_args)
    8080
    … …  
    1511511 patch in commit-queue [106]
    152152""",
    153             "process_work_item": "MOCK run_and_throw_if_fail: ['echo', '--status-host=example.com', 'land-attachment', '--force-clean', '--build', '--test', '--non-interactive', '--ignore-builders', '--build-style=both', '--quiet', 76543]\n",
     153            "process_work_item": "MOCK run_and_throw_if_fail: ['echo', '--status-host=example.com', 'land-attachment', '--force-clean', '--build', '--test', '--non-interactive', '--ignore-builders', '--build-style=both', '--quiet', '76543']\n",
    154154        }
    155155        self.assert_queue_outputs(CommitQueue(), tool=tool, work_item=rollout_patch, expected_stderr=expected_stderr)

  • trunk/WebKitTools/Scripts/webkitpy/tool/commands/upload.py

    r58014 r58023  
    3131import os
    3232import re
     33import StringIO
    3334import sys
    3435
    … …  
    260261        return comment_text
    261262
     263    def _diff_file_for_commit(self, tool, commit_id):
     264        diff = tool.scm().create_patch_from_local_commit(commit_id)
     265        return StringIO.StringIO(diff) # add_patch_to_bug expects a file-like object
     266
    262267    def execute(self, options, args, tool):
    263268        commit_ids = tool.scm().commit_ids_from_commitish_arguments(args)
    … …  
    280285                have_obsoleted_patches.add(bug_id)
    281286
    282             diff = tool.scm().create_patch_from_local_commit(commit_id)
     287            diff_file = self._diff_file_for_commit(tool, commit_id)
    283288            description = options.description or commit_message.description(lstrip=True, strip_url=True)
    284289            comment_text = self._comment_text_for_commit(options, commit_message, tool, commit_id)
    285             tool.bugs.add_patch_to_bug(bug_id, diff, description, comment_text, mark_for_review=options.review, mark_for_commit_queue=options.request_commit)
     290            tool.bugs.add_patch_to_bug(bug_id, diff_file, description, comment_text, mark_for_review=options.review, mark_for_commit_queue=options.request_commit)
    286291
    287292
    … …  
    400405
    401406        diff = tool.scm().create_patch_from_local_commit(commit_id)
    402         bug_id = tool.bugs.create_bug(bug_title, comment_text, options.component, diff, "Patch", cc=options.cc, mark_for_review=options.review, mark_for_commit_queue=options.request_commit)
     407        diff_file = StringIO.StringIO(diff) # create_bug expects a file-like object
     408        bug_id = tool.bugs.create_bug(bug_title, comment_text, options.component, diff_file, "Patch", cc=options.cc, mark_for_review=options.review, mark_for_commit_queue=options.request_commit)
    403409
    404410        if bug_id and len(commit_ids) > 1:
    … …  
    419425
    420426        diff = tool.scm().create_patch()
    421         bug_id = tool.bugs.create_bug(bug_title, comment_text, options.component, diff, "Patch", cc=options.cc, mark_for_review=options.review, mark_for_commit_queue=options.request_commit)
     427        diff_file = StringIO.StringIO(diff) # create_bug expects a file-like object
     428        bug_id = tool.bugs.create_bug(bug_title, comment_text, options.component, diff_file, "Patch", cc=options.cc, mark_for_review=options.review, mark_for_commit_queue=options.request_commit)
    422429
    423430    def prompt_for_bug_title_and_comment(self):

  • trunk/WebKitTools/Scripts/webkitpy/tool/mocktool.py

    r58014 r58023  
    261261                   bug_description,
    262262                   component=None,
    263                    diff=None,
     263                   patch_file_object=None,
    264264                   patch_description=None,
    265265                   cc=None,
    … …  
    303303    def add_patch_to_bug(self,
    304304                         bug_id,
    305                          diff,
     305                         patch_file_object,
    306306                         description,
    307307                         comment_text=None,

  • trunk/WebKitTools/Scripts/webkitpy/tool/steps/abstractstep.py

    r58014 r58023  
    4040        log("Running %s" % script_name)
    4141        # FIXME: This should use self.port()
    42         self._tool.executive.run_and_throw_if_fail([port.script_path(script_name)], quiet)
     42        self._tool.executive.run_and_throw_if_fail(port.script_path(script_name), quiet)
    4343
    4444    # FIXME: The port should live on the tool.

  • trunk/WebKitTools/Scripts/webkitpy/tool/steps/postdiff.py

    r58014 r58023  
    2727# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2828
     29import StringIO
     30
    2931from webkitpy.tool.steps.abstractstep import AbstractStep
    3032from webkitpy.tool.steps.options import Options
    … …  
    4345    def run(self, state):
    4446        diff = self.cached_lookup(state, "diff")
     47        diff_file = StringIO.StringIO(diff) # add_patch_to_bug expects a file-like object
    4548        description = self._options.description or "Patch"
    4649        comment_text = None
    … …  
    5053        if codereview_issue:
    5154            description += "-%s" % state["codereview_issue"]
    52         self._tool.bugs.add_patch_to_bug(state["bug_id"], diff, description, comment_text=comment_text, mark_for_review=self._options.review, mark_for_commit_queue=self._options.request_commit)
     55        self._tool.bugs.add_patch_to_bug(state["bug_id"], diff_file, description, comment_text=comment_text, mark_for_review=self._options.review, mark_for_commit_queue=self._options.request_commit)
    5356        if self._options.open_bug:
    5457            self._tool.user.open_url(self._tool.bugs.bug_url_for_bug_id(state["bug_id"]))

  • trunk/WebKitTools/Scripts/webkitpy/tool/steps/postdiffforcommit.py

    r58014 r58023  
    2727# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2828
     29import StringIO
     30
    2931from webkitpy.tool.steps.abstractstep import AbstractStep
    3032
    … …  
    3436        self._tool.bugs.add_patch_to_bug(
    3537            state["bug_id"],
    36             self.cached_lookup(state, "diff"),
     38            StringIO.StringIO(self.cached_lookup(state, "diff")),
    3739            "Patch for landing",
    3840            mark_for_review=False,

  • trunk/WebKitTools/Scripts/webkitpy/tool/steps/postdiffforrevert.py

    r58014 r58023  
    2727# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2828
     29import StringIO
     30
    2931from webkitpy.common.net.bugzilla import Attachment
    3032from webkitpy.tool.steps.abstractstep import AbstractStep
    … …  
    4345        self._tool.bugs.add_patch_to_bug(
    4446            state["bug_id"],
    45             self.cached_lookup(state, "diff"),
     47            StringIO.StringIO(self.cached_lookup(state, "diff")),
    4648            "%s%s" % (Attachment.rollout_preamble, state["revision"]),
    4749            comment_text=comment_text,

  • trunk/WebKitTools/Scripts/webkitpy/tool/steps/steps_unittest.py

    r58014 r58023  
    4949        options = Mock()
    5050        options.update = True
    51         expected_stderr = "Updating working directory\n"
    52         OutputCapture().assert_outputs(self, self._run_step, [Update, options], expected_stderr=expected_stderr)
     51        self._run_step(Update, options)
    5352
    5453    def test_prompt_for_bug_or_title_step(self):
Note: See TracChangeset for help on using the changeset viewer.