def test_read_text_file_unicode_decode_error(self): fs = FileSystem() text_path = None try: text_path = tempfile.mktemp(prefix='write_text_unittest_') fs.write_binary_file(text_path, bytearray(b'\x73\x74\x72\x8b')) self.assertRaises(UnicodeDecodeError, fs.read_text_file, text_path) self.assertEqual(u'str\ufffd', fs.read_text_file(text_path, errors='replace')) self.assertEqual('str', fs.read_text_file(text_path, errors='ignore')) finally: if text_path and fs.isfile(text_path): os.remove(text_path)
def load_ews_classes(cls): filesystem = FileSystem() json_path = filesystem.join( filesystem.dirname( filesystem.path_to_module('webkitpy.common.config')), 'ews.json') try: ewses = json.loads(filesystem.read_text_file(json_path)) except ValueError: return None classes = [] for name, config in ewses.iteritems(): classes.append( type( name.encode('utf-8').translate(None, ' -'), (cls, ), { 'name': config.get('name', config['port'] + '-ews'), 'port_name': config['port'], 'architecture': config.get('architecture', None), '_build_style': config.get('style', "release"), 'watchers': config.get('watchers', []), 'run_tests': config.get('runTests', cls.run_tests), '_group': config.get('group', None), })) return classes
def load_test_repositories(): filesystem = FileSystem() webkit_finder = WebKitFinder(filesystem) test_repositories_path = webkit_finder.path_from_webkit_base( "LayoutTests", "imported", "w3c", "resources", "TestRepositories" ) return json.loads(filesystem.read_text_file(test_repositories_path))
def load_json(self): filesystem = FileSystem() json_path = filesystem.join(filesystem.dirname(filesystem.path_to_module('webkitpy.common.config')), 'contributors.json') try: contributors = json.loads(filesystem.read_text_file(json_path)) except ValueError, e: sys.exit('contributors.json is malformed: ' + str(e))
def load_ews_classes(cls): filesystem = FileSystem() json_path = filesystem.join(filesystem.dirname(filesystem.path_to_module('webkitpy.common.config')), 'ews.json') try: ewses = json.loads(filesystem.read_text_file(json_path)) except ValueError: return None classes = [] for name, config in ewses.items(): if sys.version_info > (3, 0): translated = string_utils.encode(name, target_type=str).translate(' -') else: translated = string_utils.encode(name, target_type=str).translate(None, ' -') classes.append(type(translated, (cls,), { 'name': config.get('name', config['port'] + '-ews'), 'port_name': config['port'], 'architecture': config.get('architecture', None), '_build_style': config.get('style', "release"), 'watchers': config.get('watchers', []), 'run_tests': config.get('runTests', cls.run_tests), '_group': config.get('group', None), 'should_build': config.get('shouldBuild', True), })) return classes
def load_json(): filesystem = FileSystem() json_path = filesystem.join(filesystem.dirname(filesystem.path_to_module('webkitpy.common.config')), 'contributors.json') contributors = json.loads(filesystem.read_text_file(json_path)) return { 'Contributors': [Contributor(name, data.get('emails'), data.get('nicks')) for name, data in contributors['Contributors'].iteritems()], 'Committers': [Committer(name, data.get('emails'), data.get('nicks')) for name, data in contributors['Committers'].iteritems()], 'Reviewers': [Reviewer(name, data.get('emails'), data.get('nicks')) for name, data in contributors['Reviewers'].iteritems()], }
def load_json(self): filesystem = FileSystem() json_path = filesystem.join( filesystem.dirname( filesystem.path_to_module('webkitpy.common.config')), 'contributors.json') try: contributors = json.loads(filesystem.read_text_file(json_path)) except ValueError, e: sys.exit('contributors.json is malformed: ' + str(e))
def load_ews_classes(cls): filesystem = FileSystem() json_path = filesystem.join(filesystem.dirname(filesystem.path_to_module('webkitpy.common.config')), 'ews.json') try: ewses = json.loads(filesystem.read_text_file(json_path)) except ValueError: return None classes = [] for name, config in ewses.iteritems(): classes.append(type(str(name.replace(' ', '')), (AbstractEarlyWarningSystem,), { 'name': config['port'] + '-ews', 'port_name': config['port'], 'watchers': config.get('watchers', []), 'run_tests': config.get('runTests', cls.run_tests), })) return classes
def load_ews_classes(cls): filesystem = FileSystem() json_path = filesystem.join(filesystem.dirname(filesystem.path_to_module('webkitpy.common.config')), 'ews.json') try: ewses = json.loads(filesystem.read_text_file(json_path)) except ValueError: return None classes = [] for name, config in ewses.iteritems(): classes.append(type(name.encode('utf-8').translate(None, ' -'), (AbstractEarlyWarningSystem,), { 'name': config.get('name', config['port'] + '-ews'), 'port_name': config['port'], 'architecture': config.get('architecture', None), '_build_style': config.get('style', "release"), 'watchers': config.get('watchers', []), 'run_tests': config.get('runTests', cls.run_tests), })) return classes
def test_read_and_write_file(self): fs = FileSystem() text_path = None binary_path = None unicode_text_string = u'\u016An\u012Dc\u014Dde\u033D' hex_equivalent = '\xC5\xAA\x6E\xC4\xAD\x63\xC5\x8D\x64\x65\xCC\xBD' try: text_path = tempfile.mktemp(prefix='tree_unittest_') binary_path = tempfile.mktemp(prefix='tree_unittest_') fs.write_text_file(text_path, unicode_text_string) contents = fs.read_binary_file(text_path) self.assertEqual(contents, hex_equivalent) fs.write_binary_file(binary_path, hex_equivalent) text_contents = fs.read_text_file(binary_path) self.assertEqual(text_contents, unicode_text_string) finally: if text_path and fs.isfile(text_path): os.remove(text_path) if binary_path and fs.isfile(binary_path): os.remove(binary_path)
def load_json(self): filesystem = FileSystem() json_path = filesystem.join( filesystem.dirname( filesystem.path_to_module('webkitpy.common.config')), 'contributors.json') try: contributors = json.loads(filesystem.read_text_file(json_path)) except ValueError as e: sys.exit('contributors.json is malformed: ' + str(e)) self._contributors = [] self._committers = [] self._reviewers = [] for name, data in contributors.items(): contributor = None status = data.get('status') if status == "reviewer": contributor = Reviewer(name, data.get('emails'), data.get('nicks'), data.get('aliases'), data.get('expertise')) self._reviewers.append(contributor) self._committers.append(contributor) elif status == "committer": contributor = Committer(name, data.get('emails'), data.get('nicks'), data.get('aliases'), data.get('expertise')) self._committers.append(contributor) elif data.get('class') == 'bot': contributor = Bot(name, data.get('emails'), data.get('nicks'), data.get('aliases'), data.get('expertise')) else: contributor = Contributor(name, data.get('emails'), data.get('nicks'), data.get('aliases'), data.get('expertise')) self._contributors.append(contributor)
def test_read_and_write_file(self): fs = FileSystem() text_path = None binary_path = None unicode_text_string = u'\u016An\u012Dc\u014Dde\u033D' hex_equivalent = b'\xC5\xAA\x6E\xC4\xAD\x63\xC5\x8D\x64\x65\xCC\xBD' malformed_text_hex = b'\x4D\x69\x63\x72\x6F\x73\x6F\x66\x74\xAE\x20\x56\x69\x73\x75\x61\x6C\x20\x53\x74\x75\x64\x69\x6F\xAE\x20\x32\x30\x31\x30\x0D\x0A' malformed_ignored_text_hex = b'\x4D\x69\x63\x72\x6F\x73\x6F\x66\x74\x20\x56\x69\x73\x75\x61\x6C\x20\x53\x74\x75\x64\x69\x6F\x20\x32\x30\x31\x30\x0D\x0A' try: text_path = tempfile.mktemp(prefix='tree_unittest_') binary_path = tempfile.mktemp(prefix='tree_unittest_') fs.write_text_file(text_path, unicode_text_string) contents = fs.read_binary_file(text_path) self.assertEqual(contents, hex_equivalent) fs.write_binary_file(binary_path, hex_equivalent) text_contents = fs.read_text_file(binary_path) self.assertEqual(text_contents, unicode_text_string) self.assertRaises(ValueError, fs.write_text_file, binary_path, malformed_text_hex) fs.write_binary_file(binary_path, malformed_text_hex) self.assertRaises(ValueError, fs.read_text_file, binary_path) text_contents = fs.read_binary_file(binary_path).decode( 'utf8', 'ignore') self.assertEqual( text_contents, malformed_ignored_text_hex.decode('utf8', 'ignore')) with fs.open_text_file_for_reading(binary_path, 'replace') as file: file.readline() finally: if text_path and fs.isfile(text_path): os.remove(text_path) if binary_path and fs.isfile(binary_path): os.remove(binary_path)
def test_read_text_file__missing(self): fs = FileSystem() with self.assertRaises(IOError): fs.read_text_file(self._missing_file)
class CMakeGenerator(object): def __init__(self, inputFilename, outputFilename): self.host = Host() self.filesystem = FileSystem() self.project = json.loads( self.filesystem.read_text_file(inputFilename)) self.enable_g711 = False self.enable_g722 = False # Current Openssl cannot really compile since they use deprecated openssl functions self.enable_boringssl = True self.enable_vpx = False self.enable_libjpeg = False self.targets = self.project["targets"] self.outputFilename = outputFilename self.skip_test_targets = True self.starting_lines = [ "cmake_minimum_required(VERSION 3.5)", "set(CMAKE_CXX_STANDARD 11)", "enable_language(ASM)", "", "if (NOT LIBWEBRTC_INPUT_DIR)", " set(LIBWEBRTC_INPUT_DIR ${CMAKE_SOURCE_DIR}/Source)", "endif ()", "if (NOT LIBWEBRTC_OUTPUT_DIR)", " set(LIBWEBRTC_OUTPUT_DIR ${CMAKE_BINARY_DIR})", "endif ()", "", "file(WRITE ${LIBWEBRTC_OUTPUT_DIR}/dummy.c \"\")", "file(MAKE_DIRECTORY ${LIBWEBRTC_OUTPUT_DIR}/obj/third_party/libjpeg_turbo/simd_asm)", "file(MAKE_DIRECTORY ${LIBWEBRTC_OUTPUT_DIR}/obj/third_party/ffmpeg/ffmpeg_yasm)", "file(MAKE_DIRECTORY ${LIBWEBRTC_OUTPUT_DIR}/obj/webrtc/sdk)", "file(MAKE_DIRECTORY ${LIBWEBRTC_OUTPUT_DIR}/gen/third_party/yasm/include)", "file(MAKE_DIRECTORY ${LIBWEBRTC_OUTPUT_DIR}/gen/webrtc/audio_coding/neteq)", "file(MAKE_DIRECTORY ${LIBWEBRTC_OUTPUT_DIR}/gen/webrtc/logging/rtc_event_log)", "file(MAKE_DIRECTORY ${LIBWEBRTC_OUTPUT_DIR}/gen/webrtc/modules/audio_coding/audio_network_adaptor)", "file(MAKE_DIRECTORY ${LIBWEBRTC_OUTPUT_DIR}/gen/webrtc/modules/audio_processing)", "file(MAKE_DIRECTORY ${LIBWEBRTC_OUTPUT_DIR}/gen/webrtc/sdk)", "file(MAKE_DIRECTORY ${LIBWEBRTC_OUTPUT_DIR}/gen/webrtc/tools/event_log_visualizer)", "file(MAKE_DIRECTORY ${LIBWEBRTC_OUTPUT_DIR}/pyproto/webrtc/audio_coding/neteq)", "file(MAKE_DIRECTORY ${LIBWEBRTC_OUTPUT_DIR}/pyproto/webrtc/logging/rtc_event_log)", "file(MAKE_DIRECTORY ${LIBWEBRTC_OUTPUT_DIR}/pyproto/webrtc/modules/audio_coding/audio_network_adaptor)", "file(MAKE_DIRECTORY ${LIBWEBRTC_OUTPUT_DIR}/pyproto/webrtc/modules/audio_coding/audio_network_adaptor)", "file(MAKE_DIRECTORY ${LIBWEBRTC_OUTPUT_DIR}/pyproto/webrtc/modules/audio_processing)", "file(MAKE_DIRECTORY ${LIBWEBRTC_OUTPUT_DIR}/pyproto/webrtc/tools/event_log_visualizer)", "", ] self.ending_lines = [ "", "set_target_properties(WebrtcBaseGtest_Prod PROPERTIES LINKER_LANGUAGE CXX)", "set_target_properties(WebrtcLoggingRtc_Event_Log_Api PROPERTIES LINKER_LANGUAGE CXX)", ] if self.enable_libjpeg: self.ending_lines.append( "set_target_properties(Third_PartyLibjpeg_TurboSimd_Asm PROPERTIES LINKER_LANGUAGE CXX)" ) self.initialize_targets() def initialize_targets(self): # Simplifying generation self.targets["//webrtc/sdk:rtc_sdk_framework_objc"]["sources"][:] = [] # Static_library requires as least one source file self.targets["//webrtc/sdk:rtc_sdk_objc"]["sources"] = [ "//out/dummy.c" ] # Executable target without any source file self.targets["//webrtc:webrtc_tests"]["type"] = "group" # Duplicate symbol issue with source_set self.targets["//webrtc/api:call_api"]["type"] = "static_library" # Simpler for linking WebCore self.targets["//third_party/boringssl:boringssl"][ "type"] = "static_library" self.targets["//third_party/boringssl:boringssl"]["outputs"] = [ "//out/libboringssl.a" ] # We use a static info plist instead of a dynamic one del self.targets["//webrtc/sdk:rtc_sdk_framework_objc_info_plist"] self.targets[ "//webrtc/sdk:rtc_sdk_framework_objc_info_plist_bundle_data"][ "deps"].remove( "//webrtc/sdk:rtc_sdk_framework_objc_info_plist") # Macro to change specific things in LibWebRTC, only used in libjingle_peerconnection currently self.targets["//webrtc/api:libjingle_peerconnection"][ "defines"].append("WEBRTC_WEBKIT_BUILD") if not self.enable_g711: self.remove_webrtc_g711() if not self.enable_g722: self.remove_g722() if self.enable_boringssl: self.ending_lines.append( "set_target_properties(Third_PartyBoringsslBoringssl_Asm PROPERTIES LINKER_LANGUAGE CXX)" ) else: self.remove_boringssl() if self.enable_vpx: self.ending_lines.append( "set_target_properties(Third_PartyLibvpxLibvpx_Yasm PROPERTIES LINKER_LANGUAGE CXX)" ) self.starting_lines.append( "file(MAKE_DIRECTORY ${LIBWEBRTC_OUTPUT_DIR}/obj/third_party/libvpx/libvpx_yasm)" ) else: self.remove_libvpx() self.remove_openmax_dl() if not self.enable_libjpeg: self.remove_libjpeg() self.remove_yasm() self.remove_webrtc_base_sha1() self.targets.pop("//build/config/sanitizers:options_sources") self.targets["//webrtc/base:rtc_base_approved"]["defines"].append( "HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE") def _remove_target(self, targetName): self.targets.pop(targetName) for name, target in self.targets.iteritems(): if "deps" in target: deps = target["deps"] if targetName in deps: deps.remove(targetName) def remove_webrtc_g711(self): self._remove_target("//webrtc/modules/audio_coding:g711_test") self._remove_target( "//webrtc/modules/audio_coding:neteq_pcmu_quality_test") self._remove_target( "//webrtc/modules/audio_coding:audio_decoder_unittests") self._remove_target("//webrtc/modules/audio_coding:g711") self.targets["//webrtc/modules/audio_coding:pcm16b"]["sources"].append( "//webrtc/modules/audio_coding/codecs/g711/audio_encoder_pcm.cc") self.targets["//webrtc/modules/audio_coding:pcm16b"]["source_outputs"][ "//webrtc/modules/audio_coding/codecs/g711/audio_encoder_pcm.cc"] = "obj/webrtc/modules/audio_coding/g711/audio_encoder_pcm.o" for name, target in self.targets.iteritems(): if "include_dirs" in target: include_dirs = target["include_dirs"] if "//webrtc/modules/audio_coding/codecs/g711/include/" in include_dirs: include_dirs.remove( "//webrtc/modules/audio_coding/codecs/g711/include/") if "defines" in target: defines = target["defines"] if "CODEC_G711" in defines: defines.remove("CODEC_G711") def remove_libjpeg(self): self.targets.pop("//third_party/libjpeg_turbo:libjpeg") self.targets.pop("//third_party:jpeg") self.targets.pop("//third_party/libjpeg_turbo:simd") self.targets.pop("//third_party/libjpeg_turbo:simd_asm") self.targets.pop("//third_party/libjpeg_turbo:simd_asm_action") libyuv = self.targets["//third_party/libyuv:libyuv"] libyuv["deps"].remove("//third_party:jpeg") libyuv["defines"].remove("HAVE_JPEG") libyuv["defines"].remove("USE_LIBJPEG_TURBO=1") self.targets["//third_party/libyuv:libyuv_unittest"]["defines"].remove( "HAVE_JPEG") self.targets["//third_party/libyuv:psnr"]["defines"].remove( "HAVE_JPEG") for name, target in self.targets.iteritems(): if "include_dirs" in target: include_dirs = target["include_dirs"] if "//third_party/openmax_dl/" in include_dirs: include_dirs.remove("//third_party/openmax_dl/") if "deps" in target: deps = target["deps"] if "//third_party:jpeg" in deps: deps.remove("//third_party:jpeg") if "defines" in target: defines = target["defines"] if "RTC_USE_OPENMAX_DL" in defines: defines.remove("RTC_USE_OPENMAX_DL") def remove_webrtc_base_sha1(self): base = self.targets["//webrtc/base:rtc_base"] base["source_outputs"].pop("//webrtc/base/sha1.cc") base["sources"].remove("//webrtc/base/sha1.cc") def remove_yasm(self): self.targets.pop("//third_party/yasm:yasm") self.targets.pop("//third_party/yasm:compile_gperf") self.targets.pop("//third_party/yasm:compile_gperf_for_include") self.targets.pop("//third_party/yasm:compile_nasm_macros") self.targets.pop("//third_party/yasm:compile_nasm_version") self.targets.pop("//third_party/yasm:compile_re2c") self.targets.pop("//third_party/yasm:compile_re2c_lc3b") self.targets.pop("//third_party/yasm:compile_win64_gas") self.targets.pop("//third_party/yasm:compile_win64_nasm") self.targets.pop("//third_party/yasm:generate_license") self.targets.pop("//third_party/yasm:generate_module") self.targets.pop("//third_party/yasm:generate_version") self.targets.pop("//third_party/yasm:yasm_utils") self.targets.pop("//third_party/yasm:genperf") self.targets.pop("//third_party/yasm:genmodule") self.targets.pop("//third_party/yasm:re2c") self.targets.pop("//third_party/yasm:genstring") self.targets.pop("//third_party/yasm:genversion") self.targets.pop("//third_party/yasm:genmacro") def remove_openmax_dl(self): self.targets.pop("//third_party/openmax_dl/dl:dl") for name, target in self.targets.iteritems(): if "include_dirs" in target: include_dirs = target["include_dirs"] if "//third_party/openmax_dl/" in include_dirs: include_dirs.remove("//third_party/openmax_dl/") if "deps" in target: deps = target["deps"] if "//third_party/openmax_dl/dl:dl" in deps: deps.remove("//third_party/openmax_dl/dl:dl") if "defines" in target: defines = target["defines"] if "RTC_USE_OPENMAX_DL" in defines: defines.remove("RTC_USE_OPENMAX_DL") common_audio = self.targets["//webrtc/common_audio:common_audio"] common_audio["source_outputs"].pop( "//webrtc/common_audio/real_fourier_openmax.cc") common_audio["sources"].remove( "//webrtc/common_audio/real_fourier_openmax.cc") def remove_libvpx(self): self.targets = { name: target for name, target in self.targets.iteritems() if not ("libvpx" in name or "vp9" in name or "vp8" in name) } for name, target in self.targets.iteritems(): if "include_dirs" in target: include_dirs = target["include_dirs"] if "//third_party/libvpx/source/libvpx/" in include_dirs: include_dirs.remove("//third_party/libvpx/source/libvpx/") if not "deps" in target: continue target["deps"] = [ dep for dep in target["deps"] if not ("libvpx" in dep or "vp9" in dep or "vp8" in dep) ] target = self.targets["//webrtc/modules/video_coding:video_coding"] target["defines"].append("RTC_DISABLE_VP8") target["defines"].append("RTC_DISABLE_VP9") target["sources"].append( "//webrtc/modules/video_coding/codecs/vp8/vp8_noop.cc") target["source_outputs"][ "//webrtc/modules/video_coding/codecs/vp8/vp8_noop.cc"] = [ "obj/webrtc/modules/video_coding/webrtc_vp8/vp8_noop.o" ] target["sources"].append( "//webrtc/modules/video_coding/codecs/vp9/vp9_noop.cc") target["source_outputs"][ "//webrtc/modules/video_coding/codecs/vp9/vp9_noop.cc"] = [ "obj/webrtc/modules/video_coding/webrtc_vp9/vp9_noop.o" ] target = self.targets["//webrtc/media:rtc_media"] target["defines"].append("RTC_DISABLE_VP8") target["defines"].append("RTC_DISABLE_VP9") def remove_boringssl(self): self.targets.pop("//third_party/boringssl:boringssl") self.targets.pop("//third_party/boringssl:boringssl_asm") for name, target in self.targets.iteritems(): if "include_dirs" in target: include_dirs = target["include_dirs"] if "//third_party/boringssl/src/include/" in include_dirs: include_dirs.remove("//third_party/boringssl/src/include/") #include_dirs.append("/usr/local/opt/openssl/include/") if not "deps" in target: continue deps = target["deps"] if "//third_party/boringssl:boringssl" in deps: deps.remove("//third_party/boringssl:boringssl") # Do we need this one? target["defines"].append("OPENSSL_NO_SSL_INTERN") # Do we need to set -L for access to the libs? target["ldflags"].extend(["-lcrypto", "-lssl"]) self.targets["//webrtc/p2p:stun_prober"]["ldflags"].extend( ["-lcrypto", "-lssl"]) def remove_g722(self): self.targets.pop("//webrtc/modules/audio_coding:g722") self.targets.pop("//webrtc/modules/audio_coding:g722_test") for name, target in self.targets.iteritems(): if "defines" in target: defines = target["defines"] if "WEBRTC_CODEC_G722" in defines: defines.remove("WEBRTC_CODEC_G722") if "CODEC_G722" in defines: defines.remove("CODEC_G722") if "include_dirs" in target: include_dirs = target["include_dirs"] if "//webrtc/modules/audio_coding/codecs/g722/include/" in include_dirs: include_dirs.remove( "//webrtc/modules/audio_coding/codecs/g722/include/") if not "deps" in target: continue deps = target["deps"] if "//webrtc/modules/audio_coding:g722" in deps: deps.remove("//webrtc/modules/audio_coding:g722") if "//webrtc/modules/audio_coding:g722_test" in target["deps"]: deps.remove("//webrtc/modules/audio_coding:g722_test") def generate(self): lines = self.starting_lines lines.extend(self._initialize_frameworks()) for name, target in self.targets.iteritems(): lines.append("\n".join( self.generate_target(self.sanitize_target_name(name), target))) lines.extend(self.generate_libwebrtc_target()) lines.extend(self.ending_lines) self.write_lazily("\n".join(lines)) def _initialize_frameworks(self): lines = [] frameworks = [] for name, target in self.targets.iteritems(): if ('sdk' in name and not "peerconnection" in name): continue if "libs" in target: frameworks.extend(target["libs"]) frameworks = list(set(frameworks)) for framework in frameworks: framework = framework.replace(".framework", "") lines.append("find_library(" + framework.upper() + "_LIBRARY " + framework + ")") return lines def write_lazily(self, content): if (self.filesystem.exists(self.outputFilename)): old_content = self.filesystem.read_text_file(self.outputFilename) if old_content == content: return self.filesystem.write_text_file(self.outputFilename, content) def sanitize_target_name(self, name): return "".join([step.title() for step in re.split('/|:', name)]) def convert_deps(self, names): return " ".join([self.sanitize_target_name(name) for name in names]) def convert_source(self, source): return source.replace("//out", "${LIBWEBRTC_OUTPUT_DIR}").replace( "//", "${LIBWEBRTC_INPUT_DIR}/") def convert_input(self, input): return input.replace("//out", "${LIBWEBRTC_OUTPUT_DIR}").replace( "//", "${LIBWEBRTC_INPUT_DIR}/") def convert_inputs(self, inputs): return " ".join(inputs).replace("//out", "${LIBWEBRTC_OUTPUT_DIR}").replace( "//", "${LIBWEBRTC_INPUT_DIR}/") def convert_output(self, output): return output.replace("//out", "${LIBWEBRTC_OUTPUT_DIR}") def convert_outputs(self, outputs): return " ".join(outputs).replace("//out", "${LIBWEBRTC_OUTPUT_DIR}") def generate_libwebrtc_target(self): skipped_sources = [ "//webrtc/base/sha1.cc", "//webrtc/base/sha1digest.cc", "//webrtc/base/md5.cc", "//webrtc/base/md5digest.cc", "//webrtc/base/json.cc" "//third_party/jsoncpp/overrides/src/lib_json/json_reader.cpp", "//third_party/jsoncpp/overrides/src/lib_json/json_value.cpp", "//third_party/jsoncpp/source/src/lib_json/json_writer.cpp" ] lines = [] lines.append("# Start of target LIBWEBRTC") objects = [] dependencies = [] for name, target in self.targets.iteritems(): if target["testonly"] or name.startswith("//webrtc/examples"): continue if "source_outputs" in target: for source, output in target["source_outputs"].iteritems(): if source in skipped_sources: continue if source.endswith(".o"): continue dependencies.append(self.sanitize_target_name(name)) if source.endswith(".asm"): objects.append(output[0].replace("_action", "")) elif output[0].endswith(".o"): filename = source.replace("//out/", "").replace("//", "Source/") if not filename.endswith(".o"): filename += ".o" objects.append( ("CMakeFiles/" + self.sanitize_target_name(name) + ".dir/" + filename)) dependencies = list(set(dependencies)) lines.append( "file(WRITE ${LIBWEBRTC_OUTPUT_DIR}/list_libwebrtc_objects \"" + "\n".join(objects) + "\")") lines.append( "add_custom_command(OUTPUT ${LIBWEBRTC_OUTPUT_DIR}/../libwebrtc.a") lines.append( " COMMAND libtool -static -o ${LIBWEBRTC_OUTPUT_DIR}/../libwebrtc.a -filelist ${LIBWEBRTC_OUTPUT_DIR}/list_libwebrtc_objects" ) lines.append(" VERBATIM)") lines.append("add_custom_target(LIBWEBRTC DEPENDS " + " ".join(dependencies) + " ${LIBWEBRTC_OUTPUT_DIR}/../libwebrtc.a)") lines.append("# End of target LIBWEBRTC") return lines def generate_target(self, name, target): if (self.skip_test_targets and target["testonly"]) or name.startswith("WebrtcExamples"): return [] lines = ["\n# Start of target " + name] if target["type"] == "action": lines.extend(self.generate_action_target(name, target)) elif target["type"] == "action_foreach": lines.extend(self.generate_action_foreach_target(name, target)) elif target["type"] == "copy": lines.extend(self.generate_copy_target(name, target)) elif target["type"] == "executable": lines.extend(self.generate_executable_target(name, target)) elif target["type"] == "shared_library": lines.extend(self.generate_shared_library_target(name, target)) elif target["type"] == "static_library": lines.extend(self.generate_static_library_target(name, target)) elif target["type"] == "create_bundle": lines.extend(self.generate_bundle_target(name, target)) elif target["type"] == "bundle_data": lines.extend(self.generate_bundle_data_target(name, target)) elif target["type"] == "group": lines.extend(self.generate_group_target(name, target)) elif target["type"] == "source_set": lines.extend(self.generate_source_set_target(name, target)) else: raise "unsupported target type: " + target["type"] lines.append("# End of target " + name) return lines def convert_arguments(self, arguments): value = "" is_first = True for argument in arguments: if not is_first: value += " " is_first = False if (argument.startswith("../")): value += "${LIBWEBRTC_INPUT_DIR}/" + argument[3:] elif (argument.startswith("gen/")): value += "${LIBWEBRTC_OUTPUT_DIR}/" + argument elif (argument.startswith("-I../")): value += "-I${LIBWEBRTC_INPUT_DIR}/" + argument[5:] elif (argument == "-I."): value += "-I${LIBWEBRTC_OUTPUT_DIR}" elif (argument == "-I.."): value += "-I${LIBWEBRTC_INPUT_DIR}" elif (argument == "-Igen"): value += "-I${LIBWEBRTC_OUTPUT_DIR}/gen" else: value += argument return value def _generate_add_dependencies(self, name, target): if not "deps" in target: return [] dependencies = self.convert_deps( [dep for dep in target["deps"] if self._is_active_dependency(dep)]) return ["add_dependencies(" + name + " " + dependencies + ")"] if len(dependencies) else [] def _is_active_dependency(self, name): return not ((self.skip_test_targets and self.targets[name]["testonly"]) or name.startswith("//webrtc/examples")) def generate_action_target(self, name, target): lines = [] outputs = self.convert_outputs(target["outputs"]) deps = self.convert_deps(target["deps"]) args = self.convert_arguments(target["args"]) script = "${LIBWEBRTC_INPUT_DIR}/" + target["script"][2:] if (script.endswith(".py")): script = "python " + script lines.append("add_custom_command(OUTPUT " + outputs) if deps: lines.append(" DEPENDS " + deps) lines.append(" COMMAND " + script + " " + args) lines.append(" VERBATIM)") lines.append("add_custom_target(" + name + " DEPENDS " + self.convert_deps(target["deps"]) + " " + self.convert_outputs(target["outputs"]) + ")") return lines def generate_action_foreach_target(self, name, target): lines = [] outputs = [self.convert_output(output) for output in target["outputs"]] deps = self.convert_deps(target["deps"]) sources = [self.convert_source(source) for source in target["sources"]] script = "${LIBWEBRTC_INPUT_DIR}/" + target["script"][2:] if (script.endswith(".py")): script = "python " + script for output, source in zip(outputs, sources): args = self.convert_arguments(target["args"]) args = args.replace("{{source}}", source).replace( "{{source_name_part}}", self.filesystem.splitext(self.filesystem.basename(source))[0]) lines.append("add_custom_command(OUTPUT " + output) lines.append(" MAIN_DEPENDENCY " + source) lines.append(" COMMAND " + script + " " + args) if deps: lines.append(" DEPENDS " + deps) lines.append(" VERBATIM)") lines.append("add_custom_target(" + name + " DEPENDS " + " ".join(outputs) + ")") return lines def generate_copy_target(self, name, target): lines = [] outputs = self.convert_outputs(target["outputs"]) sources = [self.convert_source(source) for source in target["sources"]] lines.append("list(APPEND " + name + " " + outputs + ")") for output, source in zip(target["outputs"], sources): lines.append("file(COPY " + source + " DESTINATION " + self.convert_output(output) + ")") lines.append("add_custom_target(" + name) lines.append(" COMMAND echo \"Generating copy target" + name + "\"") lines.append(" VERBATIM)") lines.extend(self._generate_add_dependencies(name, target)) return lines def _compute_compile_target_objects(self, name): target = self.targets[name] if target["type"] == "source_set" and not "sources" in target: return [] sources = ["$<TARGET_OBJECTS:" + self.sanitize_target_name(name) + ">"] for dep in self.targets[name]["deps"]: if not self.targets[dep]["type"] == "source_set": continue sources.extend(self._compute_compile_target_objects(dep)) return sources def _compute_compile_target_sources(self, target): sources = [ self.convert_source(source) for source in target["sources"] if not source.endswith(".h") ] if "sources" in target else [] if target["type"] == "source_set": return sources for dep in target["deps"]: if not self.targets[dep]["type"] == "source_set": continue sources.extend(self._compute_compile_target_objects(dep)) return sources def _generate_compile_target_sources(self, name, target): lines = [] sources = self._compute_compile_target_sources(target) if len(sources): lines.append("set(" + name + "_SOURCES " + "\n ".join(sources) + ")") return lines def _compute_link_flags(self, target): if not "ldflags" in target: return [] flags = target["ldflags"] self._remove_next_flag = False def keep_flag(flag): if self._remove_next_flag: self._remove_next_flag = False return False if flag == "-isysroot": self._remove_next_flag = True return False return True return filter(keep_flag, flags) def _compute_compile_flags(self, target): flags = [] for flag in [ "asmflags", "cflags", "cflags_c", "cflags_cc", "cflags_objc", "cflags_objcc" ]: if flag in target: flags.extend(target[flag]) self._remove_next_flag = False def keep_flag(flag): if self._remove_next_flag: self._remove_next_flag = False return False if flag == "-Xclang": self._remove_next_flag = True return False if flag == "-isysroot": self._remove_next_flag = True return False if flag == "-Wno-undefined-var-template": return False if flag == "-Wno-nonportable-include-path": return False if flag == "-Wno-address-of-packed-member": return False if flag == "-std=c++11": return False return True cleaned_flags = filter(keep_flag, flags) no_duplicate_flags = [] [ no_duplicate_flags.append(flag) for flag in cleaned_flags if not no_duplicate_flags.count(flag) ] return no_duplicate_flags def compute_include_dirs(self, target): dirs = [] if "include_dirs" in target: dirs.extend(target["include_dirs"]) return dirs def _generate_compile_target_options(self, name, target): lines = [] flags = self._compute_compile_flags(target) compilation_flags = "\" \"".join(flags) lines.append("target_compile_options(" + name + " PRIVATE \"" + compilation_flags + "\")") if "defines" in target: lines.append("target_compile_definitions(" + name + " PRIVATE " + " ".join(target["defines"]) + ")") dirs = list(set(self.compute_include_dirs(target))) if len(dirs): lines.append("target_include_directories(" + name + " PRIVATE " + self.convert_inputs(dirs) + ")") ldflags = self._compute_link_flags(target) if ldflags: lines.append("set_target_properties(" + name + " PROPERTIES LINK_FLAGS \"" + " ".join(ldflags) + "\")") return lines def _compute_linked_libraries(self, target): libraries = [] for dep in target["deps"]: dep_target = self.targets[dep] if dep_target["type"] == "static_library" or dep_target[ "type"] == "shared_library": libraries.append(self.sanitize_target_name(dep)) elif dep_target["type"] == "group" or dep_target[ "type"] == "source_set": libraries.extend(self._compute_linked_libraries(dep_target)) return libraries def _generate_linked_libraries(self, name, target): return [("target_link_libraries(" + name + " " + library + ")") for library in self._compute_linked_libraries(target)] def _handle_frameworks(self, name, target): if not "libs" in target: return [] lines = [] for framework in target["libs"]: framework = framework.replace(".framework", "").upper() lines.append("target_include_directories(" + name + " PRIVATE ${" + framework + "_INCLUDE_DIR})") lines.append("target_link_libraries(" + name + " ${" + framework + "_LIBRARY})") return lines def _set_output(self, name, target): if not "outputs" in target: return [] lines = [] output = target["outputs"][0] if not output.startswith("//out/"): raise "Output not in build directory" output_dir = "${LIBWEBRTC_OUTPUT_DIR}/" + self.filesystem.dirname( output[6:]) output_name = self.filesystem.basename(output[6:]) if output_name.startswith("lib") and output_name.endswith(".a"): output_name = output_name[3:-2] lines.append("set_target_properties(" + name + " PROPERTIES RUNTIME_OUTPUT_DIRECTORY " + output_dir + ")") lines.append("set_target_properties(" + name + " PROPERTIES OUTPUT_NAME " + output_name + ")") return lines def generate_executable_target(self, name, target): lines = self._generate_compile_target_sources(name, target) if len(lines): lines.append("add_executable(" + name + " ${" + name + "_SOURCES})") else: lines.append("add_executable(" + name + ")") lines.extend(self._generate_compile_target_options(name, target)) lines.extend(self._set_output(name, target)) lines.extend(self._generate_linked_libraries(name, target)) lines.extend(self._handle_frameworks(name, target)) lines.extend(self._generate_add_dependencies(name, target)) return lines def generate_shared_library_target(self, name, target): lines = self._generate_compile_target_sources(name, target) if len(lines): lines.append("add_library(" + name + " SHARED ${" + name + "_SOURCES})") else: lines.append("add_library(" + name + " SHARED)") lines.extend(self._generate_compile_target_options(name, target)) lines.extend(self._set_output(name, target)) lines.extend(self._generate_linked_libraries(name, target)) lines.extend(self._handle_frameworks(name, target)) lines.extend(self._generate_add_dependencies(name, target)) return lines def generate_static_library_target(self, name, target): lines = self._generate_compile_target_sources(name, target) lines.append("add_library(" + name + " STATIC" + ((" ${" + name + "_SOURCES}") if len(lines) else "") + ")") lines.extend(self._generate_compile_target_options(name, target)) lines.extend(self._set_output(name, target)) lines.extend(self._generate_linked_libraries(name, target)) lines.extend(self._handle_frameworks(name, target)) return lines def generate_bundle_data_target(self, name, target): lines = [] lines.append("add_custom_target(" + name + ")") lines.extend(self._generate_add_dependencies(name, target)) return lines def generate_bundle_target(self, name, target): # We replace dynamically Info.plist with a static one. info_plist = "${LIBWEBRTC_INPUT_DIR}/../WebKit/" + self.filesystem.basename( target["bundle_data"]["source_files"][-1]) lines = self.generate_shared_library_target(name, target) lines.append("set_target_properties(" + name + """ PROPERTIES FRAMEWORK TRUE FRAMEWORK_VERSION C MACOSX_FRAMEWORK_INFO_PLIST """ + info_plist + ")") return lines def generate_group_target(self, name, target): lines = [] lines.append("add_custom_target(" + name + ")") lines.extend(self._generate_add_dependencies(name, target)) return lines def generate_source_set_target(self, name, target): if not "sources" in target or not len(target["sources"]): return [] lines = self._generate_compile_target_sources(name, target) if len(lines): lines.append("add_library(" + name + " OBJECT ${" + name + "_SOURCES})") else: lines.append("add_library(" + name + " OBJECT)") lines.extend(self._generate_compile_target_options(name, target)) return lines
def load_test_repositories(): filesystem = FileSystem() webkit_finder = WebKitFinder(filesystem) test_repositories_path = webkit_finder.path_from_webkit_base('LayoutTests', 'imported', 'w3c', 'resources', 'TestRepositories') return json.loads(filesystem.read_text_file(test_repositories_path))
def load_test_repositories(): filesystem = FileSystem() webkit_finder = WebKitFinder(filesystem) test_repositories_path = webkit_finder.path_from_webkit_base( 'LayoutTests', 'imported', 'w3c', 'resources', 'TestRepositories') return json.loads(filesystem.read_text_file(test_repositories_path))