Changeset 264949 in webkit


Ignore:
Timestamp:
Jul 27, 2020 3:11:26 PM (4 years ago)
Author:
Jonathan Bedard
Message:

[webkitcorepy] Add string_utils (Part 2)
​https://bugs.webkit.org/show_bug.cgi?id=214405

Reviewed by Dewei Zhu.

Use webkitcorepy.string_utils instead of unicode_compatibility for unicode conversions.

  • Scripts/webkitpy/api_tests/runner.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/bindings/main.py: Replace unicode_compatibility with string_utils,

remove unused imports.

  • Scripts/webkitpy/common/checkout/changelog.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/common/checkout/changelog_unittest.py: Make imports explicit.
  • Scripts/webkitpy/common/checkout/checkout.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/common/checkout/checkout_unittest.py: Replace unicode_compatibility with

string_utils, remove unused imports

  • Scripts/webkitpy/common/checkout/diff_parser_unittest.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/common/checkout/scm/git.py: Replace unicode_compatibility with string_utils,

remove unused imports.

  • Scripts/webkitpy/common/checkout/scm/scm.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/common/checkout/scm/scm_unittest.py: Replace unicode_compatibility with string_utils,

remove unused imports.

  • Scripts/webkitpy/common/checkout/scm/svn.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/common/config/committers.py: Replace unicode_compatibility with string_utils,

remove unused imports.

  • Scripts/webkitpy/common/net/bugzilla/bugzilla.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/common/net/bugzilla/bugzilla_unittest.py: Replace unicode_compatibility with

string_utils, remove unused imports.

  • Scripts/webkitpy/common/net/buildbot/buildbot.py: Ditto.
  • Scripts/webkitpy/common/net/ewsserver.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/common/net/web_mock.py: Ditto.
  • Scripts/webkitpy/common/prettypatch.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/common/read_checksum_from_png.py: Ditto.
  • Scripts/webkitpy/common/read_checksum_from_png_unittest.py: Ditto
  • Scripts/webkitpy/common/system/abstractexecutive.py: Ditto.
  • Scripts/webkitpy/common/system/crashlogs.py: Ditto.
  • Scripts/webkitpy/common/system/crashlogs_unittest.py: Ditto.
  • Scripts/webkitpy/common/system/executive.py: Ditto.
  • Scripts/webkitpy/common/system/executive_mock.py: Ditto.
  • Scripts/webkitpy/common/system/executive_unittest.py: Replace unicode_compatibility with string_utils,

remove unused imports.

  • Scripts/webkitpy/common/system/filesystem.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/common/system/filesystem_mock.py: Replace unicode_compatibility with string_utils,

remove unused imports.

  • Scripts/webkitpy/common/system/outputcapture.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/common/system/outputtee_unittest.py: Ditto.
  • Scripts/webkitpy/common/wavediff.py: Replace unicode_compatibility with string_utils, remove

unused imports.

  • Scripts/webkitpy/layout_tests/controllers/single_test_runner.py: Replace unicode_compatibility with

string_utils, remove unused imports.

  • Scripts/webkitpy/layout_tests/lint_test_expectations_unittest.py: Replace unicode_compatibility with

string_utils.

  • Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py: Ditto.
  • Scripts/webkitpy/layout_tests/views/buildbot_results_unittest.py: Replace unicode_compatibility with

string_utils, remove unused imports.

  • Scripts/webkitpy/layout_tests/views/metered_stream_unittest.py: Replace unicode_compatibility with

string_utils.

  • Scripts/webkitpy/layout_tests/views/printing_unittest.py: Replace unicode_compatibility with

string_utils, remove unused imports.

  • Scripts/webkitpy/performance_tests/perftest_unittest.py: Remove unused imports.
  • Scripts/webkitpy/performance_tests/perftestsrunner_integrationtest.py: Ditto.
  • Scripts/webkitpy/performance_tests/perftestsrunner_unittest.py: Replace unicode_compatibility with

string_utils, remove unused imports.

  • Scripts/webkitpy/port/base.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/port/driver.py: Replace unicode_compatibility with string_utils, remove unused imports.
  • Scripts/webkitpy/port/image_diff.py: Ditto.
  • Scripts/webkitpy/port/leakdetector.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/port/leakdetector_valgrind.py: Replace unicode_compatibility with string_utils, remove

unused imports.

  • Scripts/webkitpy/port/leakdetector_valgrind_unittest.py: Ditto.
  • Scripts/webkitpy/port/linux_get_crash_log.py: Ditto.
  • Scripts/webkitpy/port/mock_drt.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/port/mock_drt_unittest.py: Replace unicode_compatibility with string_utils, remove

unused imports.

  • Scripts/webkitpy/port/server_process.py: Ditto.
  • Scripts/webkitpy/port/server_process_mock.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/port/test.py: Ditto.
  • Scripts/webkitpy/results/upload_unittest.py: Ditto.
  • Scripts/webkitpy/style/checkers/cpp.py: Replace unicode_compatibility with string_utils, remove

unused imports.

  • Scripts/webkitpy/style/checkers/cpp_unittest.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/style/checkers/python.py: Ditto.
  • Scripts/webkitpy/style/patchreader.py: Ditto.
  • Scripts/webkitpy/test/main.py: Replace unicode_compatibility with string_utils, remove unused imports.
  • Scripts/webkitpy/test/main_unittest.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/test/printer.py: Ditto.
  • Scripts/webkitpy/test/runner_unittest.py: Ditto.
  • Scripts/webkitpy/test/skip_unittest.py: Ditto.
  • Scripts/webkitpy/tool/bot/irc_command.py: Replace unicode_compatibility with string_utils, remove

unused imports.

  • Scripts/webkitpy/tool/commands/earlywarningsystem.py: Ditto.
  • Scripts/webkitpy/tool/commands/queues.py: Remove unused imports.
  • Scripts/webkitpy/tool/commands/queues_unittest.py: Ditto.
  • Scripts/webkitpy/tool/steps/haslanded.py: Replace unicode_compatibility with string_utils, remove

unused imports.

  • Scripts/webkitpy/w3c/test_converter_unittest.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/w3c/test_exporter.py: Replace unicode_compatibility with string_utils, remove unused

imports.

  • Scripts/webkitpy/w3c/wpt_github.py: Replace unicode_compatibility with string_utils.
  • Scripts/webkitpy/w3c/wpt_github_unittest.py: Replace unicode_compatibility with string_utils, remove

unused imports.

  • Scripts/webkitpy/xcode/simulated_device_unittest.py: Replace unicode_compatibility with string_utils.
Location:
trunk/Tools
Files:
73 edited

Legend:

Unmodified
Added
Removed

  • trunk/Tools/ChangeLog

    r264947 r264949  
     12020-07-27  Jonathan Bedard  <jbedard@apple.com>
     2
     3        [webkitcorepy] Add string_utils (Part 2)
     4        https://bugs.webkit.org/show_bug.cgi?id=214405
     5
     6        Reviewed by Dewei Zhu.
     7
     8        Use webkitcorepy.string_utils instead of unicode_compatibility for unicode conversions.
     9
     10        * Scripts/webkitpy/api_tests/runner.py: Replace unicode_compatibility with string_utils.
     11        * Scripts/webkitpy/bindings/main.py: Replace unicode_compatibility with string_utils,
     12        remove unused imports.
     13        * Scripts/webkitpy/common/checkout/changelog.py: Replace unicode_compatibility with string_utils.
     14        * Scripts/webkitpy/common/checkout/changelog_unittest.py: Make imports explicit.
     15        * Scripts/webkitpy/common/checkout/checkout.py: Replace unicode_compatibility with string_utils.
     16        * Scripts/webkitpy/common/checkout/checkout_unittest.py: Replace unicode_compatibility with
     17        string_utils, remove unused imports
     18        * Scripts/webkitpy/common/checkout/diff_parser_unittest.py: Replace unicode_compatibility with string_utils.
     19        * Scripts/webkitpy/common/checkout/scm/git.py: Replace unicode_compatibility with string_utils,
     20        remove unused imports.
     21        * Scripts/webkitpy/common/checkout/scm/scm.py: Replace unicode_compatibility with string_utils.
     22        * Scripts/webkitpy/common/checkout/scm/scm_unittest.py: Replace unicode_compatibility with string_utils,
     23        remove unused imports.
     24        * Scripts/webkitpy/common/checkout/scm/svn.py: Replace unicode_compatibility with string_utils.
     25        * Scripts/webkitpy/common/config/committers.py: Replace unicode_compatibility with string_utils,
     26        remove unused imports.
     27        * Scripts/webkitpy/common/net/bugzilla/bugzilla.py: Replace unicode_compatibility with string_utils.
     28        * Scripts/webkitpy/common/net/bugzilla/bugzilla_unittest.py: Replace unicode_compatibility with
     29        string_utils, remove unused imports.
     30        * Scripts/webkitpy/common/net/buildbot/buildbot.py: Ditto.
     31        * Scripts/webkitpy/common/net/ewsserver.py: Replace unicode_compatibility with string_utils.
     32        * Scripts/webkitpy/common/net/web_mock.py: Ditto.
     33        * Scripts/webkitpy/common/prettypatch.py: Replace unicode_compatibility with string_utils.
     34        * Scripts/webkitpy/common/read_checksum_from_png.py: Ditto.
     35        * Scripts/webkitpy/common/read_checksum_from_png_unittest.py: Ditto
     36        * Scripts/webkitpy/common/system/abstractexecutive.py: Ditto.
     37        * Scripts/webkitpy/common/system/crashlogs.py: Ditto.
     38        * Scripts/webkitpy/common/system/crashlogs_unittest.py: Ditto.
     39        * Scripts/webkitpy/common/system/executive.py: Ditto.
     40        * Scripts/webkitpy/common/system/executive_mock.py: Ditto.
     41        * Scripts/webkitpy/common/system/executive_unittest.py: Replace unicode_compatibility with string_utils,
     42        remove unused imports.
     43        * Scripts/webkitpy/common/system/filesystem.py: Replace unicode_compatibility with string_utils.
     44        * Scripts/webkitpy/common/system/filesystem_mock.py: Replace unicode_compatibility with string_utils,
     45        remove unused imports.
     46        * Scripts/webkitpy/common/system/outputcapture.py: Replace unicode_compatibility with string_utils.
     47        * Scripts/webkitpy/common/system/outputtee_unittest.py: Ditto.
     48        * Scripts/webkitpy/common/wavediff.py: Replace unicode_compatibility with string_utils, remove
     49        unused imports.
     50        * Scripts/webkitpy/layout_tests/controllers/single_test_runner.py: Replace unicode_compatibility with
     51        string_utils, remove unused imports.
     52        * Scripts/webkitpy/layout_tests/lint_test_expectations_unittest.py: Replace unicode_compatibility with
     53        string_utils.
     54        * Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py: Ditto.
     55        * Scripts/webkitpy/layout_tests/views/buildbot_results_unittest.py: Replace unicode_compatibility with
     56        string_utils, remove unused imports.
     57        * Scripts/webkitpy/layout_tests/views/metered_stream_unittest.py: Replace unicode_compatibility with
     58        string_utils.
     59        * Scripts/webkitpy/layout_tests/views/printing_unittest.py: Replace unicode_compatibility with
     60        string_utils, remove unused imports.
     61        * Scripts/webkitpy/performance_tests/perftest_unittest.py: Remove unused imports.
     62        * Scripts/webkitpy/performance_tests/perftestsrunner_integrationtest.py: Ditto.
     63        * Scripts/webkitpy/performance_tests/perftestsrunner_unittest.py: Replace unicode_compatibility with
     64        string_utils, remove unused imports.
     65        * Scripts/webkitpy/port/base.py: Replace unicode_compatibility with string_utils.
     66        * Scripts/webkitpy/port/driver.py: Replace unicode_compatibility with string_utils, remove unused imports.
     67        * Scripts/webkitpy/port/image_diff.py: Ditto.
     68        * Scripts/webkitpy/port/leakdetector.py: Replace unicode_compatibility with string_utils.
     69        * Scripts/webkitpy/port/leakdetector_valgrind.py: Replace unicode_compatibility with string_utils, remove
     70        unused imports.
     71        * Scripts/webkitpy/port/leakdetector_valgrind_unittest.py: Ditto.
     72        * Scripts/webkitpy/port/linux_get_crash_log.py: Ditto.
     73        * Scripts/webkitpy/port/mock_drt.py: Replace unicode_compatibility with string_utils.
     74        * Scripts/webkitpy/port/mock_drt_unittest.py: Replace unicode_compatibility with string_utils, remove
     75        unused imports.
     76        * Scripts/webkitpy/port/server_process.py: Ditto.
     77        * Scripts/webkitpy/port/server_process_mock.py: Replace unicode_compatibility with string_utils.
     78        * Scripts/webkitpy/port/test.py: Ditto.
     79        * Scripts/webkitpy/results/upload_unittest.py: Ditto.
     80        * Scripts/webkitpy/style/checkers/cpp.py: Replace unicode_compatibility with string_utils, remove
     81        unused imports.
     82        * Scripts/webkitpy/style/checkers/cpp_unittest.py: Replace unicode_compatibility with string_utils.
     83        * Scripts/webkitpy/style/checkers/python.py: Ditto.
     84        * Scripts/webkitpy/style/patchreader.py: Ditto.
     85        * Scripts/webkitpy/test/main.py: Replace unicode_compatibility with string_utils, remove unused imports.
     86        * Scripts/webkitpy/test/main_unittest.py: Replace unicode_compatibility with string_utils.
     87        * Scripts/webkitpy/test/printer.py: Ditto.
     88        * Scripts/webkitpy/test/runner_unittest.py: Ditto.
     89        * Scripts/webkitpy/test/skip_unittest.py: Ditto.
     90        * Scripts/webkitpy/tool/bot/irc_command.py: Replace unicode_compatibility with string_utils, remove
     91        unused imports.
     92        * Scripts/webkitpy/tool/commands/earlywarningsystem.py: Ditto.
     93        * Scripts/webkitpy/tool/commands/queues.py: Remove unused imports.
     94        * Scripts/webkitpy/tool/commands/queues_unittest.py: Ditto.
     95        * Scripts/webkitpy/tool/steps/haslanded.py: Replace unicode_compatibility with string_utils, remove
     96        unused imports.
     97        * Scripts/webkitpy/w3c/test_converter_unittest.py: Replace unicode_compatibility with string_utils.
     98        * Scripts/webkitpy/w3c/test_exporter.py: Replace unicode_compatibility with string_utils, remove unused
     99        imports.
     100        * Scripts/webkitpy/w3c/wpt_github.py: Replace unicode_compatibility with string_utils.
     101        * Scripts/webkitpy/w3c/wpt_github_unittest.py: Replace unicode_compatibility with string_utils, remove
     102        unused imports.
     103        * Scripts/webkitpy/xcode/simulated_device_unittest.py: Replace unicode_compatibility with string_utils.
     104
    11052020-07-27  Sihui Liu  <sihui_liu@appe.com>
    2106

  • trunk/Tools/Scripts/webkitpy/api_tests/runner.py

    r252616 r264949  
    2525import time
    2626
     27from webkitcorepy import string_utils
     28
    2729from webkitpy.common import message_pool
    2830from webkitpy.common.iteration_compatibility import iteritems
    2931from webkitpy.port.server_process import ServerProcess, _log as server_process_logger
    3032from webkitpy.xcode.simulated_device import SimulatedDeviceManager
    31 from webkitpy.common.unicode_compatibility import decode_for
    3233
    3334
    … …  
    180181
    181182                if stderr_line:
    182                     stderr_line = decode_for(stderr_line, str)
     183                    stderr_line = string_utils.decode(stderr_line, target_type=str)
    183184                    stderr_buffer += stderr_line
    184185                    self.post('log', output=stderr_line[:-1])
    185186                if stdout_line:
    186                     stdout_line = decode_for(stdout_line, str)
     187                    stdout_line = string_utils.decode(stdout_line, target_type=str)
    187188                    if '**PASS**' in stdout_line:
    188189                        status = Runner.STATUS_PASSED
    … …  
    203204
    204205        finally:
    205             remaining_stderr = decode_for(server_process.pop_all_buffered_stderr(), str)
    206             remaining_stdout = decode_for(server_process.pop_all_buffered_stdout(), str)
     206            remaining_stderr = string_utils.decode(server_process.pop_all_buffered_stderr(), target_type=str)
     207            remaining_stdout = string_utils.decode(server_process.pop_all_buffered_stdout(), target_type=str)
    207208            self.post('log', output=remaining_stderr + remaining_stdout)
    208209            output_buffer = stderr_buffer + stdout_buffer + remaining_stderr + remaining_stdout

  • trunk/Tools/Scripts/webkitpy/bindings/main.py

    r260484 r264949  
    2828import os.path
    2929import shutil
    30 import subprocess
    3130import sys
    3231import tempfile
     32
     33from webkitcorepy import string_utils
     34
    3335from webkitpy.common.checkout.scm.detection import detect_scm_system
    3436from webkitpy.common.system.executive import ScriptError
    35 from webkitpy.common.unicode_compatibility import encode_if_necessary
    3637
    3738
    … …  
    7879            if extension != '.idl':
    7980                continue
    80             os.write(idl_files_list[0], encode_if_necessary(os.path.join(input_directory, input_file) + "\n"))
     81            os.write(idl_files_list[0], string_utils.encode(os.path.join(input_directory, input_file) + "\n"))
    8182        os.close(idl_files_list[0])
    8283

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

    r252489 r264949  
    3333import textwrap
    3434
     35from webkitcorepy import StringIO, unicode
     36
    3537from webkitpy.common.config.committers import CommitterList
    3638from webkitpy.common.system.filesystem import FileSystem
    37 from webkitpy.common.unicode_compatibility import StringIO, unicode
    3839import webkitpy.common.config.urls as config_urls
    3940

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

    r261408 r264949  
    3131
    3232from webkitpy.common.system.filesystem_mock import MockFileSystem
    33 from webkitpy.common.unicode_compatibility import StringIO
    34 from webkitpy.common.checkout.changelog import *
     33from webkitpy.common.checkout.changelog import ChangeLog, ChangeLogEntry, CommitterList, parse_bug_id_from_changelog
     34from webkitcorepy import StringIO
    3535
    3636

  • trunk/Tools/Scripts/webkitpy/common/checkout/checkout.py

    r251613 r264949  
    2929import sys
    3030
    31 if sys.version_info > (3, 0):
    32     from functools import reduce
     31from webkitcorepy import StringIO
    3332
    3433from webkitpy.common.config import urls
    … …  
    3837from webkitpy.common.memoized import memoized
    3938from webkitpy.common.system.executive import ScriptError
    40 from webkitpy.common.unicode_compatibility import StringIO
     39
     40if sys.version_info > (3, 0):
     41    from functools import reduce
    4142
    4243

  • trunk/Tools/Scripts/webkitpy/common/checkout/checkout_unittest.py

    r258097 r264949  
    2727# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2828
    29 import codecs
    3029import os
    31 import shutil
    32 import tempfile
    3330import unittest
     31
     32from webkitcorepy import string_utils
    3433
    3534from webkitpy.common.checkout.checkout import Checkout
    … …  
    4342from webkitpy.common.system.executive_mock import MockExecutive
    4443from webkitpy.common.system.outputcapture import OutputCapture
    45 from webkitpy.common.unicode_compatibility import encode_if_necessary
    4644from webkitpy.thirdparty.mock import Mock
    4745
    … …  
    345343            # The ChangeLog utf-8 decoding should ignore invalid codepoints.
    346344            invalid_utf8 = b'\255'
    347             return encode_if_necessary(_changelog1) + invalid_utf8
     345            return string_utils.encode(_changelog1) + invalid_utf8
    348346        checkout = self._make_checkout()
    349347        checkout._scm.contents_at_revision = mock_contents_at_revision

  • trunk/Tools/Scripts/webkitpy/common/checkout/diff_parser_unittest.py

    r251613 r264949  
    3030import unittest
    3131
     32from webkitcorepy import StringIO
     33
    3234import webkitpy.common.checkout.diff_parser as diff_parser
    33 
    34 from webkitpy.common.unicode_compatibility import StringIO
    3535from webkitpy.common.checkout.diff_test_data import DIFF_TEST_DATA
    3636

  • trunk/Tools/Scripts/webkitpy/common/checkout/scm/git.py

    r258897 r264949  
    3030import datetime
    3131import logging
    32 import os
    3332import re
     33
     34from webkitcorepy import string_utils
    3435
    3536from webkitpy.common.memoized import memoized
    … …  
    3940from webkitpy.common.checkout.scm.scm import AuthenticationError, SCM, commit_error_handler
    4041from webkitpy.common.checkout.scm.svn import SVNRepository
    41 from webkitpy.common.unicode_compatibility import decode_for, encode_if_necessary
    4242
    4343_log = logging.getLogger(__name__)
    … …  
    349349            return diff
    350350
    351         return encode_if_necessary("Subversion Revision: ") + encode_if_necessary(revision) + encode_if_necessary('\n') + encode_if_necessary(diff)
     351        return string_utils.encode("Subversion Revision: ") + string_utils.encode(revision) + string_utils.encode('\n') + string_utils.encode(diff)
    352352
    353353    def create_patch(self, git_commit=None, changed_files=None, git_index=False):

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

    r254359 r264949  
    3434import sys
    3535
     36from webkitcorepy import unicode
     37
    3638from webkitpy.common.system.executive import Executive, ScriptError
    3739from webkitpy.common.system.filesystem import FileSystem
    38 from webkitpy.common.unicode_compatibility import unicode
    3940
    4041_log = logging.getLogger(__name__)

  • trunk/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py

    r264425 r264949  
    5757from webkitpy.common.checkout.scm.git import Git, AmbiguousCommitError
    5858from webkitpy.common.checkout.scm.detection import detect_scm_system
    59 from webkitpy.common.checkout.scm.scm import SCM, CheckoutNeedsUpdate, commit_error_handler, AuthenticationError
     59from webkitpy.common.checkout.scm.scm import CheckoutNeedsUpdate, commit_error_handler, AuthenticationError
    6060from webkitpy.common.checkout.scm.svn import SVN
    61 from webkitpy.common.unicode_compatibility import decode_if_necessary
    6261
    6362

  • trunk/Tools/Scripts/webkitpy/common/checkout/scm/svn.py

    r264425 r264949  
    3737import tempfile
    3838
    39 from webkitcorepy import Version
     39from webkitcorepy import Version, string_utils
    4040
    4141from webkitpy.common.checkout.scm.scm import AuthenticationError, SCM, commit_error_handler
    … …  
    4444from webkitpy.common.system.executive import Executive, ScriptError
    4545from webkitpy.common.webkit_finder import WebKitFinder
    46 from webkitpy.common.unicode_compatibility import encode_if_necessary
    4746
    4847
    … …  
    417416    def propget(self, pname, path):
    418417        dir, base = os.path.split(path)
    419         return encode_if_necessary(self._run_svn(['pget', pname, base], cwd=dir).rstrip("\n"))
     418        return string_utils.encode(self._run_svn(['pget', pname, base], cwd=dir).rstrip("\n"))

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

    r251613 r264949  
    3434import sys
    3535
     36from webkitcorepy import string_utils, unicode
     37
    3638from functools import reduce
    3739from webkitpy.common.editdistance import edit_distance
    38 from webkitpy.common.memoized import memoized
    3940from webkitpy.common.system.filesystem import FileSystem
    40 from webkitpy.common.unicode_compatibility import encode_for, unicode
    4141
    4242
    … …  
    7474
    7575    def __str__(self):
    76         return encode_for(u'"{}" <{}>'.format(unicode(self.full_name), unicode(self.emails[0])), str)
     76        return string_utils.encode(u'"{}" <{}>'.format(unicode(self.full_name), unicode(self.emails[0])), target_type=str)
    7777
    7878    def __unicode__(self):

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

    r262775 r264949  
    4040
    4141from datetime import datetime  # used in timestamp()
    42 
    43 from webkitpy.common.unicode_compatibility import BytesIO, StringIO, unicode, decode_for
    44 from webkitpy.common.net.bugzilla.attachment import Attachment
     42from webkitcorepy import BytesIO, StringIO, string_utils, unicode
     43
    4544from webkitpy.common.net.bugzilla.bug import Bug
    4645
    … …  
    296295        review_queue_url = "request.cgi?action=queue&requester=%s&product=&type=review&requestee=&component=&group=requestee" % urllib.quote(search_string)
    297296        results_page = self._load_query(review_queue_url)
    298         return bool(re.search('did not match anything', decode_for(results_page.read(), str)))
     297        return bool(re.search('did not match anything', string_utils.decode(results_page.read(), target_type=str)))
    299298
    300299
    … …  
    566565            # "invalid" assume it's the login failure page.
    567566            if match and re.search(b'Invalid', match.group(1), re.IGNORECASE):
    568                 errorMessage = "Bugzilla login failed: {}".format(decode_for(match.group(1), str))
     567                errorMessage = "Bugzilla login failed: {}".format(string_utils.decode(match.group(1), target_type=str))
    569568                # raise an exception only if this was the last attempt
    570569                if attempts < 5:
    … …  
    641640    @staticmethod
    642641    def _parse_attachment_id_from_add_patch_to_bug_response(response_html):
    643         response_html = decode_for(response_html, str)
     642        response_html = string_utils.decode(response_html, target_type=str)
    644643        match = re.search('<title>Attachment (?P<attachment_id>\d+) added to Bug \d+</title>', response_html)
    645644        if match:
    … …  
    685684    # FIXME: There has to be a more concise way to write this method.
    686685    def _check_create_bug_response(self, response_html):
    687         response_html = decode_for(response_html, str)
     686        response_html = string_utils.decode(response_html, target_type=str)
    688687        match = re.search('<title>Bug (?P<bug_id>\d+) Submitted[^<]*</title>', response_html)
    689688        if match:

  • trunk/Tools/Scripts/webkitpy/common/net/bugzilla/bugzilla_unittest.py

    r262775 r264949  
    2828
    2929import datetime
    30 import sys
    3130import unittest
     31
     32from webkitcorepy import StringIO
    3233
    3334from webkitpy.common.config import urls
    … …  
    3637from webkitpy.common.net.bugzilla.bugzilla import Bugzilla, BugzillaQueries, CommitQueueFlag, EditUsersParser
    3738from webkitpy.common.system.outputcapture import OutputCapture
    38 from webkitpy.common.unicode_compatibility import StringIO
    3939from webkitpy.thirdparty.BeautifulSoup import BeautifulSoup
    4040from webkitpy.thirdparty.mock import Mock

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

    r251259 r264949  
    2929
    3030import json
    31 import operator
    3231import re
    3332import sys
    34 import urllib
     33
     34from webkitcorepy import string_utils, unicode
    3535
    3636import webkitpy.common.config.urls as config_urls
    … …  
    4141from webkitpy.common.net.regressionwindow import RegressionWindow
    4242from webkitpy.common.system.logutils import get_logger
    43 from webkitpy.common.unicode_compatibility import decode_for, unicode
    4443from webkitpy.thirdparty.autoinstalled.mechanize import Browser
    4544from webkitpy.thirdparty.BeautifulSoup import BeautifulSoup
    … …  
    5150else:
    5251    from urllib2 import HTTPError, quote, URLError, urlopen
    53 
    5452
    5553
    … …  
    320318            # work around the Qts bot being on a broken internet connection.
    321319            # The real fix is https://bugs.webkit.org/show_bug.cgi?id=37099
    322             builder['is_green'] = not re.search('fail', decode_for(cell.renderContents(), str)) or \
    323                                  bool(re.search('lost', decode_for(cell.renderContents(), str)))
     320            builder['is_green'] = not re.search('fail', string_utils.decode(cell.renderContents(), target_type=str)) or \
     321                bool(re.search('lost', string_utils.decode(cell.renderContents(), target_type=str)))
    324322
    325323            status_link_regexp = r"builders/(?P<builder_name>.*)/builds/(?P<build_number>\d+)"
    … …  
    337335    def _parse_current_build_cell(self, builder, cell):
    338336        # Convert rendered contents to native string
    339         rendered = decode_for(cell.renderContents(), str)
     337        rendered = string_utils.decode(cell.renderContents(), target_type=str)
    340338
    341339        # BeautifulSoup and bs4 render differently

  • trunk/Tools/Scripts/webkitpy/common/net/ewsserver.py

    r251374 r264949  
    2121# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2222
     23from webkitcorepy import unicode
     24
    2325from webkitpy.common.config.urls import ewsserver_default_host
    2426from webkitpy.common.net.networktransaction import NetworkTransaction
    25 from webkitpy.common.unicode_compatibility import unicode
    2627
    2728import logging

  • trunk/Tools/Scripts/webkitpy/common/net/web_mock.py

    r251112 r264949  
    2828# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2929
    30 from webkitpy.common.unicode_compatibility import StringIO
     30from webkitcorepy import StringIO
    3131
    3232import sys

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

    r253128 r264949  
    3131import os
    3232import tempfile
     33
     34from webkitcorepy import string_utils
     35
    3336from webkitpy.common.system.executive import ScriptError
    34 from webkitpy.common.unicode_compatibility import encode_if_necessary
    3537
    3638_log = logging.getLogger(__name__)
    … …  
    5153        # Diffs can contain multiple text files of different encodings
    5254        # so we always deal with them as byte arrays, not unicode strings.
    53         diff = encode_if_necessary(diff)
    54         pretty_diff = encode_if_necessary(self.pretty_diff(diff))
     55        diff = string_utils.encode(diff)
     56        pretty_diff = string_utils.encode(self.pretty_diff(diff))
    5557        diff_file = tempfile.NamedTemporaryFile(suffix=".html")
    5658        diff_file.write(pretty_diff)

  • trunk/Tools/Scripts/webkitpy/common/read_checksum_from_png.py

    r252443 r264949  
    2828
    2929
    30 from webkitpy.common.unicode_compatibility import encode_if_necessary, decode_for
     30from webkitcorepy import string_utils
    3131
    3232def read_checksum(filehandle):
    3333    # We expect the comment to be at the beginning of the file.
    34     data = encode_if_necessary(filehandle.read(2048))
     34    data = string_utils.encode(filehandle.read(2048))
    3535    comment_key = b'tEXtchecksum\x00'
    3636    comment_pos = data.find(comment_key)
    … …  
    3939
    4040    checksum_pos = comment_pos + len(comment_key)
    41     return decode_for(data[checksum_pos:checksum_pos + 32], str)
     41    return string_utils.decode(data[checksum_pos:checksum_pos + 32], target_type=str)

  • trunk/Tools/Scripts/webkitpy/common/read_checksum_from_png_unittest.py

    r251955 r264949  
    2323
    2424import unittest
     25
     26from webkitcorepy import StringIO
     27
    2528from webkitpy.common import read_checksum_from_png
    26 from webkitpy.common.unicode_compatibility import StringIO
    2729
    2830

  • trunk/Tools/Scripts/webkitpy/common/system/abstractexecutive.py

    r263649 r264949  
    2424import time
    2525
     26from webkitcorepy import string_utils, unicode
     27
    2628from webkitpy.common.system.filesystem import FileSystem
    27 from webkitpy.common import unicode_compatibility
    2829
    2930class AbstractExecutive(object):
    … …  
    102103
    103104    def _stringify_args(self, args):
    104         return map(unicode_compatibility.unicode, args)
     105        return map(unicode, args)
    105106
    106107    def command_for_printing(self, args):
    … …  
    108109        The string should be copy/paste ready for execution in a shell."""
    109110        args = self._stringify_args(args)
    110         return unicode_compatibility.decode_if_necessary(unicode_compatibility.encode_if_necessary(' '.join(args), 'unicode_escape'))
     111        return string_utils.decode(string_utils.encode(' '.join(args), encoding='unicode_escape'))
    111112
    112113    def run_command(self, args, cwd=None, env=None, input=None, stdout=None, error_handler=None, ignore_errors=False,

  • trunk/Tools/Scripts/webkitpy/common/system/crashlogs.py

    r250375 r264949  
    3232import re
    3333
    34 from webkitpy.common import unicode_compatibility
     34from webkitcorepy import string_utils
    3535
    3636
    … …  
    112112            try:
    113113                if not newer_than or self._host.filesystem.mtime(path) > newer_than:
    114                     log_file = unicode_compatibility.decode_if_necessary(self._host.filesystem.read_binary_file(path), 'ascii', 'ignore')
     114                    log_file = string_utils.decode(self._host.filesystem.read_binary_file(path), encoding='ascii', errors='ignore')
    115115                    match = self.GLOBAL_PID_REGEX.search(log_file)
    116116                    if match:

  • trunk/Tools/Scripts/webkitpy/common/system/crashlogs_unittest.py

    r250375 r264949  
    2424import unittest
    2525
     26from webkitcorepy import string_utils
     27
    2628from webkitpy.common.system.crashlogs import CrashLogs
    2729from webkitpy.common.system.filesystem_mock import MockFileSystem
    2830from webkitpy.common.system.systemhost import SystemHost
    2931from webkitpy.common.system.systemhost_mock import MockSystemHost
    30 from webkitpy.common import unicode_compatibility
    3132
    3233# Needed to support Windows port tests
    … …  
    300301        self.files['/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150723_quadzen.crash'] = self.misformatted_mock_crash_report
    301302
    302         self.files = {key: unicode_compatibility.encode_if_necessary(value) for key, value in self.files.items()}
     303        self.files = {key: string_utils.encode(value) for key, value in self.files.items()}
    303304
    304305        self.filesystem = MockFileSystem(self.files)
    … …  
    318319
    319320        for test, crash_log in all_logs.items():
    320             self.assertTrue(crash_log in [unicode_compatibility.decode_if_necessary(value) for value in self.files.values()])
     321            self.assertTrue(crash_log in [string_utils.decode(value) for value in self.files.values()])
    321322            if test.split('-')[0] != 'Sandbox':
    322323                self.assertTrue(test == "Unknown" or int(test.split("-")[1]) in range(28527, 28531))

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

    r263649 r264949  
    3737import time
    3838
     39from webkitcorepy import StringIO, string_utils, unicode
     40
    3941from webkitpy.common.system.abstractexecutive import AbstractExecutive
    4042from webkitpy.common.system.outputtee import Tee
    41 from webkitpy.common import unicode_compatibility
    4243
    4344
    … …  
    7273                    (self, output_limit, self.output[-output_limit:])
    7374            return u"%s\n\n%s" % (self, self.output)
    74         return unicode_compatibility.unicode(self)
     75        return unicode(self)
    7576
    7677    def command_name(self):
    … …  
    128129            while child_process.poll() is None:
    129130                output_line = child_process.stdout.readline()
    130                 teed_output.write(unicode_compatibility.decode_for(output_line, str))
     131                teed_output.write(string_utils.decode(output_line, target_type=str))
    131132            return child_process.poll()
    132133
    … …  
    138139    def run_and_throw_if_fail(self, args, quiet=False, decode_output=True, **kwargs):
    139140        # Cache the child's output locally so it can be used for error reports.
    140         child_out_file = unicode_compatibility.StringIO()
     141        child_out_file = StringIO()
    141142        tee_stdout = sys.stdout
    142143        try:
    … …  
    154155
    155156        if decode_output:
    156             child_output = unicode_compatibility.decode_if_necessary(child_output, self._child_process_encoding())
     157            child_output = string_utils.decode(child_output, encoding=self._child_process_encoding())
    157158        else:
    158             child_output = unicode_compatibility.encode_if_necessary(child_output, self._child_process_encoding())
     159            child_output = string_utils.encode(child_output, encoding=self._child_process_encoding())
    159160
    160161        if exit_code:
    … …  
    307308                        # leading white-spaces, so strip it before split.
    308309                        pid, process_name = line.strip().split(b' ', 1)
    309                         if process_name_filter(unicode_compatibility.decode_for(process_name, str)):
     310                        if process_name_filter(string_utils.decode(process_name, target_type=str)):
    310311                            running_pids.append(int(pid))
    311312                    except ValueError as e:
    … …  
    375376        # for an example of a regresion caused by passing a unicode string directly.
    376377        # FIXME: We may need to encode differently on different platforms.
    377         input = unicode_compatibility.encode_if_necessary(input, self._child_process_encoding())
     378        input = string_utils.encode(input, encoding=self._child_process_encoding())
    378379        return (self.PIPE, input)
    379380
    … …  
    408409                output = process.communicate()[0]
    409410            else:
    410                 output = process.communicate(unicode_compatibility.encode_if_necessary(string_to_communicate, 'utf-8'))[0]
     411                output = process.communicate(string_utils.encode(string_to_communicate, encoding='utf-8'))[0]
    411412
    412413            # run_command automatically decodes to unicode() and converts CRLF to LF unless explicitly told not to.
    413414            if decode_output:
    414                 output = unicode_compatibility.decode_if_necessary(output, self._child_process_encoding()).replace('\r\n', '\n')
     415                output = string_utils.decode(output, encoding=self._child_process_encoding()).replace('\r\n', '\n')
    415416
    416417            # wait() is not threadsafe and can throw OSError due to:
    … …  
    465466        if not self._should_encode_child_process_arguments():
    466467            return argument
    467         return unicode_compatibility.encode_if_necessary(argument, self._child_process_encoding())
     468        return string_utils.encode(argument, encoding=self._child_process_encoding())
    468469
    469470    def _stringify_args(self, args):
    470471        # Popen will throw an exception if args are non-strings (like int())
    471         string_args = map(unicode_compatibility.unicode, args)
     472        string_args = map(unicode, args)
    472473        # The Windows implementation of Popen cannot handle unicode strings. :(
    473474        return map(self._encode_argument_if_needed, string_args)

  • trunk/Tools/Scripts/webkitpy/common/system/executive_mock.py

    r263649 r264949  
    3030import os
    3131
    32 from webkitpy.common.unicode_compatibility import BytesIO, decode_for, encode_if_necessary, unicode
     32from webkitcorepy import BytesIO, string_utils, unicode
     33
    3334from webkitpy.common.system.executive import ScriptError
    3435
    … …  
    3940    def __init__(self, stdout='MOCK STDOUT\n', stderr=''):
    4041        self.pid = 42
    41         self.stdout = BytesIO(encode_if_necessary(stdout))
    42         self.stderr = BytesIO(encode_if_necessary(stderr))
     42        self.stdout = BytesIO(string_utils.encode(stdout))
     43        self.stderr = BytesIO(string_utils.encode(stderr))
    4344        self.stdin = BytesIO()
    4445        self.returncode = 0
    … …  
    139140            input_string = ""
    140141            if input:
    141                 input_string = ", input=%s" % decode_for(input, str)
     142                input_string = ", input=%s" % string_utils.decode(input, target_type=str)
    142143            _log.info("MOCK run_command: %s, cwd=%s%s%s" % (args, cwd, env_string, input_string))
    143144        output = "MOCK output of child process"

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

    r253462 r264949  
    2929
    3030import os
    31 import errno
    3231import signal
    3332import subprocess
    … …  
    4746from webkitpy.common.system.executive import Executive, ScriptError
    4847from webkitpy.common.system.filesystem_mock import MockFileSystem
    49 from webkitpy.common import unicode_compatibility
     48
     49from webkitcorepy import string_utils
    5050
    5151
    … …  
    140140        else:
    141141            encoding = 'utf-8'
    142         encoded_tor = unicode_compatibility.encode_if_necessary(unicode_tor_input, encoding)
     142        encoded_tor = string_utils.encode(unicode_tor_input, encoding=encoding)
    143143        # On Windows, we expect the unicode->mbcs->unicode roundtrip to be
    144144        # lossy. On other platforms, we expect a lossless roundtrip.
    145145        if sys.platform.startswith('win'):
    146             unicode_tor_output = unicode_compatibility.decode_if_necessary(encoded_tor, encoding)
     146            unicode_tor_output = string_utils.decode(encoded_tor, encoding=encoding)
    147147        else:
    148148            unicode_tor_output = unicode_tor_input

  • trunk/Tools/Scripts/webkitpy/common/system/filesystem.py

    r252443 r264949  
    4040import time
    4141
    42 from webkitpy.common.unicode_compatibility import decode_if_necessary, encode_for
     42from webkitcorepy import string_utils
    4343
    4444
    … …  
    228228    def write_binary_file(self, path, contents):
    229229        with open(path, 'wb') as f:
    230             f.write(encode_for(contents, bytes))
     230            f.write(string_utils.encode(contents, target_type=bytes))
    231231
    232232    def open_text_file_for_reading(self, path, errors='strict'):
    … …  
    258258        The file is written encoded as UTF-8 with no BOM."""
    259259        with codecs.open(path, 'w', 'utf-8', errors=errors) as f:
    260             f.write(decode_if_necessary(contents, errors=errors))
     260            f.write(string_utils.decode(contents, errors=errors))
    261261
    262262    def sha1(self, path):

  • trunk/Tools/Scripts/webkitpy/common/system/filesystem_mock.py

    r253391 r264949  
    3131import os
    3232import re
    33 import sys
    34 
    35 from webkitpy.common import unicode_compatibility
    36 from webkitpy.common.system import path
     33
     34from webkitcorepy import UnicodeIO, string_utils
    3735
    3836class MockFileSystem(object):
    … …  
    4947                not exist.
    5048        """
    51         self.files = {name: unicode_compatibility.encode_if_necessary(contents) for name, contents in (files or {}).items()}
     49        self.files = {name: string_utils.encode(contents) for name, contents in (files or {}).items()}
    5250        self.written_files = {}
    5351        self.last_tmpdir = None
    … …  
    330328        # FIXME: should this assert if dirname(path) doesn't exist?
    331329        self.maybe_make_directory(self.dirname(path))
    332         self.files[path] = unicode_compatibility.encode_for(contents, bytes)
    333         self.written_files[path] = unicode_compatibility.encode_for(contents, bytes)
     330        self.files[path] = string_utils.encode(contents)
     331        self.written_files[path] = string_utils.encode(contents)
    334332
    335333    def open_text_file_for_reading(self, path, errors='strict'):
    … …  
    345343
    346344    def write_text_file(self, path, contents, errors='strict'):
    347         return self.write_binary_file(path, unicode_compatibility.encode_if_necessary(contents, 'utf-8', errors=errors))
     345        return self.write_binary_file(path, string_utils.encode(contents, encoding='utf-8', errors=errors))
    348346
    349347    def sha1(self, path):
    … …  
    454452
    455453    def write(self, string):
    456         self.fs.files[self.path] += unicode_compatibility.encode_if_necessary(string, 'utf-8')
     454        self.fs.files[self.path] += string_utils.encode(string, encoding='utf-8')
    457455        self.fs.written_files[self.path] = self.fs.files[self.path]
    458456
    … …  
    460458class WritableTextFileObject(WritableBinaryFileObject):
    461459    def write(self, str):
    462         WritableBinaryFileObject.write(self, unicode_compatibility.encode_if_necessary(str, 'utf-8'))
     460        WritableBinaryFileObject.write(self, string_utils.encode(str, encoding='utf-8'))
    463461
    464462
    … …  
    493491class ReadableTextFileObject(ReadableBinaryFileObject):
    494492    def __init__(self, fs, path, data):
    495         super(ReadableTextFileObject, self).__init__(fs, path, unicode_compatibility.UnicodeIO(unicode_compatibility.decode_for(data, unicode_compatibility.unicode)))
     493        super(ReadableTextFileObject, self).__init__(fs, path, UnicodeIO(string_utils.decode(data)))
    496494
    497495    def close(self):

  • trunk/Tools/Scripts/webkitpy/common/system/outputcapture.py

    r250375 r264949  
    3333import unittest
    3434
    35 from webkitpy.common.unicode_compatibility import StringIO
     35from webkitcorepy import StringIO
    3636
    3737

  • trunk/Tools/Scripts/webkitpy/common/system/outputtee_unittest.py

    r250375 r264949  
    2929import unittest
    3030
    31 from webkitpy.common.system.outputtee import Tee, OutputTee
    32 from webkitpy.common.unicode_compatibility import StringIO
     31from webkitcorepy import StringIO
     32
     33from webkitpy.common.system.outputtee import Tee
    3334
    3435

  • trunk/Tools/Scripts/webkitpy/common/wavediff.py

    r254340 r264949  
    2222
    2323import struct
    24 import sys
    25 import tempfile
    2624import wave
    2725
    28 from webkitpy.common.unicode_compatibility import BytesIO, StringIO
     26from webkitcorepy import BytesIO, StringIO
    2927
    3028

  • trunk/Tools/Scripts/webkitpy/layout_tests/controllers/single_test_runner.py

    r259667 r264949  
    3030import logging
    3131import re
    32 import time
    33 
    34 from webkitpy.common.unicode_compatibility import decode_for
     32
     33from webkitcorepy import string_utils
    3534from webkitpy.layout_tests.controllers import test_result_writer
    3635from webkitpy.port.driver import DriverInput, DriverOutput
    … …  
    216215            _log.debug("%s %s output stderr lines:" % (self._worker_name, testname))
    217216        for line in driver_output.error.splitlines():
    218             _log.debug("  {}".format(decode_for(line, str)))
     217            _log.debug("  {}".format(string_utils.decode(line, target_type=str)))
    219218        return failures
    220219

  • trunk/Tools/Scripts/webkitpy/layout_tests/lint_test_expectations_unittest.py

    r253219 r264949  
    3030import unittest
    3131
     32from webkitcorepy import StringIO
     33
    3234from webkitpy.common.host_mock import MockHost
    33 from webkitpy.common.unicode_compatibility import StringIO
    3435from webkitpy.layout_tests import lint_test_expectations
    3536

  • trunk/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py

    r261629 r264949  
    3333import unittest
    3434
    35 from webkitpy.common.unicode_compatibility import StringIO
     35from webkitcorepy import StringIO
     36
    3637from webkitpy.common.system import outputcapture, path
    3738from webkitpy.common.system.crashlogs_unittest import make_mock_crash_report_darwin
    … …  
    3940from webkitpy.common.host import Host
    4041from webkitpy.common.host_mock import MockHost
    41 from webkitpy.common.unicode_compatibility import StringIO
    42 
    4342from webkitpy.layout_tests import run_webkit_tests
    4443from webkitpy.layout_tests.models.test_run_results import INTERRUPTED_EXIT_STATUS

  • trunk/Tools/Scripts/webkitpy/layout_tests/views/buildbot_results_unittest.py

    r252560 r264949  
    2929import unittest
    3030
     31from webkitcorepy import StringIO
     32
    3133from webkitpy.common.host_mock import MockHost
    32 from webkitpy.common.unicode_compatibility import StringIO
    3334from webkitpy.tool.mocktool import MockOptions
    34 
    35 from webkitpy.layout_tests.models import test_expectations
    36 from webkitpy.layout_tests.models import test_failures
    37 from webkitpy.layout_tests.models import test_run_results
    3835from webkitpy.layout_tests.models import test_run_results
    3936from webkitpy.layout_tests.models import test_run_results_unittest

  • trunk/Tools/Scripts/webkitpy/layout_tests/views/metered_stream_unittest.py

    r252560 r264949  
    3434import unittest
    3535
    36 from webkitpy.common.unicode_compatibility import StringIO
     36from webkitcorepy import StringIO
     37
    3738from webkitpy.layout_tests.views.metered_stream import MeteredStream
    3839

  • trunk/Tools/Scripts/webkitpy/layout_tests/views/printing_unittest.py

    r252560 r264949  
    3131import optparse
    3232import sys
    33 import time
    3433import unittest
    3534
     35from webkitcorepy import StringIO
     36
    3637from webkitpy.common.host_mock import MockHost
    37 
    38 from webkitpy.common.system import logtesting
    39 from webkitpy.common.unicode_compatibility import StringIO
    40 from webkitpy import port
    41 from webkitpy.layout_tests.controllers import manager
    4238from webkitpy.layout_tests.models import test_expectations
    4339from webkitpy.layout_tests.models import test_failures

  • trunk/Tools/Scripts/webkitpy/performance_tests/perftest_unittest.py

    r253392 r264949  
    2727# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2828
    29 import json
    30 import math
    3129import unittest
    3230
    3331from webkitpy.common.host_mock import MockHost
    3432from webkitpy.common.system.outputcapture import OutputCapture
    35 from webkitpy.common.unicode_compatibility import StringIO
    3633from webkitpy.port.driver import DriverOutput
    37 from webkitpy.port.test import TestDriver
    3834from webkitpy.port.test import TestPort
    3935from webkitpy.performance_tests.perftest import PerfTest

  • trunk/Tools/Scripts/webkitpy/performance_tests/perftestsrunner_integrationtest.py

    r253392 r264949  
    3636from webkitpy.common.host_mock import MockHost
    3737from webkitpy.common.system.outputcapture import OutputCapture
    38 from webkitpy.common.unicode_compatibility import StringIO
    3938from webkitpy.port.driver import DriverOutput
    4039from webkitpy.port.test import TestPort

  • trunk/Tools/Scripts/webkitpy/performance_tests/perftestsrunner_unittest.py

    r253392 r264949  
    3030
    3131import json
    32 import re
    3332import unittest
     33
     34from webkitcorepy import StringIO
    3435
    3536from webkitpy.common.host_mock import MockHost
    3637from webkitpy.common.system.outputcapture import OutputCapture
    37 from webkitpy.common.unicode_compatibility import StringIO
    3838from webkitpy.port.test import TestPort
    39 from webkitpy.performance_tests.perftest import DEFAULT_TEST_RUNNER_COUNT
    4039from webkitpy.performance_tests.perftestsrunner import PerfTestsRunner
    4140

  • trunk/Tools/Scripts/webkitpy/port/base.py

    r264451 r264949  
    4242from collections import OrderedDict
    4343from functools import partial
     44from webkitcorepy import string_utils
    4445
    4546from webkitpy.common import find_files
    … …  
    5354from webkitpy.common.wavediff import WaveDiff
    5455from webkitpy.common.webkit_finder import WebKitFinder
    55 from webkitpy.common.unicode_compatibility import encode_for, encode_if_necessary, decode_for
    5656from webkitpy.layout_tests.models.test_configuration import TestConfiguration
    5757from webkitpy.port import config as port_config
    … …  
    327327        """Returns a string containing the diff of the two text strings
    328328        in 'unified diff' format."""
    329         expected_filename = decode_for(encode_if_necessary(expected_filename), str)
    330         actual_filename = decode_for(encode_if_necessary(actual_filename), str)
     329        expected_filename = string_utils.decode(string_utils.encode(expected_filename), target_type=str)
     330        actual_filename = string_utils.decode(string_utils.encode(actual_filename), target_type=str)
    331331        diff = difflib.unified_diff(expected_text.splitlines(True),
    332332                                    actual_text.splitlines(True),
    … …  
    489489            if not self._filesystem.exists(baseline_path):
    490490                return None
    491         text = decode_for(self._filesystem.read_binary_file(baseline_path), str)
     491        text = string_utils.decode(self._filesystem.read_binary_file(baseline_path), target_type=str)
    492492        return text.replace("\r\n", "\n")
    493493
    … …  
    14931493            run_script_command.extend(args)
    14941494        output = self._executive.run_command(run_script_command, cwd=self.webkit_base(), decode_output=decode_output, env=env)
    1495         _log.debug('Output of %s:\n%s' % (run_script_command, encode_for(output, str) if decode_output else output))
     1495        _log.debug('Output of %s:\n%s' % (run_script_command, string_utils.encode(output, target_type=str) if decode_output else output))
    14961496        return output
    14971497

  • trunk/Tools/Scripts/webkitpy/port/driver.py

    r260130 r264949  
    3535import time
    3636import os
     37
    3738from collections import defaultdict
    38 
    39 from os.path import normpath
     39from webkitcorepy import string_utils
     40
    4041from webkitpy.common.system import path
    4142from webkitpy.common.system.profiler import ProfilerFactory
    42 from webkitpy.common.unicode_compatibility import encode_if_necessary, decode_for
    4343
    4444
    … …  
    8888            crashed_pid=None, crash_log=None, pid=None):
    8989        # FIXME: Args could be renamed to better clarify what they do.
    90         self.text = decode_for(text, str) if text else None
     90        self.text = string_utils.decode(text, target_type=str) if text else None
    9191        self.image = image  # May be empty-string if the test crashes.
    9292        self.image_hash = image_hash
    9393        self.image_diff = None  # image_diff gets filled in after construction.
    94         self.audio = encode_if_necessary(audio) if audio else None  # Binary format is port-dependent.
     94        self.audio = string_utils.encode(audio) if audio else None  # Binary format is port-dependent.
    9595        self.crash = crash
    9696        self.crashed_process_name = crashed_process_name
    … …  
    216216        text, audio = self._read_first_block(deadline, driver_input.test_name)  # First block is either text or audio
    217217        image, actual_image_hash = self._read_optional_image_block(deadline, driver_input.test_name)  # The second (optional) block is image data.
    218         text = decode_for(text, str)
     218        text = string_utils.decode(text, target_type=str)
    219219
    220220        crashed = self.has_crashed()
    … …  
    230230            out, err = self._server_process.stop(self._port.driver_stop_timeout() if stop_when_done else 0.0)
    231231            if out:
    232                 text += decode_for(out, str)
     232                text += string_utils.decode(out, target_type=str)
    233233            if err:
    234                 self.error_from_test += decode_for(err, str)
     234                self.error_from_test += string_utils.decode(err, target_type=str)
    235235            self._server_process = None
    236236
    … …  
    285285            m = re.match(b'^([^:]+): ([0-9]+)$', line)
    286286            if m:
    287                 process_name = decode_for(m.group(1), str)
    288                 process_id = decode_for(m.group(2), str)
     287                process_name = string_utils.decode(m.group(1), target_type=str)
     288                process_id = string_utils.decode(m.group(2), target_type=str)
    289289                child_processes[process_name].append(process_id)
    290290
    … …  
    550550        if out_line.startswith(b"#PID UNRESPONSIVE - "):
    551551            match = re.match(b'#PID UNRESPONSIVE - (\S+)', out_line)
    552             child_process_name = decode_for(match.group(1), str) if match else 'WebProcess'
     552            child_process_name = string_utils.decode(match.group(1), target_type=str) if match else 'WebProcess'
    553553            match = re.search(b'pid (\d+)', out_line)
    554554            child_process_pid = int(match.group(1)) if match else None
    … …  
    573573        elif error_line.startswith(b"#CRASHED - "):
    574574            match = re.match(b'#CRASHED - (\S+)', error_line)
    575             self._crashed_process_name = decode_for(match.group(1), str) if match else 'WebProcess'
     575            self._crashed_process_name = string_utils.decode(match.group(1), target_type=str) if match else 'WebProcess'
    576576            match = re.search(b'pid (\d+)', error_line)
    577577            self._crashed_pid = int(match.group(1)) if match else None
    … …  
    580580        elif error_line.startswith(b"#PROCESS UNRESPONSIVE - "):
    581581            match = re.match(b'#PROCESS UNRESPONSIVE - (\S+)', error_line)
    582             child_process_name = decode_for(match.group(1), str) if match else 'WebProcess'
     582            child_process_name = string_utils.decode(match.group(1), target_type=str) if match else 'WebProcess'
    583583            match = re.search(b'pid (\d+)', error_line)
    584584            child_process_pid = int(match.group(1)) if match else None
    … …  
    587587            if child_process_pid:
    588588                self._port.sample_process(child_process_name, child_process_pid, self._target_host)
    589             self.error_from_test += decode_for(error_line, str)
     589            self.error_from_test += string_utils.decode(error_line, target_type=str)
    590590            self._server_process.write('#SAMPLE FINISHED\n', True)  # Must be able to ignore a broken pipe here, target process may already be closed.
    591591            return True
    … …  
    641641    def _read_header(self, block, line, header_text, header_attr, header_filter=None):
    642642        if line.startswith(header_text) and getattr(block, header_attr) is None:
    643             value = decode_for(line.split()[1], str)
     643            value = string_utils.decode(line.split()[1], target_type=str)
    644644            if header_filter:
    645645                value = header_filter(value)
    … …  
    662662        # Note, we're not reading ExpectedHash: here, but we could.
    663663        # If the line wasn't a header, we just append it to the content.
    664         block.content = encode_if_necessary(block.content) + line
     664        block.content = string_utils.encode(block.content) + line
    665665
    666666    def _strip_eof(self, line):
    … …  
    707707                # Don't wait until we're done with headers, just read the binary blob right now.
    708708                if content_length_before_header_check != block._content_length:
    709                     block.content = encode_if_necessary(self._server_process.read_stdout(deadline, block._content_length))
     709                    block.content = string_utils.encode(self._server_process.read_stdout(deadline, block._content_length))
    710710
    711711            if err_line:
    … …  
    725725                    deadline += 10 * 60 * 1000
    726726                if asan_violation_detected:
    727                     self._crash_report_from_driver += decode_for(err_line, str)
     727                    self._crash_report_from_driver += string_utils.decode(err_line, target_type=str)
    728728                else:
    729                     self.error_from_test += decode_for(err_line, str)
     729                    self.error_from_test += string_utils.decode(err_line, target_type=str)
    730730
    731731        if asan_violation_detected and not self._crashed_process_name:
    … …  
    760760        else:
    761761            try:
    762                 self.decoded_content = decode_for(self.content, str)
     762                self.decoded_content = string_utils.decode(self.content, target_type=str)
    763763            except UnicodeDecodeError:
    764764                self.decoded_content = None

  • trunk/Tools/Scripts/webkitpy/port/image_diff.py

    r254929 r264949  
    3535import time
    3636
    37 from webkitpy.port import server_process
    38 from webkitpy.common.unicode_compatibility import BytesIO, decode_for, encode_if_necessary
     37from webkitcorepy import BytesIO, string_utils
    3938
    4039
    … …  
    6059            # Note that although we are handed 'old', 'new', ImageDiff wants 'new', 'old'.
    6160            buffer = BytesIO()
    62             buffer.write(encode_if_necessary('Content-Length: {}\n'.format(len(actual_contents))))
     61            buffer.write(string_utils.encode('Content-Length: {}\n'.format(len(actual_contents))))
    6362            buffer.write(actual_contents)
    64             buffer.write(encode_if_necessary('Content-Length: {}\n'.format(len(expected_contents))))
     63            buffer.write(string_utils.encode('Content-Length: {}\n'.format(len(expected_contents))))
    6564            buffer.write(expected_contents)
    6665            self._process.write(buffer.getvalue())
    … …  
    9392            if output.startswith(b'Content-Length'):
    9493                m = re.match(b'Content-Length: (\d+)', output)
    95                 content_length = int(decode_for(m.group(1), str))
     94                content_length = int(string_utils.decode(m.group(1), target_type=str))
    9695                output_image = self._process.read_stdout(deadline, content_length)
    9796                output = self._process.read_stdout_line(deadline)
    9897                break
    9998
    100         stderr = decode_for(self._process.pop_all_buffered_stderr(), str)
     99        stderr = string_utils.decode(self._process.pop_all_buffered_stderr(), target_type=str)
    101100        err_str = ''
    102101        if stderr:
    … …  
    112111            if m.group(2) == b'passed':
    113112                return (None, 0, None)
    114             diff_percent = float(decode_for(m.group(1), str))
     113            diff_percent = float(string_utils.decode(m.group(1), target_type=str))
    115114
    116115        return (output_image, diff_percent, err_str or None)

  • trunk/Tools/Scripts/webkitpy/port/leakdetector.py

    r251808 r264949  
    3131import re
    3232
     33from webkitcorepy import string_utils
     34
    3335from webkitpy.common.system.executive import ScriptError
    34 from webkitpy.common.unicode_compatibility import encode_if_necessary
    3536
    3637_log = logging.getLogger(__name__)
    … …  
    8081        if not leaks_output:
    8182            return 0, 0, 0
    82         leaks_output = encode_if_necessary(leaks_output)
     83        leaks_output = string_utils.encode(leaks_output)
    8384        _, count, bytes = re.search(b'Process (?P<pid>\\d+): (?P<count>\\d+) leaks? for (?P<bytes>\\d+) total', leaks_output).groups()
    8485        excluded_match = re.search(b'(?P<excluded>\\d+) leaks? excluded', leaks_output)

  • trunk/Tools/Scripts/webkitpy/port/leakdetector_valgrind.py

    r251808 r264949  
    3232import logging
    3333import re
    34 import subprocess
    3534from xml.dom.minidom import parseString
    3635from xml.parsers.expat import ExpatError
    3736
    38 from webkitpy.common.unicode_compatibility import encode_if_necessary, decode_for
     37from webkitcorepy import string_utils
    3938
    4039_log = logging.getLogger(__name__)
    … …  
    199198        # By printing out this hash we can find duplicate reports between tests and
    200199        # different shards running on multiple buildbots
    201         return int(hashlib.md5(encode_if_necessary(self.unique_string())).hexdigest()[:16], 16)
     200        return int(hashlib.md5(string_utils.encode(self.unique_string())).hexdigest()[:16], 16)
    202201
    203202    def __hash__(self):
    … …  
    225224        except ExpatError as e:
    226225            parse_failed = True
    227             _log.error("could not parse %s: %s" % (decode_for(leaks_output, str), e))
     226            _log.error("could not parse %s: %s" % (string_utils.decode(leaks_output, target_type=str), e))
    228227            return
    229228

  • trunk/Tools/Scripts/webkitpy/port/leakdetector_valgrind_unittest.py

    r251808 r264949  
    2424# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2525
    26 import logging
    2726import unittest
     27
     28from webkitcorepy import string_utils
    2829
    2930from webkitpy.common.system.executive_mock import MockExecutive2
    3031from webkitpy.common.system.filesystem_mock import MockFileSystem
    3132from webkitpy.common.system.outputcapture import OutputCapture
    32 from webkitpy.common.unicode_compatibility import decode_for
    3333from webkitpy.port.leakdetector_valgrind import LeakDetectorValgrind
    3434
    … …  
    809809def mock_run_cppfilt_command(args):
    810810    if args[0] == 'c++filt':
    811         return valgrind_output_cppfilt_map[decode_for(args[2], str)]
     811        return valgrind_output_cppfilt_map[string_utils.decode(args[2], target_type=str)]
    812812    return ""
    813813

  • trunk/Tools/Scripts/webkitpy/port/linux_get_crash_log.py

    r258626 r264949  
    2828# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2929
    30 import datetime
    3130import os
    3231import re
    33 import shutil
    3432import subprocess
    3533import tempfile
    3634import time
    3735
     36from webkitcorepy import string_utils
     37
    3838from webkitpy.common.system.executive import ScriptError
    39 from webkitpy.common.unicode_compatibility import decode_if_necessary
    4039from webkitpy.common.webkit_finder import WebKitFinder
    4140
    … …  
    115114        proc = self._executive.popen(cmd, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    116115        crash_log, stderr = proc.communicate()
    117         errors = decode_if_necessary(str(stderr or '<empty>'), errors='ignore').splitlines()
     116        errors = string_utils.decode(str(stderr or '<empty>'), errors='ignore').splitlines()
    118117        return crash_log, errors
    119118
    … …  
    150149            crash_log, errors = self._get_trace_from_systemd(coredumpctl, pid_representation)
    151150
    152         stderr_lines = errors + decode_if_necessary(str(stderr or '<empty>'), errors='ignore').splitlines()
     151        stderr_lines = errors + string_utils.decode(str(stderr or '<empty>'), errors='ignore').splitlines()
    153152        errors_str = '\n'.join(('STDERR: ' + stderr_line) for stderr_line in stderr_lines)
    154153        cppfilt_proc = self._executive.popen(

  • trunk/Tools/Scripts/webkitpy/port/mock_drt.py

    r253910 r264949  
    4949    sys.path.append(script_dir)
    5050
    51 from webkitpy.common.unicode_compatibility import decode_for
    5251from webkitpy.common.system.systemhost import SystemHost
    5352from webkitpy.port.driver import DriverInput, DriverOutput, DriverProxy
    5453from webkitpy.port.factory import PortFactory
     54
     55from webkitcorepy import string_utils
    5556
    5657_log = logging.getLogger(__name__)
    … …  
    232233                self._stdout.write('Content-Type: image/png\n')
    233234                self._stdout.write('Content-Length: %s\n' % len(output.image))
    234                 self._stdout.write(decode_for(output.image, str))
     235                self._stdout.write(string_utils.decode(output.image, target_type=str))
    235236        self._stdout.write('#EOF\n')
    236237        self._stdout.flush()

  • trunk/Tools/Scripts/webkitpy/port/mock_drt_unittest.py

    r251808 r264949  
    2929"""Unit tests for MockDRT."""
    3030
    31 import sys
    3231import unittest
    3332
     33from webkitcorepy import StringIO
     34
    3435from webkitpy.common.system.systemhost_mock import MockSystemHost
    35 from webkitpy.common.unicode_compatibility import StringIO
    3636from webkitpy.port import mock_drt
    3737from webkitpy.port import port_testcase

  • trunk/Tools/Scripts/webkitpy/port/server_process.py

    r264523 r264949  
    3636import time
    3737
    38 from webkitpy.common.system.executive import ScriptError
    39 from webkitpy.common.unicode_compatibility import encode_if_necessary
     38from webkitcorepy import string_utils
    4039
    4140# Note that although win32 python does provide an implementation of
    … …  
    186185            self._start()
    187186        try:
    188             self._proc.stdin.write(encode_if_necessary(bytes))
     187            self._proc.stdin.write(string_utils.encode(bytes))
    189188            self._proc.stdin.flush()
    190189        except (IOError, ValueError) as e:

  • trunk/Tools/Scripts/webkitpy/port/server_process_mock.py

    r254929 r264949  
    2727# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2828
    29 from webkitpy.common.unicode_compatibility import encode_if_necessary
     29from webkitcorepy import string_utils
    3030
    3131
    … …  
    3333    def __init__(self, port_obj=None, name=None, cmd=None, env=None, universal_newlines=False, lines=None, crashed=False, target_host=None, crash_message=None):
    3434        self.timed_out = False
    35         self.lines = [encode_if_necessary(line) for line in (lines or [])]
     35        self.lines = [string_utils.encode(line) for line in (lines or [])]
    3636        self.crashed = crashed
    3737        self.writes = []

  • trunk/Tools/Scripts/webkitpy/port/test.py

    r257144 r264949  
    2929import time
    3030
     31from webkitcorepy import string_utils
     32
    3133from webkitpy.port import Port, Driver, DriverOutput
    3234from webkitpy.layout_tests.models.test_configuration import TestConfiguration
    3335from webkitpy.common.system.crashlogs import CrashLogs
    3436from webkitpy.common.version_name_map import PUBLIC_TABLE, VersionNameMap
    35 from webkitpy.common.unicode_compatibility import decode_for, encode_if_necessary
    3637
    3738
    … …  
    443444
    444445    def diff_image(self, expected_contents, actual_contents, tolerance=None):
    445         expected_contents = encode_if_necessary(expected_contents)
    446         actual_contents = encode_if_necessary(actual_contents)
     446        expected_contents = string_utils.encode(expected_contents)
     447        actual_contents = string_utils.encode(actual_contents)
    447448        diffed = actual_contents != expected_contents
    448449        if not actual_contents and not expected_contents:
    … …  
    454455        if diffed:
    455456            return ("< {}\n---\n> {}\n".format(
    456                 decode_for(expected_contents, str),
    457                 decode_for(actual_contents, str),
     457                string_utils.decode(expected_contents, target_type=str),
     458                string_utils.decode(actual_contents, target_type=str),
    458459            ), 1, None)
    459460        return (None, 0, None)

  • trunk/Tools/Scripts/webkitpy/results/upload_unittest.py

    r261000 r264949  
    3030import unittest
    3131
     32from webkitcorepy import BytesIO
     33
    3234from webkitpy.results.upload import Upload
    3335from webkitpy.thirdparty import mock
    34 from webkitpy.common.unicode_compatibility import BytesIO
    3536
    3637if sys.version_info > (3, 0):

  • trunk/Tools/Scripts/webkitpy/style/checkers/cpp.py

    r264581 r264949  
    4444import re
    4545import string
    46 import sys
    4746import unicodedata
     47
     48from webkitcorepy import unicode
    4849
    4950from webkitpy.style.checkers.common import match, search, sub, subn
    5051from webkitpy.common.memoized import memoized
    51 from webkitpy.common.unicode_compatibility import unicode
    5252
    5353# The key to use to provide a class to fake loading a header file.

  • trunk/Tools/Scripts/webkitpy/style/checkers/cpp_unittest.py

    r261415 r264949  
    4242import re
    4343import unittest
    44 from webkitpy.common.unicode_compatibility import decode_if_necessary
     44
     45from webkitcorepy import string_utils
     46
    4547from webkitpy.style.checkers import cpp as cpp_style
    4648from webkitpy.style.checkers.cpp import CppChecker
    … …  
    24662468            error_collector = ErrorCollector(self.assertTrue)
    24672469            self.process_file_data('foo.cpp', 'cpp',
    2468                                    decode_if_necessary(raw_bytes, encoding='utf8', errors='replace').split('\n'),
     2470                                   string_utils.decode(raw_bytes, encoding='utf8', errors='replace').split('\n'),
    24692471                                   error_collector)
    24702472            # The warning appears only once.

  • trunk/Tools/Scripts/webkitpy/style/checkers/python.py

    r264579 r264949  
    2727import sys
    2828
     29from webkitcorepy import StringIO
     30
    2931from webkitpy.common.system.filesystem import FileSystem
    30 from webkitpy.common.unicode_compatibility import StringIO
    3132from webkitpy.common.system.outputcapture import OutputCaptureScope
    3233from webkitpy.common.webkit_finder import WebKitFinder

  • trunk/Tools/Scripts/webkitpy/style/patchreader.py

    r252468 r264949  
    3232import re
    3333
     34from webkitcorepy import string_utils
     35
    3436from webkitpy.common.checkout.diff_parser import DiffParser
    3537from webkitpy.common.system.executive import Executive
    3638from webkitpy.common.system.filesystem import FileSystem
    3739from webkitpy.common.checkout.scm.detection import SCMDetector
    38 from webkitpy.common.unicode_compatibility import decode_for
    3940
    4041
    … …  
    5758        """Check style in the given patch."""
    5859        fs = fs or FileSystem()
    59         patch_string = decode_for(patch_string, str)
     60        patch_string = string_utils.decode(patch_string, target_type=str)
    6061        patch_files = DiffParser(patch_string.splitlines()).files
    6162

  • trunk/Tools/Scripts/webkitpy/test/main.py

    r264776 r264949  
    3838
    3939from webkitpy.common.system.logutils import configure_logging
    40 from webkitpy.common.system.executive import ScriptError
    4140from webkitpy.common.system.filesystem import FileSystem
    4241from webkitpy.common.host import Host
    43 from webkitpy.common.unicode_compatibility import StringIO
    4442from webkitpy.test.finder import Finder
    4543from webkitpy.test.printer import Printer
    … …  
    4745from webkitpy.results.upload import Upload
    4846from webkitpy.results.options import upload_options
     47
     48from webkitcorepy import StringIO
    4949
    5050_log = logging.getLogger(__name__)

  • trunk/Tools/Scripts/webkitpy/test/main_unittest.py

    r253219 r264949  
    2525import unittest
    2626
    27 from webkitpy.common.unicode_compatibility import StringIO
     27from webkitcorepy import StringIO
     28
    2829from webkitpy.common.system.filesystem import FileSystem
    2930from webkitpy.common.system.executive import Executive

  • trunk/Tools/Scripts/webkitpy/test/printer.py

    r253219 r264949  
    2424import logging
    2525
     26from webkitcorepy import StringIO
     27
    2628from webkitpy.common.system import outputcapture
    2729from webkitpy.common.system.systemhost import SystemHost
    28 from webkitpy.common.unicode_compatibility import StringIO
    2930from webkitpy.layout_tests.views.metered_stream import MeteredStream
    3031from webkitpy.tool.grammar import pluralize

  • trunk/Tools/Scripts/webkitpy/test/runner_unittest.py

    r253219 r264949  
    2525import unittest
    2626
    27 from webkitpy.common.unicode_compatibility import StringIO
     27from webkitcorepy import StringIO
     28
    2829from webkitpy.tool.mocktool import MockOptions
    2930from webkitpy.test.printer import Printer

  • trunk/Tools/Scripts/webkitpy/test/skip_unittest.py

    r253219 r264949  
    2424import unittest
    2525
    26 from webkitpy.common.unicode_compatibility import StringIO
     26from webkitcorepy import StringIO
     27
    2728from webkitpy.test.skip import skip_if
    2829

  • trunk/Tools/Scripts/webkitpy/tool/bot/irc_command.py

    r258097 r264949  
    3131import re
    3232
     33from webkitcorepy import unicode
     34
    3335from webkitpy.common.config import irc as config_irc
    3436from webkitpy.common.config import urls
    3537from webkitpy.common.config.committers import CommitterList
    36 from webkitpy.common.net.web import Web
    3738from webkitpy.common.system.executive import ScriptError
    38 from webkitpy.common.unicode_compatibility import unicode
    3939from webkitpy.tool.bot.queueengine import TerminateQueue
    4040from webkitpy.tool.grammar import join_with_separators

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

    r263592 r264949  
    3030import json
    3131import logging
    32 import os
    3332from optparse import make_option
    3433import sys
    3534
    36 from webkitpy.common.config.committers import CommitterList
    37 from webkitpy.common.config.ports import DeprecatedPort
     35from webkitcorepy import string_utils
     36
    3837from webkitpy.common.system.filesystem import FileSystem
    3938from webkitpy.common.system.executive import ScriptError
    40 from webkitpy.common.unicode_compatibility import encode_for
    4139from webkitpy.tool.bot.earlywarningsystemtask import EarlyWarningSystemTask, EarlyWarningSystemTaskDelegate
    4240from webkitpy.tool.bot.layouttestresultsreader import LayoutTestResultsReader
    4341from webkitpy.tool.bot.jsctestresultsreader import JSCTestResultsReader
    4442from webkitpy.tool.bot.patchanalysistask import UnableToApplyPatch, PatchIsNotValid, PatchIsNotApplicable
    45 from webkitpy.tool.bot.queueengine import QueueEngine
    4643from webkitpy.tool.commands.queues import AbstractReviewQueue
    4744
    … …  
    157154        for name, config in ewses.items():
    158155            if sys.version_info > (3, 0):
    159                 translated = encode_for(name, str).translate(' -')
     156                translated = string_utils.encode(name, target_type=str).translate(' -')
    160157            else:
    161                 translated = encode_for(name, str).translate(None, ' -')
     158                translated = string_utils.encode(name, target_type=str).translate(None, ' -')
    162159
    163160            classes.append(type(translated, (cls,), {

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

    r263168 r264949  
    2828# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2929
    30 import codecs
    3130import logging
    3231import os
    33 import re
    3432import sys
    35 import time
    3633import traceback
    3734
    … …  
    3936
    4037from webkitpy.common.config.ports import DeprecatedPort
    41 from webkitpy.common.net.bugzilla import Attachment
    4238from webkitpy.common.system.executive import ScriptError
    43 from webkitpy.common.unicode_compatibility import BytesIO
    4439from webkitpy.tool.bot.botinfo import BotInfo
    45 from webkitpy.tool.bot.flakytestreporter import FlakyTestReporter
    46 from webkitpy.tool.bot.layouttestresultsreader import LayoutTestResultsReader
    47 from webkitpy.tool.bot.patchanalysistask import UnableToApplyPatch, PatchIsNotValid
    4840from webkitpy.tool.bot.queueengine import QueueEngine, QueueEngineDelegate
    4941from webkitpy.tool.commands.stepsequence import StepSequenceErrorHandler
    50 from webkitpy.tool.multicommandtool import Command, TryAgain
     42from webkitpy.tool.multicommandtool import Command
    5143
    5244_log = logging.getLogger(__name__)

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

    r263168 r264949  
    2828# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2929
    30 import os
    31 
    32 from webkitpy.common.checkout.scm import CheckoutNeedsUpdate
    33 from webkitpy.common.checkout.scm.scm_mock import MockSCM
    34 from webkitpy.common.net.layouttestresults import LayoutTestResults
    35 from webkitpy.common.net.bugzilla import Attachment
    3630from webkitpy.common.system.outputcapture import OutputCapture
    37 from webkitpy.common.unicode_compatibility import StringIO
    38 from webkitpy.layout_tests.models import test_results
    39 from webkitpy.layout_tests.models import test_failures
    4031from webkitpy.thirdparty.mock import Mock
    4132from webkitpy.tool.commands.commandtest import CommandsTest
    4233from webkitpy.tool.commands.queues import *
    43 from webkitpy.tool.commands.queuestest import QueuesTest
    44 from webkitpy.tool.commands.stepsequence import StepSequence
    45 from webkitpy.tool.mocktool import MockTool, MockOptions
     34from webkitpy.tool.mocktool import MockTool
    4635
    4736

  • trunk/Tools/Scripts/webkitpy/tool/steps/haslanded.py

    r253128 r264949  
    2828
    2929import logging
    30 import sys
    3130import re
    3231import tempfile
    3332
    34 from webkitpy.tool.steps.abstractstep import AbstractStep
     33from webkitcorepy import StringIO
     34
    3535from webkitpy.common.system.executive import Executive, ScriptError
    3636from webkitpy.common.checkout import diff_parser
    37 from webkitpy.common.unicode_compatibility import StringIO
    3837
    3938from webkitpy.tool.steps import confirmdiff

  • trunk/Tools/Scripts/webkitpy/w3c/test_converter_unittest.py

    r261552 r264949  
    3030import unittest
    3131
     32from webkitcorepy import unicode
     33
    3234from webkitpy.common.host import Host
    3335from webkitpy.common.system.outputcapture import OutputCapture
    3436from webkitpy.common.webkit_finder import WebKitFinder
    35 from webkitpy.common.unicode_compatibility import unicode
    3637from webkitpy.thirdparty.BeautifulSoup import BeautifulSoup
    3738from webkitpy.w3c.test_converter import _W3CTestConverter

  • trunk/Tools/Scripts/webkitpy/w3c/test_exporter.py

    r253587 r264949  
    2828import logging
    2929import os
    30 import time
    3130import json
    3231import sys
     32
     33from webkitcorepy import string_utils
    3334
    3435from webkitpy.common.checkout.scm.git import Git
    … …  
    4041from webkitpy.w3c.common import WPT_GH_ORG, WPT_GH_REPO_NAME, WPT_GH_URL, WPTPaths
    4142from webkitpy.common.memoized import memoized
    42 from webkitpy.common.unicode_compatibility import encode_if_necessary, decode_for
    4343
    4444if sys.version_info > (3, 0):
    … …  
    161161
    162162    def _is_ignored_file(self, filename):
    163         filename = decode_for(filename, str)
     163        filename = string_utils.decode(filename, target_type=str)
    164164        for suffix in EXCLUDED_FILE_SUFFIXES:
    165165            if filename.endswith(suffix):
    … …  
    186186        patch_data = self._wpt_patch
    187187        if b'diff' not in patch_data:
    188             _log.info('No changes to upstream, patch data is: "{}"'.format(decode_for(patch_data, str)))
     188            _log.info('No changes to upstream, patch data is: "{}"'.format(string_utils.decode(patch_data, target_type=str)))
    189189            return b''
    190190        # FIXME: We can probably try to use --relative git parameter to not do that replacement.
    191         patch_data = patch_data.replace(encode_if_necessary(WEBKIT_WPT_DIR) + b'/', b'')
     191        patch_data = patch_data.replace(string_utils.encode(WEBKIT_WPT_DIR) + b'/', b'')
    192192
    193193        # FIXME: Support stripping of <!-- webkit-test-runner --> comments.

  • trunk/Tools/Scripts/webkitpy/w3c/wpt_github.py

    r253391 r264949  
    3232import re
    3333import sys
     34
    3435from collections import namedtuple
     36from webkitcorepy import string_utils
    3537
    3638from webkitpy.common.memoized import memoized
    3739from webkitpy.w3c.common import WPT_GH_ORG, WPT_GH_REPO_NAME, EXPORT_PR_LABEL
    38 from webkitpy.common.unicode_compatibility import encode_if_necessary, decode_for
    3940
    4041if sys.version_info > (3, 0):
    … …  
    6970    def auth_token(self):
    7071        assert self.has_credentials()
    71         return decode_for(base64.b64encode(encode_if_necessary('{}:{}'.format(self.user, self.token))), str)
     72        return string_utils.decode(base64.b64encode(string_utils.encode('{}:{}'.format(self.user, self.token))), target_type=str)
    7273
    7374    def request(self, path, method, body=None):

  • trunk/Tools/Scripts/webkitpy/w3c/wpt_github_unittest.py

    r253391 r264949  
    3030import unittest
    3131
     32from webkitcorepy import string_utils
     33
    3234from webkitpy.common.host_mock import MockHost
    33 from webkitpy.common.unicode_compatibility import encode_if_necessary, decode_for
    34 from webkitpy.w3c.wpt_github import WPTGitHub, MergeError
     35from webkitpy.w3c.wpt_github import WPTGitHub
    3536
    3637
    … …  
    4748        self.assertEqual(
    4849            self.wpt_github.auth_token(),
    49             decode_for(base64.encodestring(encode_if_necessary('rutabaga:decafbad')), str).strip())
     50            string_utils.decode(base64.encodestring(string_utils.encode('rutabaga:decafbad')), target_type=str).strip())

  • trunk/Tools/Scripts/webkitpy/xcode/simulated_device_unittest.py

    r264425 r264949  
    1 # Copyright (C) 2017-2019 Apple Inc. All rights reserved.
     1# Copyright (C) 2017-2020 Apple Inc. All rights reserved.
    22#
    33# Redistribution and use in source and binary forms, with or without
    … …  
    2424import unittest
    2525
    26 from webkitcorepy import Version
     26from webkitcorepy import string_utils, Version
    2727
    2828from webkitpy.common.system.executive_mock import MockExecutive2
    2929from webkitpy.common.system.filesystem_mock import MockFileSystem
    3030from webkitpy.common.system.systemhost_mock import MockSystemHost
    31 from webkitpy.common.unicode_compatibility import encode_if_necessary
    3231from webkitpy.xcode.device_type import DeviceType
    3332from webkitpy.xcode.simulated_device import DeviceRequest, SimulatedDeviceManager, SimulatedDevice
    … …  
    652651        device_plist = device.filesystem.expanduser(device.filesystem.join(SimulatedDeviceManager.simulator_device_path, device.udid, 'device.plist'))
    653652        index_position = device.filesystem.files[device_plist].index(b'</integer>') - 1
    654         device.filesystem.files[device_plist] = device.filesystem.files[device_plist][:index_position] + encode_if_necessary(str(state)) + device.filesystem.files[device_plist][index_position + 1:]
     653        device.filesystem.files[device_plist] = device.filesystem.files[device_plist][:index_position] + string_utils.encode(str(state)) + device.filesystem.files[device_plist][index_position + 1:]
    655654
    656655    def test_swapping_devices(self):
Note: See TracChangeset for help on using the changeset viewer.