Copy disabled (too large)
Download .txt
Showing preview only (23,310K chars total). Download the full file to get everything.
Repository: tomahawk-player/tomahawk-resolvers
Branch: master
Commit: 7f827bbe410c
Files: 1395
Total size: 21.9 MB
Directory structure:
gitextract_xt8_barv/
├── .gitignore
├── 4shared/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── 4shared.js
│ └── metadata.json
├── 8tracks/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── 8tracks.js
│ └── metadata.json
├── HACKING.md
├── README.md
├── admin/
│ ├── json2desktop.rb
│ ├── makeaxe.rb
│ └── spotify-synchrotron/
│ ├── linux/
│ │ └── create_synchrotron.rb
│ ├── mac/
│ │ └── create_synchrotron.rb
│ └── win/
│ └── create_synchrotron.rb
├── amazon/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── amazon.js
│ │ └── config.ui
│ └── metadata.json
├── ampache/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── ampache.js
│ │ └── config.ui
│ └── metadata.json
├── archive/
│ ├── README
│ ├── dilandau/
│ │ └── content/
│ │ ├── contents/
│ │ │ └── code/
│ │ │ └── dilandau.js
│ │ └── metadata.json
│ ├── exfm/
│ │ └── content/
│ │ ├── contents/
│ │ │ └── code/
│ │ │ └── exfm.js
│ │ └── metadata.json
│ ├── grooveshark/
│ │ └── content/
│ │ ├── contents/
│ │ │ └── code/
│ │ │ ├── config.ui
│ │ │ └── grooveshark.js
│ │ └── metadata.json
│ ├── rdio/
│ │ └── content/
│ │ ├── contents/
│ │ │ └── code/
│ │ │ └── rdio.js
│ │ └── metadata.json
│ ├── rdio-metadata/
│ │ └── content/
│ │ ├── contents/
│ │ │ └── code/
│ │ │ └── rdio-metadata.js
│ │ └── metadata.json
│ └── spotify/
│ ├── BreakPad.cpp
│ ├── BreakPad.h
│ ├── CMakeLists.txt
│ ├── PlaylistClosure.cpp
│ ├── PlaylistClosure.h
│ ├── appkey.h
│ ├── audiohttpserver.cpp
│ ├── audiohttpserver.h
│ ├── breakpad/
│ │ ├── CMakeLists.txt
│ │ ├── client/
│ │ │ ├── apple/
│ │ │ │ └── Framework/
│ │ │ │ └── BreakpadDefines.h
│ │ │ ├── linux/
│ │ │ │ ├── android_link.h
│ │ │ │ ├── android_ucontext.h
│ │ │ │ ├── crash_generation/
│ │ │ │ │ ├── client_info.h
│ │ │ │ │ ├── crash_generation_client.cc
│ │ │ │ │ ├── crash_generation_client.h
│ │ │ │ │ ├── crash_generation_server.cc
│ │ │ │ │ └── crash_generation_server.h
│ │ │ │ ├── data/
│ │ │ │ │ ├── linux-gate-amd.sym
│ │ │ │ │ └── linux-gate-intel.sym
│ │ │ │ ├── handler/
│ │ │ │ │ ├── exception_handler.cc
│ │ │ │ │ ├── exception_handler.h
│ │ │ │ │ └── exception_handler_unittest.cc
│ │ │ │ ├── log/
│ │ │ │ │ ├── log.cc
│ │ │ │ │ └── log.h
│ │ │ │ ├── minidump_writer/
│ │ │ │ │ ├── directory_reader.h
│ │ │ │ │ ├── directory_reader_unittest.cc
│ │ │ │ │ ├── line_reader.h
│ │ │ │ │ ├── line_reader_unittest.cc
│ │ │ │ │ ├── linux_core_dumper.cc
│ │ │ │ │ ├── linux_core_dumper.h
│ │ │ │ │ ├── linux_core_dumper_unittest.cc
│ │ │ │ │ ├── linux_dumper.cc
│ │ │ │ │ ├── linux_dumper.h
│ │ │ │ │ ├── linux_dumper_unittest_helper.cc
│ │ │ │ │ ├── linux_ptrace_dumper.cc
│ │ │ │ │ ├── linux_ptrace_dumper.h
│ │ │ │ │ ├── linux_ptrace_dumper_unittest.cc
│ │ │ │ │ ├── minidump_extension_linux.h
│ │ │ │ │ ├── minidump_writer.cc
│ │ │ │ │ ├── minidump_writer.h
│ │ │ │ │ └── minidump_writer_unittest.cc
│ │ │ │ └── sender/
│ │ │ │ └── google_crash_report_sender.cc
│ │ │ ├── mac/
│ │ │ │ ├── Breakpad.xcodeproj/
│ │ │ │ │ └── project.pbxproj
│ │ │ │ ├── Framework/
│ │ │ │ │ ├── Breakpad.h
│ │ │ │ │ ├── Breakpad.mm
│ │ │ │ │ ├── Breakpad_Prefix.pch
│ │ │ │ │ ├── Info.plist
│ │ │ │ │ ├── OnDemandServer.h
│ │ │ │ │ └── OnDemandServer.mm
│ │ │ │ ├── UnitTests-Info.plist
│ │ │ │ ├── crash_generation/
│ │ │ │ │ ├── ConfigFile.h
│ │ │ │ │ ├── ConfigFile.mm
│ │ │ │ │ ├── Inspector.h
│ │ │ │ │ ├── Inspector.mm
│ │ │ │ │ ├── InspectorMain.mm
│ │ │ │ │ ├── client_info.h
│ │ │ │ │ ├── crash_generation_client.cc
│ │ │ │ │ ├── crash_generation_client.h
│ │ │ │ │ ├── crash_generation_server.cc
│ │ │ │ │ └── crash_generation_server.h
│ │ │ │ ├── handler/
│ │ │ │ │ ├── breakpad_nlist_64.cc
│ │ │ │ │ ├── breakpad_nlist_64.h
│ │ │ │ │ ├── dynamic_images.cc
│ │ │ │ │ ├── dynamic_images.h
│ │ │ │ │ ├── exception_handler.cc
│ │ │ │ │ ├── exception_handler.h
│ │ │ │ │ ├── mach_vm_compat.h
│ │ │ │ │ ├── minidump_generator.cc
│ │ │ │ │ ├── minidump_generator.h
│ │ │ │ │ ├── minidump_test.xcodeproj/
│ │ │ │ │ │ └── project.pbxproj
│ │ │ │ │ ├── minidump_tests32-Info.plist
│ │ │ │ │ ├── minidump_tests64-Info.plist
│ │ │ │ │ ├── obj-cTestCases-Info.plist
│ │ │ │ │ ├── protected_memory_allocator.cc
│ │ │ │ │ ├── protected_memory_allocator.h
│ │ │ │ │ └── testcases/
│ │ │ │ │ ├── DynamicImagesTests.cc
│ │ │ │ │ ├── DynamicImagesTests.h
│ │ │ │ │ ├── breakpad_nlist_test.cc
│ │ │ │ │ ├── breakpad_nlist_test.h
│ │ │ │ │ ├── dwarftests.h
│ │ │ │ │ ├── dwarftests.mm
│ │ │ │ │ └── testdata/
│ │ │ │ │ ├── dump_syms_dwarf_data
│ │ │ │ │ └── dump_syms_i386_breakpad.sym
│ │ │ │ ├── sender/
│ │ │ │ │ ├── Breakpad.xib
│ │ │ │ │ ├── English.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── ReporterIcon.graffle
│ │ │ │ │ ├── crash_report_sender-Info.plist
│ │ │ │ │ ├── crash_report_sender.h
│ │ │ │ │ ├── crash_report_sender.icns
│ │ │ │ │ ├── crash_report_sender.m
│ │ │ │ │ ├── da.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── de.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── es.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── fr.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── it.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── ja.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── nl.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── no.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── sl.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── sv.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── tr.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── uploader.h
│ │ │ │ │ └── uploader.mm
│ │ │ │ ├── testapp/
│ │ │ │ │ ├── Controller.h
│ │ │ │ │ ├── Controller.m
│ │ │ │ │ ├── English.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── MainMenu.xib
│ │ │ │ │ ├── Info.plist
│ │ │ │ │ ├── TestClass.h
│ │ │ │ │ ├── TestClass.mm
│ │ │ │ │ ├── bomb.icns
│ │ │ │ │ ├── crashInMain
│ │ │ │ │ ├── crashduringload
│ │ │ │ │ └── main.m
│ │ │ │ └── tests/
│ │ │ │ ├── BreakpadFramework_Test.mm
│ │ │ │ ├── SimpleStringDictionaryTest.h
│ │ │ │ ├── SimpleStringDictionaryTest.mm
│ │ │ │ ├── crash_generation_server_test.cc
│ │ │ │ ├── exception_handler_test.cc
│ │ │ │ ├── minidump_generator_test.cc
│ │ │ │ ├── minidump_generator_test_helper.cc
│ │ │ │ ├── spawn_child_process.h
│ │ │ │ └── testlogging.h
│ │ │ ├── minidump_file_writer-inl.h
│ │ │ ├── minidump_file_writer.cc
│ │ │ ├── minidump_file_writer.h
│ │ │ ├── minidump_file_writer_unittest.cc
│ │ │ ├── solaris/
│ │ │ │ └── handler/
│ │ │ │ ├── exception_handler.cc
│ │ │ │ ├── exception_handler.h
│ │ │ │ ├── exception_handler_test.cc
│ │ │ │ ├── minidump_generator.cc
│ │ │ │ ├── minidump_generator.h
│ │ │ │ ├── minidump_test.cc
│ │ │ │ ├── solaris_lwp.cc
│ │ │ │ └── solaris_lwp.h
│ │ │ └── windows/
│ │ │ ├── breakpad_client.gyp
│ │ │ ├── common/
│ │ │ │ ├── auto_critical_section.h
│ │ │ │ └── ipc_protocol.h
│ │ │ ├── crash_generation/
│ │ │ │ ├── ReadMe.txt
│ │ │ │ ├── client_info.cc
│ │ │ │ ├── client_info.h
│ │ │ │ ├── crash_generation.gyp
│ │ │ │ ├── crash_generation_client.cc
│ │ │ │ ├── crash_generation_client.h
│ │ │ │ ├── crash_generation_server.cc
│ │ │ │ ├── crash_generation_server.h
│ │ │ │ ├── minidump_generator.cc
│ │ │ │ └── minidump_generator.h
│ │ │ ├── handler/
│ │ │ │ ├── exception_handler.cc
│ │ │ │ ├── exception_handler.gyp
│ │ │ │ └── exception_handler.h
│ │ │ ├── sender/
│ │ │ │ ├── crash_report_sender.cc
│ │ │ │ ├── crash_report_sender.gyp
│ │ │ │ └── crash_report_sender.h
│ │ │ ├── tests/
│ │ │ │ └── crash_generation_app/
│ │ │ │ ├── abstract_class.cc
│ │ │ │ ├── abstract_class.h
│ │ │ │ ├── crash_generation_app.cc
│ │ │ │ ├── crash_generation_app.gyp
│ │ │ │ ├── crash_generation_app.h
│ │ │ │ ├── crash_generation_app.rc
│ │ │ │ └── resource.h
│ │ │ └── unittests/
│ │ │ ├── client_tests.gyp
│ │ │ ├── crash_generation_server_test.cc
│ │ │ ├── dump_analysis.cc
│ │ │ ├── dump_analysis.h
│ │ │ ├── exception_handler_death_test.cc
│ │ │ ├── exception_handler_test.cc
│ │ │ ├── minidump_test.cc
│ │ │ └── testing.gyp
│ │ ├── common/
│ │ │ ├── basictypes.h
│ │ │ ├── byte_cursor.h
│ │ │ ├── byte_cursor_unittest.cc
│ │ │ ├── convert_UTF.c
│ │ │ ├── convert_UTF.h
│ │ │ ├── dwarf/
│ │ │ │ ├── bytereader-inl.h
│ │ │ │ ├── bytereader.cc
│ │ │ │ ├── bytereader.h
│ │ │ │ ├── bytereader_unittest.cc
│ │ │ │ ├── cfi_assembler.cc
│ │ │ │ ├── cfi_assembler.h
│ │ │ │ ├── dwarf2diehandler.cc
│ │ │ │ ├── dwarf2diehandler.h
│ │ │ │ ├── dwarf2diehandler_unittest.cc
│ │ │ │ ├── dwarf2enums.h
│ │ │ │ ├── dwarf2reader.cc
│ │ │ │ ├── dwarf2reader.h
│ │ │ │ ├── dwarf2reader_cfi_unittest.cc
│ │ │ │ ├── dwarf2reader_die_unittest.cc
│ │ │ │ ├── dwarf2reader_test_common.h
│ │ │ │ ├── functioninfo.cc
│ │ │ │ ├── functioninfo.h
│ │ │ │ ├── line_state_machine.h
│ │ │ │ └── types.h
│ │ │ ├── dwarf_cfi_to_module.cc
│ │ │ ├── dwarf_cfi_to_module.h
│ │ │ ├── dwarf_cfi_to_module_unittest.cc
│ │ │ ├── dwarf_cu_to_module.cc
│ │ │ ├── dwarf_cu_to_module.h
│ │ │ ├── dwarf_cu_to_module_unittest.cc
│ │ │ ├── dwarf_line_to_module.cc
│ │ │ ├── dwarf_line_to_module.h
│ │ │ ├── dwarf_line_to_module_unittest.cc
│ │ │ ├── language.cc
│ │ │ ├── language.h
│ │ │ ├── linux/
│ │ │ │ ├── dump_symbols.cc
│ │ │ │ ├── dump_symbols.h
│ │ │ │ ├── dump_symbols_unittest.cc
│ │ │ │ ├── eintr_wrapper.h
│ │ │ │ ├── elf_core_dump.cc
│ │ │ │ ├── elf_core_dump.h
│ │ │ │ ├── elf_core_dump_unittest.cc
│ │ │ │ ├── elf_symbols_to_module.cc
│ │ │ │ ├── elf_symbols_to_module.h
│ │ │ │ ├── elf_symbols_to_module_unittest.cc
│ │ │ │ ├── file_id.cc
│ │ │ │ ├── file_id.h
│ │ │ │ ├── file_id_unittest.cc
│ │ │ │ ├── google_crashdump_uploader.cc
│ │ │ │ ├── google_crashdump_uploader.h
│ │ │ │ ├── google_crashdump_uploader_test.cc
│ │ │ │ ├── guid_creator.cc
│ │ │ │ ├── guid_creator.h
│ │ │ │ ├── http_upload.cc
│ │ │ │ ├── http_upload.h
│ │ │ │ ├── libcurl_wrapper.cc
│ │ │ │ ├── libcurl_wrapper.h
│ │ │ │ ├── linux_libc_support.h
│ │ │ │ ├── linux_libc_support_unittest.cc
│ │ │ │ ├── memory_mapped_file.cc
│ │ │ │ ├── memory_mapped_file.h
│ │ │ │ ├── memory_mapped_file_unittest.cc
│ │ │ │ ├── safe_readlink.cc
│ │ │ │ ├── safe_readlink.h
│ │ │ │ ├── safe_readlink_unittest.cc
│ │ │ │ ├── synth_elf.cc
│ │ │ │ ├── synth_elf.h
│ │ │ │ ├── synth_elf_unittest.cc
│ │ │ │ └── tests/
│ │ │ │ ├── crash_generator.cc
│ │ │ │ └── crash_generator.h
│ │ │ ├── mac/
│ │ │ │ ├── Breakpad.xcconfig
│ │ │ │ ├── BreakpadDebug.xcconfig
│ │ │ │ ├── BreakpadRelease.xcconfig
│ │ │ │ ├── GTMDefines.h
│ │ │ │ ├── GTMGarbageCollection.h
│ │ │ │ ├── GTMLogger.h
│ │ │ │ ├── GTMLogger.m
│ │ │ │ ├── HTTPMultipartUpload.h
│ │ │ │ ├── HTTPMultipartUpload.m
│ │ │ │ ├── MachIPC.h
│ │ │ │ ├── MachIPC.mm
│ │ │ │ ├── SimpleStringDictionary.h
│ │ │ │ ├── SimpleStringDictionary.mm
│ │ │ │ ├── bootstrap_compat.cc
│ │ │ │ ├── bootstrap_compat.h
│ │ │ │ ├── byteswap.h
│ │ │ │ ├── dump_syms.h
│ │ │ │ ├── dump_syms.mm
│ │ │ │ ├── file_id.cc
│ │ │ │ ├── file_id.h
│ │ │ │ ├── macho_id.cc
│ │ │ │ ├── macho_id.h
│ │ │ │ ├── macho_reader.cc
│ │ │ │ ├── macho_reader.h
│ │ │ │ ├── macho_reader_unittest.cc
│ │ │ │ ├── macho_utilities.cc
│ │ │ │ ├── macho_utilities.h
│ │ │ │ ├── macho_walker.cc
│ │ │ │ ├── macho_walker.h
│ │ │ │ ├── scoped_task_suspend-inl.h
│ │ │ │ ├── string_utilities.cc
│ │ │ │ ├── string_utilities.h
│ │ │ │ └── testing/
│ │ │ │ ├── GTMSenTestCase.h
│ │ │ │ └── GTMSenTestCase.m
│ │ │ ├── md5.cc
│ │ │ ├── md5.h
│ │ │ ├── memory.h
│ │ │ ├── memory_range.h
│ │ │ ├── memory_range_unittest.cc
│ │ │ ├── memory_unittest.cc
│ │ │ ├── module.cc
│ │ │ ├── module.h
│ │ │ ├── module_unittest.cc
│ │ │ ├── solaris/
│ │ │ │ ├── dump_symbols.cc
│ │ │ │ ├── dump_symbols.h
│ │ │ │ ├── file_id.cc
│ │ │ │ ├── file_id.h
│ │ │ │ ├── guid_creator.cc
│ │ │ │ ├── guid_creator.h
│ │ │ │ └── message_output.h
│ │ │ ├── stabs_reader.cc
│ │ │ ├── stabs_reader.h
│ │ │ ├── stabs_reader_unittest.cc
│ │ │ ├── stabs_to_module.cc
│ │ │ ├── stabs_to_module.h
│ │ │ ├── stabs_to_module_unittest.cc
│ │ │ ├── string_conversion.cc
│ │ │ ├── string_conversion.h
│ │ │ ├── test_assembler.cc
│ │ │ ├── test_assembler.h
│ │ │ ├── test_assembler_unittest.cc
│ │ │ ├── testdata/
│ │ │ │ └── func-line-pairing.h
│ │ │ └── windows/
│ │ │ ├── guid_string.cc
│ │ │ ├── guid_string.h
│ │ │ ├── http_upload.cc
│ │ │ ├── http_upload.h
│ │ │ ├── pdb_source_line_writer.cc
│ │ │ ├── pdb_source_line_writer.h
│ │ │ ├── string_utils-inl.h
│ │ │ └── string_utils.cc
│ │ ├── config.h.in
│ │ ├── google_breakpad/
│ │ │ ├── common/
│ │ │ │ ├── breakpad_types.h
│ │ │ │ ├── minidump_cpu_amd64.h
│ │ │ │ ├── minidump_cpu_arm.h
│ │ │ │ ├── minidump_cpu_ppc.h
│ │ │ │ ├── minidump_cpu_ppc64.h
│ │ │ │ ├── minidump_cpu_sparc.h
│ │ │ │ ├── minidump_cpu_x86.h
│ │ │ │ ├── minidump_exception_linux.h
│ │ │ │ ├── minidump_exception_mac.h
│ │ │ │ ├── minidump_exception_solaris.h
│ │ │ │ ├── minidump_exception_win32.h
│ │ │ │ ├── minidump_format.h
│ │ │ │ └── minidump_size.h
│ │ │ └── processor/
│ │ │ ├── basic_source_line_resolver.h
│ │ │ ├── call_stack.h
│ │ │ ├── code_module.h
│ │ │ ├── code_modules.h
│ │ │ ├── exploitability.h
│ │ │ ├── fast_source_line_resolver.h
│ │ │ ├── memory_region.h
│ │ │ ├── minidump.h
│ │ │ ├── minidump_processor.h
│ │ │ ├── process_state.h
│ │ │ ├── source_line_resolver_base.h
│ │ │ ├── source_line_resolver_interface.h
│ │ │ ├── stack_frame.h
│ │ │ ├── stack_frame_cpu.h
│ │ │ ├── stackwalker.h
│ │ │ ├── symbol_supplier.h
│ │ │ └── system_info.h
│ │ ├── processor/
│ │ │ ├── address_map-inl.h
│ │ │ ├── address_map.h
│ │ │ ├── address_map_unittest.cc
│ │ │ ├── basic_code_module.h
│ │ │ ├── basic_code_modules.cc
│ │ │ ├── basic_code_modules.h
│ │ │ ├── basic_source_line_resolver.cc
│ │ │ ├── basic_source_line_resolver_types.h
│ │ │ ├── basic_source_line_resolver_unittest.cc
│ │ │ ├── binarystream.cc
│ │ │ ├── binarystream.h
│ │ │ ├── binarystream_unittest.cc
│ │ │ ├── call_stack.cc
│ │ │ ├── cfi_frame_info-inl.h
│ │ │ ├── cfi_frame_info.cc
│ │ │ ├── cfi_frame_info.h
│ │ │ ├── cfi_frame_info_unittest.cc
│ │ │ ├── contained_range_map-inl.h
│ │ │ ├── contained_range_map.h
│ │ │ ├── contained_range_map_unittest.cc
│ │ │ ├── disassembler_x86.cc
│ │ │ ├── disassembler_x86.h
│ │ │ ├── disassembler_x86_unittest.cc
│ │ │ ├── exploitability.cc
│ │ │ ├── exploitability_unittest.cc
│ │ │ ├── exploitability_win.cc
│ │ │ ├── exploitability_win.h
│ │ │ ├── fast_source_line_resolver.cc
│ │ │ ├── fast_source_line_resolver_types.h
│ │ │ ├── fast_source_line_resolver_unittest.cc
│ │ │ ├── linked_ptr.h
│ │ │ ├── logging.cc
│ │ │ ├── logging.h
│ │ │ ├── map_serializers-inl.h
│ │ │ ├── map_serializers.h
│ │ │ ├── map_serializers_unittest.cc
│ │ │ ├── minidump.cc
│ │ │ ├── minidump_dump.cc
│ │ │ ├── minidump_dump_test
│ │ │ ├── minidump_processor.cc
│ │ │ ├── minidump_processor_unittest.cc
│ │ │ ├── minidump_stackwalk.cc
│ │ │ ├── minidump_stackwalk_machine_readable_test
│ │ │ ├── minidump_stackwalk_test
│ │ │ ├── minidump_unittest.cc
│ │ │ ├── module_comparer.cc
│ │ │ ├── module_comparer.h
│ │ │ ├── module_factory.h
│ │ │ ├── module_serializer.cc
│ │ │ ├── module_serializer.h
│ │ │ ├── pathname_stripper.cc
│ │ │ ├── pathname_stripper.h
│ │ │ ├── pathname_stripper_unittest.cc
│ │ │ ├── postfix_evaluator-inl.h
│ │ │ ├── postfix_evaluator.h
│ │ │ ├── postfix_evaluator_unittest.cc
│ │ │ ├── process_state.cc
│ │ │ ├── proto/
│ │ │ │ ├── README
│ │ │ │ └── process_state.proto
│ │ │ ├── range_map-inl.h
│ │ │ ├── range_map.h
│ │ │ ├── range_map_unittest.cc
│ │ │ ├── scoped_ptr.h
│ │ │ ├── simple_serializer-inl.h
│ │ │ ├── simple_serializer.h
│ │ │ ├── simple_symbol_supplier.cc
│ │ │ ├── simple_symbol_supplier.h
│ │ │ ├── source_line_resolver_base.cc
│ │ │ ├── source_line_resolver_base_types.h
│ │ │ ├── stackwalker.cc
│ │ │ ├── stackwalker_amd64.cc
│ │ │ ├── stackwalker_amd64.h
│ │ │ ├── stackwalker_amd64_unittest.cc
│ │ │ ├── stackwalker_arm.cc
│ │ │ ├── stackwalker_arm.h
│ │ │ ├── stackwalker_arm_unittest.cc
│ │ │ ├── stackwalker_ppc.cc
│ │ │ ├── stackwalker_ppc.h
│ │ │ ├── stackwalker_selftest.cc
│ │ │ ├── stackwalker_selftest_sol.s
│ │ │ ├── stackwalker_sparc.cc
│ │ │ ├── stackwalker_sparc.h
│ │ │ ├── stackwalker_unittest_utils.h
│ │ │ ├── stackwalker_x86.cc
│ │ │ ├── stackwalker_x86.h
│ │ │ ├── stackwalker_x86_unittest.cc
│ │ │ ├── static_address_map-inl.h
│ │ │ ├── static_address_map.h
│ │ │ ├── static_address_map_unittest.cc
│ │ │ ├── static_contained_range_map-inl.h
│ │ │ ├── static_contained_range_map.h
│ │ │ ├── static_contained_range_map_unittest.cc
│ │ │ ├── static_map-inl.h
│ │ │ ├── static_map.h
│ │ │ ├── static_map_iterator-inl.h
│ │ │ ├── static_map_iterator.h
│ │ │ ├── static_map_unittest.cc
│ │ │ ├── static_range_map-inl.h
│ │ │ ├── static_range_map.h
│ │ │ ├── static_range_map_unittest.cc
│ │ │ ├── synth_minidump.cc
│ │ │ ├── synth_minidump.h
│ │ │ ├── synth_minidump_unittest.cc
│ │ │ ├── synth_minidump_unittest_data.h
│ │ │ ├── testdata/
│ │ │ │ ├── ascii_read_av.dmp
│ │ │ │ ├── ascii_read_av_block_write.dmp
│ │ │ │ ├── ascii_read_av_clobber_write.dmp
│ │ │ │ ├── ascii_read_av_conditional.dmp
│ │ │ │ ├── ascii_read_av_then_jmp.dmp
│ │ │ │ ├── ascii_read_av_xchg_write.dmp
│ │ │ │ ├── ascii_write_av.dmp
│ │ │ │ ├── ascii_write_av_arg_to_call.dmp
│ │ │ │ ├── exec_av_on_stack.dmp
│ │ │ │ ├── linux_test_app.cc
│ │ │ │ ├── minidump2.dmp
│ │ │ │ ├── minidump2.dump.out
│ │ │ │ ├── minidump2.stackwalk.machine_readable.out
│ │ │ │ ├── minidump2.stackwalk.out
│ │ │ │ ├── module0.out
│ │ │ │ ├── module1.out
│ │ │ │ ├── module2.out
│ │ │ │ ├── module3_bad.out
│ │ │ │ ├── module4_bad.out
│ │ │ │ ├── null_read_av.dmp
│ │ │ │ ├── null_write_av.dmp
│ │ │ │ ├── read_av_clobber_write.dmp
│ │ │ │ ├── read_av_conditional.dmp
│ │ │ │ ├── read_av_non_null.dmp
│ │ │ │ ├── stack_exhaustion.dmp
│ │ │ │ ├── symbols/
│ │ │ │ │ ├── kernel32.pdb/
│ │ │ │ │ │ └── BCE8785C57B44245A669896B6A19B9542/
│ │ │ │ │ │ └── kernel32.sym
│ │ │ │ │ └── test_app.pdb/
│ │ │ │ │ └── 5A9832E5287241C1838ED98914E9B7FF1/
│ │ │ │ │ └── test_app.sym
│ │ │ │ ├── test_app.cc
│ │ │ │ └── write_av_non_null.dmp
│ │ │ ├── tokenize.cc
│ │ │ ├── tokenize.h
│ │ │ └── windows_frame_info.h
│ │ └── third_party/
│ │ ├── curl/
│ │ │ ├── COPYING
│ │ │ ├── curl.h
│ │ │ ├── curlbuild.h
│ │ │ ├── curlrules.h
│ │ │ ├── curlver.h
│ │ │ ├── easy.h
│ │ │ ├── mprintf.h
│ │ │ ├── multi.h
│ │ │ ├── stdcheaders.h
│ │ │ ├── typecheck-gcc.h
│ │ │ └── types.h
│ │ ├── glog/
│ │ │ ├── AUTHORS
│ │ │ ├── COPYING
│ │ │ ├── ChangeLog
│ │ │ ├── INSTALL
│ │ │ ├── NEWS
│ │ │ ├── README
│ │ │ ├── README.windows
│ │ │ ├── aclocal.m4
│ │ │ ├── compile
│ │ │ ├── config.guess
│ │ │ ├── config.sub
│ │ │ ├── configure
│ │ │ ├── configure.ac
│ │ │ ├── depcomp
│ │ │ ├── doc/
│ │ │ │ ├── designstyle.css
│ │ │ │ └── glog.html
│ │ │ ├── google-glog.sln
│ │ │ ├── install-sh
│ │ │ ├── libglog.pc.in
│ │ │ ├── ltmain.sh
│ │ │ ├── m4/
│ │ │ │ ├── ac_have_attribute.m4
│ │ │ │ ├── ac_have_builtin_expect.m4
│ │ │ │ ├── ac_have_sync_val_compare_and_swap.m4
│ │ │ │ ├── ac_rwlock.m4
│ │ │ │ ├── acx_pthread.m4
│ │ │ │ ├── google_namespace.m4
│ │ │ │ ├── libtool.m4
│ │ │ │ ├── ltoptions.m4
│ │ │ │ ├── ltsugar.m4
│ │ │ │ ├── ltversion.m4
│ │ │ │ ├── lt~obsolete.m4
│ │ │ │ ├── namespaces.m4
│ │ │ │ ├── pc_from_ucontext.m4
│ │ │ │ ├── stl_namespace.m4
│ │ │ │ └── using_operator.m4
│ │ │ ├── missing
│ │ │ ├── mkinstalldirs
│ │ │ ├── packages/
│ │ │ │ ├── deb/
│ │ │ │ │ ├── README
│ │ │ │ │ ├── changelog
│ │ │ │ │ ├── compat
│ │ │ │ │ ├── control
│ │ │ │ │ ├── copyright
│ │ │ │ │ ├── docs
│ │ │ │ │ ├── libgoogle-glog-dev.dirs
│ │ │ │ │ ├── libgoogle-glog-dev.install
│ │ │ │ │ ├── libgoogle-glog0.dirs
│ │ │ │ │ ├── libgoogle-glog0.install
│ │ │ │ │ └── rules
│ │ │ │ ├── deb.sh
│ │ │ │ ├── rpm/
│ │ │ │ │ └── rpm.spec
│ │ │ │ └── rpm.sh
│ │ │ ├── src/
│ │ │ │ ├── base/
│ │ │ │ │ ├── commandlineflags.h
│ │ │ │ │ ├── googleinit.h
│ │ │ │ │ └── mutex.h
│ │ │ │ ├── config.h.in
│ │ │ │ ├── config_for_unittests.h
│ │ │ │ ├── demangle.cc
│ │ │ │ ├── demangle.h
│ │ │ │ ├── demangle_unittest.cc
│ │ │ │ ├── demangle_unittest.sh
│ │ │ │ ├── demangle_unittest.txt
│ │ │ │ ├── glog/
│ │ │ │ │ ├── log_severity.h
│ │ │ │ │ ├── logging.h.in
│ │ │ │ │ ├── raw_logging.h.in
│ │ │ │ │ ├── stl_logging.h.in
│ │ │ │ │ └── vlog_is_on.h.in
│ │ │ │ ├── googletest.h
│ │ │ │ ├── logging.cc
│ │ │ │ ├── logging_striplog_test.sh
│ │ │ │ ├── logging_striptest10.cc
│ │ │ │ ├── logging_striptest2.cc
│ │ │ │ ├── logging_striptest_main.cc
│ │ │ │ ├── logging_unittest.cc
│ │ │ │ ├── logging_unittest.err
│ │ │ │ ├── mock-log.h
│ │ │ │ ├── mock-log_test.cc
│ │ │ │ ├── raw_logging.cc
│ │ │ │ ├── signalhandler.cc
│ │ │ │ ├── signalhandler_unittest.cc
│ │ │ │ ├── signalhandler_unittest.sh
│ │ │ │ ├── stacktrace.h
│ │ │ │ ├── stacktrace_generic-inl.h
│ │ │ │ ├── stacktrace_libunwind-inl.h
│ │ │ │ ├── stacktrace_powerpc-inl.h
│ │ │ │ ├── stacktrace_unittest.cc
│ │ │ │ ├── stacktrace_x86-inl.h
│ │ │ │ ├── stacktrace_x86_64-inl.h
│ │ │ │ ├── stl_logging_unittest.cc
│ │ │ │ ├── symbolize.cc
│ │ │ │ ├── symbolize.h
│ │ │ │ ├── symbolize_unittest.cc
│ │ │ │ ├── utilities.cc
│ │ │ │ ├── utilities.h
│ │ │ │ ├── utilities_unittest.cc
│ │ │ │ ├── vlog_is_on.cc
│ │ │ │ └── windows/
│ │ │ │ ├── config.h
│ │ │ │ ├── glog/
│ │ │ │ │ ├── log_severity.h
│ │ │ │ │ ├── logging.h
│ │ │ │ │ ├── raw_logging.h
│ │ │ │ │ ├── stl_logging.h
│ │ │ │ │ └── vlog_is_on.h
│ │ │ │ ├── port.cc
│ │ │ │ ├── port.h
│ │ │ │ └── preprocess.sh
│ │ │ └── vsprojects/
│ │ │ ├── libglog/
│ │ │ │ └── libglog.vcproj
│ │ │ ├── libglog_static/
│ │ │ │ └── libglog_static.vcproj
│ │ │ ├── logging_unittest/
│ │ │ │ └── logging_unittest.vcproj
│ │ │ └── logging_unittest_static/
│ │ │ └── logging_unittest_static.vcproj
│ │ ├── libdisasm/
│ │ │ ├── TODO
│ │ │ ├── ia32_implicit.c
│ │ │ ├── ia32_implicit.h
│ │ │ ├── ia32_insn.c
│ │ │ ├── ia32_insn.h
│ │ │ ├── ia32_invariant.c
│ │ │ ├── ia32_invariant.h
│ │ │ ├── ia32_modrm.c
│ │ │ ├── ia32_modrm.h
│ │ │ ├── ia32_opcode_tables.c
│ │ │ ├── ia32_opcode_tables.h
│ │ │ ├── ia32_operand.c
│ │ │ ├── ia32_operand.h
│ │ │ ├── ia32_reg.c
│ │ │ ├── ia32_reg.h
│ │ │ ├── ia32_settings.c
│ │ │ ├── ia32_settings.h
│ │ │ ├── libdis.h
│ │ │ ├── qword.h
│ │ │ ├── swig/
│ │ │ │ ├── README
│ │ │ │ ├── libdisasm.i
│ │ │ │ ├── libdisasm_oop.i
│ │ │ │ └── ruby/
│ │ │ │ └── extconf.rb
│ │ │ ├── x86_disasm.c
│ │ │ ├── x86_format.c
│ │ │ ├── x86_imm.c
│ │ │ ├── x86_imm.h
│ │ │ ├── x86_insn.c
│ │ │ ├── x86_misc.c
│ │ │ ├── x86_operand_list.c
│ │ │ └── x86_operand_list.h
│ │ ├── linux/
│ │ │ └── include/
│ │ │ └── gflags/
│ │ │ ├── gflags.h
│ │ │ └── gflags_completions.h
│ │ ├── lss/
│ │ │ └── linux_syscall_support.h
│ │ └── protobuf/
│ │ └── protobuf/
│ │ ├── CHANGES.txt
│ │ ├── CONTRIBUTORS.txt
│ │ ├── COPYING.txt
│ │ ├── INSTALL.txt
│ │ ├── README.txt
│ │ ├── autogen.sh
│ │ ├── benchmarks/
│ │ │ ├── ProtoBench.java
│ │ │ ├── google_size.proto
│ │ │ ├── google_speed.proto
│ │ │ └── readme.txt
│ │ ├── configure.ac
│ │ ├── editors/
│ │ │ ├── README.txt
│ │ │ ├── proto.vim
│ │ │ └── protobuf-mode.el
│ │ ├── examples/
│ │ │ ├── AddPerson.java
│ │ │ ├── ListPeople.java
│ │ │ ├── README.txt
│ │ │ ├── add_person.cc
│ │ │ ├── add_person.py
│ │ │ ├── addressbook.proto
│ │ │ ├── list_people.cc
│ │ │ └── list_people.py
│ │ ├── generate_descriptor_proto.sh
│ │ ├── gtest/
│ │ │ ├── CHANGES
│ │ │ ├── CMakeLists.txt
│ │ │ ├── CONTRIBUTORS
│ │ │ ├── COPYING
│ │ │ ├── README
│ │ │ ├── build-aux/
│ │ │ │ └── .keep
│ │ │ ├── codegear/
│ │ │ │ ├── gtest.cbproj
│ │ │ │ ├── gtest.groupproj
│ │ │ │ ├── gtest_all.cc
│ │ │ │ ├── gtest_link.cc
│ │ │ │ ├── gtest_main.cbproj
│ │ │ │ └── gtest_unittest.cbproj
│ │ │ ├── configure.ac
│ │ │ ├── include/
│ │ │ │ └── gtest/
│ │ │ │ ├── gtest-death-test.h
│ │ │ │ ├── gtest-message.h
│ │ │ │ ├── gtest-param-test.h
│ │ │ │ ├── gtest-param-test.h.pump
│ │ │ │ ├── gtest-spi.h
│ │ │ │ ├── gtest-test-part.h
│ │ │ │ ├── gtest-typed-test.h
│ │ │ │ ├── gtest.h
│ │ │ │ ├── gtest_pred_impl.h
│ │ │ │ ├── gtest_prod.h
│ │ │ │ └── internal/
│ │ │ │ ├── gtest-death-test-internal.h
│ │ │ │ ├── gtest-filepath.h
│ │ │ │ ├── gtest-internal.h
│ │ │ │ ├── gtest-linked_ptr.h
│ │ │ │ ├── gtest-param-util-generated.h
│ │ │ │ ├── gtest-param-util-generated.h.pump
│ │ │ │ ├── gtest-param-util.h
│ │ │ │ ├── gtest-port.h
│ │ │ │ ├── gtest-string.h
│ │ │ │ ├── gtest-tuple.h
│ │ │ │ ├── gtest-tuple.h.pump
│ │ │ │ ├── gtest-type-util.h
│ │ │ │ └── gtest-type-util.h.pump
│ │ │ ├── m4/
│ │ │ │ ├── acx_pthread.m4
│ │ │ │ └── gtest.m4
│ │ │ ├── msvc/
│ │ │ │ ├── gtest-md.sln
│ │ │ │ ├── gtest-md.vcproj
│ │ │ │ ├── gtest.sln
│ │ │ │ ├── gtest.vcproj
│ │ │ │ ├── gtest_main-md.vcproj
│ │ │ │ ├── gtest_main.vcproj
│ │ │ │ ├── gtest_prod_test-md.vcproj
│ │ │ │ ├── gtest_prod_test.vcproj
│ │ │ │ ├── gtest_unittest-md.vcproj
│ │ │ │ └── gtest_unittest.vcproj
│ │ │ ├── run_tests.py
│ │ │ ├── samples/
│ │ │ │ ├── prime_tables.h
│ │ │ │ ├── sample1.cc
│ │ │ │ ├── sample1.h
│ │ │ │ ├── sample10_unittest.cc
│ │ │ │ ├── sample1_unittest.cc
│ │ │ │ ├── sample2.cc
│ │ │ │ ├── sample2.h
│ │ │ │ ├── sample2_unittest.cc
│ │ │ │ ├── sample3-inl.h
│ │ │ │ ├── sample3_unittest.cc
│ │ │ │ ├── sample4.cc
│ │ │ │ ├── sample4.h
│ │ │ │ ├── sample4_unittest.cc
│ │ │ │ ├── sample5_unittest.cc
│ │ │ │ ├── sample6_unittest.cc
│ │ │ │ ├── sample7_unittest.cc
│ │ │ │ ├── sample8_unittest.cc
│ │ │ │ └── sample9_unittest.cc
│ │ │ ├── scripts/
│ │ │ │ ├── fuse_gtest_files.py
│ │ │ │ ├── gen_gtest_pred_impl.py
│ │ │ │ ├── gtest-config.in
│ │ │ │ ├── pump.py
│ │ │ │ ├── upload.py
│ │ │ │ └── upload_gtest.py
│ │ │ ├── src/
│ │ │ │ ├── gtest-all.cc
│ │ │ │ ├── gtest-death-test.cc
│ │ │ │ ├── gtest-filepath.cc
│ │ │ │ ├── gtest-internal-inl.h
│ │ │ │ ├── gtest-port.cc
│ │ │ │ ├── gtest-test-part.cc
│ │ │ │ ├── gtest-typed-test.cc
│ │ │ │ ├── gtest.cc
│ │ │ │ └── gtest_main.cc
│ │ │ ├── test/
│ │ │ │ ├── gtest-death-test_test.cc
│ │ │ │ ├── gtest-filepath_test.cc
│ │ │ │ ├── gtest-linked_ptr_test.cc
│ │ │ │ ├── gtest-listener_test.cc
│ │ │ │ ├── gtest-message_test.cc
│ │ │ │ ├── gtest-options_test.cc
│ │ │ │ ├── gtest-param-test2_test.cc
│ │ │ │ ├── gtest-param-test_test.cc
│ │ │ │ ├── gtest-param-test_test.h
│ │ │ │ ├── gtest-port_test.cc
│ │ │ │ ├── gtest-test-part_test.cc
│ │ │ │ ├── gtest-tuple_test.cc
│ │ │ │ ├── gtest-typed-test2_test.cc
│ │ │ │ ├── gtest-typed-test_test.cc
│ │ │ │ ├── gtest-typed-test_test.h
│ │ │ │ ├── gtest-unittest-api_test.cc
│ │ │ │ ├── gtest_all_test.cc
│ │ │ │ ├── gtest_break_on_failure_unittest.py
│ │ │ │ ├── gtest_break_on_failure_unittest_.cc
│ │ │ │ ├── gtest_color_test.py
│ │ │ │ ├── gtest_color_test_.cc
│ │ │ │ ├── gtest_env_var_test.py
│ │ │ │ ├── gtest_env_var_test_.cc
│ │ │ │ ├── gtest_environment_test.cc
│ │ │ │ ├── gtest_filter_unittest.py
│ │ │ │ ├── gtest_filter_unittest_.cc
│ │ │ │ ├── gtest_help_test.py
│ │ │ │ ├── gtest_help_test_.cc
│ │ │ │ ├── gtest_list_tests_unittest.py
│ │ │ │ ├── gtest_list_tests_unittest_.cc
│ │ │ │ ├── gtest_main_unittest.cc
│ │ │ │ ├── gtest_nc.cc
│ │ │ │ ├── gtest_nc_test.py
│ │ │ │ ├── gtest_no_test_unittest.cc
│ │ │ │ ├── gtest_output_test.py
│ │ │ │ ├── gtest_output_test_.cc
│ │ │ │ ├── gtest_output_test_golden_lin.txt
│ │ │ │ ├── gtest_output_test_golden_win.txt
│ │ │ │ ├── gtest_pred_impl_unittest.cc
│ │ │ │ ├── gtest_prod_test.cc
│ │ │ │ ├── gtest_repeat_test.cc
│ │ │ │ ├── gtest_shuffle_test.py
│ │ │ │ ├── gtest_shuffle_test_.cc
│ │ │ │ ├── gtest_sole_header_test.cc
│ │ │ │ ├── gtest_stress_test.cc
│ │ │ │ ├── gtest_test_utils.py
│ │ │ │ ├── gtest_throw_on_failure_ex_test.cc
│ │ │ │ ├── gtest_throw_on_failure_test.py
│ │ │ │ ├── gtest_throw_on_failure_test_.cc
│ │ │ │ ├── gtest_uninitialized_test.py
│ │ │ │ ├── gtest_uninitialized_test_.cc
│ │ │ │ ├── gtest_unittest.cc
│ │ │ │ ├── gtest_xml_outfile1_test_.cc
│ │ │ │ ├── gtest_xml_outfile2_test_.cc
│ │ │ │ ├── gtest_xml_outfiles_test.py
│ │ │ │ ├── gtest_xml_output_unittest.py
│ │ │ │ ├── gtest_xml_output_unittest_.cc
│ │ │ │ ├── gtest_xml_test_utils.py
│ │ │ │ ├── production.cc
│ │ │ │ ├── production.h
│ │ │ │ ├── run_tests_util.py
│ │ │ │ └── run_tests_util_test.py
│ │ │ └── xcode/
│ │ │ ├── Config/
│ │ │ │ ├── DebugProject.xcconfig
│ │ │ │ ├── FrameworkTarget.xcconfig
│ │ │ │ ├── General.xcconfig
│ │ │ │ ├── ReleaseProject.xcconfig
│ │ │ │ ├── StaticLibraryTarget.xcconfig
│ │ │ │ └── TestTarget.xcconfig
│ │ │ ├── Resources/
│ │ │ │ └── Info.plist
│ │ │ ├── Samples/
│ │ │ │ └── FrameworkSample/
│ │ │ │ ├── Info.plist
│ │ │ │ ├── WidgetFramework.xcodeproj/
│ │ │ │ │ └── project.pbxproj
│ │ │ │ ├── runtests.sh
│ │ │ │ ├── widget.cc
│ │ │ │ ├── widget.h
│ │ │ │ └── widget_test.cc
│ │ │ ├── Scripts/
│ │ │ │ ├── runtests.sh
│ │ │ │ └── versiongenerate.py
│ │ │ └── gtest.xcodeproj/
│ │ │ └── project.pbxproj
│ │ ├── java/
│ │ │ ├── README.txt
│ │ │ ├── pom.xml
│ │ │ └── src/
│ │ │ ├── main/
│ │ │ │ └── java/
│ │ │ │ └── com/
│ │ │ │ └── google/
│ │ │ │ └── protobuf/
│ │ │ │ ├── AbstractMessage.java
│ │ │ │ ├── AbstractMessageLite.java
│ │ │ │ ├── BlockingRpcChannel.java
│ │ │ │ ├── BlockingService.java
│ │ │ │ ├── ByteString.java
│ │ │ │ ├── CodedInputStream.java
│ │ │ │ ├── CodedOutputStream.java
│ │ │ │ ├── Descriptors.java
│ │ │ │ ├── DynamicMessage.java
│ │ │ │ ├── ExtensionRegistry.java
│ │ │ │ ├── ExtensionRegistryLite.java
│ │ │ │ ├── FieldSet.java
│ │ │ │ ├── GeneratedMessage.java
│ │ │ │ ├── GeneratedMessageLite.java
│ │ │ │ ├── Internal.java
│ │ │ │ ├── InvalidProtocolBufferException.java
│ │ │ │ ├── LazyStringArrayList.java
│ │ │ │ ├── LazyStringList.java
│ │ │ │ ├── Message.java
│ │ │ │ ├── MessageLite.java
│ │ │ │ ├── MessageLiteOrBuilder.java
│ │ │ │ ├── MessageOrBuilder.java
│ │ │ │ ├── ProtocolMessageEnum.java
│ │ │ │ ├── RepeatedFieldBuilder.java
│ │ │ │ ├── RpcCallback.java
│ │ │ │ ├── RpcChannel.java
│ │ │ │ ├── RpcController.java
│ │ │ │ ├── RpcUtil.java
│ │ │ │ ├── Service.java
│ │ │ │ ├── ServiceException.java
│ │ │ │ ├── SingleFieldBuilder.java
│ │ │ │ ├── SmallSortedMap.java
│ │ │ │ ├── TextFormat.java
│ │ │ │ ├── UninitializedMessageException.java
│ │ │ │ ├── UnknownFieldSet.java
│ │ │ │ ├── UnmodifiableLazyStringList.java
│ │ │ │ └── WireFormat.java
│ │ │ └── test/
│ │ │ └── java/
│ │ │ └── com/
│ │ │ └── google/
│ │ │ └── protobuf/
│ │ │ ├── AbstractMessageTest.java
│ │ │ ├── CodedInputStreamTest.java
│ │ │ ├── CodedOutputStreamTest.java
│ │ │ ├── DeprecatedFieldTest.java
│ │ │ ├── DescriptorsTest.java
│ │ │ ├── DynamicMessageTest.java
│ │ │ ├── ForceFieldBuildersPreRun.java
│ │ │ ├── GeneratedMessageTest.java
│ │ │ ├── LazyStringArrayListTest.java
│ │ │ ├── LazyStringEndToEndTest.java
│ │ │ ├── LiteTest.java
│ │ │ ├── MessageTest.java
│ │ │ ├── NestedBuildersTest.java
│ │ │ ├── RepeatedFieldBuilderTest.java
│ │ │ ├── ServiceTest.java
│ │ │ ├── SingleFieldBuilderTest.java
│ │ │ ├── SmallSortedMapTest.java
│ │ │ ├── TestBadIdentifiers.java
│ │ │ ├── TestUtil.java
│ │ │ ├── TextFormatTest.java
│ │ │ ├── UnknownFieldSetTest.java
│ │ │ ├── UnmodifiableLazyStringListTest.java
│ │ │ ├── WireFormatTest.java
│ │ │ ├── multiple_files_test.proto
│ │ │ ├── nested_builders_test.proto
│ │ │ ├── nested_extension.proto
│ │ │ ├── nested_extension_lite.proto
│ │ │ ├── non_nested_extension.proto
│ │ │ ├── non_nested_extension_lite.proto
│ │ │ └── test_bad_identifiers.proto
│ │ ├── m4/
│ │ │ ├── ac_system_extensions.m4
│ │ │ ├── acx_check_suncc.m4
│ │ │ ├── acx_pthread.m4
│ │ │ └── stl_hash.m4
│ │ ├── post_process_dist.sh
│ │ ├── protobuf-lite.pc.in
│ │ ├── protobuf.pc.in
│ │ ├── python/
│ │ │ ├── README.txt
│ │ │ ├── ez_setup.py
│ │ │ ├── google/
│ │ │ │ ├── __init__.py
│ │ │ │ └── protobuf/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── descriptor.py
│ │ │ │ ├── internal/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── api_implementation.py
│ │ │ │ │ ├── containers.py
│ │ │ │ │ ├── cpp_message.py
│ │ │ │ │ ├── decoder.py
│ │ │ │ │ ├── descriptor_test.py
│ │ │ │ │ ├── encoder.py
│ │ │ │ │ ├── generator_test.py
│ │ │ │ │ ├── message_listener.py
│ │ │ │ │ ├── message_test.py
│ │ │ │ │ ├── more_extensions.proto
│ │ │ │ │ ├── more_messages.proto
│ │ │ │ │ ├── python_message.py
│ │ │ │ │ ├── reflection_test.py
│ │ │ │ │ ├── service_reflection_test.py
│ │ │ │ │ ├── test_util.py
│ │ │ │ │ ├── text_format_test.py
│ │ │ │ │ ├── type_checkers.py
│ │ │ │ │ ├── wire_format.py
│ │ │ │ │ └── wire_format_test.py
│ │ │ │ ├── message.py
│ │ │ │ ├── pyext/
│ │ │ │ │ ├── python-proto2.cc
│ │ │ │ │ ├── python_descriptor.cc
│ │ │ │ │ ├── python_descriptor.h
│ │ │ │ │ ├── python_protobuf.cc
│ │ │ │ │ └── python_protobuf.h
│ │ │ │ ├── reflection.py
│ │ │ │ ├── service.py
│ │ │ │ ├── service_reflection.py
│ │ │ │ └── text_format.py
│ │ │ ├── mox.py
│ │ │ ├── setup.py
│ │ │ └── stubout.py
│ │ ├── src/
│ │ │ ├── google/
│ │ │ │ └── protobuf/
│ │ │ │ ├── SEBS
│ │ │ │ ├── compiler/
│ │ │ │ │ ├── code_generator.cc
│ │ │ │ │ ├── code_generator.h
│ │ │ │ │ ├── command_line_interface.cc
│ │ │ │ │ ├── command_line_interface.h
│ │ │ │ │ ├── command_line_interface_unittest.cc
│ │ │ │ │ ├── cpp/
│ │ │ │ │ │ ├── cpp_bootstrap_unittest.cc
│ │ │ │ │ │ ├── cpp_enum.cc
│ │ │ │ │ │ ├── cpp_enum.h
│ │ │ │ │ │ ├── cpp_enum_field.cc
│ │ │ │ │ │ ├── cpp_enum_field.h
│ │ │ │ │ │ ├── cpp_extension.cc
│ │ │ │ │ │ ├── cpp_extension.h
│ │ │ │ │ │ ├── cpp_field.cc
│ │ │ │ │ │ ├── cpp_field.h
│ │ │ │ │ │ ├── cpp_file.cc
│ │ │ │ │ │ ├── cpp_file.h
│ │ │ │ │ │ ├── cpp_generator.cc
│ │ │ │ │ │ ├── cpp_generator.h
│ │ │ │ │ │ ├── cpp_helpers.cc
│ │ │ │ │ │ ├── cpp_helpers.h
│ │ │ │ │ │ ├── cpp_message.cc
│ │ │ │ │ │ ├── cpp_message.h
│ │ │ │ │ │ ├── cpp_message_field.cc
│ │ │ │ │ │ ├── cpp_message_field.h
│ │ │ │ │ │ ├── cpp_plugin_unittest.cc
│ │ │ │ │ │ ├── cpp_primitive_field.cc
│ │ │ │ │ │ ├── cpp_primitive_field.h
│ │ │ │ │ │ ├── cpp_service.cc
│ │ │ │ │ │ ├── cpp_service.h
│ │ │ │ │ │ ├── cpp_string_field.cc
│ │ │ │ │ │ ├── cpp_string_field.h
│ │ │ │ │ │ ├── cpp_test_bad_identifiers.proto
│ │ │ │ │ │ └── cpp_unittest.cc
│ │ │ │ │ ├── importer.cc
│ │ │ │ │ ├── importer.h
│ │ │ │ │ ├── importer_unittest.cc
│ │ │ │ │ ├── java/
│ │ │ │ │ │ ├── java_enum.cc
│ │ │ │ │ │ ├── java_enum.h
│ │ │ │ │ │ ├── java_enum_field.cc
│ │ │ │ │ │ ├── java_enum_field.h
│ │ │ │ │ │ ├── java_extension.cc
│ │ │ │ │ │ ├── java_extension.h
│ │ │ │ │ │ ├── java_field.cc
│ │ │ │ │ │ ├── java_field.h
│ │ │ │ │ │ ├── java_file.cc
│ │ │ │ │ │ ├── java_file.h
│ │ │ │ │ │ ├── java_generator.cc
│ │ │ │ │ │ ├── java_generator.h
│ │ │ │ │ │ ├── java_helpers.cc
│ │ │ │ │ │ ├── java_helpers.h
│ │ │ │ │ │ ├── java_message.cc
│ │ │ │ │ │ ├── java_message.h
│ │ │ │ │ │ ├── java_message_field.cc
│ │ │ │ │ │ ├── java_message_field.h
│ │ │ │ │ │ ├── java_plugin_unittest.cc
│ │ │ │ │ │ ├── java_primitive_field.cc
│ │ │ │ │ │ ├── java_primitive_field.h
│ │ │ │ │ │ ├── java_service.cc
│ │ │ │ │ │ ├── java_service.h
│ │ │ │ │ │ ├── java_string_field.cc
│ │ │ │ │ │ └── java_string_field.h
│ │ │ │ │ ├── main.cc
│ │ │ │ │ ├── mock_code_generator.cc
│ │ │ │ │ ├── mock_code_generator.h
│ │ │ │ │ ├── package_info.h
│ │ │ │ │ ├── parser.cc
│ │ │ │ │ ├── parser.h
│ │ │ │ │ ├── parser_unittest.cc
│ │ │ │ │ ├── plugin.cc
│ │ │ │ │ ├── plugin.h
│ │ │ │ │ ├── plugin.pb.cc
│ │ │ │ │ ├── plugin.pb.h
│ │ │ │ │ ├── plugin.proto
│ │ │ │ │ ├── python/
│ │ │ │ │ │ ├── python_generator.cc
│ │ │ │ │ │ ├── python_generator.h
│ │ │ │ │ │ └── python_plugin_unittest.cc
│ │ │ │ │ ├── subprocess.cc
│ │ │ │ │ ├── subprocess.h
│ │ │ │ │ ├── test_plugin.cc
│ │ │ │ │ ├── zip_output_unittest.sh
│ │ │ │ │ ├── zip_writer.cc
│ │ │ │ │ └── zip_writer.h
│ │ │ │ ├── descriptor.cc
│ │ │ │ ├── descriptor.h
│ │ │ │ ├── descriptor.pb.cc
│ │ │ │ ├── descriptor.pb.h
│ │ │ │ ├── descriptor.proto
│ │ │ │ ├── descriptor_database.cc
│ │ │ │ ├── descriptor_database.h
│ │ │ │ ├── descriptor_database_unittest.cc
│ │ │ │ ├── descriptor_unittest.cc
│ │ │ │ ├── dynamic_message.cc
│ │ │ │ ├── dynamic_message.h
│ │ │ │ ├── dynamic_message_unittest.cc
│ │ │ │ ├── extension_set.cc
│ │ │ │ ├── extension_set.h
│ │ │ │ ├── extension_set_heavy.cc
│ │ │ │ ├── extension_set_unittest.cc
│ │ │ │ ├── generated_message_reflection.cc
│ │ │ │ ├── generated_message_reflection.h
│ │ │ │ ├── generated_message_reflection_unittest.cc
│ │ │ │ ├── generated_message_util.cc
│ │ │ │ ├── generated_message_util.h
│ │ │ │ ├── io/
│ │ │ │ │ ├── coded_stream.cc
│ │ │ │ │ ├── coded_stream.h
│ │ │ │ │ ├── coded_stream_inl.h
│ │ │ │ │ ├── coded_stream_unittest.cc
│ │ │ │ │ ├── gzip_stream.cc
│ │ │ │ │ ├── gzip_stream.h
│ │ │ │ │ ├── gzip_stream_unittest.sh
│ │ │ │ │ ├── package_info.h
│ │ │ │ │ ├── printer.cc
│ │ │ │ │ ├── printer.h
│ │ │ │ │ ├── printer_unittest.cc
│ │ │ │ │ ├── tokenizer.cc
│ │ │ │ │ ├── tokenizer.h
│ │ │ │ │ ├── tokenizer_unittest.cc
│ │ │ │ │ ├── zero_copy_stream.cc
│ │ │ │ │ ├── zero_copy_stream.h
│ │ │ │ │ ├── zero_copy_stream_impl.cc
│ │ │ │ │ ├── zero_copy_stream_impl.h
│ │ │ │ │ ├── zero_copy_stream_impl_lite.cc
│ │ │ │ │ ├── zero_copy_stream_impl_lite.h
│ │ │ │ │ └── zero_copy_stream_unittest.cc
│ │ │ │ ├── lite_unittest.cc
│ │ │ │ ├── message.cc
│ │ │ │ ├── message.h
│ │ │ │ ├── message_lite.cc
│ │ │ │ ├── message_lite.h
│ │ │ │ ├── message_unittest.cc
│ │ │ │ ├── package_info.h
│ │ │ │ ├── reflection_ops.cc
│ │ │ │ ├── reflection_ops.h
│ │ │ │ ├── reflection_ops_unittest.cc
│ │ │ │ ├── repeated_field.cc
│ │ │ │ ├── repeated_field.h
│ │ │ │ ├── repeated_field_unittest.cc
│ │ │ │ ├── service.cc
│ │ │ │ ├── service.h
│ │ │ │ ├── stubs/
│ │ │ │ │ ├── common.cc
│ │ │ │ │ ├── common.h
│ │ │ │ │ ├── common_unittest.cc
│ │ │ │ │ ├── hash.h
│ │ │ │ │ ├── map-util.h
│ │ │ │ │ ├── once.cc
│ │ │ │ │ ├── once.h
│ │ │ │ │ ├── once_unittest.cc
│ │ │ │ │ ├── stl_util-inl.h
│ │ │ │ │ ├── structurally_valid.cc
│ │ │ │ │ ├── structurally_valid_unittest.cc
│ │ │ │ │ ├── strutil.cc
│ │ │ │ │ ├── strutil.h
│ │ │ │ │ ├── strutil_unittest.cc
│ │ │ │ │ ├── substitute.cc
│ │ │ │ │ └── substitute.h
│ │ │ │ ├── test_util.cc
│ │ │ │ ├── test_util.h
│ │ │ │ ├── test_util_lite.cc
│ │ │ │ ├── test_util_lite.h
│ │ │ │ ├── testdata/
│ │ │ │ │ ├── golden_message
│ │ │ │ │ ├── golden_packed_fields_message
│ │ │ │ │ ├── text_format_unittest_data.txt
│ │ │ │ │ └── text_format_unittest_extensions_data.txt
│ │ │ │ ├── testing/
│ │ │ │ │ ├── file.cc
│ │ │ │ │ ├── file.h
│ │ │ │ │ ├── googletest.cc
│ │ │ │ │ ├── googletest.h
│ │ │ │ │ ├── zcgunzip.cc
│ │ │ │ │ └── zcgzip.cc
│ │ │ │ ├── text_format.cc
│ │ │ │ ├── text_format.h
│ │ │ │ ├── text_format_unittest.cc
│ │ │ │ ├── unittest.proto
│ │ │ │ ├── unittest_custom_options.proto
│ │ │ │ ├── unittest_embed_optimize_for.proto
│ │ │ │ ├── unittest_empty.proto
│ │ │ │ ├── unittest_enormous_descriptor.proto
│ │ │ │ ├── unittest_import.proto
│ │ │ │ ├── unittest_import_lite.proto
│ │ │ │ ├── unittest_lite.proto
│ │ │ │ ├── unittest_lite_imports_nonlite.proto
│ │ │ │ ├── unittest_mset.proto
│ │ │ │ ├── unittest_no_generic_services.proto
│ │ │ │ ├── unittest_optimize_for.proto
│ │ │ │ ├── unknown_field_set.cc
│ │ │ │ ├── unknown_field_set.h
│ │ │ │ ├── unknown_field_set_unittest.cc
│ │ │ │ ├── wire_format.cc
│ │ │ │ ├── wire_format.h
│ │ │ │ ├── wire_format_lite.cc
│ │ │ │ ├── wire_format_lite.h
│ │ │ │ ├── wire_format_lite_inl.h
│ │ │ │ └── wire_format_unittest.cc
│ │ │ └── solaris/
│ │ │ └── libstdc++.la
│ │ └── vsprojects/
│ │ ├── config.h
│ │ ├── convert2008to2005.sh
│ │ ├── extract_includes.bat
│ │ ├── libprotobuf-lite.vcproj
│ │ ├── libprotobuf.vcproj
│ │ ├── libprotoc.vcproj
│ │ ├── lite-test.vcproj
│ │ ├── protobuf.sln
│ │ ├── protoc.vcproj
│ │ ├── readme.txt
│ │ ├── test_plugin.vcproj
│ │ └── tests.vcproj
│ ├── callbacks.h
│ ├── cmake/
│ │ ├── FindQJSON.cmake
│ │ └── Findlibspotify.cmake
│ ├── consolewatcher.cpp
│ ├── consolewatcher.h
│ ├── kdsingleapplicationguard/
│ │ ├── kdlockedsharedmemorypointer.cpp
│ │ ├── kdlockedsharedmemorypointer.h
│ │ ├── kdsharedmemorylocker.cpp
│ │ ├── kdsharedmemorylocker.h
│ │ ├── kdsingleapplicationguard.cpp
│ │ ├── kdsingleapplicationguard.h
│ │ ├── kdtoolsglobal.cpp
│ │ ├── kdtoolsglobal.h
│ │ ├── license-gpl
│ │ ├── pimpl_ptr.cpp
│ │ └── pimpl_ptr.h
│ ├── logger.cpp
│ ├── logger.h
│ ├── main.cpp
│ ├── main.h
│ ├── qxtweb-standalone/
│ │ ├── CMakeLists.txt
│ │ ├── README.txt
│ │ └── qxtweb/
│ │ ├── QxtAbstractHttpConnector
│ │ ├── QxtAbstractWebService
│ │ ├── QxtAbstractWebSessionManager
│ │ ├── QxtHtmlTemplate
│ │ ├── QxtHttpServerConnector
│ │ ├── QxtHttpSessionManager
│ │ ├── QxtMail
│ │ ├── QxtScgiServerConnector
│ │ ├── QxtSendmail
│ │ ├── QxtWeb
│ │ ├── QxtWebCgiService
│ │ ├── QxtWebContent
│ │ ├── QxtWebErrorEvent
│ │ ├── QxtWebEvent
│ │ ├── QxtWebFileUploadEvent
│ │ ├── QxtWebPageEvent
│ │ ├── QxtWebRedirectEvent
│ │ ├── QxtWebRemoveCookieEvent
│ │ ├── QxtWebRequestEvent
│ │ ├── QxtWebServiceDirectory
│ │ ├── QxtWebSlotService
│ │ ├── QxtWebStoreCookieEvent
│ │ ├── qxtabstracthttpconnector.cpp
│ │ ├── qxtabstracthttpconnector.h
│ │ ├── qxtabstractwebservice.cpp
│ │ ├── qxtabstractwebservice.h
│ │ ├── qxtabstractwebsessionmanager.cpp
│ │ ├── qxtabstractwebsessionmanager.h
│ │ ├── qxtabstractwebsessionmanager_p.h
│ │ ├── qxtboundcfunction.h
│ │ ├── qxtboundfunction.h
│ │ ├── qxtboundfunctionbase.h
│ │ ├── qxtglobal.cpp
│ │ ├── qxtglobal.h
│ │ ├── qxthtmltemplate.cpp
│ │ ├── qxthtmltemplate.h
│ │ ├── qxthttpserverconnector.cpp
│ │ ├── qxthttpsessionmanager.cpp
│ │ ├── qxthttpsessionmanager.h
│ │ ├── qxtmetaobject.cpp
│ │ ├── qxtmetaobject.h
│ │ ├── qxtmetatype.h
│ │ ├── qxtnull.cpp
│ │ ├── qxtnull.h
│ │ ├── qxtnullable.h
│ │ ├── qxtscgiserverconnector.cpp
│ │ ├── qxtweb.h
│ │ ├── qxtwebcgiservice.cpp
│ │ ├── qxtwebcgiservice.h
│ │ ├── qxtwebcgiservice_p.h
│ │ ├── qxtwebcontent.cpp
│ │ ├── qxtwebcontent.h
│ │ ├── qxtwebevent.cpp
│ │ ├── qxtwebevent.h
│ │ ├── qxtwebservicedirectory.cpp
│ │ ├── qxtwebservicedirectory.h
│ │ ├── qxtwebservicedirectory_p.h
│ │ ├── qxtwebslotservice.cpp
│ │ └── qxtwebslotservice.h
│ ├── spotify.desktop
│ ├── spotify_key.h
│ ├── spotifyiodevice.cpp
│ ├── spotifyiodevice.h
│ ├── spotifyloghandler.cpp
│ ├── spotifyloghandler.h
│ ├── spotifyplayback.cpp
│ ├── spotifyplayback.h
│ ├── spotifyplaylists.cpp
│ ├── spotifyplaylists.h
│ ├── spotifyresolver.cpp
│ ├── spotifyresolver.h
│ ├── spotifysearch.cpp
│ ├── spotifysearch.h
│ ├── spotifysession.cpp
│ ├── spotifysession.h
│ └── tomahawkspotify.kdev4
├── authproxy/
│ ├── app.yaml
│ ├── authproxy.go
│ └── index.html
├── bandcamp/
│ ├── README.md
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── bandcamp.js
│ └── metadata.json
├── bandcampmobile/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── bandcampm.js
│ └── metadata.json
├── beatsmusic/
│ ├── LICENSE
│ ├── content/
│ │ ├── contents/
│ │ │ └── code/
│ │ │ ├── async.js
│ │ │ ├── beatsmusic.js
│ │ │ ├── config.ui
│ │ │ └── test.js
│ │ └── metadata.json
│ └── helpers/
│ └── resolve.js
├── beets/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── beets.js
│ │ └── config.ui
│ └── metadata.json
├── bower.json
├── deezer/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── deezer.js
│ └── metadata.json
├── deezer-metadata/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── deezer-metadata.js
│ └── metadata.json
├── docs/
│ ├── .gitignore
│ ├── docs/
│ │ ├── basic.md
│ │ ├── index.md
│ │ ├── searchresolve.md
│ │ └── urllookup.md
│ └── mkdocs.yml
├── examples/
│ ├── javascript/
│ │ └── content/
│ │ ├── contents/
│ │ │ └── code/
│ │ │ ├── config.ui
│ │ │ └── example.js
│ │ └── metadata.json
│ ├── php/
│ │ └── php-resolver.php
│ └── streamtest/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── streamtest.js
│ └── metadata.json
├── gmusic/
│ ├── .gitignore
│ ├── COPYING.txt
│ ├── README.md
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── gmusic.js
│ └── metadata.json
├── hatchet-metadata/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── hatchet-metadata.js
│ └── metadata.json
├── itunes/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── itunes.js
│ └── metadata.json
├── jamendo/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── jamendo.js
│ └── metadata.json
├── jazz-on-line/
│ ├── jazz-on-line-resolver.py
│ ├── jol_search.py
│ └── listing.txt
├── kibergrad/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── kibergrad.js
│ └── metadata.json
├── lastfm/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── lastfm.js
│ └── metadata.json
├── muzebra/
│ └── muzebra.js
├── myzuka/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── myzuka.js
│ └── metadata.json
├── netease/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── netease.js
│ └── metadata.json
├── officialfm/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── officialfm.js
│ └── metadata.json
├── omnify-metadata/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── omnify-metadata.js
│ └── metadata.json
├── package.json
├── prostopleer/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── pleer.js
│ └── metadata.json
├── qobuz/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── qobuz.js
│ └── metadata.json
├── rhapsody/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── rhapsody.js
│ └── metadata.json
├── soundcloud/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ ├── soundcloud.js
│ │ └── test.js
│ └── metadata.json
├── spotify/
│ ├── LICENSE
│ ├── content/
│ │ ├── contents/
│ │ │ └── code/
│ │ │ ├── config.ui
│ │ │ └── spotify.js
│ │ └── metadata.json
│ └── native/
│ ├── CMakeLists.txt
│ ├── CMakeModules/
│ │ ├── FindMicrohttpd.cmake
│ │ └── FindSpotify.cmake
│ └── main.cpp
├── spotify-metadata/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── spotify-metadata.js
│ └── metadata.json
├── subsonic/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── subsonic.js
│ └── metadata.json
├── synology-audiostation/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── synology-audiostation.js
│ └── metadata.json
├── test/
│ ├── buster.js
│ └── utils.js
├── tidal/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── tidal.js
│ └── metadata.json
├── tomahawk-metadata/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── tomahawk-metadata.js
│ └── metadata.json
├── tomahk-metadata/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── tomahk-metadata.js
│ └── metadata.json
├── tools/
│ ├── getstreamurl.js
│ ├── resolve.js
│ ├── search.js
│ └── urllookup.js
├── vibe3/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── vibe3.js
│ └── metadata.json
├── vkontakte/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── vkontakte.js
│ └── metadata.json
├── youtube/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── youtube.js
│ └── metadata.json
├── youtube-metadata/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── youtube-metadata.js
│ └── metadata.json
├── zaycevnet/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── strstr.js
│ │ └── zaycev.js
│ └── metadata.json
└── zv.fm/
└── content/
├── contents/
│ └── code/
│ └── zv.js
└── metadata.json
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
.directory
*.a
*.o
._*
*.user
Makefile*
moc_*
*~
.DS_Store
build
*.axe
*.md5
node_modules/
metadata.desktop
###IntelliJ###
*.iml
*.ipr
*.iws
.idea/
================================================
FILE: 4shared/content/contents/code/4shared.js
================================================
/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===
*
* Copyright 2011, lasconic <lasconic@gmail.com>
* Fixed in 2014 by Lorenz Hübschle-Schneider <lorenz@4z2.de>
*
* Tomahawk is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Tomahawk is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Tomahawk. If not, see <http://www.gnu.org/licenses/>.
*/
var FSharedResolver = Tomahawk.extend(TomahawkResolver, {
settings: {
name: '4shared',
icon: '4shared-icon.png',
weight: 50,
timeout: 5
},
resolve: function (qid, artist, album, title) {
// Parse a file detail page
var parseFileDetailPage = function (fileXhr) {
var response = fileXhr.responseText,
urlRegex = /<\!-- file: (https?:\/\/.*\.mp3) -->/gi,
durationRegex = /options_[0-9]+\['duration'\] = '([0-9]+).0';/gi,
bitrateRegex = /<b>Bit Rate:<\/b>\n\s+([0-9]+) kbps \|/gi,
match;
// Find mp3 URL
match = urlRegex.exec(response);
if (!match) {
return;
}
var mp3Url = match[1];
// Find track duration
match = durationRegex.exec(response);
var duration = match ? parseInt(match[1], 10) : null;
// Try to find bit rate (only present on some files)
match = bitrateRegex.exec(response);
var bitrate = match ? parseInt(match[1], 10) : 128;
var result = {
artist: artist,
album: album,
track: title,
source: that.settings.name,
url: mp3Url,
duration: duration,
extension: 'mp3',
bitrate: bitrate,
score: 0.80
};
// return this result
Tomahawk.addTrackResults({
qid: qid,
results: [result]
});
};
// build query to 4shared
var request = [title, artist].join(" ").trim();
var url = "http://search.4shared.com/network/searchXml.jsp?q=";
url += encodeURIComponent(request);
url += "&searchExtention=mp3&sortType=1&sortOrder=1&searchmode=3";
// send request and parse it into javascript
var that = this;
Tomahawk.asyncRequest(url, function (xhr) {
// parse xml
var domParser = new DOMParser(),
xmlDoc = domParser.parseFromString(xhr.responseText, "text/xml"),
results = xmlDoc.getElementsByTagName("result-files");
// check the response
if (results.length > 0 && results[0].childNodes.length > 0) {
var links = xmlDoc.getElementsByTagName("file"),
link, fileDetailUrl;
// walk through the results
for (var i = 0; i < links.length; i++) {
link = links[i];
fileDetailUrl = link.getElementsByTagName("url")[0].textContent;
fileDetailUrl = decodeURI(fileDetailUrl);
// process this file detail page
Tomahawk.asyncRequest(fileDetailUrl, parseFileDetailPage);
}
}
});
},
search: function (qid, searchString) {
return {
qid: qid,
results: []
};
}
});
Tomahawk.resolver.instance = FSharedResolver;
================================================
FILE: 4shared/content/metadata.json
================================================
{
"name": "4Shared",
"pluginName": "4shared",
"author": "lasconic",
"email": "lasconic@gmail.com",
"version": "0.1.6",
"website": "http://gettomahawk.com",
"description": "Looks for tracks to play from www.4shared.com.",
"type": "resolver/javascript",
"manifest": {
"main": "contents/code/4shared.js",
"scripts": [],
"icon": "contents/images/icon.png",
"resources": [
"contents/code/4shared-icon.png"
]
}
}
================================================
FILE: 8tracks/content/contents/code/8tracks.js
================================================
/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===
*
* Copyright 2011, Janez Troha (https://github.com/dz0ny)
* Copyright 2011, Leo Franchi <lfranchi@kde.org>
*
* Tomahawk is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Tomahawk is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Tomahawk. If not, see <http://www.gnu.org/licenses/>.
*/
var EightTracksResolver = Tomahawk.extend(TomahawkResolver, {
settings: {
name: '8tracks Resolver',
weight: 80,
timeout: 5,
api: "1442c0d04625c9d959527ae7d4a430afe9d2d1d9",
token: null
},
init: function() {
this.settings.token = window.localStorage["play_token"];
if (!this.settings.token) {
var that = this;
this.get("http://8tracks.com/sets/new.json?api_key="+this.settings.api, true, function(data) {
that.settings.token = data.play_token;
});
}
},
get: function (url, force, callback) {
var cached = window.sessionStorage[url];
if (!cached || force) {
Tomahawk.asyncRequest(url, function(xhr){
callback.call(window, JSON.parse(xhr.responseText));
window.sessionStorage[url] = xhr.responseText;
});
} else {
callback.call(window, JSON.parse(cached));
}
},
resolve: function (qid, artist, album, title) {
if(!this.settings.token) // either wait for init fetch to work, or give up
return;
var api = this.settings.api;
var token = this.settings.token;
var url = "http://8tracks.com/mixes.json?api_key="+api+"&per_page=1&sort=popular&q=";
if(artist != "" )
url += artist.replace(" ","+");
var doGet = this.get;
if (!window.localStorage[artist+album+title]) {
doGet(url, true, function(data) {
var res = data.mixes;
if (res.length) {
doGet("http://8tracks.com/sets/"+token+"/play.json?api_key="+api+"&mix_id="+res[0].id, false, function(data) {
var track = data.set.track;
var response = { results: [] };
response.qid = qid;
response.results.push({
artist : track.performer
, track : track.name
, album : track.release_name
, year : track.year
, url : track.url
, duration : track.play_duration
, source : "8tracks"
, score : 1.00
});
window.localStorage[artist+album+track] = JSON.stringify(response.results)
Tomahawk.addTrackResults(response);
});
}
});
} else {
var response = { results: [] };
response.qid = qid;
response.results = JSON.parse(window.localStorage[artist+album+title]);
return response;
}
},
search: function (qid, searchString) {
var return1 = {
qid: qid,
results: new Array()
};
return return1;
}
});
Tomahawk.resolver.instance = EightTracksResolver;
================================================
FILE: 8tracks/content/metadata.json
================================================
{
"name": "8tracks",
"pluginName": "8tracks",
"author": "Janez and Leo",
"email": "lfranchi@kde.org",
"version": "0.1",
"website": "http://gettomahawk.com",
"description": "Looks for tracks to play from 8tracks.com.",
"type": "resolver/javascript",
"manifest": {
"main": "contents/code/8tracks.js",
"scripts": [],
"icon": "contents/images/icon.png",
"resources": [
"contents/code/8tracks-icon.png"
]
}
}
================================================
FILE: HACKING.md
================================================
# Tomahawk Resolvers Developer Documentation
## Developing resolvers
The best way to get you started with writing your own Resolver is by looking at the [`Example Resolver`](https://github.com/tomahawk-player/tomahawk-resolvers/tree/master/examples/javascript). It's well documented and includes almost every aspect of the Tomahawk Resolver API.
The API you should develop against is defined in [`tomahawk.js`](https://github.com/tomahawk-player/tomahawk/blob/master/data/js/tomahawk.js) and [`JSResolverHelper`](https://github.com/tomahawk-player/tomahawk/blob/master/src/libtomahawk/resolvers/JSResolverHelper.h) in the Tomahawk main repo. This API is also being used in the [`Tomahawk Android`](https://github.com/tomahawk-player/tomahawk-android) App. Furthermore we also have an implementation in [`NodeJS`](https://github.com/xhochy/node-tomahawkjs). This means that you only have to write one resolver and have it work right away on Desktop, Android and Node!
Since apiVersion 0.9 the resolver API has changed quite a bit.
Previously this was the way of returning results to Tomahawk in the "resolve"-function:
```javascript
resolve: function(qid, artist, album, track) {
var results = getResultArray(artist, album, track);
Tomahawk.addTrackResults(qid, results);
}
```
Now with the new promise-based API, the same implementation would be like this:
```javascript
resolve: function (params) {
return getResultArray(params.artist, params.album, params.track);
}
```
You can get the function parameters from the params map. Instead of relying on callback functions you are now able to return your results directly. Alternatively you can also return an RSVP.Promise object. But the real power of promises only becomes clear when you look at the way a "resolve"-request is normally being implemented in the real world:
```javascript
resolve: function (params) {
var q = params.artist + " " + params.track;
return Tomahawk.get("http://someurl.org/search?q=" + q).then(function (result) {
var results = parseResultArray(result);
if (!results) {
throw new Error("Sry, couldn't get results");
} else {
return results;
}
});
}
```
In one compact code block we are able to make a request. Then we parse the given "result" and simply return it without having to care about any request-id(qid) or callback-function. In addition we have a neat way of throwing an Error when something went wrong. Not to mention all the nice magic that comes with promise-functions like "all". If you're interested you might want to check out this great tutorial by Jake Archibald http://www.html5rocks.com/en/tutorials/es6/promises/.
If you have questions, look for us in #tomahawk on irc.freenode.net.
### Licensing
Tomahawk resolvers are _not_ considered derivative works of Tomahawk. The resolver API is public, and resolvers could potentially be used without Tomahawk. The previously mentioned `tomahawk.js` file is non-copyleft open source, released under a permissive X11-style license.
Developers who create and release a resolver have no further obligation as far as licensing and distribution is concerned.
## Packaging resolvers
### Structure overview
Starting with Tomahawk 0.7, all resolver directories must be structured as follows.
Mandatory:
```
content/
+ metadata.json
```
Suggested:
```
content/
+ metadata.json
+ contents/
+ code/
+ <resolver script>.js
+ config.ui
+ <everything else>
+ images/
+ icon.png
```
This structure is commonly referred to as a resolver bundle, i.e. a resolver script with all related files and metadata.
A bundle can be packaged or unpackaged (i.e. as it is in this repo), thus resolvers can be installed manually in two ways:
* from an unpackaged bundle,
* from a package (or axe).
### Installing a resolver bundle
To install a resolver from an unpackaged bundle (the preferred way for testing and development), in Tomahawk's Settings dialog click on "Install from file" and select the resolver's main .js file.
Keep in mind that with such a path, Tomahawk expects to find the file `metadata.json` in `../..` from the main script's path. If `metadata.json` is not found, it is likely that your resolver directory is not structured properly. The resolver's main script will still be loaded, but any additional scripts will not and the accounts list in the Settings dialog will not show any metadata for the resolver (e.g. author, version, etc.). This is a **bad thing**. The only reason why a resolver without `metadata.json` is still loaded is backward compatibility. Plain unbundled .js files as resolvers are deprecated. You should update your resolver to a proper bundle structure as soon as possible.
A packaged resolver bundle is a file with file extension `axe`. It is a compressed archive with all the contents of a resolver directory. To install such a bundle (the preferred way for end users who wish to install a resolver manually), in Tomahawk's Settings dialog click on "Install from file" and select the package file (`<something>.axe`).
**WARNING** for developers and testers: the installation process for an *unpackaged* bundle loads the resolver in-place. This means that any changed to the resolver script are applied immediately, simply by disabling and re-enabling the "installed" resolver with the account's checkbox in the accounts list. There is usually no need to remove and re-install the resolver. This also means that changes to the directory structure may make the resolver stop functioning. On the other hand, packaged bundles (axes) are decompressed and copied to a Tomahawk-managed directory (`<local user data dir>/manualresolvers`) during the installation process, so any change to the axe can only be applied by re-installing.
### Packaging
#### metadata.json
Every resolver bundle directory must contain a metadata file. This file must be named `metadata.json`, and it must be located in the directory `content` relative to the top-level resolver bundle directory.
For example, this is a `metadata.json` file for Subsonic:
```
{
"name": "Subsonic",
"pluginName": "subsonic",
"author": "mack_t and Teo",
"email": "teo@kde.org",
"version": "0.5",
"website": "http://gettomahawk.com",
"description": "Searches your Subsonic server for music to play",
"type": "resolver/javascript",
"manifest": {
"main": "contents/code/subsonic.js",
"scripts": [],
"icon": "contents/images/icon.png",
"resources": [
"contents/code/config.ui",
"contents/code/runnersid-icon.png",
"contents/code/subsonic-icon.png",
"contents/code/subsonic.png"
]
}
}
```
For most purposes all the fields are mandatory.
**WARNING**: the manifest object **must** list all the files required by the resolver. Unlisted scripts will not be loaded, and any unlisted files will not be packaged.
#### makeaxe.rb
If your resolver directory conforms to the previously described structure and your `metadata.json` is complete, the harder part is done. The Tomahawk team provides you with a script to automate the packaging process: [`makeaxe.rb`](admin/makeaxe.rb). You will need [ruby](http://www.ruby-lang.org/en/) 1.9.2 or later and the [zip](https://rubygems.org/gems/zip) gem.
To create a package from a resolver directory, simply run `makeaxe.rb` with the directory path passed as parameter.
E.g. on Linux and Mac OS X, for Subsonic and from the repository root, you would do the following:
```
% ruby admin/makeaxe.rb subsonic
% ls subsonic
content/ subsonic-0.5.axe subsonic-0.5.md5
```
In this case, `subsonic-0.5.axe` is the compressed bundle and `subsonic-0.5.md5` is the MD5 checksum file.
Please note that `makeaxe.rb` does not simply compress the contents of the directory, it also checks the metadata file and adds additional data, including a packaging timestamp and the revision hash, if any.
Optionally, if you pass the `--release` parameter to `makeaxe.rb` it will not include the commit hash in the axe, as would be expected in a release-worthy package.
Happy packaging!
================================================
FILE: README.md
================================================
# Tomahawk Resolvers
Supported resolvers are distributed and updated automatically through Tomahawk's Settings dialog.
To manually install a resolver either
* clone this repo, or
* download the .zip (see .zip button at the top of the repo page at https://github.com/tomahawk-player/tomahawk-resolvers), or
* download all the files within the individual resolver folder you are installing.
After you have the files locally, open Tomahawk's preferences and from the "Services" tab click "Install from File" and select the .axe or .js file for the resolver you are installing.
Since March 2013 Tomahawk resolvers have switched to a new directory structure for easy packaging. Ideally, you should download [nightly .axe files](http://teom.org/axes/nightly/), if available.
For developer documentation, see [HACKING.md](HACKING.md).
## Capabilities
Not all resolvers feature the same capabilities, this is either due to the lacking capabilities of the service they connect to or that the capability is not yet implemented.
Some of the features need authentication (e.g. being a premium subscriber to this service), some can be used without any subscription or authentication at all.
**Available Capabilities:**
* **Resolving**: Given a tuple of `Artist,Track` (or a triple `Artist,Album,Track`) return a stream URL (and some metadata about it) so that one can play this track.
* **Search**: (Fuzzily) find tracks, artists and albums on all services matching a query that can be streamed.
* **Open Artist URL**: Given an URL about an artist of a service, return the information about that. (This opens the artist page in Tomahawk).
* **Open Album URL**: Given an URL about an album of a service, return the information about that. (This opens the album page in Tomahawk).
* **Open Playlist**: Given an URL about a playlist of a service, return the information about that. (This imports the playlist in Tomahawk if it was not previously imported)
* **Open Track URL**: Given an URL about a track of a service, return the information about that. (This opens the track page in Tomahawk and plays it).
* **Collection**: Browse the collection of music stored by the user in this service.
**Legend:**
* ✔ - Supports without authentication
* :key: - Authentication required
* ? - Unknown
* ✘ - No support for this capability
**Notes:**
* Some services can search without being authenticated but only resolve after authentication. At the moment, we do not support this in Tomahawk but this may change in future.
| *Resolver* | Resolving | Search | Open Artist URL | Open Album URL | Open Playlist | Open Track URL | Collection |
|:----------:|:---------:|:------:|:---------------:|:--------------:|:-------------:|:--------------:|:----------:|
| 4shared | ✔ | ✔ | ✘ | ✘ | ✘ | ✘ | ✘ |
| 8tracks | ✔ | ✔ | ✘ | ✘ | ✘ | ✘ | ✘ |
| ampache | :key: | :key: | ✘ | ✘ | ✘ | ✘ | :key: |
| bandcamp | ✔ | ✘ | ✔ | ✔ | ✘ | ✔ | ✘ |
| beatsmusic | :key: | ✔ | ✔ | ✔ | :key: | ✔ | ✘ |
| beets | :key: | :key: | ✘ | ✘ | ✘ | ✘ | :key: |
| deezer-metadata | ✘ | ✘ | ✔ | ✔ | ✔ | ✔ | ✘ |
| dilandau | ✔ | ✔ | ✘ | ✘ | ✘ | ✘ | ✘ |
| exfm | ✔ | ✔ | ✘ | ✘ | ✔ | ✔ | ✘ |
| grooveshark | :key: | :key: | ✘ | ✘ | ✘ | ✘ | ✘ |
| jamendo | ✔ | ✔ | ✘ | ✘ | ✘ | ✘ | ✘ |
| jazz-on-line | ? | ? | ? | ? | ? | ? | ? |
| lastfm | ✔ | ✘ | ✔ | ✔ | ✘ | ✔ | ✘ |
| muzebra | ✔ | ✔ | ✘ | ✘ | ✘ | ✘ | ✘ |
| officialfm | ✔ | ✔ | ✘ | ✘ | ✘ | ✘ | ✘ |
| qobuz | :key: | :key: | ✘ | ✘ | ✘ | ✘ | ✘ |
| rdio-metadata | ✘ | ✘ | ✔ | ✔ | ✔ | ✔ | ✘ |
| soundcloud | ✔ | ✔ | ✔ | ✔ | ✔ | ✔ | ✘ |
| spotify-metadata | ✘ | ✘ | ✔ | ✔ | ✔ | ✔ | ✘ |
| spotify | :key: | :key: | ✘ | ✘ | :key: | ✘ | ✘ |
| subsonic | :key: | :key: | ✘ | ✘ | ✘ | ✘ | :key: |
| synology-audiostation | :key: | :key: | ✘ | ✘ | ✘ | ✘ | :key: |
| tomahk-metadata | ✘ | ✘ | ✔ | ✔ | ✔ | ✔ | ✘ |
| vibe3 | ✔ | ✔ | ✘ | ✘ | ✘ | ✘ | ✘ |
| vkontakte | ✔ | ✔ | ✘ | ✘ | ✘ | ✘ | ✘ |
| youtube | ✔ | ✔ | ✘ | ✘ | ✘ | ✘ | ✘ |
| youtube-metadata | ✘ | ✘ | ✘ | ✘ | ✔ | ✔ | ✘ |
================================================
FILE: admin/json2desktop.rb
================================================
#!/usr/bin/env ruby
# === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===
#
# Copyright 2013, Teo Mrnjavac <teo@kde.org>
#
# Tomahawk is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Tomahawk is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Tomahawk. If not, see <http://www.gnu.org/licenses/>.
#
# This script converts a json metadata/manifest file into a desktop file for Synchrotron.
#
require 'json'
if ARGV.length < 1
puts "This script converts a Tomahawk resolver's metadata/manifest JSON file"
puts "into a desktop file for Synchrotron."
puts "Usage: ruby json2desktop.rb path_to_metadata_file.json"
exit
end
inputPath = File.absolute_path( ARGV[0] )
outputPath = File.join( File.dirname( inputPath ), "metadata.desktop" )
if not File.exists?( inputPath ) or not File.readable?( inputPath )
puts "Cannot read input file."
exit
end
if File.exists?( outputPath ) and not File.writable?( outputPath )
puts "Cannot write to output file."
exit
end
inputFile = File.open( inputPath, 'r' )
inputString = inputFile.read
input = JSON.parse( inputString )
inputFile.close unless inputFile == nil
# check if outputPath exists, maybe save stuff and/or overwrite, yes?
File.open( outputPath, 'w' ) do |f|
f.write "\
############################################################################
## Desktop file generated from JSON file '#{File.basename( inputPath )}'
##
## Created: #{Time.now.utc.to_s}
## by: json2desktop.rb, https://github.com/tomahawk-player
##
## #### WARNING! ####
## All changes made to this file will be lost!
############################################################################
[Desktop Entry]\n"
unless input["name"].nil? || input["name"].empty?
f.write "Name=#{input["name"]}\n"
end
unless input["description"].nil? || input["description"].empty?
f.write "Comment=#{input["description"]}\n"
end
f.write "\nType=Service\nX-KDE-ServiceTypes=Tomahawk/Resolver\n"
unless input["manifest"].nil?
unless input["manifest"]["main"].nil? || input["manifest"]["main"].empty?
f.write "X-Synchrotron-MainScript=#{input["manifest"]["main"]}\n"
end
end
unless input["platform"].nil? || input["platform"].empty? || input["platform"] == "any"
f.write "X-Synchrotron-Type=#{input["platform"]}\n"
end
unless input["tomahawkVersion"].nil? || input["tomahawkVersion"].empty?
f.write "X-Synchrotron-Requires-Tomahawk-Version=#{input["tomahawkVersion"]}\n"
end
f.write "\n"
unless input["pluginName"].nil? || input["pluginName"].empty?
f.write "X-KDE-PluginInfo-Name=#{input["pluginName"]}\n"
end
f.write "X-KDE-PluginInfo-Category=Resolver\n"
unless input["author"].nil? || input["author"].empty?
f.write "X-KDE-PluginInfo-Author=#{input["author"]}\n"
end
unless input["email"].nil? || input["email"].empty?
f.write "X-KDE-PluginInfo-Email=#{input["email"]}\n"
end
unless input["version"].nil? || input["version"].empty?
f.write "X-KDE-PluginInfo-Version=#{input["version"]}\n"
end
unless input["website"].nil? || input["website"].empty?
f.write "X-KDE-PluginInfo-Website=#{input["website"]}\n"
end
end
================================================
FILE: admin/makeaxe.rb
================================================
#!/usr/bin/env ruby
# === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===
#
# Copyright 2013, Teo Mrnjavac <teo@kde.org>
#
# Tomahawk is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Tomahawk is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Tomahawk. If not, see <http://www.gnu.org/licenses/>.
#
# This script reads a json metadata/manifest file and creates a Tomahawk
# resolver bundle (axe).
# The script should be executed with the top-level resolver directory path as
# parameter, and expects the following structure:
# Mandatory:
# content/
# + metadata.json
# Suggested:
# content/
# + metadata.json
# + contents/
# + code/
# + <resolver script>.js
# + config.ui
# + <everything else>
# + images/
# + icon.png
#
require 'rubygems'
require 'json'
require 'zipruby'
require 'digest/md5'
BUNDLEVERSION = 1 #might never be used but best to plan ahead
def usage
puts "This script creates a Tomahawk resolver bundle."
puts "\nMake sure you have the zipruby gem."
puts "\nUsage: ruby makeaxe.rb path_to_resolver_directory [options]"
puts " --release\tskip trying to add the git revision hash to the bundle"
puts " --help\t\tthis help message"
end
if ARGV.length < 1 or not ARGV.delete( "--help" ).nil?
usage
exit
end
if not ARGV.delete( "--release" ).nil?
release = true
else
release = false
end
inputPath = File.absolute_path( ARGV[0] )
if not Dir.exists?( inputPath )
puts "Bad input directory path."
exit
end
metadataRelPath = "content/metadata.json"
metadataPath = File.join( inputPath, metadataRelPath )
if not File.exists?( metadataPath ) or not File.readable?( metadataPath )
puts "Cannot find metadata file."
puts "Make sure #{metadataRelPath} exists and is readable."
exit
end
metadataFile = File.open( metadataPath, 'r' )
metadataString = metadataFile.read
metadata = JSON.parse( metadataString )
metadataFile.close unless metadataFile == nil
if not metadata["pluginName"].nil? and
not metadata["name"].nil? and
not metadata["version"].nil? and
not metadata["description"].nil? and
not metadata["type"].nil? and
not metadata["manifest"].nil? and
not metadata["manifest"]["main"].nil? and
not metadata["manifest"]["icon"].nil?
outputPath = File.join( inputPath, metadata["pluginName"] + "-" + metadata["version"] + ".axe" )
puts "Bundle metadata looks ok."
else
puts "Bad metadata file."
exit
end
# Let's add some stuff to the metadata file, this is information that's much
# easier to fill in automatically now than manually whenever.
# * Timestamp of right now i.e. packaging time.
# * Git revision because it makes sense, especially during development.
# * Bundle format version, which might never be used but we add it just in
# case we ever need to distinguish one bundle format from another.
# We save it all as _metadata.json, which then gets added to the archive as
# metadata.json instead of the original one.
_metadataPath = File.join( inputPath, "content/_metadata.json" )
if not File.exists?( _metadataPath ) or File.writable?( _metadataPath )
File.open( _metadataPath, 'w' ) do |f|
metadata["timestamp"] = Time.now.utc.to_i
unless release
gitCmd = "git rev-parse --short HEAD 2>&1"
inGit = system( gitCmd + "&>/dev/null" ) #will return true only if we're in a repo
if inGit
revision = %x[ #{gitCmd} ].sub( "\n", "" )
metadata["revision"] = revision
end
end
metadata["bundleVersion"] = BUNDLEVERSION
f.write( JSON.pretty_generate( metadata ) )
end
end
# Let's do some zipping according to the manifest.
filesToZip = []
begin
m = metadata["manifest"]
filesToZip << File.join( "content", m["main"] )
m["scripts"].each do |s|
filesToZip << File.join( "content", s )
end
filesToZip << File.join( "content", m["icon"] )
if not m["iconBackground"].nil?
filesToZip << File.join( "content", m["iconBackground"] )
end
if not m["iconWhite"].nil?
filesToZip << File.join( "content", m["iconWhite"] )
end
m["resources"].each do |s|
filesToZip << File.join( "content", s )
end
end
puts "Creating package for #{metadata["name"]}: '#{File.basename( outputPath )}'."
if File.exists?( outputPath )
File.delete( outputPath )
end
Zip::Archive.open( outputPath, Zip::CREATE | Zip::TRUNC ) do |z|
filesToZip.each do |relPath|
z.add_file( relPath, File.join( inputPath, relPath ) )
end
z.add_file( metadataRelPath, _metadataPath )
end
puts "Cleaning up."
File.delete( _metadataPath )
File.open( outputPath, 'r' ) do |f|
File.open( outputPath.sub( "axe", "md5" ), 'w' ) do |g|
g.write( Digest::MD5.hexdigest( f.read ).to_s + "\t" + File.basename( outputPath ) )
end
end
puts "All done. Have a nice day."
================================================
FILE: admin/spotify-synchrotron/linux/create_synchrotron.rb
================================================
#!/usr/bin/env ruby
#
# This takes a binary for 32bit or 64bit linux
# the signed zip file + manifest suitable for uploading to Synchrotron
#
#
require 'pathname'
LIBSPOTIFY_VERSION = "libspotify.so.12"
if ARGV.length < 7
puts "Usage: ruby create_synchrotron.rb [x86|x64] [version 0.0.0] /path/to/static/builddir resolvername_tomahawkresolver metadata.desktop private_key_file /path/to/tomahawk-synchrotron"
puts "\n"
puts "If you don't have the tomahawk private key and you think you should, ask leo :)"
exit
end
fullPath = File.join(ARGV[2], ARGV[3])
if not File.directory?(ARGV[2]) or not File.exists?(fullPath) or not File.exists?(ARGV[4]) or not File.exists?(ARGV[5]) or not File.directory?(ARGV[6])
puts "One of your arguments didn't exist!"
exit
end
libspotify = File.join(ARGV[2], LIBSPOTIFY_VERSION)
resolver = ARGV[3].split("_")[0]
platform = "linux-#{ARGV[0]}"
puts "Creating zipfile for #{resolver} in folder #{fullPath}..."
folder = "#{resolver}-#{platform}"
`mkdir #{folder}`
`cp #{fullPath} #{folder}`
`cp #{libspotify} #{folder}`
tarball = "#{resolver}-#{platform}.zip"
`pushd #{folder} && zip -r "#{tarball}" * && mv "#{tarball}" .. && popd`
`rm -rf #{folder}`
signature = `openssl dgst -sha1 -binary < "#{tarball}" | openssl dgst -dss1 -sign "#{ARGV[5]}" | openssl enc -base64`
puts "Signature: #{signature}"
fd = File.open(ARGV[4], 'r')
manifest = fd.read
manifest["_SIGNATURE_"] = signature
manifest["_ZIPFILE_"] = tarball
manifest["_PLATFORM_"] = platform
manifest["_TYPE_"] = platform
manifest["_VERSION_"] = ARGV[1]
manifest["_BINARY_"] = ARGV[3]
resolverDir = "#{ARGV[6]}/resolvers/#{resolver}-#{platform}/content"
`mkdir -p #{resolverDir}` if not File.directory?(resolverDir)
File.open("#{resolverDir}/metadata.desktop", "w") do |f|
f.write(manifest)
end
`mv #{tarball} #{resolverDir}`
================================================
FILE: admin/spotify-synchrotron/mac/create_synchrotron.rb
================================================
#!/usr/bin/env ruby
#
# This takes a binary for osx and creates
# the signed zip file + manifest suitable for uploading to Synchrotron
#
# Note that this assumes the resolver has been built against a STATIC qt and qjson.
# See static_notes.txt in spotify/ for the qt configure line to use.
#
require 'pathname'
LIBSPOTIFY_VERSION = "#{`brew ls -version libspotify | tr -s " " "\012" | tail -n 1`}".strip
puts "Using libspotify version: #{LIBSPOTIFY_VERSION}"
if ARGV.length < 4
puts "Usage: ruby create_synchrotron.rb spotify_tomahawkresolver metadata.desktop private_key_file /path/to/tomahawk-synchrotron"
puts "\n"
puts "If you don't have the tomahawk private key and you think you should, ask leo :)"
exit
end
if not File.exists?(ARGV[0]) or not File.exists?(ARGV[1]) or not File.exists?(ARGV[2]) or not File.directory?(ARGV[3])
puts "One of your arguments didn't exist!"
exit
end
resolver = Pathname.new(ARGV[0]).basename.to_s
resolvername = resolver.split("_")[0]
platform = "osx"
puts "Creating zipfile for #{resolver}..."
`cp #{ARGV[0]} #{resolver}`
# Manually install_name_tool the spotify binary to point to relative paths.
# This will make the resolver look for libspotify in the current directory.
`install_name_tool -change /usr/local/lib/libspotify.#{LIBSPOTIFY_VERSION}.dylib @executable_path/libspotify.#{LIBSPOTIFY_VERSION}.dylib #{resolver}`
LIBSPOTIFY_LOCAL = "libspotify.#{LIBSPOTIFY_VERSION}.dylib"
`cp /usr/local/lib/libspotify.#{LIBSPOTIFY_VERSION}.dylib #{LIBSPOTIFY_LOCAL}`
`chmod +rw #{LIBSPOTIFY_LOCAL}`
tarball = "#{resolvername}-#{platform}.zip"
`zip -r #{tarball} #{resolver} #{LIBSPOTIFY_LOCAL}`
`rm #{resolver}`
`rm #{LIBSPOTIFY_LOCAL}`
puts "Signing..."
signature = `openssl dgst -sha1 -binary < "#{tarball}" | openssl dgst -dss1 -sign "#{ARGV[2]}" | openssl enc -base64`
puts "Signature: #{signature}"
fd = File.open(ARGV[1], 'r')
manifest = fd.read
manifest["_SIGNATURE_"] = signature
manifest["_ZIPFILE_"] = tarball
manifest["_PLATFORM_"] = platform
manifest["_TYPE_"] = platform
manifest["_BINARY_"] = resolver
resolverDir = "#{ARGV[3]}/resolvers/#{resolvername}-#{platform}/content"
`mkdir -p #{resolverDir}` if not File.directory?(resolverDir)
File.open("#{resolverDir}/metadata.desktop", "w") do |f|
f.write(manifest)
end
`mv #{tarball} #{resolverDir}`
================================================
FILE: admin/spotify-synchrotron/win/create_synchrotron.rb
================================================
#!/usr/bin/env ruby
#
# This takes a binary for windows and creates
# the signed zip file + manifest suitable for uploading to Synchrotron
#
# This requires 7zip installed in C:\program files\7-Zip\7z.exe, and openssh installed as well.
#
# This will createa standalone zip file that bundles qt, libjqon, libqxtweb, and libspotify.
# It expects a standalone spotify_tomahawkresolver.exe with the necessarily libs in the same folder
#
require 'pathname'
zipper = "C:\\Program Files\\7-Zip\\7z.exe"
if ARGV.length < 5
puts "Usage: ruby create_synchrotron_win.rb /path/to/resolver_folder resolver_name.exe metadata.desktop private_key_file /path/to/tomahawk-synchrotron"
puts "\nCall this from any directory."
puts "If you don't have the tomahawk private key and you think you should, ask leo :)"
exit
end
if not File.directory?(ARGV[0]) or not File.exists?(ARGV[2]) or not File.exists?(ARGV[3]) or not File.directory?(ARGV[4])
puts "One of your arguments didn't exist!"
exit
end
fullPath = File.join(ARGV[0], ARGV[1])
resolver = ARGV[1].split("_")[0]
platform = "win"
puts "Creating zipfile for #{resolver} in folder #{fullPath}..."
folder = "#{resolver}-#{platform}"
`mkdir #{folder}`
`copy #{ARGV[0]} #{folder}`
tarball = "#{resolver}-#{platform}.zip"
`pushd #{folder} && "#{zipper}" a -tzip "#{tarball}" * && move "#{tarball}" .. && popd`
`del /q #{folder}`
`rd #{folder}`
#puts "Signing... openssl dgst -sha1 -binary < \"#{tarball}\" | openssl dgst -dss1 -sign \"#{ARGV[3]}\" | openssl enc -base64"
signature = `openssl dgst -sha1 -binary < "#{tarball}" | openssl dgst -dss1 -sign "#{ARGV[3]}" | openssl enc -base64`
puts "Signature: #{signature}"
fd = File.open(ARGV[2], 'r')
manifest = fd.read
manifest["_SIGNATURE_"] = signature
manifest["_ZIPFILE_"] = tarball
manifest["_PLATFORM_"] = platform
manifest["_TYPE_"] = platform
manifest["_BINARY_"] = ARGV[1]
resolverDir = "#{ARGV[4]}\\resolvers\\#{resolver}-#{platform}\\content"
`mkdir #{resolverDir}` if not File.directory?(resolverDir)
File.open("#{resolverDir}/metadata.desktop", "w") do |f|
f.write(manifest)
end
`move #{tarball} #{resolverDir}`
================================================
FILE: amazon/content/contents/code/amazon.js
================================================
/* Amazon Music resolver for Tomahawk.
*
* Written in 2015 by Creepy Guy In The Corner
*
* To the extent possible under law, the author(s) have dedicated all
* copyright and related and neighboring rights to this software to
* the public domain worldwide. This software is distributed without
* any warranty.
*
* You should have received a copy of the CC0 Public Domain Dedication
* along with this software. If not, see:
* http://creativecommons.org/publicdomain/zero/1.0/
*/
var AmazonResolver = Tomahawk.extend( Tomahawk.Resolver, {
apiVersion: 0.9,
api_location : 'https://www.amazon.com/',
logged_in: null, // null, = not yet tried, 0 = pending, 1 = success, 2 = failed
settings: {
cacheTime: 300,
name: 'Amazon Music',
icon: '../images/icon.png',
weight: 95,
timeout: 8,
user_agent: 'Mozilla/6.0 (X11; Ubuntu; Linux x86_64; rv:40.0) Gecko/20100101 Firefox/40.0'
},
getConfigUi: function() {
return {
"widget": Tomahawk.readBase64( "config.ui" ),
fields: [{
name: "email",
widget: "email_edit",
property: "text"
}, {
name: "password",
widget: "password_edit",
property: "text"
},{
name: "region",
widget: "region",
property: "currentIndex"
}]
};
},
/**
* Defines this Resolver's config dialog UI.
*/
configUi: [
{
id: "email",
type: "textfield",
label: "E-Mail"
},
{
id: "password",
type: "textfield",
label: "Password",
isPassword: true
},
{
id: "region",
type: "dropdown",
label: "Region",
items: [".com", ".de", ".co.uk"],
defaultValue: 0
}
],
newConfigSaved: function(config) {
var that = this;
var changed =
this._email !== config.email ||
this._password !== config.password ||
this._region !== config.region;
if (changed) {
return this._get(this.api_location + "gp/dmusic/cloudplayer/forceSignOut").then(function(resp){
that.init();
amazonCollection.wipe({id: amazonCollection.settings.id}).then(function () {
window.localStorage.removeItem("amzn_collection_version_key");
that.init();
});
});
}
},
testConfig: function (config) {
var that = this;
return that._get(that.api_location + "gp/dmusic/cloudplayer/forceSignOut").then(
function () {
return that._getLoginPromise(config, true).then(function (resp) {
var appConfigRe = /amznMusic.appConfig *?= *?({.*});/g;
if (appConfigRe.exec(resp) != null) {
return Tomahawk.ConfigTestResultType.Success;
} else {
return Tomahawk.ConfigTestResultType.InvalidCredentials;
}
}, function (error) {
return "Internal error.";
});
});
},
_request: function(url, method, options, use_csrf_headers){
if (typeof options === 'undefined')
options = {};
if (!options.hasOwnProperty('headers'))
options.headers = {};
if (use_csrf_headers) {
options.headers['csrf-token'] = this._appConfig['CSRFTokenConfig']['csrf_token'];
options.headers['csrf-rnd'] = this._appConfig['CSRFTokenConfig']['csrf_rnd'];
options.headers['csrf-ts'] = this._appConfig['CSRFTokenConfig']['csrf_ts'];
}
options.headers['User-Agent'] = 'Mozilla/5.0 (X11; Linux x86_64; rv:48.0) Gecko/20100101 Firefox/48.0';
options.headers['Accept-Language'] = 'en-US,en;q=0.5';
if (method === 'POST')
return Tomahawk.post( url, options);
else
return Tomahawk.get( url, options);
},
_post: function (url, options, use_csrf_headers) {
return this._request(url, 'POST', options, use_csrf_headers);
},
_get: function (url, options, use_csrf_headers) {
return this._request(url, 'GET', options, use_csrf_headers);
},
_domains : ['.com', '.de', '.co.uk'],
init: function() {
var config = this.getUserConfig();
this._email = config.email;
this._password = config.password;
this._region = config.region || 0;
if (!this._email || !this._password) {
Tomahawk.PluginManager.unregisterPlugin("collection", amazonCollection);
Tomahawk.log("Invalid configuration.");
return;
}
this.api_location = 'https://www.amazon' + this._domains[this._region] + '/';
var that = this;
return this._get(this.api_location + "gp/dmusic/cloudplayer/forceSignOut").then(function(resp){
return that._login(config);
});
},
_convertTrack2: function (entry) {
var track = {
artist: Tomahawk.htmlDecode(entry.artist.name),
album: Tomahawk.htmlDecode(entry.album.title),
track: Tomahawk.htmlDecode(entry.title),
title: Tomahawk.htmlDecode(entry.title),
albumpos: entry.trackNum,
discnumber: entry.discNum,
duration: entry.duration,
checked: true,
type: "track",
url : 'amzn://track/' + entry.duration + '/COID//ASIN/' + entry.asin + '/IDTYPE/ASIN'
};
// also has originalReleaseDate with values like 1476921600000
track.hint = track.url;
return track;
},
_convertTrack: function (entry) {
if (entry.hasOwnProperty('metadata'))
entry = entry.metadata;
var track = {
artist: Tomahawk.htmlDecode(entry.artistName),
albumArtist: Tomahawk.htmlDecode(entry.albumArtistName),
album: Tomahawk.htmlDecode(entry.albumName),
track: Tomahawk.htmlDecode(entry.title),
title: Tomahawk.htmlDecode(entry.title),
albumpos: entry.trackNum,
discnumber: entry.discNum,
duration: entry.duration,
checked: true,
size: entry.size,
bitrate: entry.bitrate,
type: "track"
};
//We request HIGH quality with this resolver which corresponds to
//256 VBR kbps, lets set it as default
track.bitrate = track.bitrate || 256;
if(entry.albumReleaseDate)
{
track['releaseyear'] = entry.albumReleaseDate.split('-')[0];
track['year'] = entry.albumReleaseDate.split('-')[0];
}
track.url = 'amzn://track/' + entry.duration + '/COID/' + entry.objectId +
'/ASIN/' + entry.asin + '/IDTYPE/';
if (entry.purchased === 'true' || entry.uploaded === 'true') {
track.url += 'COID';
} else {
track.url += 'ASIN';
}
track.hint = track.url;
return track;
},
search: function (params) {
if (!this.logged_in) {
return this._defer(this.search, params, this);
} else if (this.logged_in === 2) {
throw new Error('Failed login, cannot search.');
}
var that = this;
if (that._appConfig.featureController.hawkfireAccess === 1)
{
// User has Music Unlimited
return that._post(that.api_location + "clientbuddy/compartments/eeb70a31c77c4ecd/handlers/search", {
data: {
"keywords" : params.query,
"offset" : 0,
"count" : 100,
"marketplaceId": that._appConfig['marketplaceId']
|| that._appConfig['cirrus']['marketplaceId'],
"features" : ["musicSubscription"],
"isMusicSubscription" : true,
"primeOnly" : false,
"requestUiContentDeliveredMetrics" : true,
"sslMedia" : true,
"types" : ["track" /* "album", "artist", "station", "playlist" */ ]
},
dataFormat: 'json',
headers : {
"x-amzn-cb-deviceid" : that._appConfig.deviceId,
"x-amzn-cb-devicetype" : that._appConfig.deviceType
}
}, false).then( function (response) {
return response.trackList.map(that._convertTrack2, that);
});
}
else if (that._appConfig.featureController.robin === 1)
{
// User has Prime
return that._post(that.api_location + "clientbuddy/compartments/32f93572142e8f7c/handlers/search", {
data: {
"keywords" : params.query,
"marketplaceId": that._appConfig['marketplaceId']
|| that._appConfig['cirrus']['marketplaceId']
},
dataFormat: 'json'
}, true).then( function (response) {
return response.tracks.filter(function(track) {
return track.isPrime;
}).map(that._convertTrack, that);
});
} else {
// User doesn't have Unlimited nor Prime
return [];
}
},
resolve: function (params) {
var query = [ params.artist, params.album, params.track ].join(' ');
return this.search({query:query});
},
_debugPrint: function (obj, spaces) {
spaces = spaces || '';
var str = '';
for (var key in obj) {
if (typeof obj[key] === "object") {
var b = ["{", "}"];
if (obj[key].constructor == Array) {
b = ["[", "]"];
}
str += spaces+key+": "+b[0]+"\n"+this._debugPrint(obj[key], spaces+' ')+"\n"+spaces+b[1]+'\n';
} else {
str += spaces+key+": "+obj[key]+"\n";
}
}
if (spaces != '') {
return str;
} else {
str.split('\n').map(Tomahawk.log, Tomahawk);
}
},
getStreamUrl: function(params) {
return this._getStreamUrlPromise(params.url).then(function (streamUrl){
return {url: streamUrl};
}).catch(Tomahawk.log);
},
_parseUrn: function (urn) {
var match = urn.match( /^amzn:\/\/([a-z]+)\/([0-9]+)\/COID\/(.*?)\/ASIN\/(.+?)\/IDTYPE\/(.+)$/ );
if (!match) return null;
var parsed = {
type : match[ 1 ],
duraion : match[ 2 ],
cdObjectId : match[ 3 ],
asin : match[ 4 ],
idType : match[ 5 ]
};
if (parsed.idType === 'COID') {
parsed.id = parsed.cdObjectId;
} else {
parsed.id = parsed.asin;
}
return parsed;
},
_getStreamUrlPromise: function (urn) {
if (!this.logged_in) {
return this._defer(this.getStreamUrl, [urn], this);
} else if (this.logged_in === 2) {
throw new Error('Failed login, cannot getStreamUrl.');
}
var parsedUrn = this._parseUrn( urn );
if (!parsedUrn || parsedUrn.type != 'track') {
Tomahawk.log( "Failed to get stream. Couldn't parse '" + urn + "'" );
return;
}
var _headers = {
'X-Amz-Target' : 'com.amazon.digitalmusiclocator.DigitalMusicLocatorServiceExternal.getRestrictedStreamingURL',
'Content-Encoding': 'amz-1.0'
};
var request = {
"appMetadata": {
"https": "true"
},
"bitRate": "HIGH",
"clientMetadata": {
"clientId": "WebCP"
},
"contentDuration": parsedUrn.duration,
"contentId": {
"identifier": parsedUrn.id,
"identifierType": parsedUrn.idType
},
"customerId": this._appConfig['customerId'],
"deviceToken": {
"deviceId": this._appConfig['deviceId'],
"deviceTypeId": this._appConfig['deviceType']
}
};
var that = this;
var cirrusData = {
"clientActionList": [{
"actionName": "streamingTerminated",
"additionalDetails": {
"trackCount": "1",
"cacheHitStatus": "none",
"source": "wifi",
"terminationReason": "userStop",
"initiationReason": "USERSTART",
"durationSeconds": "3",
"initialPlaybackDelayMilliseconds": "1541",
"initialPlaybackDelaySeconds": "1.541",
"transferSpeedBPS": "",
"selectionSourceType": "AUTO_PLAYLIST",
"isDirectedPlay": "true",
"isShufflePlay": "false",
"pageType": "recentlyPlayed",
"selectionSourceId": "RECENTLY_PLAYED",
"resourceType": "CLOUD_PLAYER",
"rebufferCount": "0",
"bitrates": "AutoMedium",
"containerLoadDelayMilliseconds": "398",
"streamOrDRMTech": "DASH",
"playerType": "HTML5",
"specificEventVersion": "2",
"appVersion": "1.0.200025.0",
"baseEventVersion": "1",
"asin": parsedUrn.asin,
"cdObjectId": parsedUrn.cdObjectId,
},
"timestamp": Date.now()
}],
'customerId' : this._appConfig['customerId'],
'deviceId' : this._appConfig['deviceId'],
'deviceType' : this._appConfig['deviceType']
};
return this._post(this.api_location + "dmls/", {
data: request,
dataFormat: 'json',
headers: _headers
}, true).then( function (response) {
Tomahawk.log(JSON.stringify(response));
if (! response.contentResponse.urlList)
throw new Error( response.contentResponse.statusMessage );
//We'll post this just to get this track to "Recently Played" on
//amazon
_headers['X-Amz-Target'] = 'com.amazon.cirrus.libraryservice.v3.CirrusLibraryServiceExternalV3.reportClientActions';
that._post(that.api_location + "cirrus/v3/", {
data: cirrusData,
dataFormat: 'json',
headers: _headers
}, true);
return response.contentResponse.urlList[0];
});
},
_defer: function (callback, args, scope) {
if (typeof this._loginPromise !== 'undefined' && 'then' in this._loginPromise) {
args = args || [];
scope = scope || this;
Tomahawk.log('Deferring action with ' + args.length + ' arguments.');
return this._loginPromise.then(function () {
Tomahawk.log('Performing deferred action with ' + args.length + ' arguments.');
callback.call(scope, args);
});
}
},
_getLoginPromise: function (config, isTestingConfig) {
var that = this;
var options = {
isTestingConfig: isTestingConfig
};
return this._get(this.api_location + "gp/dmusic/cloudplayer/forceSignIn", options).then(
function (resp) {
if (resp.indexOf('amznMusic.appConfig') !== -1 )
{
//We are already logged in
Tomahawk.log("Already logged in\n");
return resp;
}
else
{
var myRE = /input type=.*? name="([^"]+)" value="([^"]+)"/g;
var match = myRE.exec(resp);
var params = {};
while (match != null) {
params[match[1]] = match[2];
match = myRE.exec(resp);
}
params['email'] = config.email.trim();
params['password'] = config.password.trim();
params['create'] = '0';
var actionRe = /action="([^"]+)"/g ;
var url = Tomahawk.htmlDecode(actionRe.exec(resp)[1]);
var tokenRE = /token...([A-F0-9]+)/g ;
var token = tokenRE.exec(resp)[1];
var options = {
data: params,
headers : { 'Referer' : 'https://www.amazon' + that._domains[that._region] + '/ap/signin?_encoding=UTF8&accountStatusPolicy=P1&openid.assoc_handle=usflex&openid.claimed_id=http%3A%2F%2Fspecs.openid.net%2Fauth%2F2.0%2Fidentifier_select&openid.identity=http%3A%2F%2Fspecs.openid.net%2Fauth%2F2.0%2Fidentifier_select&openid.mode=checkid_setup&openid.ns=http%3A%2F%2Fspecs.openid.net%2Fauth%2F2.0&openid.ns.pape=http%3A%2F%2Fspecs.openid.net%2Fextensions%2Fpape%2F1.0&openid.pape.max_auth_age=0&openid.return_to=https%3A%2F%2Fwww.amazon' + that._domains[that._region] + '%3A443%2Fgp%2Fredirect.html%3F_encoding%3DUTF8%26location%3Dhttps%253A%252F%252Fmusic.amazon' + that._domains[that._region] + '%253Fref_%253Ddm_wcp_sfso%26source%3Dstandards%26token%3D' + token + '%23&pageId=amzn_cpweb&showRmrMe=1' }
};
if (isTestingConfig) {
options.isTestingConfig = true;
}
return that._post(url, options);
}
},
function (error) {
Tomahawk.log(JSON.stringify(error));
Tomahawk.log('Error getting login page');
that.logged_in = 2;
}
);
},
_login: function (config) {
// If a login is already in progress don't start another!
if (this.logged_in === 0) return;
this.logged_in = 0;
var that = this;
this._loginPromise = this._getLoginPromise(config, false).then(
function (resp) {
var appConfigRe = /amznMusic.appConfig *?= *?({.*});/g;
that._appConfig = JSON.parse(appConfigRe.exec(resp)[1]);
that.logged_in = 1;
that.api_location = 'https://' + that._appConfig['serverName'] + '/';
amazonCollection.settings['description'] = that._appConfig['customerName'];
Tomahawk.PluginManager.registerPlugin("collection", amazonCollection);
that._checkForLibraryUpdates().then(function(){
amazonCollection.addTracks({
id: amazonCollection.settings.id,
tracks: []
});
}, function (error) {
Tomahawk.PluginManager.unregisterPlugin("collection", amazonCollection);
Tomahawk.log("Failed updating Library:" + error);
});
Tomahawk.log(that.settings.name + " successfully logged in.");
},
function (error) {
Tomahawk.log(that.settings.name + " failed login: " + JSON.stringify(error));
delete that._appConfig;
that.logged_in = 2;
}
).catch(function(error) {
Tomahawk.log(that.settings.name + " failed login: " + JSON.stringify(error));
that.logged_in = 2;
});
return this._loginPromise;
},
//Collection/Library
//
_checkForLibraryUpdates: function() {
var that = this;
//Check for library updates every 15 Minutes
setTimeout(function(){that._checkForLibraryUpdates()}, 1000 * 60 * 15);
var currentVersion = Tomahawk.localStorage.getItem("amzn_collection_version_key");
var _query = {
'caller' : 'checkServerChange',
'Operation' : 'getGlobalLastUpdatedDate',
'ContentType' : 'JSON',
'customerInfo.customerId' : this._appConfig['customerId'],
'customerInfo.deviceId' : this._appConfig['deviceId'],
'customerInfo.deviceType' : this._appConfig['deviceType']
};
return this._post(this.api_location + 'cirrus/', {
data: _query
}, true).then( function (response) {
var serverVersion = response.getGlobalLastUpdatedDateResponse.getGlobalLastUpdatedDateResult.date.toString();
if( currentVersion != serverVersion ) {
Tomahawk.log('Server-side library updated, syncing');
amazonCollection.wipe({id: amazonCollection.settings.id}).then(function () {
Tomahawk.localStorage.removeItem("amzn_collection_version_key");
that._getLibraryTracks().then(function(tracks) {
amazonCollection.addTracks({
id: amazonCollection.settings.id,
tracks: tracks
}).then(function () {
Tomahawk.log("Updated Library to version with date:" + serverVersion);
Tomahawk.localStorage.setItem("amzn_collection_version_key", serverVersion);
});
});
});
} else {
Tomahawk.log('Library up-to-date');
}
});
},
_getLibraryTracks: function(previousResults, nextResultsToken) {
var that = this;
if (!previousResults)
previousResults = [];
if (!nextResultsToken)
nextResultsToken = '';
var _query = {
'ContentType' : 'JSON',
'Operation' : 'searchLibrary',
'albumArtUrlsRedirects' : 'false',
'caller' : 'getServerSongs',
'countOnly': 'false',
'customerInfo.customerId' : this._appConfig['customerId'],
'customerInfo.deviceId' : this._appConfig['deviceId'],
'customerInfo.deviceType' : this._appConfig['deviceType'],
'distinctOnly' : 'false',
'maxResults' : '1000',
'nextResultsToken' : nextResultsToken,
'searchCriteria.member.1.attributeName' : 'keywords',
'searchCriteria.member.1.attributeValue' : '',
'searchCriteria.member.1.comparisonType' : 'LIKE',
'searchCriteria.member.2.attributeName' : 'assetType',
'searchCriteria.member.2.attributeValue' : 'AUDIO',
'searchCriteria.member.2.comparisonType' : 'EQUALS',
'searchCriteria.member.3.attributeName' : 'status',
'searchCriteria.member.3.attributeValue' : 'AVAILABLE',
'searchCriteria.member.3.comparisonType' : 'EQUALS',
'searchReturnType' : 'TRACKS',
'selectedColumns.member.1' : 'albumArtistName',
'selectedColumns.member.10' : 'title',
'selectedColumns.member.11' : 'status',
'selectedColumns.member.12' : 'trackStatus',
'selectedColumns.member.13' : 'extension',
'selectedColumns.member.14' : 'asin',
'selectedColumns.member.15' : 'primeStatus',
'selectedColumns.member.2' : 'albumName',
'selectedColumns.member.3' : 'artistName',
'selectedColumns.member.4' : 'assetType',
'selectedColumns.member.5' : 'duration',
'selectedColumns.member.6' : 'objectId',
'selectedColumns.member.7' : 'sortAlbumArtistName',
'selectedColumns.member.8' : 'sortAlbumName',
'selectedColumns.member.9' : 'sortArtistName',
'sortCriteriaList' : '',
'sortCriteriaList.member.1.sortColumn' : 'sortTitle',
'sortCriteriaList.member.1.sortType' : 'ASC'
};
return that._post(this.api_location + 'cirrus/', {
data: _query
}, true).then(function(response) {
previousResults = previousResults.concat(response
.searchLibraryResponse
.searchLibraryResult
.searchReturnItemList
.filter(function(track) {
track = track.metadata;
return (
track.purchased === 'true' ||
track.uploaded === 'true' ||
(track.primeStatus === 'PRIME' && that._appConfig.featureController.robin === 1) ||
(track.isMusicSubscription === 'true' && that._appConfig.featureController.hawkfireAccess === 1));
})
.map(that._convertTrack, that));
nextResultsToken = response.searchLibraryResponse.searchLibraryResult.nextResultsToken;
if (null === nextResultsToken)
return previousResults;
return that._getLibraryTracks(previousResults, nextResultsToken);
});
}
});
var amazonCollection = Tomahawk.extend(Tomahawk.Collection, {
resolver: AmazonResolver,
settings: {
id: "amazon",
prettyname: "Amazon Music Library",
iconfile: "contents/images/icon.png"
}
});
Tomahawk.resolver.instance = AmazonResolver;
================================================
FILE: amazon/content/contents/code/config.ui
================================================
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Form</class>
<widget class="QWidget" name="Form">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>390</width>
<height>120</height>
</rect>
</property>
<property name="minimumSize">
<size>
<width>250</width>
<height>120</height>
</size>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_3">
<item>
<layout class="QFormLayout" name="formLayout">
<property name="fieldGrowthPolicy">
<enum>QFormLayout::ExpandingFieldsGrow</enum>
</property>
<item row="0" column="0">
<widget class="QLabel" name="label">
<property name="text">
<string>Email</string>
</property>
<property name="alignment">
<set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QLineEdit" name="email_edit"/>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label_2">
<property name="text">
<string>Password</string>
</property>
<property name="alignment">
<set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QLineEdit" name="password_edit">
<property name="echoMode">
<enum>QLineEdit::Password</enum>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QLabel" name="label_3">
<property name="text">
<string>Region</string>
</property>
</widget>
</item>
<item row="2" column="1">
<widget class="QComboBox" name="region">
<item>
<property name="text">
<string>.com</string>
</property>
</item>
<item>
<property name="text">
<string>.de</string>
</property>
</item>
<item>
<property name="text">
<string>.co.uk</string>
</property>
</item>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>
================================================
FILE: amazon/content/metadata.json
================================================
{
"name": "Amazon Music",
"pluginName": "amazon",
"author": "Creepy Guy In The Corner",
"email": "",
"version": "0.0.13",
"website": "http://gettomahawk.com",
"description": "Streams music from Amazon Music",
"type": "resolver/javascript",
"manifest": {
"main": "contents/code/amazon.js",
"icon": "contents/images/icon.png",
"iconWhite": "contents/images/iconWhite.png",
"iconBackground": "contents/images/iconBackground.png",
"scripts": [],
"resources": [
"contents/code/config.ui"
]
},
"staticCapabilities": [
"configTestable"
]
}
================================================
FILE: ampache/content/contents/code/ampache.js
================================================
/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===
*
* Copyright 2011, Dominik Schmidt <domme@tomahawk-player.org>
* Copyright 2011, Leo Franchi <lfranchi@kde.org>
* Copyright 2013, Teo Mrnjavac <teo@kde.org>
* Copyright 2015, Enno Gottschalk <mrmaffen@googlemail.com>
*
* Tomahawk is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation, version 3.
*
* Tomahawk is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
var AmpacheResolver = Tomahawk.extend(Tomahawk.Resolver, {
apiVersion: 0.9,
_ready: false,
settings: {
name: 'Ampache',
icon: 'ampache-icon.png',
weight: 85,
timeout: 5,
limit: 10
},
getConfigUi: function () {
var uiData = Tomahawk.readBase64("config.ui");
return {
"widget": uiData,
fields: [{
name: "server",
widget: "serverLineEdit",
property: "text"
}, {
name: "username",
widget: "usernameLineEdit",
property: "text"
}, {
name: "password",
widget: "passwordLineEdit",
property: "text"
}],
images: [{
"owncloud.png": Tomahawk.readBase64("owncloud.png")
}, {
"ampache.png": Tomahawk.readBase64("ampache.png")
}]
};
},
/**
* Defines this Resolver's config dialog UI.
*/
configUi: [
{
id: "server",
type: "textfield",
label: "Server URL",
defaultValue: "http://localhost/ampache"
},
{
id: "username",
type: "textfield",
label: "Username"
},
{
id: "password",
type: "textfield",
label: "Password",
isPassword: true
}
],
newConfigSaved: function (newConfig) {
if ((newConfig.username != this.username) || (newConfig.password != this.password)
|| (newConfig.server != this.server)) {
Tomahawk.log("Invalidating cache");
var that = this;
ampacheCollection.wipe({id: ampacheCollection.settings.id}).then(function () {
window.localStorage.removeItem("ampache_last_cache_update");
that.init();
});
}
},
init: function () {
var that = this;
this._ready = false;
if (!this.element) {
this.element = document.createElement('div');
}
// check resolver is properly configured
var userConfig = this.getUserConfig();
if (!userConfig.username || !userConfig.password || !userConfig.server) {
Tomahawk.log("Ampache Resolver not properly configured!");
return;
}
this._sanitizeConfig(userConfig);
this.username = userConfig.username;
this.password = userConfig.password;
this.server = userConfig.server;
return this._login(this.username, this.password, this.server).then(function () {
if (that.auth) {
that._ensureCollection();
}
});
},
_ensureCollection: function () {
var that = this;
return ampacheCollection.revision({
id: ampacheCollection.settings.id
}).then(function (result) {
var lastCollectionUpdate = window.localStorage["ampache_last_collection_update"];
if (lastCollectionUpdate && lastCollectionUpdate == result) {
Tomahawk.log("Collection database has not been changed since last time.");
var add;
if (window.localStorage["ampache_last_cache_update"]) {
var date = new Date(parseInt(window.localStorage["ampache_last_cache_update"]));
add = date.toISOString();
}
return that._fetchAndStoreCollection(add);
} else {
Tomahawk.log("Collection database has been changed. Wiping and re-fetching...");
return ampacheCollection.wipe({
id: ampacheCollection.settings.id
}).then(function () {
return that._fetchAndStoreCollection();
});
}
});
},
_fetchAndStoreCollection: function (add) {
var that = this;
if (!this._requestPromise) {
Tomahawk.log("Checking if collection needs to be updated");
var time = Date.now();
var settings = {
offset: 0,
limit: 1000000 // EHRM.
};
if (add) {
settings.add = add;
}
this._requestPromise = this._apiCall("songs", settings).then(function (xmlDoc) {
var songs;
var songElements = xmlDoc.getElementsByTagName("song")[0];
if (songElements !== undefined && songElements.childNodes.length > 0) {
songs = xmlDoc.getElementsByTagName("song");
}
Tomahawk.PluginManager.registerPlugin("collection", ampacheCollection);
if (songs && songs.length > 0) {
Tomahawk.log("Collection needs to be updated");
var tracks = that._parseSongResponse(xmlDoc);
ampacheCollection.addTracks({
id: ampacheCollection.settings.id,
tracks: tracks
}).then(function (newRevision) {
Tomahawk.log("Updated cache in " + (Date.now() - time) + "ms");
window.localStorage["ampache_last_cache_update"] = Date.now();
window.localStorage["ampache_last_collection_update"] = newRevision;
});
} else {
Tomahawk.log("Collection doesn't need to be updated");
ampacheCollection.addTracks({
id: ampacheCollection.settings.id,
tracks: []
});
}
}, function (xhr) {
Tomahawk.log("Tomahawk.get failed: " + xhr.status + " - "
+ xhr.statusText + " - " + xhr.responseText);
}).finally(function () {
that._requestPromise = undefined;
});
}
return this._requestPromise;
},
testConfig: function (config) {
var that = this;
this._sanitizeConfig(config);
return this._login(config.username, config.password, config.server)
.then(function (response) {
if (!that.auth) {
Tomahawk.log("auth failed!");
var error = response.getElementsByTagName("error")[0];
if (typeof error != 'undefined' && error.getAttribute("code") == "403") {
return TomahawkConfigTestResultType.InvalidAccount;
} else {
return TomahawkConfigTestResultType.InvalidCredentials;
}
} else {
return TomahawkConfigTestResultType.Success;
}
}, function () {
return TomahawkConfigTestResultType.CommunicationError;
});
},
_sanitizeConfig: function (config) {
if (!config.server) {
config.server = "http://localhost/ampache";
} else {
if (config.server.search(".*:\/\/") < 0) {
// couldn't find a proper protocol, so we default to "http://"
config.server = "http://" + config.server;
}
config.server = config.server.trim();
}
return config;
},
_handshake: function (username, password, server) {
var time = Tomahawk.timestamp();
var key, passphrase;
if (typeof CryptoJS !== "undefined" && typeof CryptoJS.SHA256 == "function") {
key = CryptoJS.SHA256(password).toString(CryptoJS.enc.Hex);
passphrase = CryptoJS.SHA256(time + key).toString(CryptoJS.enc.Hex);
} else {
key = Tomahawk.sha256(password);
passphrase = Tomahawk.sha256(time + key);
}
var params = {};
params.user = username;
params.timestamp = time;
params.version = 350001;
params.auth = passphrase;
return this._apiCallBase(server, 'handshake',
params).then(this._parseHandshakeResult);
},
_parseHandshakeResult: function (xmlDoc) {
var roots = xmlDoc.getElementsByTagName("root");
var auth = roots[0] === undefined ? false : Tomahawk.valueForSubNode(roots[0], "auth");
if (!auth) {
Tomahawk.log("INVALID HANDSHAKE RESPONSE!");
return xmlDoc;
}
Tomahawk.log("New auth token: " + auth);
var pingInterval = parseInt(roots[0] === undefined ? 0 : Tomahawk.valueForSubNode(roots[0],
"session_length")) * 1000;
var trackCount = roots[0] === undefined ? (-1) : Tomahawk.valueForSubNode(roots[0],
"songs");
return {
auth: auth,
trackCount: trackCount > -1 ? parseInt(trackCount) : trackCount,
pingInterval: pingInterval
};
},
_login: function (username, password, server) {
var that = this;
return this._handshake(username, password, server).then(function (result) {
that.auth = result.auth;
that.trackCount = result.trackCount;
Tomahawk.log("Ampache Resolver properly initialised!");
that._ready = true;
// FIXME: the old timer should be cancelled ...
if (result.pingInterval) {
window.setInterval(that._ping, result.pingInterval - 60);
}
return result;
});
},
_apiCallBase: function (serverUrl, action, params) {
params = params || {};
params.action = action;
var options = {
url: serverUrl.replace(/\/$/, "") + "/server/xml.server.php",
data: params
};
return Tomahawk.get(options);
},
_apiCall: function (action, params) {
if (!this.auth) {
throw new Error("Not authed, can't do api call");
}
params = params || {};
params.auth = this.auth;
var that = this;
return this._apiCallBase(this.server, action, params).then(function (xmlDoc) {
var error = xmlDoc.getElementsByTagName("error")[0];
if (typeof error != 'undefined' && error.getAttribute("code") == "401") //session expired
{
Tomahawk.log("Let's reauth for: " + action);
return that._login(that.username, that.password, that.server).then(function () {
return that._apiCallBase(action, params);
}, function () {
throw new Error("Could not renew session.");
});
}
return xmlDoc;
});
},
_ping: function () {
this._apiCall('ping').then(function () {
Tomahawk.log('Ping succeeded.');
}, function () {
Tomahawk.log('Ping failed.');
});
},
_decodeEntity: function (str) {
this.element.innerHTML = str;
return this.element.textContent;
},
_parseSongResponse: function (xmlDoc) {
var results = [];
// check the response
var songElements = xmlDoc.getElementsByTagName("song")[0];
if (songElements !== undefined && songElements.childNodes.length > 0) {
var songs = xmlDoc.getElementsByTagName("song");
// walk through the results and store it in 'results'
for (var i = 0; i < songs.length; i++) {
var song = songs[i];
results.push({
artist: this._decodeEntity(Tomahawk.valueForSubNode(song, "artist")),
album: this._decodeEntity(Tomahawk.valueForSubNode(song, "album")),
track: this._decodeEntity(Tomahawk.valueForSubNode(song, "title")),
albumpos: Tomahawk.valueForSubNode(song, "track"),
//result.year = 0;//valueForSubNode(song, "year");
source: this.settings.name,
url: "ampache://track/" + song.getAttribute("id"),
//mimetype: valueForSubNode(song, "mime"), //FIXME what's up here? it was there before :\
//result.bitrate = valueForSubNode(song, "title");
size: Tomahawk.valueForSubNode(song, "size"),
duration: Tomahawk.valueForSubNode(song, "time"),
score: Tomahawk.valueForSubNode(song, "rating")
});
}
}
return results;
},
getStreamUrl: function (params) {
var url = params.url;
var settings = {
filter: url.replace("ampache://track/", "")
};
return this._apiCall("song", settings).then(function (xmlDoc) {
// check the response
var songs = xmlDoc.getElementsByTagName("song");
if (songs[0] !== undefined && songs[0].childNodes.length > 0) {
return {
url: Tomahawk.valueForSubNode(songs[0], "url")
}
} else {
throw new Error("Wasn't able to get streaming url for song " + settings.filter);
}
});
},
resolve: function (params) {
var artist = params.artist;
var album = params.album;
var track = params.track;
return this.search({query: artist + " " + track});
},
search: function (params) {
var query = params.query;
if (!this._ready) {
return;
}
params = {
filter: query,
limit: this.settings.limit
};
var that = this;
return this._apiCall("search_songs", params).then(function (xmlDoc) {
return that._parseSongResponse(xmlDoc);
});
}
});
Tomahawk.resolver.instance = AmpacheResolver;
var ampacheCollection = Tomahawk.extend(Tomahawk.Collection, {
resolver: AmpacheResolver,
settings: {
id: "ampache",
prettyname: "Ampache",
description: AmpacheResolver.getUserConfig()
? AmpacheResolver._sanitizeConfig(AmpacheResolver.getUserConfig()).server
.replace(/^http:\/\//, "")
.replace(/^https:\/\//, "")
.replace(/\/$/, "")
.replace(/\/remote.php\/ampache/, "")
: "",
iconfile: "contents/images/icon.png",
trackcount: AmpacheResolver.trackCount
}
});
/*
* TEST ENVIRONMENT
*/
/*TomahawkResolver.getUserConfig = function() {
return {
username: "domme",
password: "foo",
ampache: "http://owncloud.lo/ampache"
//ampache: "http://owncloud.lo/apps/media"
};
};*/
//
// var resolver = Tomahawk.resolver.instance;
//
//
// // configure tests
// var search = {
// filter: "I Fell"
// };
//
// var resolve = {
// artist: "The Aquabats!",
// title: "I Fell Asleep On My Arm"
// };
// // end configure
//
//
//
//
//tests
//resolver.init();
//
// // test search
// //Tomahawk.log("Search for: " + search.filter );
// var response1 = resolver.search( 1234, search.filter );
// //Tomahawk.dumpResult( response1 );
//
// // test resolve
// //Tomahawk.log("Resolve: " + resolve.artist + " - " + resolve.album + " - " + resolve.title );
// var response2 = resolver.resolve( 1235, resolve.artist, resolve.album, resolve.title );
// //Tomahawk.dumpResult( response2 );
// Tomahawk.log("test");
// n = 0;
// var items = resolver.getArtists( n ).results;
// for(var i=0;i<items.length;i++)
// {
// artist = items[i];
// Tomahawk.log("Artist: " + artist);
// var albums = resolver.getAlbums( ++n, artist ).results;
// for(var j=0;j<albums.length;j++)
// {
// var album = albums[j];
// Tomahawk.dumpResult( resolver.getTracks( ++n, artist, album ) );
// }
// }
//
// phantom.exit();
================================================
FILE: ampache/content/contents/code/config.ui
================================================
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Form</class>
<widget class="QWidget" name="Form">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>447</width>
<height>318</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QLabel" name="label_2">
<property name="text">
<string/>
</property>
<property name="pixmap">
<pixmap>ampache.png</pixmap>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label">
<property name="text">
<string/>
</property>
<property name="pixmap">
<pixmap>owncloud.png</pixmap>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_3">
<property name="font">
<font>
<italic>false</italic>
</font>
</property>
<property name="text">
<string><html><head/><body><p>For ownCloud instances, the Server URL is<br/>http://<span style=" color:#585858;">ownCloud base url</span>/remote.php/ampache</p></body></html></string>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</item>
<item>
<layout class="QFormLayout" name="formLayout">
<item row="0" column="0">
<widget class="QLabel" name="serverLabel">
<property name="text">
<string>Server URL:</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QLineEdit" name="serverLineEdit"/>
</item>
<item row="1" column="0">
<widget class="QLabel" name="usernameLabel">
<property name="text">
<string>Username:</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QLineEdit" name="usernameLineEdit"/>
</item>
<item row="2" column="0">
<widget class="QLabel" name="passwordLabel">
<property name="text">
<string>Password:</string>
</property>
</widget>
</item>
<item row="2" column="1">
<widget class="QLineEdit" name="passwordLineEdit">
<property name="echoMode">
<enum>QLineEdit::Password</enum>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>
================================================
FILE: ampache/content/metadata.json
================================================
{
"name": "Ampache",
"pluginName": "ampache",
"author": "Dominik, Leo, Teo and Enno",
"email": "teo@kde.org",
"version": "0.4.3",
"website": "http://gettomahawk.com",
"description": "Connects to an Ampache or ownCloud server and resolves tracks.",
"type": "resolver/javascript",
"manifest": {
"main": "contents/code/ampache.js",
"scripts": [],
"icon": "contents/images/icon.png",
"iconWhite": "contents/images/iconWhite.png",
"iconBackground": "contents/images/iconBackground.png",
"resources": [
"contents/code/config.ui",
"contents/code/ampache-icon.png",
"contents/code/ampache.png",
"contents/code/owncloud-icon.png",
"contents/code/owncloud.png"
]
},
"staticCapabilities": [
"configTestable"
]
}
================================================
FILE: archive/README
================================================
Resolvers in this directory are not functional anymore because the used API
is not available anymore. The resolver may still be helpful as a basis for
developing new resolvers.
================================================
FILE: archive/dilandau/content/contents/code/dilandau.js
================================================
/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===
*
* Copyright 2011, lasconic <lasconic@gmail.com>
* Copyright 2011, Leo Franchi <lfranchi@kde.org>
* Copyright 2012, Thierry Göckel <thierry@strayrayday.lu>
*
* Tomahawk is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Tomahawk is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Tomahawk. If not, see <http://www.gnu.org/licenses/>.
*/
var DilandauResolver = Tomahawk.extend(TomahawkResolver, {
settings: {
name: 'Dilandau',
icon: 'dilandau-icon.png',
weight: 90,
timeout: 10
},
handleResponse: function(qid, artist, album, title) {
var that = this;
return function (xhr) {
var matches = [];
var xmlString = xhr.responseText;
xmlString.replace(/<a class="button tip download_button" title="[^"]*" href="([^"]*)"/g, function() {
matches.push(Array.prototype.slice.call(arguments,1,2));
});
var matchesTitle = [];
xmlString.replace(/<h2 class="title_song" title="([^"]*)"/g, function() {
matchesTitle.push(Array.prototype.slice.call(arguments,1,2));
});
var results = [];
var empty = {
qid: qid,
results: []
};
if (matches.length > 0 && matches.length === matchesTitle.length) {
var stop = matches.length;
for (var i = 0; i < matches.length; i++) {
var url = matches[i][0];
var dTitle = matchesTitle[i];
var dTitleLower = dTitle.toString().toLowerCase();
if (dTitleLower.indexOf(artist.toLowerCase()) === -1 || dTitleLower.indexOf(title.toLowerCase()) === -1) {
stop = stop - 1;
continue;
}
else {
(function(qid, url) {
var http = new XMLHttpRequest();
http.open('HEAD', url, true);
http.onreadystatechange = function() {
if (http.readyState === 4){
if (http.status === 200 && http.getResponseHeader("Content-Type") !== null && (http.getResponseHeader("Content-Type").indexOf("audio") !== -1 || http.getResponseHeader("Content-Type").indexOf("video") !== -1 )){
var result = {};
result.artist = artist;
result.track = title;
result.source = that.settings.name;
result.url = url;
result.mimetype = "audio/mpeg";
result.bitrate = 128;
result.score = 0.9;
results.push(result);
stop = stop - 1;
if (stop === 0){
var return1 = {
qid: qid,
results: [results[0]]
};
Tomahawk.addTrackResults(return1);
}
}
else {
stop = stop - 1;
}
}
};
http.send(null);
})(qid, url);
}
}
if (stop === 0){
Tomahawk.addTrackResults(empty);
}
}
else {
Tomahawk.addTrackResults(empty);
}
};
},
resolve: function (qid, artist, album, title) {
// build query to Dilandau
var url = "http://www.dilandau.eu/download_music/";
var request = "";
if (title !== ""){
request += title.replace(/ /g, '-');
}
if (artist !== "") {
if (title !== ""){
request += '-';
}
request += artist.replace(/ /g, '-');
}
url += encodeURIComponent(request);
url += "-1.html";
// send request and parse it into javascript
Tomahawk.asyncRequest(url, this.handleResponse(qid, artist, album, title));
},
search: function (qid, searchString) {
var return1 = {
qid: qid,
results: new Array()
};
return return1;
}
});
Tomahawk.resolver.instance = DilandauResolver;
================================================
FILE: archive/dilandau/content/metadata.json
================================================
{
"name": "Dilandau",
"pluginName": "dilandau",
"author": "lasconic",
"email": "lasconic@gmail.com",
"version": "0.4.1",
"website": "http://gettomahawk.com",
"description": "Uses mp3 search engine http://www.dilandau.eu/ to find tracks.",
"type": "resolver/javascript",
"manifest": {
"main": "contents/code/dilandau.js",
"scripts": [],
"icon": "contents/images/icon.png",
"resources": [
"contents/code/dilandau-icon.png"
]
}
}
================================================
FILE: archive/exfm/content/contents/code/exfm.js
================================================
/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===
*
* Copyright 2011, lasonic <lasconic@gmail.com>
* Copyright 2013, Uwe L. Korn <uwelk@xhochy.com>
*
* Tomahawk is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Tomahawk is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Tomahawk. If not, see <http://www.gnu.org/licenses/>.
*/
var ExfmResolver = Tomahawk.extend(TomahawkResolver, {
settings: {
name: 'Ex.fm',
icon: 'exfm-icon.png',
weight: 30,
timeout: 5
},
init: function () {
Tomahawk.PluginManager.registerPlugin("linkParser", this);
},
cleanTitle: function (title, artist) {
// If the title contains a newline character, strip them off and remove additional spacing
var newTitle = "",
stringArray = title.split("\n");
title.split("\n").forEach(function (split) {
newTitle += split.trim() + " ";
});
// Remove dash and quotation characters.
newTitle = newTitle.replace("\u2013", "").replace(" ", " ").replace("\u201c", "").replace("\u201d", "");
// If the artist is included in the song title, cut it
if (newTitle.toLowerCase().indexOf(artist.toLowerCase() + " -") === 0) {
newTitle = newTitle.slice(artist.length + 2).trim();
} else if (newTitle.toLowerCase().indexOf(artist.toLowerCase() + "-") === 0) {
newTitle = newTitle.slice(artist.length + 1).trim();
} else if (newTitle.toLowerCase().indexOf(artist.toLowerCase()) === 0) {
// FIXME: This might break results where the artist name is a substring of the song title.
newTitle = newTitle.slice(artist.length).trim();
}
return newTitle;
},
resolve: function (qid, artist, album, title) {
var that = this,
// Build search query for ex.fm
url = "https://ex.fm/api/v3/song/search/" + encodeURIComponent(title) + "?start=0&results=20&client_id=tomahawk";
// send request and parse it into javascript
Tomahawk.asyncRequest(url, function (xhr) {
// parse json
var response = JSON.parse(xhr.responseText),
results = [];
// check the response
if (response.results > 0) {
response.songs.forEach(function (song) {
if (typeof(song.url) == 'undefined' || song.url == null) {
return;
}
if ((song.url.indexOf("http://api.soundcloud") === 0) || (song.url.indexOf("https://api.soundcloud") === 0)) { // unauthorised, use soundcloud resolver instead
return;
}
if (song.artist === null || song.title === null) {
// This track misses relevant information, so we are going to ignore it.
return;
}
var result = {},
dTitle = that.cleanTitle(song.title, song.artist),
dArtist = song.artist,
dAlbum = "";
if (song.album !== null) {
dAlbum = song.album;
}
if (typeof(song.sources) != 'undefined' && song.sources != null && song.sources.length > 0) {
result.linkUrl = song.sources[0]
}
if ((dTitle.toLowerCase().indexOf(title.toLowerCase()) !== -1 && dArtist.toLowerCase().indexOf(artist.toLowerCase()) !== -1) || (artist === "" && album === "")) {
result.artist = ((dArtist !== "") ? dArtist : artist);
result.album = ((dAlbum !== "") ? dAlbum : album);
result.track = ((dTitle !== "") ? dTitle : title);
result.source = that.settings.name;
result.url = song.url;
result.extension = "mp3";
result.score = 0.80;
results.push(result);
}
});
}
Tomahawk.addTrackResults({qid: qid, results: results});
});
},
canParseUrl: function (url, type) {
// Ex.fm does not support artists and only lists the album of the week as an album
switch (type) {
case TomahawkUrlType.Album:
return /https?:\/\/(www\.)?ex.fm\/explore\/album-of-the-week/.test(url);
case TomahawkUrlType.Artist:
return false;
case TomahawkUrlType.Track:
return /https?:\/\/(www\.)?ex.fm\/song\//.test(url)
// case TomahawkUrlType.Playlist:
// case TomahawkUrlType.Any:
default:
return /https?:\/\/(www\.)?ex.fm\//.test(url);
}
},
track2Result: function (item) {
var result = {
type: "track",
title: item.title,
artist: item.artist,
album: item.album
};
return result;
},
lookupUrl: function (url) {
var urlParts = url.split('/').filter(function (item) { return item !== "" });
var query = "https://ex.fm/api/v3";
var that = this;
if (urlParts.length === 3) {
// Url matches a user, e.g. https://ex.fm/xhochy
query += "/user/" + urlParts[2] + "/trending";
query += "?client_id=tomahawk";
} else if (/\/explore\/site-of-the-day/.test(url)) {
// Site of the day
query += "/sotd?results=1";
query += "&client_id=tomahawk";
} else if (urlParts[2] == 'explore' && urlParts[3] == 'album-of-the-week') {
query += '/atow?results=1';
query += "&client_id=tomahawk";
} else if (urlParts[2] == 'explore' && urlParts[3] == 'mixtape-of-the-month') {
query += '/motm?results=1';
query += "&client_id=tomahawk";
} else if (/\/song\//.test(url)) {
// Just one simple song
query += "/song/" + urlParts[3];
query += "?client_id=tomahawk";
} else if (/https?:\/\/(www\.)?ex.fm\/site\//.test(url)) {
query += url.replace(/https?:\/\/(www\.)?ex.fm/, '');
query += "?client_id=tomahawk";
} else if (urlParts[2] == "search") {
query += "/song/search/" + urlParts[3];
query += "?client_id=tomahawk";
} else {
query += url.replace(/https?:\/\/(www\.)?ex.fm/, '');
query += "?client_id=tomahawk";
}
Tomahawk.asyncRequest(query, function (xhr) {
var res = JSON.parse(xhr.responseText);
if (res.hasOwnProperty("song")) {
// One single song
return that.track2Result(res.song);
} else if (res.hasOwnProperty("site") && res.site.hasOwnProperty("songs")) {
// A site with songs
var guid;
if (typeof CryptoJS !== "undefined" && typeof CryptoJS.SHA256 == "function") {
guid = CryptoJS.SHA256(query).toString(CryptoJS.enc.Hex);
} else {
guid = Tomahawk.sha256(query);
}
var result = {
type: "playlist",
title: res.site.title,
guid: 'exfm-site-' + guid,
info: "ex.fm parse of : " + res.site.url,
creator: "exfm",
url: url,
tracks: []
};
res.site.songs.forEach(function (item) {
result.tracks.push(that.track2Result(item));
});
Tomahawk.addUrlResult(url, result);
} else if (res.hasOwnProperty("songs")) {
// A list of songs
var guid;
if (typeof CryptoJS !== "undefined" && typeof CryptoJS.SHA256 == "function") {
guid = CryptoJS.SHA256(query).toString(CryptoJS.enc.Hex);
} else {
guid = Tomahawk.sha256(query);
}
var result = {
type: "playlist",
title: "ex.fm" + url.replace(/https?:\/\/(www\.)?ex.fm/, ''),
guid: 'exfm-playlist-' + guid,
info: "A playlist imported from ex.fm: " + url,
creator: "exfm",
url: url,
tracks: []
};
res.songs.forEach(function (item) {
result.tracks.push(that.track2Result(item));
});
Tomahawk.addUrlResult(url, result);
} else {
Tomahawk.log("Could not parse ex.fm URL: " + url);
Tomahawk.addUrlResult(url, {})
};
});
},
search: function (qid, searchString) {
this.settings.strictMatch = false;
this.resolve(qid, "", "", searchString);
}
});
Tomahawk.resolver.instance = ExfmResolver;
================================================
FILE: archive/exfm/content/metadata.json
================================================
{
"name": "ex.fm",
"pluginName": "ex.fm",
"author": "Nicolas and Uwe",
"email": "uwelk@xhochy.com",
"version": "0.3.3",
"website": "http://gettomahawk.com",
"description": "Resolves tracks via the ex.fm API",
"type": "resolver/javascript",
"manifest": {
"main": "contents/code/exfm.js",
"scripts": [
],
"icon": "contents/images/icon.png",
"resources": [
"contents/code/exfm-icon.png"
]
}
}
================================================
FILE: archive/grooveshark/content/contents/code/config.ui
================================================
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Form</class>
<widget class="QWidget" name="Form">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>447</width>
<height>305</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QLabel" name="label_2">
<property name="text">
<string/>
</property>
<property name="pixmap">
<pixmap>grooveshark.png</pixmap>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label">
<property name="text">
<string>Tomahawk requires a Grooveshark Anywhere account.</string>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</item>
<item>
<layout class="QFormLayout" name="formLayout">
<property name="fieldGrowthPolicy">
<enum>QFormLayout::FieldsStayAtSizeHint</enum>
</property>
<item row="0" column="0">
<widget class="QLabel" name="usernameLabel">
<property name="text">
<string>Username</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QLineEdit" name="usernameLineEdit"/>
</item>
<item row="1" column="0">
<widget class="QLabel" name="passwordLabel">
<property name="text">
<string>Password</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QLineEdit" name="passwordLineEdit">
<property name="echoMode">
<enum>QLineEdit::Password</enum>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>
================================================
FILE: archive/grooveshark/content/contents/code/grooveshark.js
================================================
/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===
*
* Copyright 2011-2012, Leo Franchi <lfranchi@kde.org>
*
* Tomahawk is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Tomahawk is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Tomahawk. If not, see <http://www.gnu.org/licenses/>.
*/
if (Tomahawk.removeDiacritics) {
var removeDiacritics = function(str) {
return Tomahawk.removeDiacritics(str);
};
} else {
// Fallback implementation for 0.7
// for removing diacritics [extracted from : http://lehelk.com/2011/05/06/script-to-remove-diacritics/]
var defaultDiacriticsRemovalMap = [
{'base':'A', 'letters':/[\u0041\u24B6\uFF21\u00C0\u00C1\u00C2\u1EA6\u1EA4\u1EAA\u1EA8\u00C3\u0100\u0102\u1EB0\u1EAE\u1EB4\u1EB2\u0226\u01E0\u00C4\u01DE\u1EA2\u00C5\u01FA\u01CD\u0200\u0202\u1EA0\u1EAC\u1EB6\u1E00\u0104\u023A\u2C6F]/g},
{'base':'AA','letters':/[\uA732]/g},
{'base':'AE','letters':/[\u00C6\u01FC\u01E2]/g},
{'base':'AO','letters':/[\uA734]/g},
{'base':'AU','letters':/[\uA736]/g},
{'base':'AV','letters':/[\uA738\uA73A]/g},
{'base':'AY','letters':/[\uA73C]/g},
{'base':'B', 'letters':/[\u0042\u24B7\uFF22\u1E02\u1E04\u1E06\u0243\u0182\u0181]/g},
{'base':'C', 'letters':/[\u0043\u24B8\uFF23\u0106\u0108\u010A\u010C\u00C7\u1E08\u0187\u023B\uA73E]/g},
{'base':'D', 'letters':/[\u0044\u24B9\uFF24\u1E0A\u010E\u1E0C\u1E10\u1E12\u1E0E\u0110\u018B\u018A\u0189\uA779]/g},
{'base':'DZ','letters':/[\u01F1\u01C4]/g},
{'base':'Dz','letters':/[\u01F2\u01C5]/g},
{'base':'E', 'letters':/[\u0045\u24BA\uFF25\u00C8\u00C9\u00CA\u1EC0\u1EBE\u1EC4\u1EC2\u1EBC\u0112\u1E14\u1E16\u0114\u0116\u00CB\u1EBA\u011A\u0204\u0206\u1EB8\u1EC6\u0228\u1E1C\u0118\u1E18\u1E1A\u0190\u018E]/g},
{'base':'F', 'letters':/[\u0046\u24BB\uFF26\u1E1E\u0191\uA77B]/g},
{'base':'G', 'letters':/[\u0047\u24BC\uFF27\u01F4\u011C\u1E20\u011E\u0120\u01E6\u0122\u01E4\u0193\uA7A0\uA77D\uA77E]/g},
{'base':'H', 'letters':/[\u0048\u24BD\uFF28\u0124\u1E22\u1E26\u021E\u1E24\u1E28\u1E2A\u0126\u2C67\u2C75\uA78D]/g},
{'base':'I', 'letters':/[\u0049\u24BE\uFF29\u00CC\u00CD\u00CE\u0128\u012A\u012C\u0130\u00CF\u1E2E\u1EC8\u01CF\u0208\u020A\u1ECA\u012E\u1E2C\u0197]/g},
{'base':'J', 'letters':/[\u004A\u24BF\uFF2A\u0134\u0248]/g},
{'base':'K', 'letters':/[\u004B\u24C0\uFF2B\u1E30\u01E8\u1E32\u0136\u1E34\u0198\u2C69\uA740\uA742\uA744\uA7A2]/g},
{'base':'L', 'letters':/[\u004C\u24C1\uFF2C\u013F\u0139\u013D\u1E36\u1E38\u013B\u1E3C\u1E3A\u0141\u023D\u2C62\u2C60\uA748\uA746\uA780]/g},
{'base':'LJ','letters':/[\u01C7]/g},
{'base':'Lj','letters':/[\u01C8]/g},
{'base':'M', 'letters':/[\u004D\u24C2\uFF2D\u1E3E\u1E40\u1E42\u2C6E\u019C]/g},
{'base':'N', 'letters':/[\u004E\u24C3\uFF2E\u01F8\u0143\u00D1\u1E44\u0147\u1E46\u0145\u1E4A\u1E48\u0220\u019D\uA790\uA7A4]/g},
{'base':'NJ','letters':/[\u01CA]/g},
{'base':'Nj','letters':/[\u01CB]/g},
{'base':'O', 'letters':/[\u004F\u24C4\uFF2F\u00D2\u00D3\u00D4\u1ED2\u1ED0\u1ED6\u1ED4\u00D5\u1E4C\u022C\u1E4E\u014C\u1E50\u1E52\u014E\u022E\u0230\u00D6\u022A\u1ECE\u0150\u01D1\u020C\u020E\u01A0\u1EDC\u1EDA\u1EE0\u1EDE\u1EE2\u1ECC\u1ED8\u01EA\u01EC\u00D8\u01FE\u0186\u019F\uA74A\uA74C]/g},
{'base':'OI','letters':/[\u01A2]/g},
{'base':'OO','letters':/[\uA74E]/g},
{'base':'OU','letters':/[\u0222]/g},
{'base':'P', 'letters':/[\u0050\u24C5\uFF30\u1E54\u1E56\u01A4\u2C63\uA750\uA752\uA754]/g},
{'base':'Q', 'letters':/[\u0051\u24C6\uFF31\uA756\uA758\u024A]/g},
{'base':'R', 'letters':/[\u0052\u24C7\uFF32\u0154\u1E58\u0158\u0210\u0212\u1E5A\u1E5C\u0156\u1E5E\u024C\u2C64\uA75A\uA7A6\uA782]/g},
{'base':'S', 'letters':/[\u0053\u24C8\uFF33\u1E9E\u015A\u1E64\u015C\u1E60\u0160\u1E66\u1E62\u1E68\u0218\u015E\u2C7E\uA7A8\uA784]/g},
{'base':'T', 'letters':/[\u0054\u24C9\uFF34\u1E6A\u0164\u1E6C\u021A\u0162\u1E70\u1E6E\u0166\u01AC\u01AE\u023E\uA786]/g},
{'base':'TZ','letters':/[\uA728]/g},
{'base':'U', 'letters':/[\u0055\u24CA\uFF35\u00D9\u00DA\u00DB\u0168\u1E78\u016A\u1E7A\u016C\u00DC\u01DB\u01D7\u01D5\u01D9\u1EE6\u016E\u0170\u01D3\u0214\u0216\u01AF\u1EEA\u1EE8\u1EEE\u1EEC\u1EF0\u1EE4\u1E72\u0172\u1E76\u1E74\u0244]/g},
{'base':'V', 'letters':/[\u0056\u24CB\uFF36\u1E7C\u1E7E\u01B2\uA75E\u0245]/g},
{'base':'VY','letters':/[\uA760]/g},
{'base':'W', 'letters':/[\u0057\u24CC\uFF37\u1E80\u1E82\u0174\u1E86\u1E84\u1E88\u2C72]/g},
{'base':'X', 'letters':/[\u0058\u24CD\uFF38\u1E8A\u1E8C]/g},
{'base':'Y', 'letters':/[\u0059\u24CE\uFF39\u1EF2\u00DD\u0176\u1EF8\u0232\u1E8E\u0178\u1EF6\u1EF4\u01B3\u024E\u1EFE]/g},
{'base':'Z', 'letters':/[\u005A\u24CF\uFF3A\u0179\u1E90\u017B\u017D\u1E92\u1E94\u01B5\u0224\u2C7F\u2C6B\uA762]/g},
{'base':'a', 'letters':/[\u0061\u24D0\uFF41\u1E9A\u00E0\u00E1\u00E2\u1EA7\u1EA5\u1EAB\u1EA9\u00E3\u0101\u0103\u1EB1\u1EAF\u1EB5\u1EB3\u0227\u01E1\u00E4\u01DF\u1EA3\u00E5\u01FB\u01CE\u0201\u0203\u1EA1\u1EAD\u1EB7\u1E01\u0105\u2C65\u0250]/g},
{'base':'aa','letters':/[\uA733]/g},
{'base':'ae','letters':/[\u00E6\u01FD\u01E3]/g},
{'base':'ao','letters':/[\uA735]/g},
{'base':'au','letters':/[\uA737]/g},
{'base':'av','letters':/[\uA739\uA73B]/g},
{'base':'ay','letters':/[\uA73D]/g},
{'base':'b', 'letters':/[\u0062\u24D1\uFF42\u1E03\u1E05\u1E07\u0180\u0183\u0253]/g},
{'base':'c', 'letters':/[\u0063\u24D2\uFF43\u0107\u0109\u010B\u010D\u00E7\u1E09\u0188\u023C\uA73F\u2184]/g},
{'base':'d', 'letters':/[\u0064\u24D3\uFF44\u1E0B\u010F\u1E0D\u1E11\u1E13\u1E0F\u0111\u018C\u0256\u0257\uA77A]/g},
{'base':'dz','letters':/[\u01F3\u01C6]/g},
{'base':'e', 'letters':/[\u0065\u24D4\uFF45\u00E8\u00E9\u00EA\u1EC1\u1EBF\u1EC5\u1EC3\u1EBD\u0113\u1E15\u1E17\u0115\u0117\u00EB\u1EBB\u011B\u0205\u0207\u1EB9\u1EC7\u0229\u1E1D\u0119\u1E19\u1E1B\u0247\u025B\u01DD]/g},
{'base':'f', 'letters':/[\u0066\u24D5\uFF46\u1E1F\u0192\uA77C]/g},
{'base':'g', 'letters':/[\u0067\u24D6\uFF47\u01F5\u011D\u1E21\u011F\u0121\u01E7\u0123\u01E5\u0260\uA7A1\u1D79\uA77F]/g},
{'base':'h', 'letters':/[\u0068\u24D7\uFF48\u0125\u1E23\u1E27\u021F\u1E25\u1E29\u1E2B\u1E96\u0127\u2C68\u2C76\u0265]/g},
{'base':'hv','letters':/[\u0195]/g},
{'base':'i', 'letters':/[\u0069\u24D8\uFF49\u00EC\u00ED\u00EE\u0129\u012B\u012D\u00EF\u1E2F\u1EC9\u01D0\u0209\u020B\u1ECB\u012F\u1E2D\u0268\u0131]/g},
{'base':'j', 'letters':/[\u006A\u24D9\uFF4A\u0135\u01F0\u0249]/g},
{'base':'k', 'letters':/[\u006B\u24DA\uFF4B\u1E31\u01E9\u1E33\u0137\u1E35\u0199\u2C6A\uA741\uA743\uA745\uA7A3]/g},
{'base':'l', 'letters':/[\u006C\u24DB\uFF4C\u0140\u013A\u013E\u1E37\u1E39\u013C\u1E3D\u1E3B\u017F\u0142\u019A\u026B\u2C61\uA749\uA781\uA747]/g},
{'base':'lj','letters':/[\u01C9]/g},
{'base':'m', 'letters':/[\u006D\u24DC\uFF4D\u1E3F\u1E41\u1E43\u0271\u026F]/g},
{'base':'n', 'letters':/[\u006E\u24DD\uFF4E\u01F9\u0144\u00F1\u1E45\u0148\u1E47\u0146\u1E4B\u1E49\u019E\u0272\u0149\uA791\uA7A5]/g},
{'base':'nj','letters':/[\u01CC]/g},
{'base':'o', 'letters':/[\u006F\u24DE\uFF4F\u00F2\u00F3\u00F4\u1ED3\u1ED1\u1ED7\u1ED5\u00F5\u1E4D\u022D\u1E4F\u014D\u1E51\u1E53\u014F\u022F\u0231\u00F6\u022B\u1ECF\u0151\u01D2\u020D\u020F\u01A1\u1EDD\u1EDB\u1EE1\u1EDF\u1EE3\u1ECD\u1ED9\u01EB\u01ED\u00F8\u01FF\u0254\uA74B\uA74D\u0275]/g},
{'base':'oi','letters':/[\u01A3]/g},
{'base':'ou','letters':/[\u0223]/g},
{'base':'oo','letters':/[\uA74F]/g},
{'base':'p','letters':/[\u0070\u24DF\uFF50\u1E55\u1E57\u01A5\u1D7D\uA751\uA753\uA755]/g},
{'base':'q','letters':/[\u0071\u24E0\uFF51\u024B\uA757\uA759]/g},
{'base':'r','letters':/[\u0072\u24E1\uFF52\u0155\u1E59\u0159\u0211\u0213\u1E5B\u1E5D\u0157\u1E5F\u024D\u027D\uA75B\uA7A7\uA783]/g},
{'base':'s','letters':/[\u0073\u24E2\uFF53\u00DF\u015B\u1E65\u015D\u1E61\u0161\u1E67\u1E63\u1E69\u0219\u015F\u023F\uA7A9\uA785\u1E9B]/g},
{'base':'t','letters':/[\u0074\u24E3\uFF54\u1E6B\u1E97\u0165\u1E6D\u021B\u0163\u1E71\u1E6F\u0167\u01AD\u0288\u2C66\uA787]/g},
{'base':'tz','letters':/[\uA729]/g},
{'base':'u','letters':/[\u0075\u24E4\uFF55\u00F9\u00FA\u00FB\u0169\u1E79\u016B\u1E7B\u016D\u00FC\u01DC\u01D8\u01D6\u01DA\u1EE7\u016F\u0171\u01D4\u0215\u0217\u01B0\u1EEB\u1EE9\u1EEF\u1EED\u1EF1\u1EE5\u1E73\u0173\u1E77\u1E75\u0289]/g},
{'base':'v','letters':/[\u0076\u24E5\uFF56\u1E7D\u1E7F\u028B\uA75F\u028C]/g},
{'base':'vy','letters':/[\uA761]/g},
{'base':'w','letters':/[\u0077\u24E6\uFF57\u1E81\u1E83\u0175\u1E87\u1E85\u1E98\u1E89\u2C73]/g},
{'base':'x','letters':/[\u0078\u24E7\uFF58\u1E8B\u1E8D]/g},
{'base':'y','letters':/[\u0079\u24E8\uFF59\u1EF3\u00FD\u0177\u1EF9\u0233\u1E8F\u00FF\u1EF7\u1E99\u1EF5\u01B4\u024F\u1EFF]/g},
{'base':'z','letters':/[\u007A\u24E9\uFF5A\u017A\u1E91\u017C\u017E\u1E93\u1E95\u01B6\u0225\u0240\u2C6C\uA763]/g}
];
var removeDiacritics = function (str) {
for(var i=0; i<defaultDiacriticsRemovalMap.length; i++) {
str = str.replace(defaultDiacriticsRemovalMap[i].letters, defaultDiacriticsRemovalMap[i].base);
}
return str;
};
}
var GroovesharkResolver = Tomahawk.extend(TomahawkResolver, {
apiKey: "tomahawkplayer",
sessionId: "",
countryId: "",
ip: "",
spell: function(a){magic=function(b){return(b=(b)?b:this).split("").map(function(d){if(!d.match(/[A-Za-z]/)){return d}c=d.charCodeAt(0)>=96;k=(d.toLowerCase().charCodeAt(0)-96+12)%26+1;return String.fromCharCode(k+(c?96:64))}).join("")};return magic(a)},
settings: {
name: 'Grooveshark',
icon: 'grooveshark-icon.png',
weight: 30,
timeout: 20
},
getConfigUi: function () {
var uiData = Tomahawk.readBase64("config.ui");
return {
"widget": uiData,
fields: [{
name: "username",
widget: "usernameLineEdit",
property: "text"
}, {
name: "password",
widget: "passwordLineEdit",
property: "text"
}],
images: [{
"grooveshark.png": Tomahawk.readBase64("grooveshark.png")
}]
};
},
newConfigSaved: function () {
var userConfig = this.getUserConfig();
if ((userConfig.username != this.username) || (userConfig.password != this.password)) {
this.sessionId = "";
this.countryId = "";
this.username = userConfig.username;
this.password = userConfig.password;
this.init();
}
},
init: function () {
var userConfig = this.getUserConfig();
if (!userConfig.username || !userConfig.password) {
Tomahawk.log("Grooveshark Resolver not properly configured!");
return;
}
// Tomahawk.log("Doing Grooveshark resolver init, got credentials: " + userConfig.username );
this.secret = this.spell("499pn17500pq8r20nso1613p2q264r7r");
this.username = userConfig.username;
this.password = userConfig.password;
this.authenticate();
Tomahawk.addCustomUrlHandler("groove", "getStreamUrl", true);
// Testing only
//Tomahawk.log("Getting playlist songs!");
//this._apiCall('getPlaylistSongs', { playlistID: '64641975' }, function (xhr) {
// Tomahawk.log("PLAYLIST RESPONSE: " + xhr.responseText );
//});
//this._apiCall('getSongsInfo', { songIDs: ['3GBAjY'] }, function(xhr) {
// Tomahawk.log("GOT SONG INFO:" + xhr.responseText );
//});
},
configTest: function() {
this.authenticate(true);
},
authenticate: function (doConfigTest) {
// Tomahawk.log("Grooveshark resolver authenticating with username: " + this.username);
var hashString;
if (typeof CryptoJS !== "undefined" && typeof CryptoJS.MD5 == "function") {
hashString = CryptoJS.MD5(this.password).toString(CryptoJS.enc.Hex);
} else {
hashString = Tomahawk.md5(this.password);
}
var params = {
login: this.username,
password: hashString
};
var errorHandler;
if (doConfigTest){
errorHandler = function () {
Tomahawk.onConfigTestResult(TomahawkConfigTestResultType.CommunicationError);
};
}
this.apiCallWithSessionId("authenticate", params, function (xhr) {
// Tomahawk.log("Got result of authenticate: " + xhr.responseText);
var ret = JSON.parse(xhr.responseText);
if (ret.result.success) {
if (ret.result.UserID == 0) {
if (doConfigTest) {
Tomahawk.onConfigTestResult(TomahawkConfigTestResultType.InvalidCredentials);
}
} else if (!ret.result.IsAnywhere) {
if (doConfigTest) {
Tomahawk.onConfigTestResult(TomahawkConfigTestResultType.Other,
"Tomahawk requires a Grooveshark Anywhere account.");
}
Tomahawk.log("Tomahawk requires a Grooveshark Anywhere account!");
} else if (doConfigTest) {
Tomahawk.onConfigTestResult(TomahawkConfigTestResultType.Success);
}
} else if (doConfigTest) {
Tomahawk.onConfigTestResult(TomahawkConfigTestResultType.InvalidAccount);
}
}, errorHandler);
},
ensureSessionId: function (callback, errorHandler) {
if (this.sessionId) {
if (callback) {
callback.call(window);
}
} else {
var that = this;
this.apiCall("startSession", [], function (xhr) {
var res = JSON.parse(xhr.responseText);
if (res.result && res.result.success) {
// Tomahawk.log("Got grooveshark session id");
that.sessionId = res.result.sessionID;
if (callback) {
callback.call(window);
}
} else {
if (errorHandler) {
errorHandler.call(window);
}
Tomahawk.log("Not able to get session id.. " + xhr.responseText);
}
}, errorHandler);
}
},
ensureClientIP: function (callback) {
if (this.ip) {
if (callback) {
callback.call(window);
}
} else {
var that = this;
Tomahawk.asyncRequest("http://toma.hk?stat=1", function (xhr) {
var result = JSON.parse(xhr.responseText);
if (result.ip) {
that.ip = result.ip;
if (callback) {
callback.call(window);
}
}
});
}
},
ensureCountryId: function (callback) {
if (this.countryId) {
if (callback) {
callback.call(window);
}
} else {
var that = this;
// Tomahawk.log("Grooveshark resolver Getting country...");
that.ensureClientIP(function () {
that.apiCall('getCountry', [], function (xhr) {
var ret = JSON.parse(xhr.responseText);
if (ret.result) {
that.countryId = ret.result;
// Tomahawk.log("Got country id: " + that.countryId);
if (callback) {
callback.call(window);
}
} else {
Tomahawk.log("Not able to get country id.. " + xhr.responseText);
}
});
});
}
},
apiCall: function (methodName, args, callback, errorHandler) {
// Tomahawk.log("_apiCall - methodName: " + methodName + ", args: " + args);
var payload = {
header: {
wsKey: this.apiKey
},
method: methodName,
parameters: args
};
if (this.sessionId != "") {
payload.header.sessionID = this.sessionId;
}
var data = JSON.stringify(payload);
var sig;
if (typeof CryptoJS !== "undefined" && typeof CryptoJS.HmacMD5 == "function") {
sig = CryptoJS.HmacMD5(data, this.secret).toString(CryptoJS.enc.Hex);
} else {
sig = Tomahawk.hmac(this.secret, data);
}
var url = "https://api.grooveshark.com/ws/3.0/?sig=" + sig;
var headers = {
"Content-Type": "application/json"
};
this.asyncRequest(url, callback, headers, {
method: 'POST',
data: data,
errorHandler: errorHandler
});
},
/**
* We can't use Tomahawk.asyncRequest, because it is only capable of sending body data in a POST
* request since Jan 26, 2014 and we need to ensure backwards compatibility.
*/
asyncRequest: function (url, callback, extraHeaders, options) {
// unpack options
var opt = options || {};
var method = opt.method || 'GET';
var xmlHttpRequest = new XMLHttpRequest();
xmlHttpRequest.open(method, url, true, opt.username, opt.password);
if (extraHeaders) {
for (var headerName in extraHeaders) {
xmlHttpRequest.setRequestHeader(headerName, extraHeaders[headerName]);
}
}
xmlHttpRequest.onreadystatechange = function () {
if (xmlHttpRequest.readyState == 4 && xmlHttpRequest.status == 200) {
callback.call(window, xmlHttpRequest);
} else if (xmlHttpRequest.readyState === 4) {
Tomahawk.log("Failed to do " + method + " request: to: " + url);
Tomahawk.log("Status Code was: " + xmlHttpRequest.status);
if (opt.hasOwnProperty('errorHandler')) {
opt.errorHandler.call(window, xmlHttpRequest);
}
}
};
xmlHttpRequest.send(opt.data || null);
},
apiCallWithCountryId: function (methodName, args, callback) {
var that = this;
that.ensureSessionId(function () {
that.ensureCountryId(function () {
args.country = that.countryId;
// Tomahawk.log("Setting country id: " + args.country);
that.apiCall(methodName, args, callback);
});
});
},
apiCallWithSessionId: function (methodName, args, callback, errorHandler) {
var that = this;
that.ensureSessionId(function () {
that.apiCall(methodName, args, callback, errorHandler);
}, errorHandler);
},
getStreamUrl: function (qid, url) {
var songId = url.replace("groove://", "");
//Tomahawk.log("Got factory function called to get grooveshark streaming url from:" + ourUrl + " and songId:" + songId);
var params = {
songID: songId
};
var that = this;
this.apiCallWithCountryId('getSubscriberStreamKey', params, function (request) {
// Tomahawk.log("Got song stream url: " + request.responseText);
var ret = JSON.parse(request.responseText);
if (ret.errors) {
Tomahawk.log("Error doing getSubscriberStreamKey api call: "
+ request.responseText);
Tomahawk.log("Deleting old session key!");
that.sessionId = "";
} else {
// ret.result.duration contains the duration of the song, we should update the duration here !
// Tomahawk.log("Reporting song stream url: " + ret.result.url);
Tomahawk.reportStreamUrl(qid, ret.result.url);
}
});
},
doSearchOrResolve: function(qid, queryText, limit) {
var params = {
query: queryText,
limit: limit
};
var that = this;
this.apiCallWithCountryId("getSongSearchResults", params, function (xhr) {
// Tomahawk.log("Got song search results: " + xhr.responseText);
var ret = JSON.parse(xhr.responseText);
if (!ret || !ret.result || !ret.result.songs) {
return;
}
var songs = ret.result.songs;
var results = []
if (songs.length === 0)
// we should try without artist name, just album song name
{
return;
}
// Tomahawk.log("Got search result with num of songs: " + songs.length);
for (var i = 0; i < songs.length; i++) {
var song = songs[i];
var songResult = {
artist: song.ArtistName,
album: song.AlbumName,
track: song.SongName,
source: that.settings.name,
url: "groove://" + song.SongID,
mimetype: 'audio/mpeg'
//duration: ret.result.uSecs/ 1000000
// score: Tomahawk.valueForSubNode(song, "rating")
};
results.push(songResult);
}
var toReturn = {
results: results,
qid: qid
};
Tomahawk.addTrackResults(toReturn);
});
},
resolve: function (qid, artist, album, title) {
var searchString = "";
if (title != "" && title != undefined)
searchString += " song:" + title;
if (artist != "" && artist != undefined)
searchString += " artist:" + artist;
if (album != "" && album != undefined)
searchString += " album:" + album;
// we use removeDiacritics cause it seems to have some problem in grooveshark resolving
this.doSearchOrResolve(qid, removeDiacritics(searchString), 1);
},
search: function (qid, searchString) {
this.doSearchOrResolve(qid, searchString, 15);
}
});
Tomahawk.resolver.instance = GroovesharkResolver;
================================================
FILE: archive/grooveshark/content/metadata.json
================================================
{
"name": "Grooveshark",
"pluginName": "grooveshark",
"author": "Leo Franchi and Enno",
"email": "lfranchi@kde.org",
"version": "0.8.0",
"website": "http://gettomahawk.com",
"description": "Searches Grooveshark for playable tracks. Requires a VIP account.",
"type": "resolver/javascript",
"manifest": {
"main": "contents/code/grooveshark.js",
"scripts": [],
"icon": "contents/images/icon.png",
"iconWhite": "contents/images/iconWhite.png",
"iconBackground": "contents/images/iconBackground.png",
"resources": [
"contents/code/config.ui",
"contents/code/grooveshark.png",
"contents/code/grooveshark.svg",
"contents/code/grooveshark-icon.png"
]
},
"staticCapabilities": [
"configTestable"
]
}
================================================
FILE: archive/rdio/content/contents/code/rdio.js
================================================
/*
* Copyright 2013, Uwe L. Korn <uwelk@xhochy.com>
* Copyright 2014, Enno Gottschalk <mrmaffen@googlemail.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*/
var RdioResolver = Tomahawk.extend(Tomahawk.Resolver, {
apiVersion: 0.9,
settings: {
name: 'rdio',
icon: 'rdio.png',
weight: 95,
timeout: 15
},
clientId: "byjtfyv7k5o7mxjd7xkdfycpnv",
clientSecret: "79es-w4OOB1aHlKST18rLj",
redirectUri: "tomahawkrdioresolver://callback",
storageKeyRefreshToken: "rdio_refresh_token",
/**
* Get the access token. Refresh when it is expired.
*/
getAccessToken: function () {
return this._getAccessToken(true);
},
/**
* Get the access token. Refresh when it is expired.
*/
_getAccessToken: function (userAuthRequired) {
var that = this;
if (!this.getAccessTokenPromise || new Date().getTime() + 60000 > that.accessTokenExpires) {
Tomahawk.log("Access token is not valid. We need to get a new one.");
this.getAccessTokenPromise = new RSVP.Promise(function (resolve, reject) {
var refreshToken = Tomahawk.localStorage.getItem(that.storageKeyRefreshToken);
if (!refreshToken && userAuthRequired) {
Tomahawk.log("Can't fetch new access token, because there's no stored refresh "
+ "token. Are you logged in?");
reject("Can't fetch new access token, because there's no stored refresh"
+ " token. Are you logged in?");
}
resolve(refreshToken);
}).then(function (refreshToken) {
Tomahawk.log("Fetching new access token ...");
var settings = {
headers: {
"Authorization": "Basic "
+ Tomahawk.base64Encode(that._spell(that.clientId)
+ ":" + that._spell(that.clientSecret)),
"Content-Type": "application/x-www-form-urlencoded"
},
data: {
"grant_type": "refresh_token",
"refresh_token": refreshToken
}
};
if (refreshToken) {
settings.data = {
"grant_type": "refresh_token",
"refresh_token": refreshToken
};
} else {
settings.data = {
"grant_type": "client_credentials"
};
}
return Tomahawk.post("https://services.rdio.com/oauth2/token", settings)
.then(function (res) {
that.accessToken = res.access_token;
that.accessTokenExpires =
new Date().getTime() + res.expires_in * 1000;
Tomahawk.log("Received new access token!");
Tomahawk.log(res.access_token);
return {
accessToken: res.access_token,
accessTokenExpires: res.expires_in
};
});
});
}
return this.getAccessTokenPromise;
},
login: function () {
Tomahawk.log("Starting login");
var authUrl = "https://www.rdio.com/oauth2/authorize";
authUrl += "?client_id=" + this._spell(this.clientId);
authUrl += "&response_type=code";
authUrl += "&redirect_uri=" + encodeURIComponent(this.redirectUri);
Tomahawk.showWebView(authUrl);
},
logout: function () {
Tomahawk.localStorage.removeItem(this.storageKeyAccessToken);
Tomahawk.localStorage.removeItem(this.storageKeyAccessTokenSecret);
Tomahawk.onConfigTestResult(TomahawkConfigTestResultType.Logout);
},
isLoggedIn: function () {
var accessToken = Tomahawk.localStorage.getItem(this.storageKeyAccessToken);
var accessTokenSecret = Tomahawk.localStorage.removeItem(this.storageKeyAccessTokenSecret);
return accessToken !== null && accessToken.length > 0
&& accessTokenSecret !== null && accessTokenSecret.length > 0;
},
/**
* This function is being called from the native side whenever it has received a redirect
* callback. In other words, the WebView shown to the user can call the js side here.
*/
onRedirectCallback: function (params) {
var url = params.url;
var error = this._getParameterByName(url, "error");
if (error) {
Tomahawk.log("Authorization failed: " + error);
Tomahawk.onConfigTestResult(TomahawkConfigTestResultType.Other, error);
} else {
Tomahawk.log("Authorization successful, fetching new refresh token ...");
var settings = {
headers: {
"Authorization": "Basic " + Tomahawk.base64Encode(this._spell(this.clientId)
+ ":" + this._spell(this.clientSecret)),
"Content-Type": "application/x-www-form-urlencoded"
},
data: {
grant_type: "authorization_code",
code: this._getParameterByName(url, "code"),
redirect_uri: this.redirectUri
}
};
var that = this;
Tomahawk.post("https://services.rdio.com/oauth2/token", settings)
.then(function (response) {
Tomahawk.localStorage.setItem(that.storageKeyRefreshToken,
response.refresh_token);
Tomahawk.log("Received new refresh token!");
Tomahawk.onConfigTestResult(TomahawkConfigTestResultType.Success);
});
}
},
/**
* Returns the value of the query parameter with the given name from the given URL.
*/
_getParameterByName: function (url, name) {
name = name.replace(/[\[]/, "\\[").replace(/[\]]/, "\\]");
var regex = new RegExp("[\\?&#]" + name + "=([^&#]*)"), results = regex.exec(url);
return results === null ? "" : decodeURIComponent(results[1].replace(/\+/g, " "));
},
init: function () {
Tomahawk.PluginManager.registerPlugin("linkParser", this);
},
_spell: function (a) {
var magic = function (b) {
return (b ? b : this).split("").map(function (d) {
if (!d.match(/[A-Za-z]/)) {
return d
}
c = d.charCodeAt(0) >= 96;
k = (d.toLowerCase().charCodeAt(0) - 96 + 12) % 26 + 1;
return String.fromCharCode(k + (c ? 96 : 64))
}).join("")
};
return magic(a)
},
resolve: function (params) {
var artist = params.artist;
var album = params.album;
var track = params.track;
var that = this;
return this.getAccessToken().then(function (response) {
var settings = {
data: {
method: "search",
query: artist + " " + track,
types: "track"
},
headers: {
"Authorization": "Bearer " + response.accessToken
}
};
return Tomahawk.post("https://services.rdio.com/api/1/", settings)
.then(function (response) {
var result = response.result;
if (response.status == 'ok') {
var results = [];
for (var i = 0; i < result.results.length; i++) {
if (result.results[i].type == 't' && result.results[i].canStream) {
results.push({
source: that.settings.name,
artist: result.results[i].artist,
track: result.results[i].name,
duration: result.results[i].duration,
url: "rdio://track/" + result.results[i].key,
album: result.results[i].album,
linkUrl: result.results[i].url
});
}
}
return results;
} else {
throw new Error('Error in resolve: ' + JSON.stringify(result));
}
}
);
});
},
search: function (params) {
var query = params.query;
return this.resolve({track: query});
},
getStreamUrl: function (params) {
var url = params.url;
return {
url: url.replace("rdio://track/", "")
};
},
canParseUrl: function (params) {
var url = params.url;
var type = params.type;
if (!url) {
throw new Error("Provided url was empty or null!");
}
switch (type) {
case TomahawkUrlType.Album:
return /https?:\/\/(www\.)?rdio.com\/artist\/([^\/]*)\/album\/([^\/]*)\/?$/.test(url);
case TomahawkUrlType.Artist:
return /https?:\/\/(www\.)?rdio.com\/artist\/([^\/]*)\/?$/.test(url);
case TomahawkUrlType.Playlist:
return /https?:\/\/(www\.)?rdio.com\/people\/([^\/]*)\/playlists\/(\d+)\//.test(url);
case TomahawkUrlType.Track:
return /https?:\/\/(www\.)?rdio.com\/artist\/([^\/]*)\/album\/([^\/]*)\/track\/([^\/]*)\/?$/.test(url);
default:
return /https?:\/\/(www\.)?rdio.com\/([^\/]*\/|)/.test(url);
}
},
lookupUrl: function (params) {
var url = params.url;
Tomahawk.log("lookupUrl: " + url);
return this._getAccessToken(false).then(function (response) {
var settings = {
data: {
method: "getObjectFromUrl",
extras: "tracks",
url: url
},
headers: {
"Authorization": "Bearer " + response.accessToken
}
};
return Tomahawk.post("https://services.rdio.com/api/1/", settings)
.then(function (response) {
Tomahawk.log("lookupUrl result: " + JSON.stringify(response));
var result = response.result;
if (response.status == 'ok') {
if (result.type == 'p') {
var tracks = result.tracks.map(function (item) {
return {
type: Tomahawk.UrlType.Track,
track: item.name,
artist: item.artist
};
});
return {
type: Tomahawk.UrlType.Playlist,
title: result.name,
guid: "rdio-playlist-" + result.key,
info: "A playlist by " + result.owner + " on rdio.",
creator: result.owner,
linkUrl: result.shortUrl,
tracks: tracks
};
} else if (result.type == 't') {
return {
type: Tomahawk.UrlType.Track,
track: result.name,
artist: result.artist
};
} else if (result.type == 'a') {
return {
type: Tomahawk.UrlType.Album,
album: result.name,
artist: result.artist
};
} else if (result.type == 'r') {
return {
type: Tomahawk.UrlType.Artist,
artist: result.name
};
}
} else {
throw new Error('Error in lookupUrl: ' + JSON.stringify(result));
}
}
);
});
}
});
Tomahawk.resolver.instance = RdioResolver;
================================================
FILE: archive/rdio/content/metadata.json
================================================
{
"name": "Rdio",
"pluginName": "rdio",
"author": "Uwe and Enno",
"email": "uwelk@xhochy.com",
"version": "0.3.1",
"website": "http://gettomahawk.com",
"description": "Stream music with Rdio. Premium Rdio account required.",
"type": "resolver/javascript",
"manifest": {
"main": "contents/code/rdio.js",
"scripts": [],
"icon": "contents/images/icon.png",
"iconWhite": "contents/images/iconWhite.png",
"iconBackground": "contents/images/iconBackground.png",
"resources": [
"contents/code/rdio.png"
]
}
}
================================================
FILE: archive/rdio-metadata/content/contents/code/rdio-metadata.js
================================================
/*
* Copyright 2013, Uwe L. Korn <uwelk@xhochy.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*/
var RdioMetadataResolver = Tomahawk.extend(TomahawkResolver, {
settings: {
name: 'rdio Metadata',
icon: 'rdio-metadata.png',
weight: 0, // We cannot resolve, so use minimum weight
timeout: 15
},
init: function() {
Tomahawk.PluginManager.registerPlugin("linkParser", this);
},
resolve: function (qid, artist, album, title) {
Tomahawk.addTrackResults({ results: [], qid: qid });
},
search: function (qid, searchString) {
Tomahawk.addTrackResults({ results: [], qid: qid });
},
canParseUrl: function (url, type) {
switch (type) {
case TomahawkUrlType.Album:
return /https?:\/\/(www\.)?rdio.com\/artist\/([^\/]*)\/album\/([^\/]*)\/?$/.test(url);
case TomahawkUrlType.Artist:
return /https?:\/\/(www\.)?rdio.com\/artist\/([^\/]*)\/?$/.test(url);
case TomahawkUrlType.Playlist:
return /https?:\/\/(www\.)?rdio.com\/people\/([^\/]*)\/playlists\/(\d+)\//.test(url);
case TomahawkUrlType.Track:
return /https?:\/\/(www\.)?rdio.com\/artist\/([^\/]*)\/album\/([^\/]*)\/track\/([^\/]*)\/?$/.test(url);
// case TomahawkUrlType.Any:
default:
return /https?:\/\/(www\.)?rdio.com\/([^\/]*\/|)/.test(url);
}
},
encodeOAuthComponent: function(url) {
return encodeURIComponent(url)
.replace(/\!/g, "%21")
.replace(/\*/g, "%2A")
.replace(/\'/g, "%27")
.replace(/\(/g, "%28")
.replace(/\)/g, "%29");
},
spell: function(a){magic=function(b){return(b=(b)?b:this).split("").map(function(d){if(!d.match(/[A-Za-z]/)){return d}c=d.charCodeAt(0)>=96;k=(d.toLowerCase().charCodeAt(0)-96+12)%26+1;return String.fromCharCode(k+(c?96:64))}).join("")};return magic(a)},
lookupUrl: function (url) {
var that = this;
var fetchUrl = 'http://api.rdio.com/1/'
var query = 'extras=tracks&method=getObjectFromUrl';
query += '&oauth_consumer_key=' + this.spell("tdo7m2m8u6r7r76mpod9jqlc");
var nonce = '';
for (i = 0; i < 8; i++) nonce += parseInt(Math.random() * 10).toString();
query += '&oauth_nonce=' + nonce;
query += '&oauth_signature_method=' + this.encodeOAuthComponent('HMAC-SHA1');
query += '&oauth_timestamp=' + Math.round((new Date()).getTime() / 1000);;
query += '&oauth_version=1.0';
query += '&url=' + this.encodeOAuthComponent(url);
var toSign = 'POST&' + this.encodeOAuthComponent(fetchUrl) + '&' + this.encodeOAuthComponent(query);
var signature = CryptoJS.HmacSHA1(toSign, this.spell("oKeSjHrS9d") + '&').toString(CryptoJS.enc.Base64);
query += '&oauth_signature=' + this.encodeOAuthComponent(signature);
Tomahawk.log(fetchUrl)
Tomahawk.log(query)
Tomahawk.asyncRequest(fetchUrl, function (xhr) {
var res = JSON.parse(xhr.responseText);
if (res.status == 'ok') {
if (res.result.type == 'p') {
var result = {
type: "playlist",
title: res.result.name,
guid: "rdio-playlist-" + res.result.key,
info: "A playlist by " + res.result.owner + " on rdio.",
creator: res.result.owner,
url: res.result.shortUrl,
tracks: []
};
result.tracks = res.result.tracks.map(function (item) { return { type: "track", title: item.name, artist: item.artist }; });
Tomahawk.addUrlResult(url, result);
} else if (res.result.type == 't') {
Tomahawk.addUrlResult(url, {
type: "track",
title: res.result.name,
artist: res.result.artist,
});
} else if (res.result.type == 'a') {
Tomahawk.addUrlResult(url, {
type: "album",
name: res.result.name,
artist: res.result.artist,
});
} else if (res.result.type == 'r') {
Tomahawk.addUrlResult(url, {
type: "artist",
name: res.result.name,
});
}
}
}, {"Content-type": "application/x-www-form-urlencoded"}, {
method: 'post',
data: query
});
}
});
Tomahawk.resolver.instance = RdioMetadataResolver;
================================================
FILE: archive/rdio-metadata/content/metadata.json
================================================
{
"name": "Rdio Metadata",
"pluginName": "rdio-metadata",
"author": "Uwe L. Korn",
"email": "uwelk@xhochy.com",
"version": "0.1.2",
"website": "http://gettomahawk.com",
"description": "(0.8+) Supports loading and drag and drop of Rdio URLs.",
"type": "resolver/javascript",
"manifest": {
"main": "contents/code/rdio-metadata.js",
"scripts": [],
"icon": "contents/images/icon.png",
"iconWhite": "contents/images/iconWhite.png",
"iconBackground": "contents/images/iconBackground.png",
"resources": [
"contents/code/rdio-metadata.png"
]
}
}
================================================
FILE: archive/spotify/BreakPad.cpp
================================================
/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===
*
* Copyright 2010-2011, Christian Muehlhaeuser <muesli@tomahawk-player.org>
*
* Tomahawk is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Tomahawk is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Tomahawk. If not, see <http://www.gnu.org/licenses/>.
*/
#include "BreakPad.h"
#include "logger.h"
#include <QCoreApplication>
#include <QString>
#include <QFileInfo>
#include <string.h>
#define CRASH_REPORTER_BINARY "tomahawk_crash_reporter"
bool s_active = true;
#ifndef WIN32
#include <unistd.h>
static bool
LaunchUploader( const char* dump_dir, const char* minidump_id, void* that, bool succeeded )
{
// DON'T USE THE HEAP!!!
// So that indeed means, no QStrings, no qDebug(), no QAnything, seriously!
if ( !succeeded )
return false;
fprintf( stderr, minidump_id );
fprintf( stderr, "\n" );
const char* crashReporter = static_cast<BreakPad*>(that)->crashReporter();
if ( !s_active || strlen( crashReporter ) == 0 )
return false;
pid_t pid = fork();
if ( pid == -1 ) // fork failed
return false;
if ( pid == 0 )
{
// we are the fork
execl( crashReporter,
crashReporter,
dump_dir,
minidump_id,
minidump_id,
(char*) 0 );
// execl replaces this process, so no more code will be executed
// unless it failed. If it failed, then we should return false.
printf( "Error: Can't launch CrashReporter!\n" );
return false;
}
// we called fork()
return true;
}
BreakPad::BreakPad( const QString& path, bool active )
#ifdef Q_OS_LINUX
: google_breakpad::ExceptionHandler( path.toStdString(), 0, LaunchUploader, this, true )
#else
: google_breakpad::ExceptionHandler( path.toStdString(), 0, LaunchUploader, this, true, 0 )
#endif
{
s_active = active;
QString reporter = QString( "%1/%2" ).arg( qApp->applicationDirPath() ).arg( CRASH_REPORTER_BINARY );
char* creporter;
std::string sreporter = reporter.toStdString();
creporter = new char[ sreporter.size() + 1 ];
strcpy( creporter, sreporter.c_str() );
m_crashReporter = creporter;
}
#else
static bool
LaunchUploader( const wchar_t* dump_dir, const wchar_t* minidump_id, void* that, EXCEPTION_POINTERS *exinfo, MDRawAssertionInfo *assertion, bool succeeded )
{
if ( !succeeded )
return false;
// DON'T USE THE HEAP!!!
// So that indeed means, no QStrings, no qDebug(), no QAnything, seriously!
// broken in mingw, hardcode it for now
// const char* productName = static_cast<BreakPad*>(that)->productName();s
// convert productName to widechars, which sadly means the product name must be Latin1
wchar_t product_name[ 256 ] = L"tomahawk";;
// char* out = (char*)product_name;
// const char* in = productName - 1;
// do {
// *out++ = *++in; //latin1 chars fit in first byte of each wchar
// *out++ = '\0'; //every second byte is NULL
// }
// while (*in);
wchar_t command[MAX_PATH * 3 + 6];
wcscpy( command, CRASH_REPORTER_BINARY L" \"" );
wcscat( command, dump_dir );
wcscat( command, L"\" \"" );
wcscat( command, minidump_id );
wcscat( command, L"\" \"" );
wcscat( command, product_name );
wcscat( command, L"\"" );
STARTUPINFO si;
PROCESS_INFORMATION pi;
ZeroMemory( &si, sizeof( si ) );
si.cb = sizeof(si);
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_SHOWNORMAL;
ZeroMemory( &pi, sizeof(pi) );
if ( CreateProcess( NULL, command, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi ) )
{
CloseHandle( pi.hProcess );
CloseHandle( pi.hThread );
TerminateProcess( GetCurrentProcess(), 1 );
}
return false;
}
BreakPad::BreakPad( const QString& path, bool active )
: google_breakpad::ExceptionHandler( path.toStdWString(), 0, LaunchUploader, this, true )
{
s_active = active;
}
#endif // WIN32
void
BreakPad::setActive( bool enabled )
{
s_active = enabled;
}
bool
BreakPad::isActive()
{
return s_active;
}
================================================
FILE: archive/spotify/BreakPad.h
================================================
/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===
*
* Copyright 2010-2011, Christian Muehlhaeuser <muesli@tomahawk-player.org>
*
* Tomahawk is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Tomahawk is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Tomahawk. If not, see <http://www.gnu.org/licenses/>.
*/
#include <QString>
#ifdef __APPLE__
# include "client/mac/handler/exception_handler.h"
#elif defined WIN32
# include "client/windows/handler/exception_handler.h"
#elif defined __linux__
# include "client/linux/handler/exception_handler.h"
#endif
class BreakPad : public google_breakpad::ExceptionHandler
{
const char* m_productName; // yes! It MUST be const char[]
const char* m_crashReporter; // again, const char[]
public:
BreakPad( const QString& dump_write_dirpath, bool active );
~BreakPad()
{}
static void setActive( bool enabled );
static bool isActive();
void setProductName( const char* s ) { m_productName = s; };
const char* productName() const { return m_productName; }
void setCrashReporter( const char* s ) { m_crashReporter = s; };
const char* crashReporter() const { return m_crashReporter; }
};
#undef char
================================================
FILE: archive/spotify/CMakeLists.txt
================================================
project(tomahawkspotify)
cmake_minimum_required(VERSION 2.8.6)
add_definitions(-fexceptions)
SET( CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" "${CMAKE_SOURCE_DIR}/cmake/" )
find_package(Qt4 REQUIRED)
find_package(QJSON REQUIRED)
find_package(libspotify REQUIRED)
find_package(Boost REQUIRED)
add_subdirectory(qxtweb-standalone)
IF( WITH_BREAKPAD )
add_subdirectory(breakpad)
ENDIF()
include_directories( qxtweb-standalone/qxtweb kdsingleapplicationguard/ breakpad/
${QT_INCLUDES}
${LIBSPOTIFY_INCLUDE_DIR}
${QJSON_INCLUDE_DIR}
${Boost_INCLUDE_DIRS}
${CMAKE_CURRENT_BINARY_DIR})
if(NOT EXISTS "${CMAKE_BINARY_DIR}/spotify-sourceicon.png")
message("Copying spotify source icon to binary dir")
file(COPY "${CMAKE_SOURCE_DIR}/spotify-sourceicon.png" DESTINATION ${CMAKE_BINARY_DIR})
else()
message("Found existing spotify source icon, not copying")
endif()
set( tomahawkspotify_SRCS
kdsingleapplicationguard/kdsingleapplicationguard.cpp
kdsingleapplicationguard/kdsharedmemorylocker.cpp
kdsingleapplicationguard/kdtoolsglobal.cpp
kdsingleapplicationguard/kdlockedsharedmemorypointer.cpp
PlaylistClosure.cpp
spotifyloghandler.cpp
spotifyplayback.cpp
spotifysearch.cpp
spotifyplaylists.cpp
spotifysession.cpp
spotifyresolver.cpp
consolewatcher.cpp
audiohttpserver.cpp
spotifyiodevice.cpp
main.cpp
)
IF( WITH_BREAKPAD )
message(STATUS "Build with support for breakpad.")
if( APPLE )
FIND_LIBRARY( COREFOUNDATION_LIBRARY CoreFoundation )
ENDIF( APPLE )
LIST( APPEND tomahawkspotify_SRCS BreakPad.cpp )
ENDIF()
set( tomahawkspotify_NOMOC_HDRS
kdsingleapplicationguard/kdsharedmemorylocker.h
kdsingleapplicationguard/kdtoolsglobal.h
kdsingleapplicationguard/kdlockedsharedmemorypointer.h
)
IF(WITH_BREAKPAD)
SET( BREAKPAD_LIBRARIES tomahawk_breakpad )
ENDIF()
add_executable(spotify_tomahawkresolver ${tomahawkspotify_SRCS} ${RC_SRCS} ${tomahawkspotify_NOMOC_HDRS} )
target_link_libraries(spotify_tomahawkresolver qxtweb-standalone ${COREFOUNDATION_LIBRARY} ${BREAKPAD_LIBRARIES} ${QT_QTCORE_LIBRARY} ${LIBSPOTIFY_LIBRARIES} ${QT_QTNETWORK_LIBRARY} ${QJSON_LIBRARIES})
SET_TARGET_PROPERTIES(spotify_tomahawkresolver PROPERTIES AUTOMOC TRUE)
include(GNUInstallDirs)
install(TARGETS spotify_tomahawkresolver RUNTIME DESTINATION ${CMAKE_INSTALL_LIBEXECDIR})
================================================
FILE: archive/spotify/PlaylistClosure.cpp
================================================
/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===
*
* Copyright 2010-2012, Leo Franchi <lfranchi@kde.org>
*
* Inspired by Clementine's Closure class
*
* Tomahawk is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Tomahawk is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Tomahawk. If not, see <http://www.gnu.org/licenses/>.
*/
#include "PlaylistClosure.h"
#include <QDebug>
PlaylistClosure::PlaylistClosure(LoadedCondition condition,
QObject* receiver,
const char* slot,
const ClosureArgumentWrapper* val0,
const ClosureArgumentWrapper* val1,
const ClosureArgumentWrapper* val2)
: condition_(condition)
, receiver_(receiver)
, val0_(val0)
, val1_(val1)
, val2_(val2)
{
const QMetaObject* meta_receiver = receiver->metaObject();
QByteArray normalised_slot = QMetaObject::normalizedSignature(slot + 1);
const int index = meta_receiver->indexOfSlot(normalised_slot.constData());
Q_ASSERT(index != -1);
slot_ = meta_receiver->method(index);
}
bool
PlaylistClosure::conditionSatisfied() const
{
return condition_();
}
void
PlaylistClosure::invoke()
{
// qDebug() << val0_->arg().name() << val0_->arg().data();
// qDebug() << val1_->arg().name() << val1_->arg().data();
// qDebug() << val2_->arg().name() << val2_->arg().data();
slot_.invoke(receiver_,
val0_ ? val0_->arg() : QGenericArgument(),
val1_ ? val1_->arg() : QGenericArgument(),
val2_ ? val2_->arg() : QGenericArgument());
}
================================================
FILE: archive/spotify/PlaylistClosure.h
================================================
/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===
*
* Copyright 2011, David Sansome <me@davidsansome.com>
* Copyright 2012, Leo Franchi <lfranchi@kde.org>
*
* Inspired by Clementine's Closure class
*
* Tomahawk is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Tomahawk is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Tomahawk. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef PLAYLISTCLOSURE_H
#define PLAYLISTCLOSURE_H
#include <libspotify/api.h>
#include <QObject>
#include <QList>
#include <QMetaMethod>
#ifdef Q_OS_WIN
#include <tr1/functional.hpp>
#else
#include <tr1/functional>
#endif
#include <boost/noncopyable.hpp>
#include <boost/scoped_ptr.hpp>
/** Use this if the following is true:
*
* 1) You are doing an operation on a playlist
* 2) Some sp_track* that you need to operate on hasn't loaded yet
* 3) You need to re-do your operation whenever it has been loaded
*/
typedef std::tr1::function<bool ()> LoadedCondition;
class ClosureArgumentWrapper {
public:
virtual ~ClosureArgumentWrapper() {}
virtual QGenericArgument arg() const = 0;
};
template<typename T>
class ClosureArgument : public ClosureArgumentWrapper {
public:
explicit ClosureArgument(const T& data) : data_(data) {}
virtual QGenericArgument arg() const {
return QArgument<T>(QMetaType::typeName(qMetaTypeId<T>()), data_);
}
private:
T data_;
};
class PlaylistClosure : boost::noncopyable
{
public:
PlaylistClosure(LoadedCondition condition,
QObject* receiver, const char* slot,
const ClosureArgumentWrapper* val0 = 0,
const ClosureArgumentWrapper* val1 = 0,
const ClosureArgumentWrapper* val2 = 0);
virtual ~PlaylistClosure() {}
bool conditionSatisfied() const;
void invoke();
private:
QObject* receiver_;
QMetaMethod slot_;
LoadedCondition condition_;
boost::scoped_ptr<const ClosureArgumentWrapper> val0_;
boost::scoped_ptr<const ClosureArgumentWrapper> val1_;
boost::scoped_ptr<const ClosureArgumentWrapper> val2_;
};
#define C_ARG(type, data) new ClosureArgument< type >(data)
template <typename T>
PlaylistClosure* NewPlaylistClosure(LoadedCondition checker,
QObject* receiver,
const char* slot,
const T& val0) {
return new PlaylistClosure(
checker, receiver, slot,
C_ARG(T, val0));
}
template <typename T0, typename T1>
PlaylistClosure* NewPlaylistClosure(
LoadedCondition checker,
QObject* receiver,
const char* slot,
const T0& val0,
const T1& val1) {
return new PlaylistClosure(
checker, receiver, slot,
C_ARG(T0, val0), C_ARG(T1, val1));
}
template <typename T0, typename T1, typename T2>
PlaylistClosure* NewPlaylistClosure(
LoadedCondition checker,
QObject* receiver,
const char* slot,
const T0& val0,
const T1& val1,
const T2& val2) {
return new PlaylistClosure(
checker, receiver, slot,
C_ARG(T0, val0), C_ARG(T1, val1), C_ARG(T2, val2));
}
#endif // PLAYLISTCLOSURE_H
================================================
FILE: archive/spotify/appkey.h
================================================
================================================
FILE: archive/spotify/audiohttpserver.cpp
================================================
/*
Copyright (c) 2011 Leo Franchi <leo@kdab.com>
Copyright (c) 2012,Hugo Lindström <hugolm84@gmail.com>
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
*/
#include "audiohttpserver.h"
#include "spotifyresolver.h"
#include "QxtWebPageEvent"
#include "spotifyiodevice.h"
#include <QString>
#include <QDebug>
AudioHTTPServer::AudioHTTPServer( QxtAbstractWebSessionManager* sm, int port, QObject* parent )
: QxtWebSlotService( sm, parent )
, m_port( port )
, m_savedDuration( 0 )
, m_savedByteRange( 0 )
{
// qDebug() << "NEW AUDIO HTTP SERVER!";
}
AudioHTTPServer::~AudioHTTPServer()
{
}
void AudioHTTPServer::sid( QxtWebRequestEvent* event, QString a )
{
qDebug() << QThread::currentThreadId() << "HTTP" << event->url.toString() << a;
// byte range, if seek
int m_savedByteRange = QString(event->headers.value( "Range" ) ).remove( "bytes=" ).remove( "-" ).toInt();
qDebug() << "Got savedByteRange?" << m_savedByteRange;
qDebug() << "sid Headers" << event->headers;
// the requested track
QString uid = a.replace( ".wav", "");
if( m_savedByteRange != 0 )
{
if( !m_savedTrackUri.isEmpty() && uid == m_savedTrackUri && m_savedByteRange > 0 && m_savedDuration > 0 )
{
int seek = convertByteRangeToMsec( m_savedByteRange );
if( seek <= 0 )
{
qDebug() << "Seekrange was invaild, aborting" << seek;
sendErrorResponse( event );
return;
}
performSeek( event, seek, uid );
return;
}
}
else
{
if( !SpotifySession::getInstance()->Playback()->trackIsOver() )
{
SpotifySession::getInstance()->Playback()->endTrack();
}
// qDebug() << QThread::currentThreadId() << "Beginning to stream requested track:" << uid;
if( uid.isEmpty() || !sApp->hasLinkFromTrack( uid ) ) {
qWarning() << "Did not find spotify track UID in our list!" << uid;
sendErrorResponse( event );
return;
}
// get the sp_track
sp_link* link = sApp->linkFromTrack( uid );
sp_track* track = sp_link_as_track( link );
m_savedTrackUri = uid;
if( !track )
{
qWarning() << QThread::currentThreadId() << "Uh oh... got null track from link :(" << sp_link_type( link );
sendErrorResponse( event );
return;
}
if( !sp_track_is_loaded( track ) )
{
qWarning() << QThread::currentThreadId() << "uh oh... track not loaded yet! Asked for:" << sp_track_name( track );
m_savedEvent = event;
m_savedTrack = track;
QTimer::singleShot( 250, this, SLOT( checkForLoaded() ) );
return;
} else
{
startStreamingResponse( event, track );
}
}
}
void AudioHTTPServer::performSeek( QxtWebRequestEvent* event, int seek, QString uid)
{
// Perform seek
spotifyiodev_ptr iodev = SpotifySession::getInstance()->Playback()->getIODeviceForNewTrack( m_savedDuration-seek );
qDebug() << QThread::currentThreadId() << "Got iodevice to send:" << iodev << iodev.isNull() << iodev->isSequential() << iodev->isReadable();
if( SpotifySession::getInstance()->Playback()->trackIsOver() )
{
qDebug() << " Seeking on track thats ended, setting offset";
sp_link* link = sApp->linkFromTrack( uid );
sp_track* track = sp_link_as_track( link );
sp_error err = sp_session_player_load( SpotifySession::getInstance()->Session(), track );
if( err != SP_ERROR_OK )
{
qWarning() << QThread::currentThreadId() << "Failed to restart track with offset from spotify :(" << sp_error_message( err );
sendErrorResponse( event );
return;
}
sp_session_player_seek( SpotifySession::getInstance()->Session(), seek );
sp_session_player_play( SpotifySession::getInstance()->Session(), true );
SpotifySession::getInstance()->Playback()->startPlaying();
}
else
{
qDebug() << " Seeking on track thats still playing";
sp_session_player_seek( SpotifySession::getInstance()->Session(), seek );
}
// Partial Content
QxtWebPageEvent* wpe = new QxtWebPageEvent( event->sessionID, event->requestID, iodev );
wpe->streaming = true;
wpe->status = 206;
QString range = QString::number(m_savedByteRange) + "-" + QString::number(m_savedDurationInBytes);
wpe->headers.insert("Content-Range", "bytes=" + range);
wpe->contentType = "audio/basic";
postEvent( wpe );
}
int AudioHTTPServer::convertByteRangeToMsec( int byteRange )
{
if( byteRange > 0 )
{
qDebug() << " === GOT BYTES " << byteRange;
//The bit rate is then 44100 samples/second x 16 bits/sample x 2 tracks
int seek = byteRange / SpotifySession::getInstance()->Playback()->m_currSamples * 16 * SpotifySession::getInstance()->Playback()->m_currChannels * 8;
/// @magic: magic number to set the seek msec straight! Donno why it works
/// probably a misscalc in byte to msec
/// Every minute, we need to remove 1440msec from the seek
seek = seek - (seek/1000/60 * 1440);
// extraDebug
int seconds = seek/1000;
int hrs = seconds / 60 / 60;
int mins = seconds / 60 % 60;
int secs = seconds % 60;
qDebug() << " ==== Seeking to : " << QString( "%1%2:%3" ).arg( hrs > 0 ? hrs < 10 ? "0" + QString::number( hrs ) + ":" : QString::number( hrs ) + ":" : "" )
.arg( mins < 10 ? "0" + QString::number( mins ) : QString::number( mins ) )
.arg( secs < 10 ? "0" + QString::number( secs ) : QString::number( secs ) ) << " ======";
return seek;
}
return -1;
}
void AudioHTTPServer::checkForLoaded()
{
qDebug() << "Checking...";
if( !sp_track_is_loaded( m_savedTrack ) ) {
qWarning() << QThread::currentThreadId() << "uh oh... track not loaded yet! Asked for:" << sp_track_name( m_savedTrack );
QTimer::singleShot( 250, this, SLOT( checkForLoaded() ) );
} else {
startStreamingResponse( m_savedEvent, m_savedTrack );
}
}
void AudioHTTPServer::startStreamingResponse( QxtWebRequestEvent* event, sp_track* track )
{
// yay we gots a track
// qDebug() << QThread::currentThreadId() << "We got a track!" << sp_track_name( track ) << sp_artist_name( sp_track_artist( track, 0 ) ) << sp_track_duration( track );
uint duration = sp_track_duration( track );
sp_error err = sp_session_player_load( SpotifySession::getInstance()->Session(), track );
if( err != SP_ERROR_OK ) {
qWarning() << QThread::currentThreadId() << "Failed to start track from spotify :(" << sp_error_message( err );
sendErrorResponse( event );
return;
}
// qDebug() << QThread::currentThreadId() << "Starting to play!";
sp_session_player_play( SpotifySession::getInstance()->Session(), true );
SpotifySession::getInstance()->Playback()->startPlaying();
m_savedDuration = duration;
m_savedDurationInBytes = duration * SpotifySession::getInstance()->Playback()->m_currSamples * 16 * SpotifySession::getInstance()->Playback()->m_currChannels / 8;
qDebug() << "Getting iodevice...";
qDebug() << "Setting durationBytes" << m_savedByteRange;
spotifyiodev_ptr iodev = SpotifySession::getInstance()->Playback()->getIODeviceForNewTrack( duration );
// qDebug() << QThread::currentThreadId() << "Got iodevice to send:" << iodev << iodev.isNull() << iodev->isSequential() << iodev->isReadable();
QxtWebPageEvent* wpe = new QxtWebPageEvent( event->sessionID, event->requestID, iodev );
wpe->streaming = true;
// Partial Content
wpe->status = 206;
wpe->headers.insert("Content-Range", "bytes=" + QString::number(0) + "-" + QString::number( m_savedDurationInBytes ) );
wpe->contentType = "audio/basic";
postEvent( wpe );
}
QString AudioHTTPServer::urlForID( const QString& id )
{
return QString( "http://localhost:%1/sid/%2.wav" ).arg( m_port ).arg( id );
}
void
AudioHTTPServer::sendErrorResponse( QxtWebRequestEvent* event )
{
qDebug() << "404" << event->url.toString();
QxtWebPageEvent* wpe = new QxtWebPageEvent( event->sessionID, event->requestID, "<h1>No Such Track</h1>" );
wpe->status = 403;
wpe->statusMessage = "no track found";
postEvent( wpe );
}
================================================
FILE: archive/spotify/audiohttpserver.h
================================================
/*
Copyright (c) 2011 Leo Franchi <leo@kdab.com>
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef AUDIOHTTPSERVER_H
#define AUDIOHTTPSERVER_H
#include <QObject>
#include "qxtwebslotservice.h"
#include <QxtWebPageEvent>
#include <libspotify/api.h>
class QxtWebRequestEvent;
class QxtWebPageEvent;
class AudioHTTPServer : public QxtWebSlotService
{
Q_OBJECT
public:
explicit AudioHTTPServer( QxtAbstractWebSessionManager* sm, int port, QObject* parent = 0 );
virtual ~AudioHTTPServer();
QString urlForID( const QString& id );
public slots:
void sid( QxtWebRequestEvent* event, QString a );
private slots:
void checkForLoaded();
private:
void startStreamingResponse( QxtWebRequestEvent* event, sp_track* );
void sendErrorResponse( QxtWebRequestEvent* event );
int convertByteRangeToMsec( int byteRange );
void performSeek( QxtWebRequestEvent* event, int seek, QString uid);
// If we need to wait for them to be loaded. Ugh.
QxtWebRequestEvent* m_savedEvent;
uint m_savedDuration;
int m_savedDurationInBytes;
int m_savedByteRange;
sp_track* m_savedTrack;
QString m_savedTrackUri;
int m_port;
};
#endif // AUDIOHTTPSERVER_H
================================================
FILE: archive/spotify/breakpad/CMakeLists.txt
================================================
PROJECT(breakpad)
cmake_minimum_required(VERSION 2.8)
set( CMAKE_MODULE_PATH
${CMAKE_MODULE_PATH}
${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules
)
if( CMAKE_COMPILER_IS_GNUCXX )
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++98")
endif()
if(${CMAKE_BUILD_TYPE} MATCHES "Release")
add_definitions(-DNDEBUG)
endif(${CMAKE_BUILD_TYPE} MATCHES "Release")
IF(UNIX)
IF(APPLE)
SET( breakpadSources
client/mac/crash_generation/crash_generation_client.cc
client/mac/crash_generation/crash_generation_server.cc
client/mac/handler/breakpad_nlist_64.cc
client/mac/handler/dynamic_images.cc
client/mac/handler/exception_handler.cc
client/mac/handler/minidump_generator.cc
client/mac/handler/protected_memory_allocator.cc
# client/mac/Framework/Breakpad.mm
# client/mac/Framework/OnDemandServer.mm
common/mac/file_id.cc
common/mac/macho_id.cc
common/mac/macho_reader.cc
common/mac/macho_utilities.cc
common/mac/macho_walker.cc
common/mac/string_utilities.cc
common/md5.cc
common/mac/dump_syms.mm
common/mac/MachIPC.mm
common/mac/SimpleStringDictionary.mm
common/mac/bootstrap_compat.cc
)
ELSE(APPLE)
SET( breakpadSources
common/linux/safe_readlink.cc
client/linux/crash_generation/crash_generation_client.cc
client/linux/crash_generation/crash_generation_server.cc
client/linux/minidump_writer/minidump_writer.cc
client/linux/minidump_writer/linux_dumper.cc
client/linux/handler/exception_handler.cc
common/linux/dump_symbols.cc
common/linux/file_id.cc
common/linux/libcurl_wrapper.cc
common/linux/google_crashdump_uploader.cc
common/linux/synth_elf.cc
common/linux/http_upload.cc
common/linux/guid_creator.cc
common/linux/elf_symbols_to_module.cc
client/minidump_file_writer.cc
client/linux/minidump_writer/linux_ptrace_dumper.cc
common/linux/memory_mapped_file.cc
client/linux/log/log.cc
)
ENDIF(APPLE)
LIST(APPEND breakpadSources
client/minidump_file_writer.cc
common/convert_UTF.c
common/string_conversion.cc
)
ENDIF(UNIX)
IF(WIN32)
ADD_DEFINITIONS( -DUNICODE -fshort-wchar )
SET( breakpadSources
client/windows/handler/exception_handler.cc
client/windows/crash_generation/crash_generation_client.cc
common/windows/guid_string.cc
)
ENDIF(WIN32)
INCLUDE_DIRECTORIES(.)
ADD_DEFINITIONS( -fPIC )
IF(WIN32)
ADD_LIBRARY( tomahawk_breakpad SHARED ${breakpadSources} )
ELSE()
ADD_LIBRARY( tomahawk_breakpad STATIC ${breakpadSources} )
ENDIF()
TARGET_LINK_LIBRARIES( tomahawk_breakpad )
================================================
FILE: archive/spotify/breakpad/client/apple/Framework/BreakpadDefines.h
================================================
// Copyright (c) 2011, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Keys for configuration file
#define kReporterMinidumpDirectoryKey "MinidumpDir"
#define kReporterMinidumpIDKey "MinidumpID"
// Filename for recording uploaded IDs
#define kReporterLogFilename "uploads.log"
// The default subdirectory of the Library to put crash dumps in
// The subdirectory is
// ~/Library/<kDefaultLibrarySubdirectory>/<GoogleBreakpadProduct>
#define kDefaultLibrarySubdirectory "Breakpad"
// Specify some special keys to be used in the configuration file that is
// generated by Breakpad and consumed by the crash_sender.
#define BREAKPAD_PRODUCT "BreakpadProduct"
#define BREAKPAD_PRODUCT_DISPLAY "BreakpadProductDisplay"
#define BREAKPAD_VERSION "BreakpadVersion"
#define BREAKPAD_VENDOR "BreakpadVendor"
#define BREAKPAD_URL "BreakpadURL"
#define BREAKPAD_REPORT_INTERVAL "BreakpadReportInterval"
#define BREAKPAD_SKIP_CONFIRM "BreakpadSkipConfirm"
#define BREAKPAD_CONFIRM_TIMEOUT "BreakpadConfirmTimeout"
#define BREAKPAD_SEND_AND_EXIT "BreakpadSendAndExit"
#define BREAKPAD_DUMP_DIRECTORY "BreakpadMinidumpLocation"
#define BREAKPAD_INSPECTOR_LOCATION "BreakpadInspectorLocation"
#define BREAKPAD_REPORTER_EXE_LOCATION \
"BreakpadReporterExeLocation"
#define BREAKPAD_LOGFILES "BreakpadLogFiles"
#define BREAKPAD_LOGFILE_UPLOAD_SIZE "BreakpadLogFileTailSize"
#define BREAKPAD_REQUEST_COMMENTS "BreakpadRequestComments"
#define BREAKPAD_COMMENTS "BreakpadComments"
#define BREAKPAD_REQUEST_EMAIL "BreakpadRequestEmail"
#define BREAKPAD_EMAIL "BreakpadEmail"
#define BREAKPAD_SERVER_TYPE "BreakpadServerType"
#define BREAKPAD_SERVER_PARAMETER_DICT "BreakpadServerParameters"
// The keys below are NOT user supplied, and are used internally.
#define BREAKPAD_PROCESS_START_TIME "BreakpadProcStartTime"
#define BREAKPAD_PROCESS_UP_TIME "BreakpadProcessUpTime"
#define BREAKPAD_PROCESS_CRASH_TIME "BreakpadProcessCrashTime"
#define BREAKPAD_LOGFILE_KEY_PREFIX "BreakpadAppLogFile"
#define BREAKPAD_SERVER_PARAMETER_PREFIX "BreakpadServerParameterPrefix_"
#define BREAKPAD_ON_DEMAND "BreakpadOnDemand"
================================================
FILE: archive/spotify/breakpad/client/linux/android_link.h
================================================
// Copyright (c) 2010, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// The Android NDK doesn't have link.h. Fortunately, the only thing
// that Breakpad uses from it is the ElfW macro, so define it here.
#ifndef GOOGLE_BREAKPAD_CLIENT_LINUX_ANDROID_LINK_H_
#define GOOGLE_BREAKPAD_CLIENT_LINUX_ANDROID_LINK_H_
// TODO(zhenghao): exec_elf.h conflicts with linux/elf.h.
// But we still need ELFSIZE.
//#include <sys/exec_elf.h>
#include <machine/exec.h>
#define ELFSIZE ARCH_ELFSIZE
#ifndef ElfW
#define ElfW(type) _ElfW (Elf, ELFSIZE, type)
#define _ElfW(e,w,t) _ElfW_1 (e, w, _##t)
#define _ElfW_1(e,w,t) e##w##t
#endif
#endif // GOOGLE_BREAKPAD_CLIENT_LINUX_ANDROID_LINK_H_
================================================
FILE: archive/spotify/breakpad/client/linux/android_ucontext.h
================================================
// Copyright (c) 2009, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Android runs a fairly new Linux kernel, so signal info is there,
// but the NDK doesn't have the structs defined, so define
// them here.
// Adapted from platform-linux.cc in V8
#ifndef GOOGLE_BREAKPAD_CLIENT_LINUX_ANDROID_UCONTEXT_H_
#define GOOGLE_BREAKPAD_CLIENT_LINUX_ANDROID_UCONTEXT_H_
#include <signal.h>
#if !defined(__GLIBC__) && (defined(__arm__) || defined(__thumb__))
struct sigcontext {
uint32_t trap_no;
uint32_t error_code;
uint32_t oldmask;
uint32_t arm_r0;
uint32_t arm_r1;
uint32_t arm_r2;
uint32_t arm_r3;
uint32_t arm_r4;
uint32_t arm_r5;
uint32_t arm_r6;
uint32_t arm_r7;
uint32_t arm_r8;
uint32_t arm_r9;
uint32_t arm_r10;
uint32_t arm_fp;
uint32_t arm_ip;
uint32_t arm_sp;
uint32_t arm_lr;
uint32_t arm_pc;
uint32_t arm_cpsr;
uint32_t fault_address;
};
typedef uint32_t __sigset_t;
typedef struct sigcontext mcontext_t;
typedef struct ucontext {
uint32_t uc_flags;
struct ucontext* uc_link;
stack_t uc_stack;
mcontext_t uc_mcontext;
__sigset_t uc_sigmask;
} ucontext_t;
#endif
#endif // GOOGLE_BREAKPAD_CLIENT_LINUX_ANDROID_UCONTEXT_H_
================================================
FILE: archive/spotify/breakpad/client/linux/crash_generation/client_info.h
================================================
// Copyright (c) 2010 Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef CLIENT_LINUX_CRASH_GENERATION_CLIENT_INFO_H_
#define CLIENT_LINUX_CRASH_GENERATION_CLIENT_INFO_H_
namespace google_breakpad {
class CrashGenerationServer;
struct ClientInfo {
CrashGenerationServer* crash_server_;
pid_t pid_;
};
}
#endif // CLIENT_LINUX_CRASH_GENERATION_CLIENT_INFO_H_
================================================
FILE: archive/spotify/breakpad/client/linux/crash_generation/crash_generation_client.cc
================================================
// Copyright (c) 2010 Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <algorithm>
#include "client/linux/crash_generation/crash_generation_client.h"
#include "common/linux/eintr_wrapper.h"
#include "common/linux/linux_libc_support.h"
#include "third_party/lss/linux_syscall_support.h"
namespace google_breakpad {
bool
CrashGenerationClient::RequestDump(const void* blob, size_t blob_size)
{
int fds[2];
sys_socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
static const unsigned kControlMsgSize = CMSG_SPACE(sizeof(int));
struct kernel_msghdr msg;
my_memset(&msg, 0, sizeof(struct kernel_msghdr));
struct kernel_iovec iov[1];
iov[0].iov_base = const_cast<void*>(blob);
iov[0].iov_len = blob_size;
msg.msg_iov = iov;
msg.msg_iovlen = sizeof(iov) / sizeof(iov[0]);
char cmsg[kControlMsgSize];
my_memset(cmsg, 0, kControlMsgSize);
msg.msg_control = cmsg;
msg.msg_controllen = sizeof(cmsg);
struct cmsghdr* hdr = CMSG_FIRSTHDR(&msg);
hdr->cmsg_level = SOL_SOCKET;
hdr->cmsg_type = SCM_RIGHTS;
hdr->cmsg_len = CMSG_LEN(sizeof(int));
int* p = reinterpret_cast<int*>(CMSG_DATA(hdr));
*p = fds[1];
HANDLE_EINTR(sys_sendmsg(server_fd_, &msg, 0));
sys_close(fds[1]);
// wait for an ACK from the server
char b;
HANDLE_EINTR(sys_read(fds[0], &b, 1));
return true;
}
//static
CrashGenerationClient*
CrashGenerationClient::TryCreate(int server_fd)
{
if (0 > server_fd)
return NULL;
return new CrashGenerationClient(server_fd);
}
}
================================================
FILE: archive/spotify/breakpad/client/linux/crash_generation/crash_generation_client.h
================================================
// Copyright (c) 2010 Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef CLIENT_LINUX_CRASH_GENERATION_CRASH_GENERATION_CLIENT_H_
#define CLIENT_LINUX_CRASH_GENERATION_CRASH_GENERATION_CLIENT_H_
#include <stddef.h>
namespace google_breakpad {
class CrashGenerationClient {
public:
~CrashGenerationClient()
{
}
/
gitextract_xt8_barv/
├── .gitignore
├── 4shared/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── 4shared.js
│ └── metadata.json
├── 8tracks/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── 8tracks.js
│ └── metadata.json
├── HACKING.md
├── README.md
├── admin/
│ ├── json2desktop.rb
│ ├── makeaxe.rb
│ └── spotify-synchrotron/
│ ├── linux/
│ │ └── create_synchrotron.rb
│ ├── mac/
│ │ └── create_synchrotron.rb
│ └── win/
│ └── create_synchrotron.rb
├── amazon/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── amazon.js
│ │ └── config.ui
│ └── metadata.json
├── ampache/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── ampache.js
│ │ └── config.ui
│ └── metadata.json
├── archive/
│ ├── README
│ ├── dilandau/
│ │ └── content/
│ │ ├── contents/
│ │ │ └── code/
│ │ │ └── dilandau.js
│ │ └── metadata.json
│ ├── exfm/
│ │ └── content/
│ │ ├── contents/
│ │ │ └── code/
│ │ │ └── exfm.js
│ │ └── metadata.json
│ ├── grooveshark/
│ │ └── content/
│ │ ├── contents/
│ │ │ └── code/
│ │ │ ├── config.ui
│ │ │ └── grooveshark.js
│ │ └── metadata.json
│ ├── rdio/
│ │ └── content/
│ │ ├── contents/
│ │ │ └── code/
│ │ │ └── rdio.js
│ │ └── metadata.json
│ ├── rdio-metadata/
│ │ └── content/
│ │ ├── contents/
│ │ │ └── code/
│ │ │ └── rdio-metadata.js
│ │ └── metadata.json
│ └── spotify/
│ ├── BreakPad.cpp
│ ├── BreakPad.h
│ ├── CMakeLists.txt
│ ├── PlaylistClosure.cpp
│ ├── PlaylistClosure.h
│ ├── appkey.h
│ ├── audiohttpserver.cpp
│ ├── audiohttpserver.h
│ ├── breakpad/
│ │ ├── CMakeLists.txt
│ │ ├── client/
│ │ │ ├── apple/
│ │ │ │ └── Framework/
│ │ │ │ └── BreakpadDefines.h
│ │ │ ├── linux/
│ │ │ │ ├── android_link.h
│ │ │ │ ├── android_ucontext.h
│ │ │ │ ├── crash_generation/
│ │ │ │ │ ├── client_info.h
│ │ │ │ │ ├── crash_generation_client.cc
│ │ │ │ │ ├── crash_generation_client.h
│ │ │ │ │ ├── crash_generation_server.cc
│ │ │ │ │ └── crash_generation_server.h
│ │ │ │ ├── data/
│ │ │ │ │ ├── linux-gate-amd.sym
│ │ │ │ │ └── linux-gate-intel.sym
│ │ │ │ ├── handler/
│ │ │ │ │ ├── exception_handler.cc
│ │ │ │ │ ├── exception_handler.h
│ │ │ │ │ └── exception_handler_unittest.cc
│ │ │ │ ├── log/
│ │ │ │ │ ├── log.cc
│ │ │ │ │ └── log.h
│ │ │ │ ├── minidump_writer/
│ │ │ │ │ ├── directory_reader.h
│ │ │ │ │ ├── directory_reader_unittest.cc
│ │ │ │ │ ├── line_reader.h
│ │ │ │ │ ├── line_reader_unittest.cc
│ │ │ │ │ ├── linux_core_dumper.cc
│ │ │ │ │ ├── linux_core_dumper.h
│ │ │ │ │ ├── linux_core_dumper_unittest.cc
│ │ │ │ │ ├── linux_dumper.cc
│ │ │ │ │ ├── linux_dumper.h
│ │ │ │ │ ├── linux_dumper_unittest_helper.cc
│ │ │ │ │ ├── linux_ptrace_dumper.cc
│ │ │ │ │ ├── linux_ptrace_dumper.h
│ │ │ │ │ ├── linux_ptrace_dumper_unittest.cc
│ │ │ │ │ ├── minidump_extension_linux.h
│ │ │ │ │ ├── minidump_writer.cc
│ │ │ │ │ ├── minidump_writer.h
│ │ │ │ │ └── minidump_writer_unittest.cc
│ │ │ │ └── sender/
│ │ │ │ └── google_crash_report_sender.cc
│ │ │ ├── mac/
│ │ │ │ ├── Breakpad.xcodeproj/
│ │ │ │ │ └── project.pbxproj
│ │ │ │ ├── Framework/
│ │ │ │ │ ├── Breakpad.h
│ │ │ │ │ ├── Breakpad.mm
│ │ │ │ │ ├── Breakpad_Prefix.pch
│ │ │ │ │ ├── Info.plist
│ │ │ │ │ ├── OnDemandServer.h
│ │ │ │ │ └── OnDemandServer.mm
│ │ │ │ ├── UnitTests-Info.plist
│ │ │ │ ├── crash_generation/
│ │ │ │ │ ├── ConfigFile.h
│ │ │ │ │ ├── ConfigFile.mm
│ │ │ │ │ ├── Inspector.h
│ │ │ │ │ ├── Inspector.mm
│ │ │ │ │ ├── InspectorMain.mm
│ │ │ │ │ ├── client_info.h
│ │ │ │ │ ├── crash_generation_client.cc
│ │ │ │ │ ├── crash_generation_client.h
│ │ │ │ │ ├── crash_generation_server.cc
│ │ │ │ │ └── crash_generation_server.h
│ │ │ │ ├── handler/
│ │ │ │ │ ├── breakpad_nlist_64.cc
│ │ │ │ │ ├── breakpad_nlist_64.h
│ │ │ │ │ ├── dynamic_images.cc
│ │ │ │ │ ├── dynamic_images.h
│ │ │ │ │ ├── exception_handler.cc
│ │ │ │ │ ├── exception_handler.h
│ │ │ │ │ ├── mach_vm_compat.h
│ │ │ │ │ ├── minidump_generator.cc
│ │ │ │ │ ├── minidump_generator.h
│ │ │ │ │ ├── minidump_test.xcodeproj/
│ │ │ │ │ │ └── project.pbxproj
│ │ │ │ │ ├── minidump_tests32-Info.plist
│ │ │ │ │ ├── minidump_tests64-Info.plist
│ │ │ │ │ ├── obj-cTestCases-Info.plist
│ │ │ │ │ ├── protected_memory_allocator.cc
│ │ │ │ │ ├── protected_memory_allocator.h
│ │ │ │ │ └── testcases/
│ │ │ │ │ ├── DynamicImagesTests.cc
│ │ │ │ │ ├── DynamicImagesTests.h
│ │ │ │ │ ├── breakpad_nlist_test.cc
│ │ │ │ │ ├── breakpad_nlist_test.h
│ │ │ │ │ ├── dwarftests.h
│ │ │ │ │ ├── dwarftests.mm
│ │ │ │ │ └── testdata/
│ │ │ │ │ ├── dump_syms_dwarf_data
│ │ │ │ │ └── dump_syms_i386_breakpad.sym
│ │ │ │ ├── sender/
│ │ │ │ │ ├── Breakpad.xib
│ │ │ │ │ ├── English.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── ReporterIcon.graffle
│ │ │ │ │ ├── crash_report_sender-Info.plist
│ │ │ │ │ ├── crash_report_sender.h
│ │ │ │ │ ├── crash_report_sender.icns
│ │ │ │ │ ├── crash_report_sender.m
│ │ │ │ │ ├── da.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── de.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── es.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── fr.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── it.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── ja.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── nl.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── no.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── sl.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── sv.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── tr.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── Localizable.strings
│ │ │ │ │ ├── uploader.h
│ │ │ │ │ └── uploader.mm
│ │ │ │ ├── testapp/
│ │ │ │ │ ├── Controller.h
│ │ │ │ │ ├── Controller.m
│ │ │ │ │ ├── English.lproj/
│ │ │ │ │ │ ├── InfoPlist.strings
│ │ │ │ │ │ └── MainMenu.xib
│ │ │ │ │ ├── Info.plist
│ │ │ │ │ ├── TestClass.h
│ │ │ │ │ ├── TestClass.mm
│ │ │ │ │ ├── bomb.icns
│ │ │ │ │ ├── crashInMain
│ │ │ │ │ ├── crashduringload
│ │ │ │ │ └── main.m
│ │ │ │ └── tests/
│ │ │ │ ├── BreakpadFramework_Test.mm
│ │ │ │ ├── SimpleStringDictionaryTest.h
│ │ │ │ ├── SimpleStringDictionaryTest.mm
│ │ │ │ ├── crash_generation_server_test.cc
│ │ │ │ ├── exception_handler_test.cc
│ │ │ │ ├── minidump_generator_test.cc
│ │ │ │ ├── minidump_generator_test_helper.cc
│ │ │ │ ├── spawn_child_process.h
│ │ │ │ └── testlogging.h
│ │ │ ├── minidump_file_writer-inl.h
│ │ │ ├── minidump_file_writer.cc
│ │ │ ├── minidump_file_writer.h
│ │ │ ├── minidump_file_writer_unittest.cc
│ │ │ ├── solaris/
│ │ │ │ └── handler/
│ │ │ │ ├── exception_handler.cc
│ │ │ │ ├── exception_handler.h
│ │ │ │ ├── exception_handler_test.cc
│ │ │ │ ├── minidump_generator.cc
│ │ │ │ ├── minidump_generator.h
│ │ │ │ ├── minidump_test.cc
│ │ │ │ ├── solaris_lwp.cc
│ │ │ │ └── solaris_lwp.h
│ │ │ └── windows/
│ │ │ ├── breakpad_client.gyp
│ │ │ ├── common/
│ │ │ │ ├── auto_critical_section.h
│ │ │ │ └── ipc_protocol.h
│ │ │ ├── crash_generation/
│ │ │ │ ├── ReadMe.txt
│ │ │ │ ├── client_info.cc
│ │ │ │ ├── client_info.h
│ │ │ │ ├── crash_generation.gyp
│ │ │ │ ├── crash_generation_client.cc
│ │ │ │ ├── crash_generation_client.h
│ │ │ │ ├── crash_generation_server.cc
│ │ │ │ ├── crash_generation_server.h
│ │ │ │ ├── minidump_generator.cc
│ │ │ │ └── minidump_generator.h
│ │ │ ├── handler/
│ │ │ │ ├── exception_handler.cc
│ │ │ │ ├── exception_handler.gyp
│ │ │ │ └── exception_handler.h
│ │ │ ├── sender/
│ │ │ │ ├── crash_report_sender.cc
│ │ │ │ ├── crash_report_sender.gyp
│ │ │ │ └── crash_report_sender.h
│ │ │ ├── tests/
│ │ │ │ └── crash_generation_app/
│ │ │ │ ├── abstract_class.cc
│ │ │ │ ├── abstract_class.h
│ │ │ │ ├── crash_generation_app.cc
│ │ │ │ ├── crash_generation_app.gyp
│ │ │ │ ├── crash_generation_app.h
│ │ │ │ ├── crash_generation_app.rc
│ │ │ │ └── resource.h
│ │ │ └── unittests/
│ │ │ ├── client_tests.gyp
│ │ │ ├── crash_generation_server_test.cc
│ │ │ ├── dump_analysis.cc
│ │ │ ├── dump_analysis.h
│ │ │ ├── exception_handler_death_test.cc
│ │ │ ├── exception_handler_test.cc
│ │ │ ├── minidump_test.cc
│ │ │ └── testing.gyp
│ │ ├── common/
│ │ │ ├── basictypes.h
│ │ │ ├── byte_cursor.h
│ │ │ ├── byte_cursor_unittest.cc
│ │ │ ├── convert_UTF.c
│ │ │ ├── convert_UTF.h
│ │ │ ├── dwarf/
│ │ │ │ ├── bytereader-inl.h
│ │ │ │ ├── bytereader.cc
│ │ │ │ ├── bytereader.h
│ │ │ │ ├── bytereader_unittest.cc
│ │ │ │ ├── cfi_assembler.cc
│ │ │ │ ├── cfi_assembler.h
│ │ │ │ ├── dwarf2diehandler.cc
│ │ │ │ ├── dwarf2diehandler.h
│ │ │ │ ├── dwarf2diehandler_unittest.cc
│ │ │ │ ├── dwarf2enums.h
│ │ │ │ ├── dwarf2reader.cc
│ │ │ │ ├── dwarf2reader.h
│ │ │ │ ├── dwarf2reader_cfi_unittest.cc
│ │ │ │ ├── dwarf2reader_die_unittest.cc
│ │ │ │ ├── dwarf2reader_test_common.h
│ │ │ │ ├── functioninfo.cc
│ │ │ │ ├── functioninfo.h
│ │ │ │ ├── line_state_machine.h
│ │ │ │ └── types.h
│ │ │ ├── dwarf_cfi_to_module.cc
│ │ │ ├── dwarf_cfi_to_module.h
│ │ │ ├── dwarf_cfi_to_module_unittest.cc
│ │ │ ├── dwarf_cu_to_module.cc
│ │ │ ├── dwarf_cu_to_module.h
│ │ │ ├── dwarf_cu_to_module_unittest.cc
│ │ │ ├── dwarf_line_to_module.cc
│ │ │ ├── dwarf_line_to_module.h
│ │ │ ├── dwarf_line_to_module_unittest.cc
│ │ │ ├── language.cc
│ │ │ ├── language.h
│ │ │ ├── linux/
│ │ │ │ ├── dump_symbols.cc
│ │ │ │ ├── dump_symbols.h
│ │ │ │ ├── dump_symbols_unittest.cc
│ │ │ │ ├── eintr_wrapper.h
│ │ │ │ ├── elf_core_dump.cc
│ │ │ │ ├── elf_core_dump.h
│ │ │ │ ├── elf_core_dump_unittest.cc
│ │ │ │ ├── elf_symbols_to_module.cc
│ │ │ │ ├── elf_symbols_to_module.h
│ │ │ │ ├── elf_symbols_to_module_unittest.cc
│ │ │ │ ├── file_id.cc
│ │ │ │ ├── file_id.h
│ │ │ │ ├── file_id_unittest.cc
│ │ │ │ ├── google_crashdump_uploader.cc
│ │ │ │ ├── google_crashdump_uploader.h
│ │ │ │ ├── google_crashdump_uploader_test.cc
│ │ │ │ ├── guid_creator.cc
│ │ │ │ ├── guid_creator.h
│ │ │ │ ├── http_upload.cc
│ │ │ │ ├── http_upload.h
│ │ │ │ ├── libcurl_wrapper.cc
│ │ │ │ ├── libcurl_wrapper.h
│ │ │ │ ├── linux_libc_support.h
│ │ │ │ ├── linux_libc_support_unittest.cc
│ │ │ │ ├── memory_mapped_file.cc
│ │ │ │ ├── memory_mapped_file.h
│ │ │ │ ├── memory_mapped_file_unittest.cc
│ │ │ │ ├── safe_readlink.cc
│ │ │ │ ├── safe_readlink.h
│ │ │ │ ├── safe_readlink_unittest.cc
│ │ │ │ ├── synth_elf.cc
│ │ │ │ ├── synth_elf.h
│ │ │ │ ├── synth_elf_unittest.cc
│ │ │ │ └── tests/
│ │ │ │ ├── crash_generator.cc
│ │ │ │ └── crash_generator.h
│ │ │ ├── mac/
│ │ │ │ ├── Breakpad.xcconfig
│ │ │ │ ├── BreakpadDebug.xcconfig
│ │ │ │ ├── BreakpadRelease.xcconfig
│ │ │ │ ├── GTMDefines.h
│ │ │ │ ├── GTMGarbageCollection.h
│ │ │ │ ├── GTMLogger.h
│ │ │ │ ├── GTMLogger.m
│ │ │ │ ├── HTTPMultipartUpload.h
│ │ │ │ ├── HTTPMultipartUpload.m
│ │ │ │ ├── MachIPC.h
│ │ │ │ ├── MachIPC.mm
│ │ │ │ ├── SimpleStringDictionary.h
│ │ │ │ ├── SimpleStringDictionary.mm
│ │ │ │ ├── bootstrap_compat.cc
│ │ │ │ ├── bootstrap_compat.h
│ │ │ │ ├── byteswap.h
│ │ │ │ ├── dump_syms.h
│ │ │ │ ├── dump_syms.mm
│ │ │ │ ├── file_id.cc
│ │ │ │ ├── file_id.h
│ │ │ │ ├── macho_id.cc
│ │ │ │ ├── macho_id.h
│ │ │ │ ├── macho_reader.cc
│ │ │ │ ├── macho_reader.h
│ │ │ │ ├── macho_reader_unittest.cc
│ │ │ │ ├── macho_utilities.cc
│ │ │ │ ├── macho_utilities.h
│ │ │ │ ├── macho_walker.cc
│ │ │ │ ├── macho_walker.h
│ │ │ │ ├── scoped_task_suspend-inl.h
│ │ │ │ ├── string_utilities.cc
│ │ │ │ ├── string_utilities.h
│ │ │ │ └── testing/
│ │ │ │ ├── GTMSenTestCase.h
│ │ │ │ └── GTMSenTestCase.m
│ │ │ ├── md5.cc
│ │ │ ├── md5.h
│ │ │ ├── memory.h
│ │ │ ├── memory_range.h
│ │ │ ├── memory_range_unittest.cc
│ │ │ ├── memory_unittest.cc
│ │ │ ├── module.cc
│ │ │ ├── module.h
│ │ │ ├── module_unittest.cc
│ │ │ ├── solaris/
│ │ │ │ ├── dump_symbols.cc
│ │ │ │ ├── dump_symbols.h
│ │ │ │ ├── file_id.cc
│ │ │ │ ├── file_id.h
│ │ │ │ ├── guid_creator.cc
│ │ │ │ ├── guid_creator.h
│ │ │ │ └── message_output.h
│ │ │ ├── stabs_reader.cc
│ │ │ ├── stabs_reader.h
│ │ │ ├── stabs_reader_unittest.cc
│ │ │ ├── stabs_to_module.cc
│ │ │ ├── stabs_to_module.h
│ │ │ ├── stabs_to_module_unittest.cc
│ │ │ ├── string_conversion.cc
│ │ │ ├── string_conversion.h
│ │ │ ├── test_assembler.cc
│ │ │ ├── test_assembler.h
│ │ │ ├── test_assembler_unittest.cc
│ │ │ ├── testdata/
│ │ │ │ └── func-line-pairing.h
│ │ │ └── windows/
│ │ │ ├── guid_string.cc
│ │ │ ├── guid_string.h
│ │ │ ├── http_upload.cc
│ │ │ ├── http_upload.h
│ │ │ ├── pdb_source_line_writer.cc
│ │ │ ├── pdb_source_line_writer.h
│ │ │ ├── string_utils-inl.h
│ │ │ └── string_utils.cc
│ │ ├── config.h.in
│ │ ├── google_breakpad/
│ │ │ ├── common/
│ │ │ │ ├── breakpad_types.h
│ │ │ │ ├── minidump_cpu_amd64.h
│ │ │ │ ├── minidump_cpu_arm.h
│ │ │ │ ├── minidump_cpu_ppc.h
│ │ │ │ ├── minidump_cpu_ppc64.h
│ │ │ │ ├── minidump_cpu_sparc.h
│ │ │ │ ├── minidump_cpu_x86.h
│ │ │ │ ├── minidump_exception_linux.h
│ │ │ │ ├── minidump_exception_mac.h
│ │ │ │ ├── minidump_exception_solaris.h
│ │ │ │ ├── minidump_exception_win32.h
│ │ │ │ ├── minidump_format.h
│ │ │ │ └── minidump_size.h
│ │ │ └── processor/
│ │ │ ├── basic_source_line_resolver.h
│ │ │ ├── call_stack.h
│ │ │ ├── code_module.h
│ │ │ ├── code_modules.h
│ │ │ ├── exploitability.h
│ │ │ ├── fast_source_line_resolver.h
│ │ │ ├── memory_region.h
│ │ │ ├── minidump.h
│ │ │ ├── minidump_processor.h
│ │ │ ├── process_state.h
│ │ │ ├── source_line_resolver_base.h
│ │ │ ├── source_line_resolver_interface.h
│ │ │ ├── stack_frame.h
│ │ │ ├── stack_frame_cpu.h
│ │ │ ├── stackwalker.h
│ │ │ ├── symbol_supplier.h
│ │ │ └── system_info.h
│ │ ├── processor/
│ │ │ ├── address_map-inl.h
│ │ │ ├── address_map.h
│ │ │ ├── address_map_unittest.cc
│ │ │ ├── basic_code_module.h
│ │ │ ├── basic_code_modules.cc
│ │ │ ├── basic_code_modules.h
│ │ │ ├── basic_source_line_resolver.cc
│ │ │ ├── basic_source_line_resolver_types.h
│ │ │ ├── basic_source_line_resolver_unittest.cc
│ │ │ ├── binarystream.cc
│ │ │ ├── binarystream.h
│ │ │ ├── binarystream_unittest.cc
│ │ │ ├── call_stack.cc
│ │ │ ├── cfi_frame_info-inl.h
│ │ │ ├── cfi_frame_info.cc
│ │ │ ├── cfi_frame_info.h
│ │ │ ├── cfi_frame_info_unittest.cc
│ │ │ ├── contained_range_map-inl.h
│ │ │ ├── contained_range_map.h
│ │ │ ├── contained_range_map_unittest.cc
│ │ │ ├── disassembler_x86.cc
│ │ │ ├── disassembler_x86.h
│ │ │ ├── disassembler_x86_unittest.cc
│ │ │ ├── exploitability.cc
│ │ │ ├── exploitability_unittest.cc
│ │ │ ├── exploitability_win.cc
│ │ │ ├── exploitability_win.h
│ │ │ ├── fast_source_line_resolver.cc
│ │ │ ├── fast_source_line_resolver_types.h
│ │ │ ├── fast_source_line_resolver_unittest.cc
│ │ │ ├── linked_ptr.h
│ │ │ ├── logging.cc
│ │ │ ├── logging.h
│ │ │ ├── map_serializers-inl.h
│ │ │ ├── map_serializers.h
│ │ │ ├── map_serializers_unittest.cc
│ │ │ ├── minidump.cc
│ │ │ ├── minidump_dump.cc
│ │ │ ├── minidump_dump_test
│ │ │ ├── minidump_processor.cc
│ │ │ ├── minidump_processor_unittest.cc
│ │ │ ├── minidump_stackwalk.cc
│ │ │ ├── minidump_stackwalk_machine_readable_test
│ │ │ ├── minidump_stackwalk_test
│ │ │ ├── minidump_unittest.cc
│ │ │ ├── module_comparer.cc
│ │ │ ├── module_comparer.h
│ │ │ ├── module_factory.h
│ │ │ ├── module_serializer.cc
│ │ │ ├── module_serializer.h
│ │ │ ├── pathname_stripper.cc
│ │ │ ├── pathname_stripper.h
│ │ │ ├── pathname_stripper_unittest.cc
│ │ │ ├── postfix_evaluator-inl.h
│ │ │ ├── postfix_evaluator.h
│ │ │ ├── postfix_evaluator_unittest.cc
│ │ │ ├── process_state.cc
│ │ │ ├── proto/
│ │ │ │ ├── README
│ │ │ │ └── process_state.proto
│ │ │ ├── range_map-inl.h
│ │ │ ├── range_map.h
│ │ │ ├── range_map_unittest.cc
│ │ │ ├── scoped_ptr.h
│ │ │ ├── simple_serializer-inl.h
│ │ │ ├── simple_serializer.h
│ │ │ ├── simple_symbol_supplier.cc
│ │ │ ├── simple_symbol_supplier.h
│ │ │ ├── source_line_resolver_base.cc
│ │ │ ├── source_line_resolver_base_types.h
│ │ │ ├── stackwalker.cc
│ │ │ ├── stackwalker_amd64.cc
│ │ │ ├── stackwalker_amd64.h
│ │ │ ├── stackwalker_amd64_unittest.cc
│ │ │ ├── stackwalker_arm.cc
│ │ │ ├── stackwalker_arm.h
│ │ │ ├── stackwalker_arm_unittest.cc
│ │ │ ├── stackwalker_ppc.cc
│ │ │ ├── stackwalker_ppc.h
│ │ │ ├── stackwalker_selftest.cc
│ │ │ ├── stackwalker_selftest_sol.s
│ │ │ ├── stackwalker_sparc.cc
│ │ │ ├── stackwalker_sparc.h
│ │ │ ├── stackwalker_unittest_utils.h
│ │ │ ├── stackwalker_x86.cc
│ │ │ ├── stackwalker_x86.h
│ │ │ ├── stackwalker_x86_unittest.cc
│ │ │ ├── static_address_map-inl.h
│ │ │ ├── static_address_map.h
│ │ │ ├── static_address_map_unittest.cc
│ │ │ ├── static_contained_range_map-inl.h
│ │ │ ├── static_contained_range_map.h
│ │ │ ├── static_contained_range_map_unittest.cc
│ │ │ ├── static_map-inl.h
│ │ │ ├── static_map.h
│ │ │ ├── static_map_iterator-inl.h
│ │ │ ├── static_map_iterator.h
│ │ │ ├── static_map_unittest.cc
│ │ │ ├── static_range_map-inl.h
│ │ │ ├── static_range_map.h
│ │ │ ├── static_range_map_unittest.cc
│ │ │ ├── synth_minidump.cc
│ │ │ ├── synth_minidump.h
│ │ │ ├── synth_minidump_unittest.cc
│ │ │ ├── synth_minidump_unittest_data.h
│ │ │ ├── testdata/
│ │ │ │ ├── ascii_read_av.dmp
│ │ │ │ ├── ascii_read_av_block_write.dmp
│ │ │ │ ├── ascii_read_av_clobber_write.dmp
│ │ │ │ ├── ascii_read_av_conditional.dmp
│ │ │ │ ├── ascii_read_av_then_jmp.dmp
│ │ │ │ ├── ascii_read_av_xchg_write.dmp
│ │ │ │ ├── ascii_write_av.dmp
│ │ │ │ ├── ascii_write_av_arg_to_call.dmp
│ │ │ │ ├── exec_av_on_stack.dmp
│ │ │ │ ├── linux_test_app.cc
│ │ │ │ ├── minidump2.dmp
│ │ │ │ ├── minidump2.dump.out
│ │ │ │ ├── minidump2.stackwalk.machine_readable.out
│ │ │ │ ├── minidump2.stackwalk.out
│ │ │ │ ├── module0.out
│ │ │ │ ├── module1.out
│ │ │ │ ├── module2.out
│ │ │ │ ├── module3_bad.out
│ │ │ │ ├── module4_bad.out
│ │ │ │ ├── null_read_av.dmp
│ │ │ │ ├── null_write_av.dmp
│ │ │ │ ├── read_av_clobber_write.dmp
│ │ │ │ ├── read_av_conditional.dmp
│ │ │ │ ├── read_av_non_null.dmp
│ │ │ │ ├── stack_exhaustion.dmp
│ │ │ │ ├── symbols/
│ │ │ │ │ ├── kernel32.pdb/
│ │ │ │ │ │ └── BCE8785C57B44245A669896B6A19B9542/
│ │ │ │ │ │ └── kernel32.sym
│ │ │ │ │ └── test_app.pdb/
│ │ │ │ │ └── 5A9832E5287241C1838ED98914E9B7FF1/
│ │ │ │ │ └── test_app.sym
│ │ │ │ ├── test_app.cc
│ │ │ │ └── write_av_non_null.dmp
│ │ │ ├── tokenize.cc
│ │ │ ├── tokenize.h
│ │ │ └── windows_frame_info.h
│ │ └── third_party/
│ │ ├── curl/
│ │ │ ├── COPYING
│ │ │ ├── curl.h
│ │ │ ├── curlbuild.h
│ │ │ ├── curlrules.h
│ │ │ ├── curlver.h
│ │ │ ├── easy.h
│ │ │ ├── mprintf.h
│ │ │ ├── multi.h
│ │ │ ├── stdcheaders.h
│ │ │ ├── typecheck-gcc.h
│ │ │ └── types.h
│ │ ├── glog/
│ │ │ ├── AUTHORS
│ │ │ ├── COPYING
│ │ │ ├── ChangeLog
│ │ │ ├── INSTALL
│ │ │ ├── NEWS
│ │ │ ├── README
│ │ │ ├── README.windows
│ │ │ ├── aclocal.m4
│ │ │ ├── compile
│ │ │ ├── config.guess
│ │ │ ├── config.sub
│ │ │ ├── configure
│ │ │ ├── configure.ac
│ │ │ ├── depcomp
│ │ │ ├── doc/
│ │ │ │ ├── designstyle.css
│ │ │ │ └── glog.html
│ │ │ ├── google-glog.sln
│ │ │ ├── install-sh
│ │ │ ├── libglog.pc.in
│ │ │ ├── ltmain.sh
│ │ │ ├── m4/
│ │ │ │ ├── ac_have_attribute.m4
│ │ │ │ ├── ac_have_builtin_expect.m4
│ │ │ │ ├── ac_have_sync_val_compare_and_swap.m4
│ │ │ │ ├── ac_rwlock.m4
│ │ │ │ ├── acx_pthread.m4
│ │ │ │ ├── google_namespace.m4
│ │ │ │ ├── libtool.m4
│ │ │ │ ├── ltoptions.m4
│ │ │ │ ├── ltsugar.m4
│ │ │ │ ├── ltversion.m4
│ │ │ │ ├── lt~obsolete.m4
│ │ │ │ ├── namespaces.m4
│ │ │ │ ├── pc_from_ucontext.m4
│ │ │ │ ├── stl_namespace.m4
│ │ │ │ └── using_operator.m4
│ │ │ ├── missing
│ │ │ ├── mkinstalldirs
│ │ │ ├── packages/
│ │ │ │ ├── deb/
│ │ │ │ │ ├── README
│ │ │ │ │ ├── changelog
│ │ │ │ │ ├── compat
│ │ │ │ │ ├── control
│ │ │ │ │ ├── copyright
│ │ │ │ │ ├── docs
│ │ │ │ │ ├── libgoogle-glog-dev.dirs
│ │ │ │ │ ├── libgoogle-glog-dev.install
│ │ │ │ │ ├── libgoogle-glog0.dirs
│ │ │ │ │ ├── libgoogle-glog0.install
│ │ │ │ │ └── rules
│ │ │ │ ├── deb.sh
│ │ │ │ ├── rpm/
│ │ │ │ │ └── rpm.spec
│ │ │ │ └── rpm.sh
│ │ │ ├── src/
│ │ │ │ ├── base/
│ │ │ │ │ ├── commandlineflags.h
│ │ │ │ │ ├── googleinit.h
│ │ │ │ │ └── mutex.h
│ │ │ │ ├── config.h.in
│ │ │ │ ├── config_for_unittests.h
│ │ │ │ ├── demangle.cc
│ │ │ │ ├── demangle.h
│ │ │ │ ├── demangle_unittest.cc
│ │ │ │ ├── demangle_unittest.sh
│ │ │ │ ├── demangle_unittest.txt
│ │ │ │ ├── glog/
│ │ │ │ │ ├── log_severity.h
│ │ │ │ │ ├── logging.h.in
│ │ │ │ │ ├── raw_logging.h.in
│ │ │ │ │ ├── stl_logging.h.in
│ │ │ │ │ └── vlog_is_on.h.in
│ │ │ │ ├── googletest.h
│ │ │ │ ├── logging.cc
│ │ │ │ ├── logging_striplog_test.sh
│ │ │ │ ├── logging_striptest10.cc
│ │ │ │ ├── logging_striptest2.cc
│ │ │ │ ├── logging_striptest_main.cc
│ │ │ │ ├── logging_unittest.cc
│ │ │ │ ├── logging_unittest.err
│ │ │ │ ├── mock-log.h
│ │ │ │ ├── mock-log_test.cc
│ │ │ │ ├── raw_logging.cc
│ │ │ │ ├── signalhandler.cc
│ │ │ │ ├── signalhandler_unittest.cc
│ │ │ │ ├── signalhandler_unittest.sh
│ │ │ │ ├── stacktrace.h
│ │ │ │ ├── stacktrace_generic-inl.h
│ │ │ │ ├── stacktrace_libunwind-inl.h
│ │ │ │ ├── stacktrace_powerpc-inl.h
│ │ │ │ ├── stacktrace_unittest.cc
│ │ │ │ ├── stacktrace_x86-inl.h
│ │ │ │ ├── stacktrace_x86_64-inl.h
│ │ │ │ ├── stl_logging_unittest.cc
│ │ │ │ ├── symbolize.cc
│ │ │ │ ├── symbolize.h
│ │ │ │ ├── symbolize_unittest.cc
│ │ │ │ ├── utilities.cc
│ │ │ │ ├── utilities.h
│ │ │ │ ├── utilities_unittest.cc
│ │ │ │ ├── vlog_is_on.cc
│ │ │ │ └── windows/
│ │ │ │ ├── config.h
│ │ │ │ ├── glog/
│ │ │ │ │ ├── log_severity.h
│ │ │ │ │ ├── logging.h
│ │ │ │ │ ├── raw_logging.h
│ │ │ │ │ ├── stl_logging.h
│ │ │ │ │ └── vlog_is_on.h
│ │ │ │ ├── port.cc
│ │ │ │ ├── port.h
│ │ │ │ └── preprocess.sh
│ │ │ └── vsprojects/
│ │ │ ├── libglog/
│ │ │ │ └── libglog.vcproj
│ │ │ ├── libglog_static/
│ │ │ │ └── libglog_static.vcproj
│ │ │ ├── logging_unittest/
│ │ │ │ └── logging_unittest.vcproj
│ │ │ └── logging_unittest_static/
│ │ │ └── logging_unittest_static.vcproj
│ │ ├── libdisasm/
│ │ │ ├── TODO
│ │ │ ├── ia32_implicit.c
│ │ │ ├── ia32_implicit.h
│ │ │ ├── ia32_insn.c
│ │ │ ├── ia32_insn.h
│ │ │ ├── ia32_invariant.c
│ │ │ ├── ia32_invariant.h
│ │ │ ├── ia32_modrm.c
│ │ │ ├── ia32_modrm.h
│ │ │ ├── ia32_opcode_tables.c
│ │ │ ├── ia32_opcode_tables.h
│ │ │ ├── ia32_operand.c
│ │ │ ├── ia32_operand.h
│ │ │ ├── ia32_reg.c
│ │ │ ├── ia32_reg.h
│ │ │ ├── ia32_settings.c
│ │ │ ├── ia32_settings.h
│ │ │ ├── libdis.h
│ │ │ ├── qword.h
│ │ │ ├── swig/
│ │ │ │ ├── README
│ │ │ │ ├── libdisasm.i
│ │ │ │ ├── libdisasm_oop.i
│ │ │ │ └── ruby/
│ │ │ │ └── extconf.rb
│ │ │ ├── x86_disasm.c
│ │ │ ├── x86_format.c
│ │ │ ├── x86_imm.c
│ │ │ ├── x86_imm.h
│ │ │ ├── x86_insn.c
│ │ │ ├── x86_misc.c
│ │ │ ├── x86_operand_list.c
│ │ │ └── x86_operand_list.h
│ │ ├── linux/
│ │ │ └── include/
│ │ │ └── gflags/
│ │ │ ├── gflags.h
│ │ │ └── gflags_completions.h
│ │ ├── lss/
│ │ │ └── linux_syscall_support.h
│ │ └── protobuf/
│ │ └── protobuf/
│ │ ├── CHANGES.txt
│ │ ├── CONTRIBUTORS.txt
│ │ ├── COPYING.txt
│ │ ├── INSTALL.txt
│ │ ├── README.txt
│ │ ├── autogen.sh
│ │ ├── benchmarks/
│ │ │ ├── ProtoBench.java
│ │ │ ├── google_size.proto
│ │ │ ├── google_speed.proto
│ │ │ └── readme.txt
│ │ ├── configure.ac
│ │ ├── editors/
│ │ │ ├── README.txt
│ │ │ ├── proto.vim
│ │ │ └── protobuf-mode.el
│ │ ├── examples/
│ │ │ ├── AddPerson.java
│ │ │ ├── ListPeople.java
│ │ │ ├── README.txt
│ │ │ ├── add_person.cc
│ │ │ ├── add_person.py
│ │ │ ├── addressbook.proto
│ │ │ ├── list_people.cc
│ │ │ └── list_people.py
│ │ ├── generate_descriptor_proto.sh
│ │ ├── gtest/
│ │ │ ├── CHANGES
│ │ │ ├── CMakeLists.txt
│ │ │ ├── CONTRIBUTORS
│ │ │ ├── COPYING
│ │ │ ├── README
│ │ │ ├── build-aux/
│ │ │ │ └── .keep
│ │ │ ├── codegear/
│ │ │ │ ├── gtest.cbproj
│ │ │ │ ├── gtest.groupproj
│ │ │ │ ├── gtest_all.cc
│ │ │ │ ├── gtest_link.cc
│ │ │ │ ├── gtest_main.cbproj
│ │ │ │ └── gtest_unittest.cbproj
│ │ │ ├── configure.ac
│ │ │ ├── include/
│ │ │ │ └── gtest/
│ │ │ │ ├── gtest-death-test.h
│ │ │ │ ├── gtest-message.h
│ │ │ │ ├── gtest-param-test.h
│ │ │ │ ├── gtest-param-test.h.pump
│ │ │ │ ├── gtest-spi.h
│ │ │ │ ├── gtest-test-part.h
│ │ │ │ ├── gtest-typed-test.h
│ │ │ │ ├── gtest.h
│ │ │ │ ├── gtest_pred_impl.h
│ │ │ │ ├── gtest_prod.h
│ │ │ │ └── internal/
│ │ │ │ ├── gtest-death-test-internal.h
│ │ │ │ ├── gtest-filepath.h
│ │ │ │ ├── gtest-internal.h
│ │ │ │ ├── gtest-linked_ptr.h
│ │ │ │ ├── gtest-param-util-generated.h
│ │ │ │ ├── gtest-param-util-generated.h.pump
│ │ │ │ ├── gtest-param-util.h
│ │ │ │ ├── gtest-port.h
│ │ │ │ ├── gtest-string.h
│ │ │ │ ├── gtest-tuple.h
│ │ │ │ ├── gtest-tuple.h.pump
│ │ │ │ ├── gtest-type-util.h
│ │ │ │ └── gtest-type-util.h.pump
│ │ │ ├── m4/
│ │ │ │ ├── acx_pthread.m4
│ │ │ │ └── gtest.m4
│ │ │ ├── msvc/
│ │ │ │ ├── gtest-md.sln
│ │ │ │ ├── gtest-md.vcproj
│ │ │ │ ├── gtest.sln
│ │ │ │ ├── gtest.vcproj
│ │ │ │ ├── gtest_main-md.vcproj
│ │ │ │ ├── gtest_main.vcproj
│ │ │ │ ├── gtest_prod_test-md.vcproj
│ │ │ │ ├── gtest_prod_test.vcproj
│ │ │ │ ├── gtest_unittest-md.vcproj
│ │ │ │ └── gtest_unittest.vcproj
│ │ │ ├── run_tests.py
│ │ │ ├── samples/
│ │ │ │ ├── prime_tables.h
│ │ │ │ ├── sample1.cc
│ │ │ │ ├── sample1.h
│ │ │ │ ├── sample10_unittest.cc
│ │ │ │ ├── sample1_unittest.cc
│ │ │ │ ├── sample2.cc
│ │ │ │ ├── sample2.h
│ │ │ │ ├── sample2_unittest.cc
│ │ │ │ ├── sample3-inl.h
│ │ │ │ ├── sample3_unittest.cc
│ │ │ │ ├── sample4.cc
│ │ │ │ ├── sample4.h
│ │ │ │ ├── sample4_unittest.cc
│ │ │ │ ├── sample5_unittest.cc
│ │ │ │ ├── sample6_unittest.cc
│ │ │ │ ├── sample7_unittest.cc
│ │ │ │ ├── sample8_unittest.cc
│ │ │ │ └── sample9_unittest.cc
│ │ │ ├── scripts/
│ │ │ │ ├── fuse_gtest_files.py
│ │ │ │ ├── gen_gtest_pred_impl.py
│ │ │ │ ├── gtest-config.in
│ │ │ │ ├── pump.py
│ │ │ │ ├── upload.py
│ │ │ │ └── upload_gtest.py
│ │ │ ├── src/
│ │ │ │ ├── gtest-all.cc
│ │ │ │ ├── gtest-death-test.cc
│ │ │ │ ├── gtest-filepath.cc
│ │ │ │ ├── gtest-internal-inl.h
│ │ │ │ ├── gtest-port.cc
│ │ │ │ ├── gtest-test-part.cc
│ │ │ │ ├── gtest-typed-test.cc
│ │ │ │ ├── gtest.cc
│ │ │ │ └── gtest_main.cc
│ │ │ ├── test/
│ │ │ │ ├── gtest-death-test_test.cc
│ │ │ │ ├── gtest-filepath_test.cc
│ │ │ │ ├── gtest-linked_ptr_test.cc
│ │ │ │ ├── gtest-listener_test.cc
│ │ │ │ ├── gtest-message_test.cc
│ │ │ │ ├── gtest-options_test.cc
│ │ │ │ ├── gtest-param-test2_test.cc
│ │ │ │ ├── gtest-param-test_test.cc
│ │ │ │ ├── gtest-param-test_test.h
│ │ │ │ ├── gtest-port_test.cc
│ │ │ │ ├── gtest-test-part_test.cc
│ │ │ │ ├── gtest-tuple_test.cc
│ │ │ │ ├── gtest-typed-test2_test.cc
│ │ │ │ ├── gtest-typed-test_test.cc
│ │ │ │ ├── gtest-typed-test_test.h
│ │ │ │ ├── gtest-unittest-api_test.cc
│ │ │ │ ├── gtest_all_test.cc
│ │ │ │ ├── gtest_break_on_failure_unittest.py
│ │ │ │ ├── gtest_break_on_failure_unittest_.cc
│ │ │ │ ├── gtest_color_test.py
│ │ │ │ ├── gtest_color_test_.cc
│ │ │ │ ├── gtest_env_var_test.py
│ │ │ │ ├── gtest_env_var_test_.cc
│ │ │ │ ├── gtest_environment_test.cc
│ │ │ │ ├── gtest_filter_unittest.py
│ │ │ │ ├── gtest_filter_unittest_.cc
│ │ │ │ ├── gtest_help_test.py
│ │ │ │ ├── gtest_help_test_.cc
│ │ │ │ ├── gtest_list_tests_unittest.py
│ │ │ │ ├── gtest_list_tests_unittest_.cc
│ │ │ │ ├── gtest_main_unittest.cc
│ │ │ │ ├── gtest_nc.cc
│ │ │ │ ├── gtest_nc_test.py
│ │ │ │ ├── gtest_no_test_unittest.cc
│ │ │ │ ├── gtest_output_test.py
│ │ │ │ ├── gtest_output_test_.cc
│ │ │ │ ├── gtest_output_test_golden_lin.txt
│ │ │ │ ├── gtest_output_test_golden_win.txt
│ │ │ │ ├── gtest_pred_impl_unittest.cc
│ │ │ │ ├── gtest_prod_test.cc
│ │ │ │ ├── gtest_repeat_test.cc
│ │ │ │ ├── gtest_shuffle_test.py
│ │ │ │ ├── gtest_shuffle_test_.cc
│ │ │ │ ├── gtest_sole_header_test.cc
│ │ │ │ ├── gtest_stress_test.cc
│ │ │ │ ├── gtest_test_utils.py
│ │ │ │ ├── gtest_throw_on_failure_ex_test.cc
│ │ │ │ ├── gtest_throw_on_failure_test.py
│ │ │ │ ├── gtest_throw_on_failure_test_.cc
│ │ │ │ ├── gtest_uninitialized_test.py
│ │ │ │ ├── gtest_uninitialized_test_.cc
│ │ │ │ ├── gtest_unittest.cc
│ │ │ │ ├── gtest_xml_outfile1_test_.cc
│ │ │ │ ├── gtest_xml_outfile2_test_.cc
│ │ │ │ ├── gtest_xml_outfiles_test.py
│ │ │ │ ├── gtest_xml_output_unittest.py
│ │ │ │ ├── gtest_xml_output_unittest_.cc
│ │ │ │ ├── gtest_xml_test_utils.py
│ │ │ │ ├── production.cc
│ │ │ │ ├── production.h
│ │ │ │ ├── run_tests_util.py
│ │ │ │ └── run_tests_util_test.py
│ │ │ └── xcode/
│ │ │ ├── Config/
│ │ │ │ ├── DebugProject.xcconfig
│ │ │ │ ├── FrameworkTarget.xcconfig
│ │ │ │ ├── General.xcconfig
│ │ │ │ ├── ReleaseProject.xcconfig
│ │ │ │ ├── StaticLibraryTarget.xcconfig
│ │ │ │ └── TestTarget.xcconfig
│ │ │ ├── Resources/
│ │ │ │ └── Info.plist
│ │ │ ├── Samples/
│ │ │ │ └── FrameworkSample/
│ │ │ │ ├── Info.plist
│ │ │ │ ├── WidgetFramework.xcodeproj/
│ │ │ │ │ └── project.pbxproj
│ │ │ │ ├── runtests.sh
│ │ │ │ ├── widget.cc
│ │ │ │ ├── widget.h
│ │ │ │ └── widget_test.cc
│ │ │ ├── Scripts/
│ │ │ │ ├── runtests.sh
│ │ │ │ └── versiongenerate.py
│ │ │ └── gtest.xcodeproj/
│ │ │ └── project.pbxproj
│ │ ├── java/
│ │ │ ├── README.txt
│ │ │ ├── pom.xml
│ │ │ └── src/
│ │ │ ├── main/
│ │ │ │ └── java/
│ │ │ │ └── com/
│ │ │ │ └── google/
│ │ │ │ └── protobuf/
│ │ │ │ ├── AbstractMessage.java
│ │ │ │ ├── AbstractMessageLite.java
│ │ │ │ ├── BlockingRpcChannel.java
│ │ │ │ ├── BlockingService.java
│ │ │ │ ├── ByteString.java
│ │ │ │ ├── CodedInputStream.java
│ │ │ │ ├── CodedOutputStream.java
│ │ │ │ ├── Descriptors.java
│ │ │ │ ├── DynamicMessage.java
│ │ │ │ ├── ExtensionRegistry.java
│ │ │ │ ├── ExtensionRegistryLite.java
│ │ │ │ ├── FieldSet.java
│ │ │ │ ├── GeneratedMessage.java
│ │ │ │ ├── GeneratedMessageLite.java
│ │ │ │ ├── Internal.java
│ │ │ │ ├── InvalidProtocolBufferException.java
│ │ │ │ ├── LazyStringArrayList.java
│ │ │ │ ├── LazyStringList.java
│ │ │ │ ├── Message.java
│ │ │ │ ├── MessageLite.java
│ │ │ │ ├── MessageLiteOrBuilder.java
│ │ │ │ ├── MessageOrBuilder.java
│ │ │ │ ├── ProtocolMessageEnum.java
│ │ │ │ ├── RepeatedFieldBuilder.java
│ │ │ │ ├── RpcCallback.java
│ │ │ │ ├── RpcChannel.java
│ │ │ │ ├── RpcController.java
│ │ │ │ ├── RpcUtil.java
│ │ │ │ ├── Service.java
│ │ │ │ ├── ServiceException.java
│ │ │ │ ├── SingleFieldBuilder.java
│ │ │ │ ├── SmallSortedMap.java
│ │ │ │ ├── TextFormat.java
│ │ │ │ ├── UninitializedMessageException.java
│ │ │ │ ├── UnknownFieldSet.java
│ │ │ │ ├── UnmodifiableLazyStringList.java
│ │ │ │ └── WireFormat.java
│ │ │ └── test/
│ │ │ └── java/
│ │ │ └── com/
│ │ │ └── google/
│ │ │ └── protobuf/
│ │ │ ├── AbstractMessageTest.java
│ │ │ ├── CodedInputStreamTest.java
│ │ │ ├── CodedOutputStreamTest.java
│ │ │ ├── DeprecatedFieldTest.java
│ │ │ ├── DescriptorsTest.java
│ │ │ ├── DynamicMessageTest.java
│ │ │ ├── ForceFieldBuildersPreRun.java
│ │ │ ├── GeneratedMessageTest.java
│ │ │ ├── LazyStringArrayListTest.java
│ │ │ ├── LazyStringEndToEndTest.java
│ │ │ ├── LiteTest.java
│ │ │ ├── MessageTest.java
│ │ │ ├── NestedBuildersTest.java
│ │ │ ├── RepeatedFieldBuilderTest.java
│ │ │ ├── ServiceTest.java
│ │ │ ├── SingleFieldBuilderTest.java
│ │ │ ├── SmallSortedMapTest.java
│ │ │ ├── TestBadIdentifiers.java
│ │ │ ├── TestUtil.java
│ │ │ ├── TextFormatTest.java
│ │ │ ├── UnknownFieldSetTest.java
│ │ │ ├── UnmodifiableLazyStringListTest.java
│ │ │ ├── WireFormatTest.java
│ │ │ ├── multiple_files_test.proto
│ │ │ ├── nested_builders_test.proto
│ │ │ ├── nested_extension.proto
│ │ │ ├── nested_extension_lite.proto
│ │ │ ├── non_nested_extension.proto
│ │ │ ├── non_nested_extension_lite.proto
│ │ │ └── test_bad_identifiers.proto
│ │ ├── m4/
│ │ │ ├── ac_system_extensions.m4
│ │ │ ├── acx_check_suncc.m4
│ │ │ ├── acx_pthread.m4
│ │ │ └── stl_hash.m4
│ │ ├── post_process_dist.sh
│ │ ├── protobuf-lite.pc.in
│ │ ├── protobuf.pc.in
│ │ ├── python/
│ │ │ ├── README.txt
│ │ │ ├── ez_setup.py
│ │ │ ├── google/
│ │ │ │ ├── __init__.py
│ │ │ │ └── protobuf/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── descriptor.py
│ │ │ │ ├── internal/
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── api_implementation.py
│ │ │ │ │ ├── containers.py
│ │ │ │ │ ├── cpp_message.py
│ │ │ │ │ ├── decoder.py
│ │ │ │ │ ├── descriptor_test.py
│ │ │ │ │ ├── encoder.py
│ │ │ │ │ ├── generator_test.py
│ │ │ │ │ ├── message_listener.py
│ │ │ │ │ ├── message_test.py
│ │ │ │ │ ├── more_extensions.proto
│ │ │ │ │ ├── more_messages.proto
│ │ │ │ │ ├── python_message.py
│ │ │ │ │ ├── reflection_test.py
│ │ │ │ │ ├── service_reflection_test.py
│ │ │ │ │ ├── test_util.py
│ │ │ │ │ ├── text_format_test.py
│ │ │ │ │ ├── type_checkers.py
│ │ │ │ │ ├── wire_format.py
│ │ │ │ │ └── wire_format_test.py
│ │ │ │ ├── message.py
│ │ │ │ ├── pyext/
│ │ │ │ │ ├── python-proto2.cc
│ │ │ │ │ ├── python_descriptor.cc
│ │ │ │ │ ├── python_descriptor.h
│ │ │ │ │ ├── python_protobuf.cc
│ │ │ │ │ └── python_protobuf.h
│ │ │ │ ├── reflection.py
│ │ │ │ ├── service.py
│ │ │ │ ├── service_reflection.py
│ │ │ │ └── text_format.py
│ │ │ ├── mox.py
│ │ │ ├── setup.py
│ │ │ └── stubout.py
│ │ ├── src/
│ │ │ ├── google/
│ │ │ │ └── protobuf/
│ │ │ │ ├── SEBS
│ │ │ │ ├── compiler/
│ │ │ │ │ ├── code_generator.cc
│ │ │ │ │ ├── code_generator.h
│ │ │ │ │ ├── command_line_interface.cc
│ │ │ │ │ ├── command_line_interface.h
│ │ │ │ │ ├── command_line_interface_unittest.cc
│ │ │ │ │ ├── cpp/
│ │ │ │ │ │ ├── cpp_bootstrap_unittest.cc
│ │ │ │ │ │ ├── cpp_enum.cc
│ │ │ │ │ │ ├── cpp_enum.h
│ │ │ │ │ │ ├── cpp_enum_field.cc
│ │ │ │ │ │ ├── cpp_enum_field.h
│ │ │ │ │ │ ├── cpp_extension.cc
│ │ │ │ │ │ ├── cpp_extension.h
│ │ │ │ │ │ ├── cpp_field.cc
│ │ │ │ │ │ ├── cpp_field.h
│ │ │ │ │ │ ├── cpp_file.cc
│ │ │ │ │ │ ├── cpp_file.h
│ │ │ │ │ │ ├── cpp_generator.cc
│ │ │ │ │ │ ├── cpp_generator.h
│ │ │ │ │ │ ├── cpp_helpers.cc
│ │ │ │ │ │ ├── cpp_helpers.h
│ │ │ │ │ │ ├── cpp_message.cc
│ │ │ │ │ │ ├── cpp_message.h
│ │ │ │ │ │ ├── cpp_message_field.cc
│ │ │ │ │ │ ├── cpp_message_field.h
│ │ │ │ │ │ ├── cpp_plugin_unittest.cc
│ │ │ │ │ │ ├── cpp_primitive_field.cc
│ │ │ │ │ │ ├── cpp_primitive_field.h
│ │ │ │ │ │ ├── cpp_service.cc
│ │ │ │ │ │ ├── cpp_service.h
│ │ │ │ │ │ ├── cpp_string_field.cc
│ │ │ │ │ │ ├── cpp_string_field.h
│ │ │ │ │ │ ├── cpp_test_bad_identifiers.proto
│ │ │ │ │ │ └── cpp_unittest.cc
│ │ │ │ │ ├── importer.cc
│ │ │ │ │ ├── importer.h
│ │ │ │ │ ├── importer_unittest.cc
│ │ │ │ │ ├── java/
│ │ │ │ │ │ ├── java_enum.cc
│ │ │ │ │ │ ├── java_enum.h
│ │ │ │ │ │ ├── java_enum_field.cc
│ │ │ │ │ │ ├── java_enum_field.h
│ │ │ │ │ │ ├── java_extension.cc
│ │ │ │ │ │ ├── java_extension.h
│ │ │ │ │ │ ├── java_field.cc
│ │ │ │ │ │ ├── java_field.h
│ │ │ │ │ │ ├── java_file.cc
│ │ │ │ │ │ ├── java_file.h
│ │ │ │ │ │ ├── java_generator.cc
│ │ │ │ │ │ ├── java_generator.h
│ │ │ │ │ │ ├── java_helpers.cc
│ │ │ │ │ │ ├── java_helpers.h
│ │ │ │ │ │ ├── java_message.cc
│ │ │ │ │ │ ├── java_message.h
│ │ │ │ │ │ ├── java_message_field.cc
│ │ │ │ │ │ ├── java_message_field.h
│ │ │ │ │ │ ├── java_plugin_unittest.cc
│ │ │ │ │ │ ├── java_primitive_field.cc
│ │ │ │ │ │ ├── java_primitive_field.h
│ │ │ │ │ │ ├── java_service.cc
│ │ │ │ │ │ ├── java_service.h
│ │ │ │ │ │ ├── java_string_field.cc
│ │ │ │ │ │ └── java_string_field.h
│ │ │ │ │ ├── main.cc
│ │ │ │ │ ├── mock_code_generator.cc
│ │ │ │ │ ├── mock_code_generator.h
│ │ │ │ │ ├── package_info.h
│ │ │ │ │ ├── parser.cc
│ │ │ │ │ ├── parser.h
│ │ │ │ │ ├── parser_unittest.cc
│ │ │ │ │ ├── plugin.cc
│ │ │ │ │ ├── plugin.h
│ │ │ │ │ ├── plugin.pb.cc
│ │ │ │ │ ├── plugin.pb.h
│ │ │ │ │ ├── plugin.proto
│ │ │ │ │ ├── python/
│ │ │ │ │ │ ├── python_generator.cc
│ │ │ │ │ │ ├── python_generator.h
│ │ │ │ │ │ └── python_plugin_unittest.cc
│ │ │ │ │ ├── subprocess.cc
│ │ │ │ │ ├── subprocess.h
│ │ │ │ │ ├── test_plugin.cc
│ │ │ │ │ ├── zip_output_unittest.sh
│ │ │ │ │ ├── zip_writer.cc
│ │ │ │ │ └── zip_writer.h
│ │ │ │ ├── descriptor.cc
│ │ │ │ ├── descriptor.h
│ │ │ │ ├── descriptor.pb.cc
│ │ │ │ ├── descriptor.pb.h
│ │ │ │ ├── descriptor.proto
│ │ │ │ ├── descriptor_database.cc
│ │ │ │ ├── descriptor_database.h
│ │ │ │ ├── descriptor_database_unittest.cc
│ │ │ │ ├── descriptor_unittest.cc
│ │ │ │ ├── dynamic_message.cc
│ │ │ │ ├── dynamic_message.h
│ │ │ │ ├── dynamic_message_unittest.cc
│ │ │ │ ├── extension_set.cc
│ │ │ │ ├── extension_set.h
│ │ │ │ ├── extension_set_heavy.cc
│ │ │ │ ├── extension_set_unittest.cc
│ │ │ │ ├── generated_message_reflection.cc
│ │ │ │ ├── generated_message_reflection.h
│ │ │ │ ├── generated_message_reflection_unittest.cc
│ │ │ │ ├── generated_message_util.cc
│ │ │ │ ├── generated_message_util.h
│ │ │ │ ├── io/
│ │ │ │ │ ├── coded_stream.cc
│ │ │ │ │ ├── coded_stream.h
│ │ │ │ │ ├── coded_stream_inl.h
│ │ │ │ │ ├── coded_stream_unittest.cc
│ │ │ │ │ ├── gzip_stream.cc
│ │ │ │ │ ├── gzip_stream.h
│ │ │ │ │ ├── gzip_stream_unittest.sh
│ │ │ │ │ ├── package_info.h
│ │ │ │ │ ├── printer.cc
│ │ │ │ │ ├── printer.h
│ │ │ │ │ ├── printer_unittest.cc
│ │ │ │ │ ├── tokenizer.cc
│ │ │ │ │ ├── tokenizer.h
│ │ │ │ │ ├── tokenizer_unittest.cc
│ │ │ │ │ ├── zero_copy_stream.cc
│ │ │ │ │ ├── zero_copy_stream.h
│ │ │ │ │ ├── zero_copy_stream_impl.cc
│ │ │ │ │ ├── zero_copy_stream_impl.h
│ │ │ │ │ ├── zero_copy_stream_impl_lite.cc
│ │ │ │ │ ├── zero_copy_stream_impl_lite.h
│ │ │ │ │ └── zero_copy_stream_unittest.cc
│ │ │ │ ├── lite_unittest.cc
│ │ │ │ ├── message.cc
│ │ │ │ ├── message.h
│ │ │ │ ├── message_lite.cc
│ │ │ │ ├── message_lite.h
│ │ │ │ ├── message_unittest.cc
│ │ │ │ ├── package_info.h
│ │ │ │ ├── reflection_ops.cc
│ │ │ │ ├── reflection_ops.h
│ │ │ │ ├── reflection_ops_unittest.cc
│ │ │ │ ├── repeated_field.cc
│ │ │ │ ├── repeated_field.h
│ │ │ │ ├── repeated_field_unittest.cc
│ │ │ │ ├── service.cc
│ │ │ │ ├── service.h
│ │ │ │ ├── stubs/
│ │ │ │ │ ├── common.cc
│ │ │ │ │ ├── common.h
│ │ │ │ │ ├── common_unittest.cc
│ │ │ │ │ ├── hash.h
│ │ │ │ │ ├── map-util.h
│ │ │ │ │ ├── once.cc
│ │ │ │ │ ├── once.h
│ │ │ │ │ ├── once_unittest.cc
│ │ │ │ │ ├── stl_util-inl.h
│ │ │ │ │ ├── structurally_valid.cc
│ │ │ │ │ ├── structurally_valid_unittest.cc
│ │ │ │ │ ├── strutil.cc
│ │ │ │ │ ├── strutil.h
│ │ │ │ │ ├── strutil_unittest.cc
│ │ │ │ │ ├── substitute.cc
│ │ │ │ │ └── substitute.h
│ │ │ │ ├── test_util.cc
│ │ │ │ ├── test_util.h
│ │ │ │ ├── test_util_lite.cc
│ │ │ │ ├── test_util_lite.h
│ │ │ │ ├── testdata/
│ │ │ │ │ ├── golden_message
│ │ │ │ │ ├── golden_packed_fields_message
│ │ │ │ │ ├── text_format_unittest_data.txt
│ │ │ │ │ └── text_format_unittest_extensions_data.txt
│ │ │ │ ├── testing/
│ │ │ │ │ ├── file.cc
│ │ │ │ │ ├── file.h
│ │ │ │ │ ├── googletest.cc
│ │ │ │ │ ├── googletest.h
│ │ │ │ │ ├── zcgunzip.cc
│ │ │ │ │ └── zcgzip.cc
│ │ │ │ ├── text_format.cc
│ │ │ │ ├── text_format.h
│ │ │ │ ├── text_format_unittest.cc
│ │ │ │ ├── unittest.proto
│ │ │ │ ├── unittest_custom_options.proto
│ │ │ │ ├── unittest_embed_optimize_for.proto
│ │ │ │ ├── unittest_empty.proto
│ │ │ │ ├── unittest_enormous_descriptor.proto
│ │ │ │ ├── unittest_import.proto
│ │ │ │ ├── unittest_import_lite.proto
│ │ │ │ ├── unittest_lite.proto
│ │ │ │ ├── unittest_lite_imports_nonlite.proto
│ │ │ │ ├── unittest_mset.proto
│ │ │ │ ├── unittest_no_generic_services.proto
│ │ │ │ ├── unittest_optimize_for.proto
│ │ │ │ ├── unknown_field_set.cc
│ │ │ │ ├── unknown_field_set.h
│ │ │ │ ├── unknown_field_set_unittest.cc
│ │ │ │ ├── wire_format.cc
│ │ │ │ ├── wire_format.h
│ │ │ │ ├── wire_format_lite.cc
│ │ │ │ ├── wire_format_lite.h
│ │ │ │ ├── wire_format_lite_inl.h
│ │ │ │ └── wire_format_unittest.cc
│ │ │ └── solaris/
│ │ │ └── libstdc++.la
│ │ └── vsprojects/
│ │ ├── config.h
│ │ ├── convert2008to2005.sh
│ │ ├── extract_includes.bat
│ │ ├── libprotobuf-lite.vcproj
│ │ ├── libprotobuf.vcproj
│ │ ├── libprotoc.vcproj
│ │ ├── lite-test.vcproj
│ │ ├── protobuf.sln
│ │ ├── protoc.vcproj
│ │ ├── readme.txt
│ │ ├── test_plugin.vcproj
│ │ └── tests.vcproj
│ ├── callbacks.h
│ ├── cmake/
│ │ ├── FindQJSON.cmake
│ │ └── Findlibspotify.cmake
│ ├── consolewatcher.cpp
│ ├── consolewatcher.h
│ ├── kdsingleapplicationguard/
│ │ ├── kdlockedsharedmemorypointer.cpp
│ │ ├── kdlockedsharedmemorypointer.h
│ │ ├── kdsharedmemorylocker.cpp
│ │ ├── kdsharedmemorylocker.h
│ │ ├── kdsingleapplicationguard.cpp
│ │ ├── kdsingleapplicationguard.h
│ │ ├── kdtoolsglobal.cpp
│ │ ├── kdtoolsglobal.h
│ │ ├── license-gpl
│ │ ├── pimpl_ptr.cpp
│ │ └── pimpl_ptr.h
│ ├── logger.cpp
│ ├── logger.h
│ ├── main.cpp
│ ├── main.h
│ ├── qxtweb-standalone/
│ │ ├── CMakeLists.txt
│ │ ├── README.txt
│ │ └── qxtweb/
│ │ ├── QxtAbstractHttpConnector
│ │ ├── QxtAbstractWebService
│ │ ├── QxtAbstractWebSessionManager
│ │ ├── QxtHtmlTemplate
│ │ ├── QxtHttpServerConnector
│ │ ├── QxtHttpSessionManager
│ │ ├── QxtMail
│ │ ├── QxtScgiServerConnector
│ │ ├── QxtSendmail
│ │ ├── QxtWeb
│ │ ├── QxtWebCgiService
│ │ ├── QxtWebContent
│ │ ├── QxtWebErrorEvent
│ │ ├── QxtWebEvent
│ │ ├── QxtWebFileUploadEvent
│ │ ├── QxtWebPageEvent
│ │ ├── QxtWebRedirectEvent
│ │ ├── QxtWebRemoveCookieEvent
│ │ ├── QxtWebRequestEvent
│ │ ├── QxtWebServiceDirectory
│ │ ├── QxtWebSlotService
│ │ ├── QxtWebStoreCookieEvent
│ │ ├── qxtabstracthttpconnector.cpp
│ │ ├── qxtabstracthttpconnector.h
│ │ ├── qxtabstractwebservice.cpp
│ │ ├── qxtabstractwebservice.h
│ │ ├── qxtabstractwebsessionmanager.cpp
│ │ ├── qxtabstractwebsessionmanager.h
│ │ ├── qxtabstractwebsessionmanager_p.h
│ │ ├── qxtboundcfunction.h
│ │ ├── qxtboundfunction.h
│ │ ├── qxtboundfunctionbase.h
│ │ ├── qxtglobal.cpp
│ │ ├── qxtglobal.h
│ │ ├── qxthtmltemplate.cpp
│ │ ├── qxthtmltemplate.h
│ │ ├── qxthttpserverconnector.cpp
│ │ ├── qxthttpsessionmanager.cpp
│ │ ├── qxthttpsessionmanager.h
│ │ ├── qxtmetaobject.cpp
│ │ ├── qxtmetaobject.h
│ │ ├── qxtmetatype.h
│ │ ├── qxtnull.cpp
│ │ ├── qxtnull.h
│ │ ├── qxtnullable.h
│ │ ├── qxtscgiserverconnector.cpp
│ │ ├── qxtweb.h
│ │ ├── qxtwebcgiservice.cpp
│ │ ├── qxtwebcgiservice.h
│ │ ├── qxtwebcgiservice_p.h
│ │ ├── qxtwebcontent.cpp
│ │ ├── qxtwebcontent.h
│ │ ├── qxtwebevent.cpp
│ │ ├── qxtwebevent.h
│ │ ├── qxtwebservicedirectory.cpp
│ │ ├── qxtwebservicedirectory.h
│ │ ├── qxtwebservicedirectory_p.h
│ │ ├── qxtwebslotservice.cpp
│ │ └── qxtwebslotservice.h
│ ├── spotify.desktop
│ ├── spotify_key.h
│ ├── spotifyiodevice.cpp
│ ├── spotifyiodevice.h
│ ├── spotifyloghandler.cpp
│ ├── spotifyloghandler.h
│ ├── spotifyplayback.cpp
│ ├── spotifyplayback.h
│ ├── spotifyplaylists.cpp
│ ├── spotifyplaylists.h
│ ├── spotifyresolver.cpp
│ ├── spotifyresolver.h
│ ├── spotifysearch.cpp
│ ├── spotifysearch.h
│ ├── spotifysession.cpp
│ ├── spotifysession.h
│ └── tomahawkspotify.kdev4
├── authproxy/
│ ├── app.yaml
│ ├── authproxy.go
│ └── index.html
├── bandcamp/
│ ├── README.md
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── bandcamp.js
│ └── metadata.json
├── bandcampmobile/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── bandcampm.js
│ └── metadata.json
├── beatsmusic/
│ ├── LICENSE
│ ├── content/
│ │ ├── contents/
│ │ │ └── code/
│ │ │ ├── async.js
│ │ │ ├── beatsmusic.js
│ │ │ ├── config.ui
│ │ │ └── test.js
│ │ └── metadata.json
│ └── helpers/
│ └── resolve.js
├── beets/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── beets.js
│ │ └── config.ui
│ └── metadata.json
├── bower.json
├── deezer/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── deezer.js
│ └── metadata.json
├── deezer-metadata/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── deezer-metadata.js
│ └── metadata.json
├── docs/
│ ├── .gitignore
│ ├── docs/
│ │ ├── basic.md
│ │ ├── index.md
│ │ ├── searchresolve.md
│ │ └── urllookup.md
│ └── mkdocs.yml
├── examples/
│ ├── javascript/
│ │ └── content/
│ │ ├── contents/
│ │ │ └── code/
│ │ │ ├── config.ui
│ │ │ └── example.js
│ │ └── metadata.json
│ ├── php/
│ │ └── php-resolver.php
│ └── streamtest/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── streamtest.js
│ └── metadata.json
├── gmusic/
│ ├── .gitignore
│ ├── COPYING.txt
│ ├── README.md
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── gmusic.js
│ └── metadata.json
├── hatchet-metadata/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── hatchet-metadata.js
│ └── metadata.json
├── itunes/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── itunes.js
│ └── metadata.json
├── jamendo/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── jamendo.js
│ └── metadata.json
├── jazz-on-line/
│ ├── jazz-on-line-resolver.py
│ ├── jol_search.py
│ └── listing.txt
├── kibergrad/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── kibergrad.js
│ └── metadata.json
├── lastfm/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── lastfm.js
│ └── metadata.json
├── muzebra/
│ └── muzebra.js
├── myzuka/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── myzuka.js
│ └── metadata.json
├── netease/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── netease.js
│ └── metadata.json
├── officialfm/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── officialfm.js
│ └── metadata.json
├── omnify-metadata/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── omnify-metadata.js
│ └── metadata.json
├── package.json
├── prostopleer/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── pleer.js
│ └── metadata.json
├── qobuz/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── qobuz.js
│ └── metadata.json
├── rhapsody/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── rhapsody.js
│ └── metadata.json
├── soundcloud/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ ├── soundcloud.js
│ │ └── test.js
│ └── metadata.json
├── spotify/
│ ├── LICENSE
│ ├── content/
│ │ ├── contents/
│ │ │ └── code/
│ │ │ ├── config.ui
│ │ │ └── spotify.js
│ │ └── metadata.json
│ └── native/
│ ├── CMakeLists.txt
│ ├── CMakeModules/
│ │ ├── FindMicrohttpd.cmake
│ │ └── FindSpotify.cmake
│ └── main.cpp
├── spotify-metadata/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── spotify-metadata.js
│ └── metadata.json
├── subsonic/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── subsonic.js
│ └── metadata.json
├── synology-audiostation/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── synology-audiostation.js
│ └── metadata.json
├── test/
│ ├── buster.js
│ └── utils.js
├── tidal/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── tidal.js
│ └── metadata.json
├── tomahawk-metadata/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── tomahawk-metadata.js
│ └── metadata.json
├── tomahk-metadata/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── tomahk-metadata.js
│ └── metadata.json
├── tools/
│ ├── getstreamurl.js
│ ├── resolve.js
│ ├── search.js
│ └── urllookup.js
├── vibe3/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── vibe3.js
│ └── metadata.json
├── vkontakte/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── vkontakte.js
│ └── metadata.json
├── youtube/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── config.ui
│ │ └── youtube.js
│ └── metadata.json
├── youtube-metadata/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ └── youtube-metadata.js
│ └── metadata.json
├── zaycevnet/
│ └── content/
│ ├── contents/
│ │ └── code/
│ │ ├── strstr.js
│ │ └── zaycev.js
│ └── metadata.json
└── zv.fm/
└── content/
├── contents/
│ └── code/
│ └── zv.js
└── metadata.json
Showing preview only (1,089K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (11179 symbols across 847 files)
FILE: admin/makeaxe.rb
function usage (line 47) | def usage
FILE: archive/spotify/BreakPad.cpp
function LaunchUploader (line 36) | static bool
function LaunchUploader (line 99) | static bool
FILE: archive/spotify/BreakPad.h
function class (line 29) | class BreakPad : public google_breakpad::ExceptionHandler
FILE: archive/spotify/PlaylistClosure.h
type std (line 47) | typedef std::tr1::function<bool ()> LoadedCondition;
function class (line 49) | class ClosureArgumentWrapper {
function virtual (line 79) | virtual ~PlaylistClosure() {}
function conditionSatisfied (line 81) | bool conditionSatisfied() const;
FILE: archive/spotify/audiohttpserver.cpp
function QString (line 238) | QString AudioHTTPServer::urlForID( const QString& id )
FILE: archive/spotify/audiohttpserver.h
function class (line 38) | class AudioHTTPServer : public QxtWebSlotService
FILE: archive/spotify/breakpad/client/linux/android_ucontext.h
type sigcontext (line 42) | struct sigcontext {
type __sigset_t (line 65) | typedef uint32_t __sigset_t;
type mcontext_t (line 66) | typedef struct sigcontext mcontext_t;
type ucontext_t (line 67) | typedef struct ucontext {
FILE: archive/spotify/breakpad/client/linux/crash_generation/client_info.h
function namespace (line 33) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/linux/crash_generation/crash_generation_client.cc
type google_breakpad (line 41) | namespace google_breakpad {
type kernel_msghdr (line 50) | struct kernel_msghdr
type kernel_msghdr (line 51) | struct kernel_msghdr
type kernel_iovec (line 52) | struct kernel_iovec
type cmsghdr (line 63) | struct cmsghdr
function CrashGenerationClient (line 81) | CrashGenerationClient*
FILE: archive/spotify/breakpad/client/linux/crash_generation/crash_generation_client.h
function namespace (line 35) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/linux/crash_generation/crash_generation_server.cc
function GetInodeForFileDescriptor (line 54) | static bool
function GetInodeForProcPath (line 77) | static bool
function FindProcessHoldingSocket (line 106) | static bool
type google_breakpad (line 164) | namespace google_breakpad {
type pollfd (line 268) | struct pollfd
type ucred (line 310) | struct ucred
type msghdr (line 315) | struct msghdr
type iovec (line 316) | struct iovec
type cmsghdr (line 339) | struct cmsghdr
type ucred (line 358) | struct ucred
type ucred (line 359) | struct ucred
type iovec (line 409) | struct iovec
FILE: archive/spotify/breakpad/client/linux/crash_generation/crash_generation_server.h
function namespace (line 37) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/linux/handler/exception_handler.cc
function tgkill (line 107) | static int tgkill(pid_t tgid, pid_t tid, int sig) {
type google_breakpad (line 112) | namespace google_breakpad {
type sigaction (line 204) | struct sigaction
type sigaction (line 216) | struct sigaction
type sigaction (line 216) | struct sigaction
type sigaction (line 227) | struct sigaction
type sigaction (line 228) | struct sigaction
type ThreadArgument (line 309) | struct ThreadArgument {
type ucontext (line 345) | struct ucontext
type ucontext (line 348) | struct ucontext
type ucontext (line 348) | struct ucontext
FILE: archive/spotify/breakpad/client/linux/handler/exception_handler.h
type sigaction (line 49) | struct sigaction
function namespace (line 51) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/linux/handler/exception_handler_unittest.cc
function sigchld_handler (line 57) | static void sigchld_handler(int signo) { }
class ExceptionHandlerTest (line 59) | class ExceptionHandlerTest : public ::testing::Test {
method SetUp (line 61) | void SetUp() {
method TearDown (line 69) | void TearDown() {
type sigaction (line 73) | struct sigaction
function TEST (line 76) | TEST(ExceptionHandlerTest, Simple) {
function DoneCallback (line 81) | static bool DoneCallback(const char* dump_path,
function TEST (line 97) | TEST(ExceptionHandlerTest, ChildCrash) {
function TEST (line 144) | TEST(ExceptionHandlerTest, InstructionPointerMemory) {
function TEST (line 269) | TEST(ExceptionHandlerTest, InstructionPointerMemoryMinBound) {
function TEST (line 391) | TEST(ExceptionHandlerTest, InstructionPointerMemoryMaxBound) {
function TEST (line 517) | TEST(ExceptionHandlerTest, InstructionPointerMemoryNullPointer) {
function SimpleCallback (line 582) | static bool SimpleCallback(const char* dump_path,
function TEST (line 598) | TEST(ExceptionHandlerTest, ModuleInfo) {
type ucred (line 665) | struct ucred
function CrashHandler (line 667) | static bool
function TEST (line 714) | TEST(ExceptionHandlerTest, ExternalDumper) {
FILE: archive/spotify/breakpad/client/linux/log/log.cc
type logger (line 38) | namespace logger {
function write (line 40) | int write(const char* buf, size_t nbytes) {
FILE: archive/spotify/breakpad/client/linux/log/log.h
function namespace (line 35) | namespace logger {
FILE: archive/spotify/breakpad/client/linux/minidump_writer/directory_reader.h
function namespace (line 42) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/linux/minidump_writer/directory_reader_unittest.cc
function TEST (line 46) | TEST(DirectoryReaderTest, CompareResults) {
FILE: archive/spotify/breakpad/client/linux/minidump_writer/line_reader.h
function namespace (line 39) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/linux/minidump_writer/line_reader_unittest.cc
function TemporaryFile (line 46) | static int TemporaryFile() {
function TEST (line 61) | TEST(LineReaderTest, EmptyFile) {
function TEST (line 72) | TEST(LineReaderTest, OneLineTerminated) {
function TEST (line 92) | TEST(LineReaderTest, OneLine) {
function TEST (line 112) | TEST(LineReaderTest, TwoLinesTerminated) {
function TEST (line 138) | TEST(LineReaderTest, TwoLines) {
function TEST (line 164) | TEST(LineReaderTest, MaxLength) {
function TEST (line 183) | TEST(LineReaderTest, TooLong) {
FILE: archive/spotify/breakpad/client/linux/minidump_writer/linux_core_dumper.cc
type google_breakpad (line 44) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/linux/minidump_writer/linux_core_dumper.h
function namespace (line 41) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/linux/minidump_writer/linux_core_dumper_unittest.cc
function TEST (line 40) | TEST(LinuxCoreDumperTest, BuildProcPath) {
function TEST (line 63) | TEST(LinuxCoreDumperTest, VerifyDumpWithMultipleThreads) {
FILE: archive/spotify/breakpad/client/linux/minidump_writer/linux_dumper.cc
function IsMappedFileOpenUnsafe (line 56) | inline static bool IsMappedFileOpenUnsafe(
type google_breakpad (line 67) | namespace google_breakpad {
function MappingInfo (line 309) | const MappingInfo* LinuxDumper::FindMapping(const void* address) const {
type kernel_stat (line 345) | struct kernel_stat
type kernel_stat (line 346) | struct kernel_stat
FILE: archive/spotify/breakpad/client/linux/minidump_writer/linux_dumper.h
function namespace (line 52) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/linux/minidump_writer/linux_dumper_unittest_helper.cc
function main (line 68) | int main(int argc, char *argv[]) {
FILE: archive/spotify/breakpad/client/linux/minidump_writer/linux_ptrace_dumper.cc
function SuspendThread (line 58) | static bool SuspendThread(pid_t pid) {
function ResumeThread (line 95) | static bool ResumeThread(pid_t pid) {
type google_breakpad (line 99) | namespace google_breakpad {
type user (line 204) | struct user
FILE: archive/spotify/breakpad/client/linux/minidump_writer/linux_ptrace_dumper.h
function namespace (line 40) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/linux/minidump_writer/linux_ptrace_dumper_unittest.cc
function string (line 62) | string GetHelperBinary() {
function TEST (line 81) | TEST(LinuxPtraceDumperTest, Setup) {
function TEST (line 85) | TEST(LinuxPtraceDumperTest, FindMappings) {
function TEST (line 94) | TEST(LinuxPtraceDumperTest, ThreadList) {
class StackHelper (line 110) | class StackHelper {
method StackHelper (line 112) | StackHelper(int fd, char* mapping, size_t size)
function TEST (line 125) | TEST(LinuxPtraceDumperTest, MergedMappings) {
function TEST (line 182) | TEST(LinuxPtraceDumperTest, VerifyStackReadWithMultipleThreads) {
function TEST (line 273) | TEST(LinuxPtraceDumperTest, BuildProcPath) {
function TEST (line 298) | TEST(LinuxPtraceDumperTest, MappingsIncludeLinuxGate) {
function TEST (line 321) | TEST(LinuxPtraceDumperTest, LinuxGateMappingID) {
function TEST (line 349) | TEST(LinuxPtraceDumperTest, LinuxGateMappingIDChild) {
function TEST (line 395) | TEST(LinuxPtraceDumperTest, FileIDsMatch) {
FILE: archive/spotify/breakpad/client/linux/minidump_writer/minidump_extension_linux.h
type MDRawLinkMap (line 60) | typedef struct {
type MDRawDebug (line 66) | typedef struct {
FILE: archive/spotify/breakpad/client/linux/minidump_writer/minidump_writer.cc
function U16 (line 91) | static void U16(void* out, uint16_t v) {
function U32 (line 98) | static void U32(void* out, uint32_t v) {
function CPUFillFromThreadInfo (line 105) | static void CPUFillFromThreadInfo(MDRawContextX86 *out,
function CPUFillFromUContext (line 166) | static void CPUFillFromUContext(MDRawContextX86 *out, const ucontext *uc,
function CPUFillFromThreadInfo (line 207) | static void CPUFillFromThreadInfo(MDRawContextAMD64 *out,
function CPUFillFromUContext (line 266) | static void CPUFillFromUContext(MDRawContextAMD64 *out, const ucontext *uc,
function CPUFillFromThreadInfo (line 316) | static void CPUFillFromThreadInfo(MDRawContextARM *out,
function CPUFillFromUContext (line 333) | static void CPUFillFromUContext(MDRawContextARM *out, const ucontext *uc,
type google_breakpad (line 367) | namespace google_breakpad {
class MinidumpWriter (line 369) | class MinidumpWriter {
method MinidumpWriter (line 371) | MinidumpWriter(const char* filename,
method Init (line 388) | bool Init() {
method Dump (line 398) | bool Dump() {
method PopSeccompStackFrame (line 523) | void PopSeccompStackFrame(RawContextCPU* cpu, const MDRawThread& thr...
method WriteThreadListStream (line 638) | bool WriteThreadListStream(MDRawDirectory* dirent) {
method ShouldIncludeMapping (line 760) | static bool ShouldIncludeMapping(const MappingInfo& mapping) {
method HaveMappingInfo (line 772) | bool HaveMappingInfo(const MappingInfo& mapping) {
method WriteMappings (line 791) | bool WriteMappings(MDRawDirectory* dirent) {
method FillRawModule (line 837) | bool FillRawModule(const MappingInfo& mapping,
method WriteMemoryListStream (line 893) | bool WriteMemoryListStream(MDRawDirectory* dirent) {
method WriteExceptionStream (line 911) | bool WriteExceptionStream(MDRawDirectory* dirent) {
method WriteSystemInfoStream (line 928) | bool WriteSystemInfoStream(MDRawDirectory* dirent) {
method WriteDSODebugStream (line 943) | bool WriteDSODebugStream(MDRawDirectory* dirent, struct r_debug* r_d...
method pid_t (line 1029) | pid_t GetCrashThread() const {
method GetStackPointer (line 1034) | uintptr_t GetStackPointer() {
method GetInstructionPointer (line 1038) | uintptr_t GetInstructionPointer() {
method GetStackPointer (line 1042) | uintptr_t GetStackPointer() {
method GetInstructionPointer (line 1046) | uintptr_t GetInstructionPointer() {
method GetStackPointer (line 1050) | uintptr_t GetStackPointer() {
method GetInstructionPointer (line 1054) | uintptr_t GetInstructionPointer() {
method NullifyDirectoryEntry (line 1061) | void NullifyDirectoryEntry(MDRawDirectory* dirent) {
method WriteCPUInformation (line 1067) | bool WriteCPUInformation(MDRawSystemInfo* sys_info) {
method WriteFile (line 1187) | bool WriteFile(MDLocationDescriptor* result, const char* filename) {
method WriteOSInformation (line 1248) | bool WriteOSInformation(MDRawSystemInfo* sys_info) {
method WriteProcFile (line 1294) | bool WriteProcFile(MDLocationDescriptor* result, pid_t pid,
type ucontext (line 1303) | struct ucontext
type _libc_fpstate (line 1304) | struct _libc_fpstate
function WriteMinidump (line 1316) | bool WriteMinidump(const char* filename, pid_t crashing_process,
function WriteMinidump (line 1322) | bool WriteMinidump(const char* filename, pid_t crashing_process,
function WriteMinidump (line 1340) | bool WriteMinidump(const char* filename,
FILE: archive/spotify/breakpad/client/linux/minidump_writer/minidump_writer.h
function namespace (line 42) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/linux/minidump_writer/minidump_writer_unittest.cc
function TEST (line 59) | TEST(MinidumpWriterTest, Setup) {
function TEST (line 90) | TEST(MinidumpWriterTest, MappingInfo) {
function TEST (line 182) | TEST(MinidumpWriterTest, MappingInfoContained) {
function TEST (line 284) | TEST(MinidumpWriterTest, DeletedBinary) {
FILE: archive/spotify/breakpad/client/linux/sender/google_crash_report_sender.cc
function CheckForRequiredFlagsOrDie (line 61) | bool CheckForRequiredFlagsOrDie() {
function main (line 86) | int main(int argc, char *argv[]) {
FILE: archive/spotify/breakpad/client/mac/Framework/OnDemandServer.h
function class (line 82) | class OnDemandServer {
FILE: archive/spotify/breakpad/client/mac/crash_generation/ConfigFile.h
function namespace (line 36) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/mac/crash_generation/Inspector.h
type InspectorInfo (line 57) | struct InspectorInfo {
type KeyValueMessageData (line 65) | struct KeyValueMessageData {
function namespace (line 80) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/mac/crash_generation/client_info.h
function namespace (line 33) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/mac/crash_generation/crash_generation_client.cc
type google_breakpad (line 35) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/mac/crash_generation/crash_generation_client.h
function namespace (line 35) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/mac/crash_generation/crash_generation_server.cc
type google_breakpad (line 36) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/mac/crash_generation/crash_generation_server.h
function namespace (line 39) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/mac/handler/breakpad_nlist_64.cc
type exec (line 87) | struct exec {
type MachBits (line 113) | struct MachBits {}
type nlist (line 115) | struct nlist
type nlist_64 (line 116) | struct nlist_64
type MachBits<nlist32> (line 119) | struct MachBits<nlist32> {
type MachBits<nlist64> (line 126) | struct MachBits<nlist64> {
function breakpad_nlist_common (line 142) | int breakpad_nlist_common(const char *name,
function breakpad_nlist (line 154) | int breakpad_nlist(const char *name,
function breakpad_nlist (line 161) | int breakpad_nlist(const char *name,
function __breakpad_fdnlist (line 171) | int __breakpad_fdnlist(int fd, nlist_type *list, const char **symbolNames,
FILE: archive/spotify/breakpad/client/mac/handler/breakpad_nlist_64.h
type nlist (line 39) | struct nlist
type nlist_64 (line 43) | struct nlist_64
FILE: archive/spotify/breakpad/client/mac/handler/dynamic_images.cc
type task_dyld_info (line 63) | struct task_dyld_info {
type task_dyld_info (line 67) | struct task_dyld_info
type task_dyld_info (line 68) | struct task_dyld_info
type google_breakpad (line 75) | namespace google_breakpad {
function mach_vm_size_t (line 88) | static mach_vm_size_t GetMemoryRegionSize(task_port_t target_task,
function string (line 154) | static string ReadTaskString(task_port_t target_task,
function kern_return_t (line 181) | kern_return_t ReadTaskMemory(task_port_t target_task,
type MachO32 (line 219) | struct MachO32 {
type nlist (line 224) | struct nlist
type MachO64 (line 229) | struct MachO64 {
type nlist_64 (line 234) | struct nlist_64
function FindTextSection (line 240) | bool FindTextSection(DynamicImage& image) {
function GetFileTypeFromHeader (line 318) | uint32_t GetFileTypeFromHeader(DynamicImage& image) {
function LookupSymbol (line 345) | static uint64_t LookupSymbol(const char* symbol_name,
function HasTaskDyldInfo (line 367) | static bool HasTaskDyldInfo() {
function SInt32 (line 371) | static SInt32 GetOSVersionInternal() {
function SInt32 (line 377) | static SInt32 GetOSVersion() {
function HasTaskDyldInfo (line 382) | static bool HasTaskDyldInfo() {
function ReadImageInfo (line 415) | void ReadImageInfo(DynamicImages& images,
function DynamicImage (line 530) | DynamicImage *DynamicImages::GetExecutableImage() {
function cpu_type_t (line 557) | cpu_type_t DynamicImages::DetermineTaskCPUType(task_t task) {
FILE: archive/spotify/breakpad/client/mac/handler/dynamic_images.h
function namespace (line 50) | namespace google_breakpad {
function class (line 206) | class DynamicImageRef {
function class (line 239) | class DynamicImages {
FILE: archive/spotify/breakpad/client/mac/handler/exception_handler.cc
type google_breakpad (line 60) | namespace google_breakpad {
type ExceptionMessage (line 73) | struct ExceptionMessage {
type ExceptionParameters (line 85) | struct ExceptionParameters {
method ExceptionParameters (line 86) | ExceptionParameters() : count(0) {}
type ExceptionReplyMessage (line 94) | struct ExceptionReplyMessage {
function boolean_t (line 132) | boolean_t breakpad_exc_server(mach_msg_header_t *InHeadP,
function boolean_t (line 189) | boolean_t breakpad_exc_server(mach_msg_header_t *request,
function kern_return_t (line 195) | kern_return_t catch_exception_raise(mach_port_t port, mach_port_t fail...
function kern_return_t (line 398) | kern_return_t ForwardException(mach_port_t task, mach_port_t failed_th...
type sigaction (line 609) | struct sigaction
type sigaction (line 616) | struct sigaction
type sigaction (line 616) | struct sigaction
FILE: archive/spotify/breakpad/client/mac/handler/exception_handler.h
function namespace (line 50) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/mac/handler/minidump_generator.cc
type google_breakpad (line 62) | namespace google_breakpad {
function string (line 171) | string MinidumpGenerator::UniqueNameInDirectory(const string &dir,
function u_int64_t (line 406) | u_int64_t MinidumpGenerator::CurrentPCForStack(
function u_int64_t (line 440) | u_int64_t
function u_int64_t (line 506) | u_int64_t
function u_int64_t (line 514) | u_int64_t
function u_int64_t (line 668) | u_int64_t
function u_int64_t (line 676) | u_int64_t
type load_command (line 1193) | struct load_command
type load_command (line 1194) | struct load_command
type load_command (line 1225) | struct load_command
type mach_header (line 1241) | struct mach_header
type rusage (line 1375) | struct rusage
type kinfo_proc (line 1386) | struct kinfo_proc
FILE: archive/spotify/breakpad/client/mac/handler/minidump_generator.h
function namespace (line 57) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/mac/handler/protected_memory_allocator.cc
function kern_return_t (line 73) | kern_return_t ProtectedMemoryAllocator::Protect() {
function kern_return_t (line 84) | kern_return_t ProtectedMemoryAllocator::Unprotect() {
FILE: archive/spotify/breakpad/client/mac/handler/protected_memory_allocator.h
function class (line 47) | class ProtectedMemoryAllocator {
FILE: archive/spotify/breakpad/client/mac/handler/testcases/DynamicImagesTests.h
function class (line 43) | class DynamicImagesTests : public TestCase {
FILE: archive/spotify/breakpad/client/mac/handler/testcases/breakpad_nlist_test.h
function class (line 43) | class BreakpadNlistTest : public TestCase {
FILE: archive/spotify/breakpad/client/mac/handler/testcases/dwarftests.h
function interface (line 40) | interface dwarftests : SenTestCase {
FILE: archive/spotify/breakpad/client/mac/sender/crash_report_sender.h
function interface (line 49) | interface LengthLimitingTextField : NSTextField {
FILE: archive/spotify/breakpad/client/mac/sender/uploader.h
function interface (line 45) | interface Uploader : NSObject {
FILE: archive/spotify/breakpad/client/mac/testapp/Controller.h
type BreakpadForkBehavior (line 34) | enum BreakpadForkBehavior {
type BreakpadForkTestCrashPoint (line 40) | enum BreakpadForkTestCrashPoint {
function interface (line 46) | interface Controller : NSObject {
FILE: archive/spotify/breakpad/client/mac/testapp/TestClass.h
function interface (line 32) | interface TestClass : NSObject {
FILE: archive/spotify/breakpad/client/mac/tests/SimpleStringDictionaryTest.h
function interface (line 33) | interface SimpleStringDictionaryTest : GTMTestCase {
FILE: archive/spotify/breakpad/client/mac/tests/crash_generation_server_test.cc
type google_breakpad (line 50) | namespace google_breakpad {
class CrashGenerationServerTest (line 75) | class CrashGenerationServerTest : public Test {
method SetUp (line 88) | void SetUp() {
function TEST_F (line 98) | TEST_F(CrashGenerationServerTest, testStartStopServer) {
function TEST_F (line 112) | TEST_F(CrashGenerationServerTest, testRequestDumpNoDump) {
function dumpCallback (line 144) | void dumpCallback(void *context, const ClientInfo &client_info,
function TEST_F (line 162) | TEST_F(CrashGenerationServerTest, testRequestDump) {
function Crasher (line 200) | static void Crasher() {
function TEST_F (line 210) | TEST_F(CrashGenerationServerTest, testChildProcessCrash) {
function TEST_F (line 271) | TEST_F(CrashGenerationServerTest, testChildProcessCrashCrossArchitecture) {
FILE: archive/spotify/breakpad/client/mac/tests/exception_handler_test.cc
type google_breakpad (line 43) | namespace google_breakpad {
class ExceptionHandlerTest (line 65) | class ExceptionHandlerTest : public Test {
function Crasher (line 72) | static void Crasher() {
function AbortCrasher (line 79) | static void AbortCrasher() {
function SoonToCrash (line 84) | static void SoonToCrash(void(*crasher)()) {
function MDCallback (line 88) | static bool MDCallback(const char *dump_dir, const char *file_name,
type stat (line 126) | struct stat
function TEST_F (line 137) | TEST_F(ExceptionHandlerTest, InProcess) {
function TEST_F (line 142) | TEST_F(ExceptionHandlerTest, InProcessAbort) {
function DumpNameMDCallback (line 147) | static bool DumpNameMDCallback(const char *dump_dir, const char *file_name,
function TEST_F (line 159) | TEST_F(ExceptionHandlerTest, WriteMinidump) {
function TEST_F (line 178) | TEST_F(ExceptionHandlerTest, WriteMinidumpWithException) {
function TEST_F (line 202) | TEST_F(ExceptionHandlerTest, DumpChildProcess) {
function TEST_F (line 273) | TEST_F(ExceptionHandlerTest, InstructionPointerMemory) {
function TEST_F (line 385) | TEST_F(ExceptionHandlerTest, InstructionPointerMemoryMinBound) {
function TEST_F (line 494) | TEST_F(ExceptionHandlerTest, InstructionPointerMemoryMaxBound) {
function TEST_F (line 607) | TEST_F(ExceptionHandlerTest, InstructionPointerMemoryNullPointer) {
function TEST_F (line 664) | TEST_F(ExceptionHandlerTest, MemoryListMultipleThreads) {
FILE: archive/spotify/breakpad/client/mac/tests/minidump_generator_test.cc
type google_breakpad (line 49) | namespace google_breakpad {
class MinidumpGeneratorTest (line 76) | class MinidumpGeneratorTest : public Test {
function TEST_F (line 89) | TEST_F(MinidumpGeneratorTest, InProcess) {
function TEST_F (line 137) | TEST_F(MinidumpGeneratorTest, OutOfProcess) {
function TEST_F (line 233) | TEST_F(MinidumpGeneratorTest, CrossArchitectureDump) {
FILE: archive/spotify/breakpad/client/mac/tests/minidump_generator_test_helper.cc
function main (line 44) | int main(int argc, char** argv) {
FILE: archive/spotify/breakpad/client/mac/tests/spawn_child_process.h
function namespace (line 51) | namespace google_breakpad_test {
FILE: archive/spotify/breakpad/client/mac/tests/testlogging.h
function namespace (line 5) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/minidump_file_writer-inl.h
function namespace (line 42) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/minidump_file_writer.cc
function MDRVA (line 209) | MDRVA MinidumpFileWriter::Allocate(size_t size) {
FILE: archive/spotify/breakpad/client/minidump_file_writer.h
function namespace (line 41) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/minidump_file_writer_unittest.cc
type StringStructure (line 56) | struct StringStructure {
type ArrayStructure (line 62) | struct ArrayStructure {
function WriteFile (line 73) | static bool WriteFile(const char *path) {
function CompareFile (line 114) | static bool CompareFile(const char *path) {
function RunTests (line 169) | static bool RunTests() {
function main (line 177) | int main(int argc, const char *argv[]) {
FILE: archive/spotify/breakpad/client/solaris/handler/exception_handler.cc
type google_breakpad (line 46) | namespace google_breakpad {
type sigaltstack (line 130) | struct sigaltstack
type sigaction (line 144) | struct sigaction
type sigaction (line 154) | struct sigaction
FILE: archive/spotify/breakpad/client/solaris/handler/exception_handler.h
function namespace (line 41) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/solaris/handler/exception_handler_test.cc
function foo2 (line 48) | static int foo2(int arg) {
function foo (line 56) | static int foo(int arg) {
function CreateCrashThread (line 78) | static void CreateCrashThread() {
function CreateThread (line 85) | static void CreateThread(int num) {
function MinidumpCallback (line 94) | static bool MinidumpCallback(const char *dump_path,
function main (line 107) | int main(int argc, char *argv[]) {
FILE: archive/spotify/breakpad/client/solaris/handler/minidump_generator.cc
type WriterArgument (line 52) | struct WriterArgument {
type FindCrashLwpContext (line 83) | struct FindCrashLwpContext {
method FindCrashLwpContext (line 88) | FindCrashLwpContext() :
function IsLwpCrashedCallback (line 99) | bool IsLwpCrashedCallback(lwpstatus_t *lsp, void *context) {
function FindCrashingLwp (line 122) | int FindCrashingLwp(uintptr_t crashing_stack_bottom,
function WriteLwpStack (line 134) | bool WriteLwpStack(const SolarisLwp *lwp_lister,
function WriteContext (line 154) | bool WriteContext(MDRawContextSPARC *context, ucontext_t *sig_ctx) {
function WriteContext (line 178) | bool WriteContext(MDRawContextSPARC *context, prgregset_t regs,
function WriteContext (line 198) | bool WriteContext(MDRawContextX86 *context, prgregset_t regs,
function WriteCrashedLwpStream (line 231) | bool WriteCrashedLwpStream(MinidumpFileWriter *minidump_writer,
function WriteLwpStream (line 272) | bool WriteLwpStream(MinidumpFileWriter *minidump_writer,
function WriteCPUInformation (line 312) | bool WriteCPUInformation(MDRawSystemInfo *sys_info) {
function WriteOSInformation (line 340) | bool WriteOSInformation(MinidumpFileWriter *minidump_writer,
type LwpInfoCallbackCtx (line 381) | struct LwpInfoCallbackCtx {
function LwpInformationCallback (line 388) | bool LwpInformationCallback(lwpstatus_t *lsp, void *context) {
function WriteLwpListStream (line 420) | bool WriteLwpListStream(MinidumpFileWriter *minidump_writer,
function WriteCVRecord (line 447) | bool WriteCVRecord(MinidumpFileWriter *minidump_writer,
type ModuleInfoCallbackCtx (line 491) | struct ModuleInfoCallbackCtx {
function ModuleInfoCallback (line 498) | bool ModuleInfoCallback(const ModuleInfo &module_info, void *context) {
function WriteModuleListStream (line 538) | bool WriteModuleListStream(MinidumpFileWriter *minidump_writer,
function WriteSystemInfoStream (line 561) | bool WriteSystemInfoStream(MinidumpFileWriter *minidump_writer,
function WriteExceptionStream (line 576) | bool WriteExceptionStream(MinidumpFileWriter *minidump_writer,
function WriteMiscInfoStream (line 628) | bool WriteMiscInfoStream(MinidumpFileWriter *minidump_writer,
function WriteBreakpadInfoStream (line 645) | bool WriteBreakpadInfoStream(MinidumpFileWriter *minidump_writer,
class AutoLwpResumer (line 663) | class AutoLwpResumer {
method AutoLwpResumer (line 665) | AutoLwpResumer(SolarisLwp *lwp) : lwp_(lwp) {}
type google_breakpad (line 743) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/solaris/handler/minidump_generator.h
function namespace (line 42) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/solaris/handler/minidump_test.cc
function SleepyFunction (line 57) | static void SleepyFunction() {
function main (line 63) | int main(int argc, char * const argv[]) {
FILE: archive/spotify/breakpad/client/solaris/handler/solaris_lwp.cc
type AddressValidatingContext (line 63) | struct AddressValidatingContext {
method AddressValidatingContext (line 67) | AddressValidatingContext() : address(0UL), is_mapped(false) {
function LocalAtoi (line 72) | static bool LocalAtoi(char *s, int *r) {
function AddressNotInModuleCallback (line 85) | static bool AddressNotInModuleCallback(const ModuleInfo &module_info,
function IterateLwpAll (line 99) | static int IterateLwpAll(int pid,
type frame (line 143) | struct frame
class AutoCloser (line 152) | class AutoCloser {
method AutoCloser (line 154) | AutoCloser(int fd) : fd_(fd) {}
function ControlLwp (line 162) | static bool ControlLwp(int lwpid, void *context) {
function read_lfile (line 196) | static bool read_lfile(int pid, const char *lname, prheader_t *lhp) {
type google_breakpad (line 227) | namespace google_breakpad {
type stat (line 303) | struct stat
type frame (line 416) | struct frame
type frame (line 419) | struct frame
type frame (line 424) | struct frame
FILE: archive/spotify/breakpad/client/solaris/handler/solaris_lwp.h
type ModuleInfo (line 64) | struct ModuleInfo {
function class (line 111) | class SolarisLwp {
FILE: archive/spotify/breakpad/client/windows/common/auto_critical_section.h
function namespace (line 35) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/windows/common/ipc_protocol.h
function namespace (line 40) | namespace google_breakpad {
type MessageTag (line 89) | enum MessageTag {
type CustomClientInfo (line 97) | struct CustomClientInfo {
type ProtocolMessage (line 103) | struct ProtocolMessage {
FILE: archive/spotify/breakpad/client/windows/crash_generation/client_info.cc
type google_breakpad (line 36) | namespace google_breakpad {
function CustomClientInfo (line 202) | CustomClientInfo ClientInfo::GetCustomInfo() const {
FILE: archive/spotify/breakpad/client/windows/crash_generation/client_info.h
function namespace (line 39) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/windows/crash_generation/crash_generation_client.cc
type google_breakpad (line 35) | namespace google_breakpad {
function HANDLE (line 187) | HANDLE CrashGenerationClient::ConnectToServer() {
function HANDLE (line 248) | HANDLE CrashGenerationClient::ConnectToPipe(const wchar_t* pipe_name,
FILE: archive/spotify/breakpad/client/windows/crash_generation/crash_generation_client.h
function namespace (line 40) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/windows/crash_generation/crash_generation_server.cc
type google_breakpad (line 39) | namespace google_breakpad {
function IsClientRequestValid (line 86) | static bool IsClientRequestValid(const ProtocolMessage& msg) {
function DWORD (line 824) | DWORD WINAPI CrashGenerationServer::CleanupClient(void* context) {
FILE: archive/spotify/breakpad/client/windows/crash_generation/crash_generation_server.h
function namespace (line 39) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/windows/crash_generation/minidump_generator.cc
type google_breakpad (line 37) | namespace google_breakpad {
function HMODULE (line 250) | HMODULE MinidumpGenerator::GetDbghelpModule() {
function HMODULE (line 272) | HMODULE MinidumpGenerator::GetRpcrt4Module() {
FILE: archive/spotify/breakpad/client/windows/crash_generation/minidump_generator.h
function namespace (line 38) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/windows/handler/exception_handler.cc
type google_breakpad (line 42) | namespace google_breakpad {
function DWORD (line 320) | DWORD ExceptionHandler::ExceptionHandlerThreadMain(void* lpParameter) {
class AutoExceptionHandler (line 355) | class AutoExceptionHandler {
method AutoExceptionHandler (line 357) | AutoExceptionHandler() {
method ExceptionHandler (line 400) | ExceptionHandler* get_handler() const { return handler_; }
function LONG (line 407) | LONG ExceptionHandler::HandleException(EXCEPTION_POINTERS* exinfo) {
function BOOL (line 837) | BOOL CALLBACK ExceptionHandler::MinidumpWriteDumpCallback(
FILE: archive/spotify/breakpad/client/windows/handler/exception_handler.h
function namespace (line 76) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/windows/sender/crash_report_sender.cc
type google_breakpad (line 44) | namespace google_breakpad {
function ReportResult (line 60) | ReportResult CrashReportSender::SendCrashReport(
FILE: archive/spotify/breakpad/client/windows/sender/crash_report_sender.h
type ReportResult (line 53) | typedef enum {
function set_max_reports_per_day (line 74) | void set_max_reports_per_day(int reports) {
FILE: archive/spotify/breakpad/client/windows/tests/crash_generation_app/abstract_class.cc
type google_breakpad (line 32) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/windows/tests/crash_generation_app/abstract_class.h
function namespace (line 33) | namespace google_breakpad {
FILE: archive/spotify/breakpad/client/windows/tests/crash_generation_app/crash_generation_app.cc
type google_breakpad (line 45) | namespace google_breakpad {
function ATOM (line 92) | ATOM MyRegisterClass(HINSTANCE instance) {
function BOOL (line 115) | BOOL InitInstance(HINSTANCE instance, int command_show) {
function AppendTextToEditBox (line 139) | static void AppendTextToEditBox(TCHAR* text) {
function DWORD (line 171) | static DWORD WINAPI AppendTextWorker(void* context) {
function ShowDumpResults (line 180) | bool ShowDumpResults(const wchar_t* dump_path,
function ShowClientConnected (line 200) | static void _cdecl ShowClientConnected(void* context,
function ShowClientCrashed (line 217) | static void _cdecl ShowClientCrashed(void* context,
function ShowClientExited (line 262) | static void _cdecl ShowClientExited(void* context,
function CrashServerStart (line 279) | void CrashServerStart() {
function CrashServerStop (line 306) | void CrashServerStop() {
function DerefZeroCrash (line 311) | void DerefZeroCrash() {
function InvalidParamCrash (line 316) | void InvalidParamCrash() {
function PureCallCrash (line 320) | void PureCallCrash() {
function RequestDump (line 324) | void RequestDump() {
function CleanUp (line 331) | void CleanUp() {
function LRESULT (line 351) | LRESULT CALLBACK WndProc(HWND wnd,
function INT_PTR (line 446) | INT_PTR CALLBACK About(HWND dlg,
function _tWinMain (line 468) | int APIENTRY _tWinMain(HINSTANCE instance,
FILE: archive/spotify/breakpad/client/windows/unittests/crash_generation_server_test.cc
class CrashGenerationServerTest (line 60) | class CrashGenerationServerTest : public ::testing::Test {
method CrashGenerationServerTest (line 62) | CrashGenerationServerTest()
class MockCrashGenerationServerCallbacks (line 77) | class MockCrashGenerationServerCallbacks {
type ClientFault (line 90) | enum ClientFault {
method SetUp (line 101) | void SetUp() {
method FaultyClient (line 105) | void FaultyClient(ClientFault fault_type) {
method DoTestFault (line 139) | void DoTestFault(ClientFault fault) {
method DoFaultyClient (line 162) | void DoFaultyClient(ClientFault fault_type, HANDLE pipe) {
method CallOnClientConnected (line 234) | static void CallOnClientConnected(
method CallOnClientDumpRequested (line 240) | static void CallOnClientDumpRequested(
method CallOnClientExited (line 248) | static void CallOnClientExited(
method CallOnClientUploadRequested (line 254) | static void CallOnClientUploadRequested(void* context, const DWORD cra...
function TEST_F (line 266) | TEST_F(CrashGenerationServerTest, PingServerTest) {
function TEST_F (line 270) | TEST_F(CrashGenerationServerTest, InvalidRegistration) {
function TEST_F (line 274) | TEST_F(CrashGenerationServerTest, TruncateRegistration) {
function TEST_F (line 278) | TEST_F(CrashGenerationServerTest, CloseAfterRegistration) {
function TEST_F (line 282) | TEST_F(CrashGenerationServerTest, ResponseBufferTooSmall) {
function TEST_F (line 286) | TEST_F(CrashGenerationServerTest, CloseAfterResponse) {
function TEST_F (line 292) | TEST_F(CrashGenerationServerTest, SendInvalidAck) {
FILE: archive/spotify/breakpad/client/windows/unittests/dump_analysis.h
type FakeTEB (line 36) | struct FakeTEB {
function class (line 41) | class DumpAnalysis {
FILE: archive/spotify/breakpad/client/windows/unittests/exception_handler_death_test.cc
class ExceptionHandlerDeathTest (line 56) | class ExceptionHandlerDeathTest : public ::testing::Test {
function BOOL (line 89) | BOOL DoesPathExist(const TCHAR *path_name) {
function MinidumpWrittenCallback (line 97) | bool MinidumpWrittenCallback(const wchar_t* dump_path,
function TEST_F (line 114) | TEST_F(ExceptionHandlerDeathTest, InProcTest) {
function clientDumpCallback (line 132) | void clientDumpCallback(void *dump_context,
function TEST_F (line 152) | TEST_F(ExceptionHandlerDeathTest, OutOfProcTest) {
function TEST_F (line 176) | TEST_F(ExceptionHandlerDeathTest, InvalidParameterTest) {
type PureVirtualCallBase (line 192) | struct PureVirtualCallBase {
method PureVirtualCallBase (line 193) | PureVirtualCallBase() {
type PureVirtualCall (line 201) | struct PureVirtualCall : public PureVirtualCallBase {
method PureVirtualCall (line 202) | PureVirtualCall() { PureFunction(); }
method PureFunction (line 203) | virtual void PureFunction() const {}
function TEST_F (line 210) | TEST_F(ExceptionHandlerDeathTest, PureVirtualCallTest) {
function wstring (line 224) | wstring find_minidump_in_directory(const wstring &directory) {
function TEST_F (line 248) | TEST_F(ExceptionHandlerDeathTest, InstructionPointerMemory) {
function TEST_F (line 340) | TEST_F(ExceptionHandlerDeathTest, InstructionPointerMemoryMinBound) {
function TEST_F (line 437) | TEST_F(ExceptionHandlerDeathTest, InstructionPointerMemoryMaxBound) {
FILE: archive/spotify/breakpad/client/windows/unittests/exception_handler_test.cc
class ExceptionHandlerTest (line 59) | class ExceptionHandlerTest : public ::testing::Test {
function BOOL (line 129) | BOOL ExceptionHandlerTest::DoesPathExist(const TCHAR *path_name) {
type PureVirtualCallBase (line 179) | struct PureVirtualCallBase {
method PureVirtualCallBase (line 180) | PureVirtualCallBase() {
type PureVirtualCall (line 188) | struct PureVirtualCall : public PureVirtualCallBase {
method PureVirtualCall (line 189) | PureVirtualCall() { PureFunction(); }
method PureFunction (line 190) | virtual void PureFunction() const {}
function TEST_F (line 216) | TEST_F(ExceptionHandlerTest, InvalidParameterMiniDumpTest) {
function TEST_F (line 287) | TEST_F(ExceptionHandlerTest, PureVirtualCallMiniDumpTest) {
function TEST_F (line 358) | TEST_F(ExceptionHandlerTest, WriteMinidumpTest) {
FILE: archive/spotify/breakpad/client/windows/unittests/minidump_test.cc
class MinidumpTest (line 59) | class MinidumpTest: public testing::Test {
method MinidumpTest (line 61) | MinidumpTest() {
method SetUp (line 67) | virtual void SetUp() {
method TearDown (line 78) | virtual void TearDown() {
method WriteDump (line 89) | bool WriteDump(ULONG flags) {
function HasFileInfo (line 131) | bool HasFileInfo(const std::wstring& file_path) {
function TEST_F (line 163) | TEST_F(MinidumpTest, Version) {
function TEST_F (line 179) | TEST_F(MinidumpTest, Normal) {
function TEST_F (line 211) | TEST_F(MinidumpTest, SmallDump) {
function TEST_F (line 242) | TEST_F(MinidumpTest, LargerDump) {
function TEST_F (line 274) | TEST_F(MinidumpTest, FullDump) {
FILE: archive/spotify/breakpad/common/byte_cursor.h
function namespace (line 48) | namespace google_breakpad {
function class (line 79) | class ByteCursor {
function set_big_endian (line 89) | void set_big_endian(bool big_endian) { big_endian_ = big_endian; }
FILE: archive/spotify/breakpad/common/byte_cursor_unittest.cc
function TEST (line 46) | TEST(Buffer, SizeOfNothing) {
function TEST (line 52) | TEST(Buffer, SizeOfSomething) {
function TEST (line 58) | TEST(Extent, AvailableEmpty) {
function TEST (line 65) | TEST(Extent, AtEndEmpty) {
function TEST (line 72) | TEST(Extent, AsBoolEmpty) {
function TEST (line 79) | TEST(Extent, AvailableSome) {
function TEST (line 86) | TEST(Extent, AtEndSome) {
function TEST (line 94) | TEST(Extent, AsBoolSome) {
function TEST (line 103) | TEST(Extent, Cursor) {
function TEST (line 139) | TEST(Extent, SetOffset) {
function TEST (line 157) | TEST(BigEndian, Signed1) {
function TEST (line 176) | TEST(BigEndian, Signed2) {
function TEST (line 206) | TEST(BigEndian, Signed4) {
function TEST (line 234) | TEST(BigEndian, Signed8) {
function TEST (line 261) | TEST(BigEndian, Unsigned1) {
function TEST (line 280) | TEST(BigEndian, Unsigned2) {
function TEST (line 310) | TEST(BigEndian, Unsigned4) {
function TEST (line 338) | TEST(BigEndian, Unsigned8) {
function TEST (line 365) | TEST(LittleEndian, Signed1) {
function TEST (line 383) | TEST(LittleEndian, Signed2) {
function TEST (line 413) | TEST(LittleEndian, Signed4) {
function TEST (line 440) | TEST(LittleEndian, Signed8) {
function TEST (line 467) | TEST(LittleEndian, Unsigned1) {
function TEST (line 485) | TEST(LittleEndian, Unsigned2) {
function TEST (line 515) | TEST(LittleEndian, Unsigned4) {
function TEST (line 542) | TEST(LittleEndian, Unsigned8) {
function TEST (line 569) | TEST(Extractor, Signed1) {
function TEST (line 579) | TEST(Extractor, Signed2) {
function TEST (line 589) | TEST(Extractor, Signed4) {
function TEST (line 603) | TEST(Extractor, Unsigned1) {
function TEST (line 613) | TEST(Extractor, Unsigned2) {
function TEST (line 623) | TEST(Extractor, Unsigned4) {
function TEST (line 638) | TEST(Extractor, Mixed) {
function TEST (line 675) | TEST(Strings, Zero) {
function TEST (line 686) | TEST(Strings, Some) {
function TEST (line 697) | TEST(Strings, TooMuch) {
function TEST (line 716) | TEST(Strings, PointTo) {
function TEST (line 736) | TEST(Strings, CString) {
function TEST (line 750) | TEST(Strings, CStringLimit) {
FILE: archive/spotify/breakpad/common/convert_UTF.c
function ConversionResult (line 61) | ConversionResult ConvertUTF32toUTF16 (const UTF32** sourceStart, const U...
function ConversionResult (line 109) | ConversionResult ConvertUTF16toUTF32 (const UTF16** sourceStart, const U...
function ConversionResult (line 212) | ConversionResult ConvertUTF16toUTF8 (const UTF16** sourceStart, const UT...
function Boolean (line 292) | static Boolean isLegalUTF8(const UTF8 *source, int length) {
function Boolean (line 323) | Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) {
function ConversionResult (line 333) | ConversionResult ConvertUTF8toUTF16 (const UTF8** sourceStart, const UTF...
function ConversionResult (line 405) | ConversionResult ConvertUTF32toUTF8 (const UTF32** sourceStart, const UT...
function ConversionResult (line 457) | ConversionResult ConvertUTF8toUTF32 (const UTF8** sourceStart, const UTF...
FILE: archive/spotify/breakpad/common/convert_UTF.h
type UTF32 (line 90) | typedef unsigned long UTF32;
type UTF16 (line 91) | typedef unsigned short UTF16;
type UTF8 (line 92) | typedef unsigned char UTF8;
type Boolean (line 93) | typedef unsigned char Boolean;
type ConversionResult (line 102) | typedef enum {
type ConversionFlags (line 109) | typedef enum {
FILE: archive/spotify/breakpad/common/dwarf/bytereader-inl.h
function namespace (line 36) | namespace dwarf2reader {
FILE: archive/spotify/breakpad/common/dwarf/bytereader.cc
type dwarf2reader (line 35) | namespace dwarf2reader {
type Endianness (line 37) | enum Endianness
function uint64 (line 65) | uint64 ByteReader::ReadInitialLength(const char* start, size_t* len) {
function uint64 (line 103) | uint64 ByteReader::ReadEncodedPointer(const char *buffer,
FILE: archive/spotify/breakpad/common/dwarf/bytereader.h
function namespace (line 38) | namespace dwarf2reader {
FILE: archive/spotify/breakpad/common/dwarf/bytereader_unittest.cc
type ReaderFixture (line 53) | struct ReaderFixture {
class Reader (line 58) | class Reader: public ReaderFixture, public Test { }
class ReaderDeathTest (line 59) | class ReaderDeathTest: public ReaderFixture, public Test { }
function TEST_F (line 61) | TEST_F(Reader, SimpleConstructor) {
function TEST_F (line 89) | TEST_F(Reader, ValidEncodings) {
function TEST_F (line 377) | TEST_F(ReaderDeathTest, DW_EH_PE_omit) {
function TEST_F (line 386) | TEST_F(Reader, DW_EH_PE_absptr4) {
function TEST_F (line 396) | TEST_F(Reader, DW_EH_PE_absptr8) {
function TEST_F (line 408) | TEST_F(Reader, DW_EH_PE_uleb128) {
function TEST_F (line 418) | TEST_F(Reader, DW_EH_PE_udata2) {
function TEST_F (line 428) | TEST_F(Reader, DW_EH_PE_udata4) {
function TEST_F (line 438) | TEST_F(Reader, DW_EH_PE_udata8Addr8) {
function TEST_F (line 450) | TEST_F(Reader, DW_EH_PE_udata8Addr4) {
function TEST_F (line 462) | TEST_F(Reader, DW_EH_PE_sleb128) {
function TEST_F (line 472) | TEST_F(Reader, DW_EH_PE_sdata2) {
function TEST_F (line 482) | TEST_F(Reader, DW_EH_PE_sdata4) {
function TEST_F (line 492) | TEST_F(Reader, DW_EH_PE_sdata8) {
function TEST_F (line 504) | TEST_F(Reader, DW_EH_PE_pcrel) {
function TEST_F (line 517) | TEST_F(Reader, DW_EH_PE_textrel) {
function TEST_F (line 530) | TEST_F(Reader, DW_EH_PE_datarel) {
function TEST_F (line 543) | TEST_F(Reader, DW_EH_PE_funcrel) {
function TEST (line 556) | TEST(UsableBase, CFI) {
function TEST (line 569) | TEST(UsableBase, Text) {
function TEST (line 581) | TEST(UsableBase, Data) {
function TEST (line 593) | TEST(UsableBase, Function) {
function TEST (line 605) | TEST(UsableBase, ClearFunction) {
type AlignedFixture (line 618) | struct AlignedFixture {
method AlignedFixture (line 619) | AlignedFixture() : reader(ENDIANNESS_BIG) { reader.SetAddressSize(4); }
class Aligned (line 629) | class Aligned: public AlignedFixture, public Test { }
function TEST_F (line 631) | TEST_F(Aligned, DW_EH_PE_aligned0) {
function TEST_F (line 639) | TEST_F(Aligned, DW_EH_PE_aligned1) {
function TEST_F (line 647) | TEST_F(Aligned, DW_EH_PE_aligned2) {
function TEST_F (line 655) | TEST_F(Aligned, DW_EH_PE_aligned3) {
function TEST_F (line 663) | TEST_F(Aligned, DW_EH_PE_aligned11) {
function TEST_F (line 672) | TEST_F(Aligned, DW_EH_PE_aligned30) {
function TEST_F (line 681) | TEST_F(Aligned, DW_EH_PE_aligned23) {
function TEST_F (line 690) | TEST_F(Aligned, DW_EH_PE_aligned03) {
FILE: archive/spotify/breakpad/common/dwarf/cfi_assembler.cc
type google_breakpad (line 40) | namespace google_breakpad {
function CFISection (line 44) | CFISection &CFISection::CIEHeader(u_int64_t code_alignment_factor,
function CFISection (line 75) | CFISection &CFISection::FDEHeader(Label cie_pointer,
function CFISection (line 110) | CFISection &CFISection::FinishEntry() {
function CFISection (line 120) | CFISection &CFISection::EncodedPointer(u_int64_t address,
FILE: archive/spotify/breakpad/common/dwarf/cfi_assembler.h
function namespace (line 46) | namespace google_breakpad {
function SetPointerEncoding (line 116) | void SetPointerEncoding(DwarfPointerEncoding encoding) {
function SetEncodedPointerBases (line 123) | void SetEncodedPointerBases(const EncodedPointerBases &bases) {
type PendingLength (line 217) | struct PendingLength {
FILE: archive/spotify/breakpad/common/dwarf/dwarf2diehandler.cc
type dwarf2reader (line 38) | namespace dwarf2reader {
type DwarfTag (line 57) | enum DwarfTag
type DwarfAttribute (line 136) | enum DwarfAttribute
type DwarfForm (line 137) | enum DwarfForm
type DwarfAttribute (line 146) | enum DwarfAttribute
type DwarfForm (line 147) | enum DwarfForm
type DwarfAttribute (line 156) | enum DwarfAttribute
type DwarfForm (line 157) | enum DwarfForm
type DwarfAttribute (line 166) | enum DwarfAttribute
type DwarfForm (line 167) | enum DwarfForm
type DwarfAttribute (line 177) | enum DwarfAttribute
type DwarfForm (line 178) | enum DwarfForm
type DwarfAttribute (line 187) | enum DwarfAttribute
type DwarfForm (line 188) | enum DwarfForm
FILE: archive/spotify/breakpad/common/dwarf/dwarf2diehandler.h
function namespace (line 165) | namespace dwarf2reader {
FILE: archive/spotify/breakpad/common/dwarf/dwarf2diehandler_unittest.cc
class MockDIEHandler (line 62) | class MockDIEHandler: public DIEHandler {
class MockRootDIEHandler (line 82) | class MockRootDIEHandler: public RootDIEHandler {
function TEST (line 106) | TEST(Dwarf2DIEHandler, SkipCompilationUnit) {
function TEST (line 127) | TEST(Dwarf2DIEHandler, SkipRootDIE) {
function TEST (line 159) | TEST(Dwarf2DIEHandler, SkipRootDIEChildren) {
function TEST (line 198) | TEST(Dwarf2DIEHandler, PassAttributeValues) {
function TEST (line 306) | TEST(Dwarf2DIEHandler, FindAndSkipChildren) {
function TEST (line 477) | TEST(Dwarf2DIEHandler, FreeHandlersOnStack) {
FILE: archive/spotify/breakpad/common/dwarf/dwarf2enums.h
function namespace (line 34) | namespace dwarf2reader {
FILE: archive/spotify/breakpad/common/dwarf/dwarf2reader.cc
type dwarf2reader (line 50) | namespace dwarf2reader {
type DwarfTag (line 104) | enum DwarfTag
type DwarfAttribute (line 122) | enum DwarfAttribute
type DwarfAttribute (line 123) | enum DwarfAttribute
type DwarfForm (line 124) | enum DwarfForm
type DwarfForm (line 124) | enum DwarfForm
type DwarfForm (line 145) | enum DwarfForm
type DwarfForm (line 150) | enum DwarfForm
function uint64 (line 249) | uint64 CompilationUnit::Start() {
type DwarfAttribute (line 306) | enum DwarfAttribute
type DwarfForm (line 307) | enum DwarfForm
type DwarfForm (line 314) | enum DwarfForm
type DwarfTag (line 500) | enum DwarfTag
function uint64 (line 522) | uint64 LineInfo::Start() {
type LineInfoHeader (line 615) | struct LineInfoHeader
type LineStateMachine (line 617) | struct LineStateMachine
type LineStateMachine (line 800) | struct LineStateMachine
class CallFrameInfo::Rule (line 866) | class CallFrameInfo::Rule {
method SetBaseRegister (line 888) | virtual void SetBaseRegister(unsigned reg) { }
method SetOffset (line 892) | virtual void SetOffset(long long offset) { }
class CallFrameInfo::UndefinedRule (line 896) | class CallFrameInfo::UndefinedRule: public CallFrameInfo::Rule {
method UndefinedRule (line 898) | UndefinedRule() { }
method Handle (line 900) | bool Handle(Handler *handler, uint64 address, int reg) const {
method Rule (line 909) | Rule *Copy() const { return new UndefinedRule(*this); }
class CallFrameInfo::SameValueRule (line 913) | class CallFrameInfo::SameValueRule: public CallFrameInfo::Rule {
method SameValueRule (line 915) | SameValueRule() { }
method Handle (line 917) | bool Handle(Handler *handler, uint64 address, int reg) const {
method Rule (line 926) | Rule *Copy() const { return new SameValueRule(*this); }
class CallFrameInfo::OffsetRule (line 931) | class CallFrameInfo::OffsetRule: public CallFrameInfo::Rule {
method OffsetRule (line 933) | OffsetRule(int base_register, long offset)
method Handle (line 936) | bool Handle(Handler *handler, uint64 address, int reg) const {
method Rule (line 947) | Rule *Copy() const { return new OffsetRule(*this); }
class CallFrameInfo::ValOffsetRule (line 960) | class CallFrameInfo::ValOffsetRule: public CallFrameInfo::Rule {
method ValOffsetRule (line 962) | ValOffsetRule(int base_register, long offset)
method Handle (line 965) | bool Handle(Handler *handler, uint64 address, int reg) const {
method Rule (line 976) | Rule *Copy() const { return new ValOffsetRule(*this); }
method SetBaseRegister (line 977) | void SetBaseRegister(unsigned reg) { base_register_ = reg; }
method SetOffset (line 978) | void SetOffset(long long offset) { offset_ = offset; }
class CallFrameInfo::RegisterRule (line 985) | class CallFrameInfo::RegisterRule: public CallFrameInfo::Rule {
method RegisterRule (line 987) | explicit RegisterRule(int register_number)
method Handle (line 990) | bool Handle(Handler *handler, uint64 address, int reg) const {
method Rule (line 999) | Rule *Copy() const { return new RegisterRule(*this); }
class CallFrameInfo::ExpressionRule (line 1005) | class CallFrameInfo::ExpressionRule: public CallFrameInfo::Rule {
method ExpressionRule (line 1007) | explicit ExpressionRule(const std::string &expression)
method Handle (line 1010) | bool Handle(Handler *handler, uint64 address, int reg) const {
method Rule (line 1019) | Rule *Copy() const { return new ExpressionRule(*this); }
class CallFrameInfo::ValExpressionRule (line 1025) | class CallFrameInfo::ValExpressionRule: public CallFrameInfo::Rule {
method ValExpressionRule (line 1027) | explicit ValExpressionRule(const std::string &expression)
method Handle (line 1030) | bool Handle(Handler *handler, uint64 address, int reg) const {
method Rule (line 1040) | Rule *Copy() const { return new ValExpressionRule(*this); }
class CallFrameInfo::RuleMap (line 1046) | class CallFrameInfo::RuleMap {
method RuleMap (line 1048) | RuleMap() : cfa_rule_(NULL) { }
method RuleMap (line 1049) | RuleMap(const RuleMap &rhs) : cfa_rule_(NULL) { *this = rhs; }
method SetCFARule (line 1055) | void SetCFARule(Rule *rule) { delete cfa_rule_; cfa_rule_ = rule; }
method Rule (line 1061) | Rule *CFARule() const { return cfa_rule_; }
class CallFrameInfo::State (line 1199) | class CallFrameInfo::State {
method State (line 1203) | State(ByteReader *reader, Handler *handler, Reporter *reporter,
type Operands (line 1219) | struct Operands {
method uint64 (line 1287) | uint64 CursorOffset() { return entry_->offset + (cursor_ - entry_->s...
method ReportIncomplete (line 1290) | bool ReportIncomplete() {
FILE: archive/spotify/breakpad/common/dwarf/dwarf2reader.h
function namespace (line 53) | namespace dwarf2reader {
FILE: archive/spotify/breakpad/common/dwarf/dwarf2reader_cfi_unittest.cc
class MockCallFrameInfoHandler (line 99) | class MockCallFrameInfoHandler: public CallFrameInfo::Handler {
class MockCallFrameErrorReporter (line 121) | class MockCallFrameErrorReporter: public CallFrameInfo::Reporter {
method MockCallFrameErrorReporter (line 123) | MockCallFrameErrorReporter() : Reporter("mock filename", "mock section...
type CFIFixture (line 138) | struct CFIFixture {
method CFIFixture (line 142) | CFIFixture() {
class CFI (line 184) | class CFI: public CFIFixture, public Test { }
function TEST_F (line 186) | TEST_F(CFI, EmptyRegion) {
function TEST_F (line 196) | TEST_F(CFI, IncompleteLength32) {
function TEST_F (line 221) | TEST_F(CFI, IncompleteLength64) {
function TEST_F (line 246) | TEST_F(CFI, IncompleteId32) {
function TEST_F (line 270) | TEST_F(CFI, BadId32) {
function TEST_F (line 297) | TEST_F(CFI, SingleCIE) {
function TEST_F (line 318) | TEST_F(CFI, OneFDE) {
function TEST_F (line 348) | TEST_F(CFI, TwoFDEsOneCIE) {
function TEST_F (line 391) | TEST_F(CFI, TwoFDEsTwoCIEs) {
function TEST_F (line 440) | TEST_F(CFI, BadVersion) {
function TEST_F (line 484) | TEST_F(CFI, BadAugmentation) {
function TEST_F (line 529) | TEST_F(CFI, CIEVersion1ReturnColumn) {
function TEST_F (line 563) | TEST_F(CFI, CIEVersion3ReturnColumn) {
type CFIInsnFixture (line 595) | struct CFIInsnFixture: public CFIFixture {
method CFIInsnFixture (line 596) | CFIInsnFixture() : CFIFixture() {
method StockCIEAndFDE (line 619) | void StockCIEAndFDE(CFISection *section) {
method ParseSection (line 659) | void ParseSection(CFISection *section, bool succeeds = true) {
class CFIInsn (line 690) | class CFIInsn: public CFIInsnFixture, public Test { }
function TEST_F (line 692) | TEST_F(CFIInsn, DW_CFA_set_loc) {
function TEST_F (line 713) | TEST_F(CFIInsn, DW_CFA_advance_loc) {
function TEST_F (line 735) | TEST_F(CFIInsn, DW_CFA_advance_loc1) {
function TEST_F (line 755) | TEST_F(CFIInsn, DW_CFA_advance_loc2) {
function TEST_F (line 775) | TEST_F(CFIInsn, DW_CFA_advance_loc4) {
function TEST_F (line 795) | TEST_F(CFIInsn, DW_CFA_MIPS_advance_loc8) {
function TEST_F (line 816) | TEST_F(CFIInsn, DW_CFA_def_cfa) {
function TEST_F (line 833) | TEST_F(CFIInsn, DW_CFA_def_cfa_sf) {
function TEST_F (line 854) | TEST_F(CFIInsn, DW_CFA_def_cfa_register) {
function TEST_F (line 871) | TEST_F(CFIInsn, DW_CFA_def_cfa_registerBadRule) {
function TEST_F (line 888) | TEST_F(CFIInsn, DW_CFA_def_cfa_offset) {
function TEST_F (line 904) | TEST_F(CFIInsn, DW_CFA_def_cfa_offset_sf) {
function TEST_F (line 927) | TEST_F(CFIInsn, DW_CFA_def_cfa_offsetBadRule) {
function TEST_F (line 943) | TEST_F(CFIInsn, DW_CFA_def_cfa_expression) {
function TEST_F (line 958) | TEST_F(CFIInsn, DW_CFA_undefined) {
function TEST_F (line 972) | TEST_F(CFIInsn, DW_CFA_same_value) {
function TEST_F (line 986) | TEST_F(CFIInsn, DW_CFA_offset) {
function TEST_F (line 1001) | TEST_F(CFIInsn, DW_CFA_offset_extended) {
function TEST_F (line 1016) | TEST_F(CFIInsn, DW_CFA_offset_extended_sf) {
function TEST_F (line 1039) | TEST_F(CFIInsn, DW_CFA_val_offset) {
function TEST_F (line 1055) | TEST_F(CFIInsn, DW_CFA_val_offset_sf) {
function TEST_F (line 1076) | TEST_F(CFIInsn, DW_CFA_register) {
function TEST_F (line 1090) | TEST_F(CFIInsn, DW_CFA_expression) {
function TEST_F (line 1107) | TEST_F(CFIInsn, DW_CFA_val_expression) {
function TEST_F (line 1124) | TEST_F(CFIInsn, DW_CFA_restore) {
function TEST_F (line 1181) | TEST_F(CFIInsn, DW_CFA_restoreNoRule) {
function TEST_F (line 1230) | TEST_F(CFIInsn, DW_CFA_restore_extended) {
function TEST_F (line 1290) | TEST_F(CFIInsn, DW_CFA_remember_and_restore_state) {
function TEST_F (line 1364) | TEST_F(CFIInsn, DW_CFA_remember_and_restore_stateCFA) {
function TEST_F (line 1388) | TEST_F(CFIInsn, DW_CFA_nop) {
function TEST_F (line 1405) | TEST_F(CFIInsn, DW_CFA_GNU_window_save) {
function TEST_F (line 1430) | TEST_F(CFIInsn, DW_CFA_GNU_args_size) {
function TEST_F (line 1447) | TEST_F(CFIInsn, DW_CFA_GNU_negative_offset_extended) {
function TEST_F (line 1465) | TEST_F(CFIInsn, SkipFDE) {
function TEST_F (line 1521) | TEST_F(CFIInsn, QuitMidentry) {
class CFIRestore (line 1537) | class CFIRestore: public CFIInsnFixture, public Test { }
function TEST_F (line 1539) | TEST_F(CFIRestore, RestoreUndefinedRuleUnchanged) {
function TEST_F (line 1556) | TEST_F(CFIRestore, RestoreUndefinedRuleChanged) {
function TEST_F (line 1579) | TEST_F(CFIRestore, RestoreSameValueRuleUnchanged) {
function TEST_F (line 1596) | TEST_F(CFIRestore, RestoreSameValueRuleChanged) {
function TEST_F (line 1619) | TEST_F(CFIRestore, RestoreOffsetRuleUnchanged) {
function TEST_F (line 1637) | TEST_F(CFIRestore, RestoreOffsetRuleChanged) {
function TEST_F (line 1662) | TEST_F(CFIRestore, RestoreOffsetRuleChangedOffset) {
function TEST_F (line 1688) | TEST_F(CFIRestore, RestoreValOffsetRuleUnchanged) {
function TEST_F (line 1706) | TEST_F(CFIRestore, RestoreValOffsetRuleChanged) {
function TEST_F (line 1731) | TEST_F(CFIRestore, RestoreValOffsetRuleChangedValOffset) {
function TEST_F (line 1757) | TEST_F(CFIRestore, RestoreRegisterRuleUnchanged) {
function TEST_F (line 1774) | TEST_F(CFIRestore, RestoreRegisterRuleChanged) {
function TEST_F (line 1798) | TEST_F(CFIRestore, RestoreRegisterRuleChangedRegister) {
function TEST_F (line 1823) | TEST_F(CFIRestore, RestoreExpressionRuleUnchanged) {
function TEST_F (line 1840) | TEST_F(CFIRestore, RestoreExpressionRuleChanged) {
function TEST_F (line 1864) | TEST_F(CFIRestore, RestoreExpressionRuleChangedExpression) {
function TEST_F (line 1890) | TEST_F(CFIRestore, RestoreValExpressionRuleUnchanged) {
function TEST_F (line 1908) | TEST_F(CFIRestore, RestoreValExpressionRuleChanged) {
function TEST_F (line 1935) | TEST_F(CFIRestore, RestoreValExpressionRuleChangedValExpression) {
type EHFrameFixture (line 1966) | struct EHFrameFixture: public CFIInsnFixture {
method EHFrameFixture (line 1967) | EHFrameFixture()
method ParseEHFrameSection (line 1979) | void ParseEHFrameSection(CFISection *section, bool succeeds = true) {
class EHFrame (line 2005) | class EHFrame: public EHFrameFixture, public Test { }
function TEST_F (line 2008) | TEST_F(EHFrame, Terminator) {
function TEST_F (line 2041) | TEST_F(EHFrame, SimpleFDE) {
function TEST_F (line 2093) | TEST_F(EHFrame, EmptyZ) {
function TEST_F (line 2122) | TEST_F(EHFrame, BadZ) {
function TEST_F (line 2144) | TEST_F(EHFrame, zL) {
function TEST_F (line 2174) | TEST_F(EHFrame, zP) {
function TEST_F (line 2203) | TEST_F(EHFrame, zR) {
function TEST_F (line 2230) | TEST_F(EHFrame, zS) {
type CFIReporterFixture (line 2255) | struct CFIReporterFixture {
method CFIReporterFixture (line 2256) | CFIReporterFixture() : reporter("test file name", "test section name")...
class CFIReporter (line 2260) | class CFIReporter: public CFIReporterFixture, public Test { }
function TEST_F (line 2262) | TEST_F(CFIReporter, Incomplete) {
function TEST_F (line 2266) | TEST_F(CFIReporter, EarlyEHTerminator) {
function TEST_F (line 2270) | TEST_F(CFIReporter, CIEPointerOutOfRange) {
function TEST_F (line 2274) | TEST_F(CFIReporter, BadCIEId) {
function TEST_F (line 2278) | TEST_F(CFIReporter, UnrecognizedVersion) {
function TEST_F (line 2282) | TEST_F(CFIReporter, UnrecognizedAugmentation) {
function TEST_F (line 2286) | TEST_F(CFIReporter, InvalidPointerEncoding) {
function TEST_F (line 2290) | TEST_F(CFIReporter, UnusablePointerEncoding) {
function TEST_F (line 2294) | TEST_F(CFIReporter, RestoreInCIE) {
function TEST_F (line 2298) | TEST_F(CFIReporter, BadInstruction) {
function TEST_F (line 2303) | TEST_F(CFIReporter, NoCFARule) {
function TEST_F (line 2308) | TEST_F(CFIReporter, EmptyStateStack) {
function TEST_F (line 2313) | TEST_F(CFIReporter, ClearingCFARule) {
type ELFSectionHeader (line 2323) | struct ELFSectionHeader {
method ELFSectionHeader (line 2324) | ELFSectionHeader(unsigned int set_type)
function AppendSectionHeader (line 2339) | void AppendSectionHeader(CFISection *table, const ELFSectionHeader &head...
function WriteELFFrameSection (line 2353) | void WriteELFFrameSection(const char *filename, const char *cfi_name,
FILE: archive/spotify/breakpad/common/dwarf/dwarf2reader_die_unittest.cc
class MockDwarf2Handler (line 74) | class MockDwarf2Handler: public Dwarf2Handler {
type DwarfTag (line 79) | enum DwarfTag
type DwarfForm (line 83) | enum DwarfForm
type DwarfAttribute (line 86) | enum DwarfAttribute
type DwarfForm (line 87) | enum DwarfForm
type DwarfAttribute (line 90) | enum DwarfAttribute
type DwarfForm (line 91) | enum DwarfForm
type DwarfAttribute (line 94) | enum DwarfAttribute
type DwarfForm (line 95) | enum DwarfForm
type DwarfAttribute (line 99) | enum DwarfAttribute
type DwarfForm (line 100) | enum DwarfForm
type DwarfForm (line 104) | enum DwarfForm
type DIEFixture (line 109) | struct DIEFixture {
method DIEFixture (line 111) | DIEFixture() {
method SectionMap (line 131) | const SectionMap &MakeSectionMap() {
type DwarfHeaderParams (line 151) | struct DwarfHeaderParams {
method DwarfHeaderParams (line 152) | DwarfHeaderParams(Endianness endianness, size_t format_size,
class DwarfHeader (line 162) | class DwarfHeader: public DIEFixture,
function TEST_P (line 165) | TEST_P(DwarfHeader, Header) {
type DwarfFormsFixture (line 232) | struct DwarfFormsFixture: public DIEFixture {
method StartSingleAttributeDIE (line 237) | void StartSingleAttributeDIE(const DwarfHeaderParams ¶ms,
method ExpectBeginCompilationUnit (line 257) | void ExpectBeginCompilationUnit(const DwarfHeaderParams ¶ms,
method ExpectEndCompilationUnit (line 270) | void ExpectEndCompilationUnit() {
method ParseCompilationUnit (line 276) | void ParseCompilationUnit(const DwarfHeaderParams ¶ms, uint64 offs...
type DwarfForms (line 287) | struct DwarfForms: public DwarfFormsFixture,
function TEST_P (line 290) | TEST_P(DwarfForms, addr) {
function TEST_P (line 315) | TEST_P(DwarfForms, block2_empty) {
function TEST_P (line 333) | TEST_P(DwarfForms, block2) {
function TEST_P (line 354) | TEST_P(DwarfForms, flag_present) {
function TEST_P (line 373) | TEST_P(DwarfForms, sec_offset) {
function TEST_P (line 398) | TEST_P(DwarfForms, exprloc) {
function TEST_P (line 417) | TEST_P(DwarfForms, ref_sig8) {
function TEST_P (line 440) | TEST_P(DwarfForms, ref_sig8_not_first) {
FILE: archive/spotify/breakpad/common/dwarf/dwarf2reader_test_common.h
function class (line 46) | class TestCompilationUnit: public google_breakpad::test_assembler::Secti...
function class (line 108) | class TestAbbrevTable: public google_breakpad::test_assembler::Section {
FILE: archive/spotify/breakpad/common/dwarf/functioninfo.cc
type dwarf2reader (line 46) | namespace dwarf2reader {
type DwarfTag (line 125) | enum DwarfTag
type DwarfAttribute (line 150) | enum DwarfAttribute
type DwarfForm (line 151) | enum DwarfForm
type DwarfAttribute (line 162) | enum DwarfAttribute
type DwarfForm (line 163) | enum DwarfForm
type DwarfAttribute (line 195) | enum DwarfAttribute
type DwarfForm (line 196) | enum DwarfForm
FILE: archive/spotify/breakpad/common/dwarf/functioninfo.h
function namespace (line 45) | namespace dwarf2reader {
FILE: archive/spotify/breakpad/common/dwarf/line_state_machine.h
function namespace (line 33) | namespace dwarf2reader {
FILE: archive/spotify/breakpad/common/dwarf/types.h
type int8 (line 38) | typedef signed char int8;
type int16 (line 39) | typedef short int16;
type int32 (line 40) | typedef int int32;
type int64 (line 41) | typedef long long int64;
type uint8 (line 43) | typedef unsigned char uint8;
type uint16 (line 44) | typedef unsigned short uint16;
type uint32 (line 45) | typedef unsigned int uint32;
type uint64 (line 46) | typedef unsigned long long uint64;
type __PTRDIFF_TYPE__ (line 49) | typedef __PTRDIFF_TYPE__ intptr;
type uintptr (line 50) | typedef unsigned __PTRDIFF_TYPE__ uintptr;
FILE: archive/spotify/breakpad/common/dwarf_cfi_to_module.cc
type google_breakpad (line 41) | namespace google_breakpad {
function string (line 125) | string DwarfCFIToModule::RegisterName(int i) {
FILE: archive/spotify/breakpad/common/dwarf_cfi_to_module.h
function namespace (line 52) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/dwarf_cfi_to_module_unittest.cc
type MockCFIReporter (line 49) | struct MockCFIReporter: public DwarfCFIToModule::Reporter {
method MockCFIReporter (line 50) | MockCFIReporter(const string &file, const string §ion)
type DwarfCFIToModuleFixture (line 57) | struct DwarfCFIToModuleFixture {
method DwarfCFIToModuleFixture (line 58) | DwarfCFIToModuleFixture()
class Entry (line 85) | class Entry: public DwarfCFIToModuleFixture, public Test { }
function TEST_F (line 87) | TEST_F(Entry, Accept) {
function TEST_F (line 99) | TEST_F(Entry, AcceptOldVersion) {
type RuleFixture (line 111) | struct RuleFixture: public DwarfCFIToModuleFixture {
method RuleFixture (line 112) | RuleFixture() : DwarfCFIToModuleFixture() {
method StartEntry (line 117) | void StartEntry() {
method CheckEntry (line 121) | void CheckEntry() {
class Rule (line 131) | class Rule: public RuleFixture, public Test { }
function TEST_F (line 133) | TEST_F(Rule, UndefinedRule) {
function TEST_F (line 143) | TEST_F(Rule, SameValueRule) {
function TEST_F (line 154) | TEST_F(Rule, OffsetRule) {
function TEST_F (line 167) | TEST_F(Rule, OffsetRuleNegative) {
function TEST_F (line 179) | TEST_F(Rule, ValOffsetRule) {
function TEST_F (line 195) | TEST_F(Rule, RegisterRule) {
function TEST_F (line 206) | TEST_F(Rule, ExpressionRule) {
function TEST_F (line 217) | TEST_F(Rule, ValExpressionRule) {
function TEST_F (line 228) | TEST_F(Rule, DefaultReturnAddressRule) {
function TEST_F (line 241) | TEST_F(Rule, DefaultReturnAddressRuleOverride) {
function TEST_F (line 253) | TEST_F(Rule, DefaultReturnAddressRuleLater) {
function TEST (line 267) | TEST(RegisterNames, I386) {
function TEST (line 276) | TEST(RegisterNames, ARM) {
function TEST (line 286) | TEST(RegisterNames, X86_64) {
FILE: archive/spotify/breakpad/common/dwarf_cu_to_module.cc
type google_breakpad (line 51) | namespace google_breakpad {
type DwarfCUToModule::Specification (line 75) | struct DwarfCUToModule::Specification {
type AbstractOrigin (line 85) | struct AbstractOrigin {
method AbstractOrigin (line 86) | AbstractOrigin() : name() {}
method AbstractOrigin (line 87) | AbstractOrigin(const string& name) : name(name) {}
type DwarfCUToModule::FilePrivate (line 96) | struct DwarfCUToModule::FilePrivate {
type DwarfCUToModule::CUContext (line 129) | struct DwarfCUToModule::CUContext {
method CUContext (line 130) | CUContext(FileContext *file_context_arg, WarningReporter *reporter_arg)
type DwarfCUToModule::DIEContext (line 160) | struct DwarfCUToModule::DIEContext {
class DwarfCUToModule::GenericDIEHandler (line 175) | class DwarfCUToModule::GenericDIEHandler: public dwarf2reader::DIEHand...
method GenericDIEHandler (line 180) | GenericDIEHandler(CUContext *cu_context, DIEContext *parent_context,
type DwarfAttribute (line 190) | enum DwarfAttribute
type DwarfForm (line 191) | enum DwarfForm
type DwarfAttribute (line 196) | enum DwarfAttribute
type DwarfForm (line 197) | enum DwarfForm
type DwarfAttribute (line 202) | enum DwarfAttribute
type DwarfForm (line 203) | enum DwarfForm
type DwarfAttribute (line 236) | enum DwarfAttribute
type DwarfForm (line 237) | enum DwarfForm
type DwarfAttribute (line 246) | enum DwarfAttribute
type DwarfForm (line 247) | enum DwarfForm
type DwarfAttribute (line 277) | enum DwarfAttribute
type DwarfForm (line 278) | enum DwarfForm
function string (line 296) | string DwarfCUToModule::GenericDIEHandler::ComputeQualifiedName() {
class DwarfCUToModule::FuncHandler (line 331) | class DwarfCUToModule::FuncHandler: public GenericDIEHandler {
method FuncHandler (line 333) | FuncHandler(CUContext *cu_context, DIEContext *parent_context,
type DwarfAttribute (line 337) | enum DwarfAttribute
type DwarfForm (line 338) | enum DwarfForm
type DwarfAttribute (line 340) | enum DwarfAttribute
type DwarfForm (line 341) | enum DwarfForm
type DwarfAttribute (line 343) | enum DwarfAttribute
type DwarfForm (line 344) | enum DwarfForm
type DwarfAttribute (line 360) | enum DwarfAttribute
type DwarfForm (line 361) | enum DwarfForm
type DwarfAttribute (line 378) | enum DwarfAttribute
type DwarfForm (line 379) | enum DwarfForm
type DwarfAttribute (line 393) | enum DwarfAttribute
type DwarfForm (line 394) | enum DwarfForm
class DwarfCUToModule::NamedScopeHandler (line 456) | class DwarfCUToModule::NamedScopeHandler: public GenericDIEHandler {
method NamedScopeHandler (line 458) | NamedScopeHandler(CUContext *cu_context, DIEContext *parent_context,
type DwarfTag (line 462) | enum DwarfTag
type DwarfTag (line 476) | enum DwarfTag
type DwarfAttribute (line 577) | enum DwarfAttribute
type DwarfForm (line 578) | enum DwarfForm
type DwarfAttribute (line 589) | enum DwarfAttribute
type DwarfForm (line 590) | enum DwarfForm
type DwarfAttribute (line 605) | enum DwarfAttribute
type DwarfForm (line 606) | enum DwarfForm
type DwarfTag (line 618) | enum DwarfTag
function within (line 694) | inline bool within(const T &item, Module::Address address) {
type DwarfTag (line 929) | enum DwarfTag
FILE: archive/spotify/breakpad/common/dwarf_cu_to_module.h
function namespace (line 50) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/dwarf_cu_to_module_unittest.cc
class MockLineToModuleFunctor (line 66) | class MockLineToModuleFunctor: public DwarfCUToModule::LineToModuleFunct...
class MockWarningReporter (line 76) | class MockWarningReporter: public DwarfCUToModule::WarningReporter {
method MockWarningReporter (line 78) | MockWarningReporter(const string &filename, uint64 cu_offset)
class CUFixtureBase (line 93) | class CUFixtureBase {
class AppendLinesFunctor (line 113) | class AppendLinesFunctor {
method AppendLinesFunctor (line 115) | AppendLinesFunctor(const vector<Module::Line> *lines) : lines_(lines...
method CUFixtureBase (line 124) | CUFixtureBase()
method SetLanguage (line 165) | void SetLanguage(dwarf2reader::DwarfLanguage language) {
method SetLanguageSigned (line 171) | void SetLanguageSigned(bool is_signed) { language_signed_ = is_signed; }
function DIEHandler (line 399) | DIEHandler *CUFixtureBase::StartNamedDIE(DIEHandler *parent,
function DIEHandler (line 423) | DIEHandler *CUFixtureBase::StartSpecifiedDIE(DIEHandler *parent,
class SimpleCU (line 686) | class SimpleCU: public CUFixtureBase, public Test {
function TEST_F (line 689) | TEST_F(SimpleCU, OneFunc) {
function TEST_F (line 704) | TEST_F(SimpleCU, IrrelevantRootChildren) {
function TEST_F (line 712) | TEST_F(SimpleCU, IrrelevantNamedScopeChildren) {
function TEST_F (line 726) | TEST_F(SimpleCU, UnusedFileContext) {
function TEST_F (line 734) | TEST_F(SimpleCU, InlineFunction) {
function TEST_F (line 749) | TEST_F(SimpleCU, InlineFunctionSignedAttribute) {
function TEST_F (line 768) | TEST_F(SimpleCU, AbstractOriginNotInlined) {
function TEST_F (line 783) | TEST_F(SimpleCU, UnknownAbstractOrigin) {
function TEST_F (line 801) | TEST_F(SimpleCU, UnnamedFunction) {
type Range (line 817) | struct Range {
type Situation (line 822) | struct Situation {
class FuncLinePairing (line 859) | class FuncLinePairing: public CUFixtureBase,
function TEST_P (line 865) | TEST_P(FuncLinePairing, Pairing) {
function TEST_F (line 910) | TEST_F(FuncLinePairing, EmptyCU) {
function TEST_F (line 918) | TEST_F(FuncLinePairing, LinesNoFuncs) {
function TEST_F (line 928) | TEST_F(FuncLinePairing, FuncsNoLines) {
function TEST_F (line 939) | TEST_F(FuncLinePairing, GapThenFunction) {
function TEST_F (line 965) | TEST_F(FuncLinePairing, GCCAlignmentStretch) {
function TEST_F (line 989) | TEST_F(FuncLinePairing, LineAtEndOfAddressSpace) {
function TEST_F (line 1009) | TEST_F(FuncLinePairing, WarnOnceFunc) {
function TEST_F (line 1027) | TEST_F(FuncLinePairing, WarnOnceLine) {
class CXXQualifiedNames (line 1045) | class CXXQualifiedNames: public CUFixtureBase,
function TEST_P (line 1054) | TEST_P(CXXQualifiedNames, TwoFunctions) {
function TEST_P (line 1076) | TEST_P(CXXQualifiedNames, FuncInEnclosureInNamespace) {
function TEST_F (line 1101) | TEST_F(CXXQualifiedNames, FunctionInClassInStructInNamespace) {
type LanguageAndQualifiedName (line 1130) | struct LanguageAndQualifiedName {
class QualifiedForLanguage (line 1146) | class QualifiedForLanguage:
function TEST_P (line 1153) | TEST_P(QualifiedForLanguage, MemberFunction) {
function TEST_P (line 1176) | TEST_P(QualifiedForLanguage, MemberFunctionSignedLanguage) {
class Specifications (line 1200) | class Specifications: public CUFixtureBase, public Test { }
function TEST_F (line 1202) | TEST_F(Specifications, Function) {
function TEST_F (line 1218) | TEST_F(Specifications, MemberFunction) {
function TEST_F (line 1240) | TEST_F(Specifications, FunctionDeclarationParent) {
function TEST_F (line 1268) | TEST_F(Specifications, NamedScopeDeclarationParent) {
function TEST_F (line 1302) | TEST_F(Specifications, InlineFunction) {
function TEST_F (line 1322) | TEST_F(Specifications, LongChain) {
function TEST_F (line 1428) | TEST_F(Specifications, InterCU) {
function TEST_F (line 1490) | TEST_F(Specifications, BadOffset) {
function TEST_F (line 1504) | TEST_F(Specifications, FunctionDefinitionHasOwnName) {
function TEST_F (line 1520) | TEST_F(Specifications, ClassDefinitionHasOwnName) {
function TEST_F (line 1553) | TEST_F(Specifications, PreferSpecificationParents) {
class CUErrors (line 1582) | class CUErrors: public CUFixtureBase, public Test { }
function TEST_F (line 1584) | TEST_F(CUErrors, BadStmtList) {
function TEST_F (line 1608) | TEST_F(CUErrors, NoLineSection) {
function TEST_F (line 1618) | TEST_F(CUErrors, BadDwarfVersion1) {
function TEST_F (line 1627) | TEST_F(CUErrors, GoodDwarfVersion2) {
function TEST_F (line 1636) | TEST_F(CUErrors, GoodDwarfVersion3) {
function TEST_F (line 1645) | TEST_F(CUErrors, BadCURootDIETag) {
type Reporter (line 1661) | struct Reporter: public Test {
method Reporter (line 1662) | Reporter()
function TEST_F (line 1685) | TEST_F(Reporter, UnknownSpecification) {
function TEST_F (line 1689) | TEST_F(Reporter, UnknownAbstractOrigin) {
function TEST_F (line 1693) | TEST_F(Reporter, MissingSection) {
function TEST_F (line 1697) | TEST_F(Reporter, BadLineInfoOffset) {
function TEST_F (line 1701) | TEST_F(Reporter, UncoveredFunctionDisabled) {
function TEST_F (line 1706) | TEST_F(Reporter, UncoveredFunctionEnabled) {
function TEST_F (line 1712) | TEST_F(Reporter, UncoveredLineDisabled) {
function TEST_F (line 1717) | TEST_F(Reporter, UncoveredLineEnabled) {
function TEST_F (line 1723) | TEST_F(Reporter, UnnamedFunction) {
FILE: archive/spotify/breakpad/common/dwarf_line_to_module.cc
function PathIsAbsolute (line 44) | static bool PathIsAbsolute(const std::string &path) {
function ExpandPath (line 50) | static std::string ExpandPath(const std::string &path,
type google_breakpad (line 57) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/dwarf_line_to_module.h
function namespace (line 44) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/dwarf_line_to_module_unittest.cc
function TEST (line 45) | TEST(SimpleModule, One) {
function TEST (line 66) | TEST(SimpleModule, Many) {
function TEST (line 126) | TEST(Filenames, Absolute) {
function TEST (line 144) | TEST(Filenames, Relative) {
function TEST (line 162) | TEST(Filenames, StrangeFile) {
function TEST (line 175) | TEST(Filenames, StrangeDirectory) {
function TEST (line 188) | TEST(Filenames, StrangeDirectoryAndFile) {
function TEST (line 203) | TEST(ModuleErrors, DirectoryZero) {
function TEST (line 219) | TEST(ModuleErrors, BadFileNumber) {
function TEST (line 233) | TEST(ModuleErrors, BadDirectoryNumber) {
function TEST (line 248) | TEST(ModuleErrors, EmptyLine) {
function TEST (line 261) | TEST(ModuleErrors, BigLine) {
function TEST (line 278) | TEST(Omitted, DroppedThenGood) {
function TEST (line 291) | TEST(Omitted, GoodThenDropped) {
function TEST (line 304) | TEST(Omitted, Mix1) {
function TEST (line 325) | TEST(Omitted, Mix2) {
FILE: archive/spotify/breakpad/common/language.cc
type google_breakpad (line 37) | namespace google_breakpad {
class CPPLanguage (line 40) | class CPPLanguage: public Language {
method CPPLanguage (line 42) | CPPLanguage() {}
method string (line 43) | string MakeQualifiedName(const string &parent_name,
class JavaLanguage (line 55) | class JavaLanguage: public Language {
method string (line 57) | string MakeQualifiedName(const string &parent_name,
class AssemblerLanguage (line 69) | class AssemblerLanguage: public Language {
method HasFunctions (line 70) | bool HasFunctions() const { return false; }
method string (line 71) | string MakeQualifiedName(const string &parent_name,
FILE: archive/spotify/breakpad/common/language.h
function namespace (line 43) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/linux/dump_symbols.cc
class FDWrapper (line 80) | class FDWrapper {
method FDWrapper (line 82) | explicit FDWrapper(int fd) :
method get (line 88) | int get() {
method release (line 91) | int release() {
class MmapWrapper (line 105) | class MmapWrapper {
method MmapWrapper (line 107) | MmapWrapper() : is_set_(false) {}
method set (line 115) | void set(void *mapped_address, size_t mapped_size) {
method release (line 120) | void release() {
function FixAddress (line 135) | static void FixAddress(void *obj_base) {
function ElfW (line 146) | static ElfW(Addr) GetLoadingAddress(const ElfW(Phdr) *program_headers,
function IsValidElf (line 159) | static bool IsValidElf(const ElfW(Ehdr) *elf_header) {
function ElfW (line 163) | static const ElfW(Shdr) *FindSectionByName(const char *name,
function LoadStabs (line 197) | static bool LoadStabs(const ElfW(Ehdr) *elf_header,
class DumperLineToModule (line 223) | class DumperLineToModule: public DwarfCUToModule::LineToModuleFunctor {
method DumperLineToModule (line 226) | explicit DumperLineToModule(dwarf2reader::ByteReader *byte_reader)
function LoadDwarf (line 238) | static bool LoadDwarf(const std::string &dwarf_filename,
function DwarfCFIRegisterNames (line 294) | static bool DwarfCFIRegisterNames(const ElfW(Ehdr) *elf_header,
function LoadDwarfCFI (line 311) | static bool LoadDwarfCFI(const std::string &dwarf_filename,
function LoadELF (line 370) | bool LoadELF(const std::string &obj_file, MmapWrapper* map_wrapper,
function ElfEndianness (line 402) | bool ElfEndianness(const ElfW(Ehdr) *elf_header, bool *big_endian) {
function ReadDebugLink (line 419) | static std::string ReadDebugLink(const ElfW(Shdr) *debuglink_section,
class LoadSymbolsInfo (line 454) | class LoadSymbolsInfo {
method LoadSymbolsInfo (line 456) | explicit LoadSymbolsInfo(const std::string &dbg_dir) :
method LoadedSection (line 462) | void LoadedSection(const std::string §ion) {
method set_loading_addr (line 473) | void set_loading_addr(ElfW(Addr) addr, const std::string &filename) {
method debuglink_file (line 494) | std::string debuglink_file() const {
method set_debuglink_file (line 497) | void set_debuglink_file(std::string file) {
function LoadSymbols (line 518) | static bool LoadSymbols(const std::string &obj_file,
function FormatIdentifier (line 693) | std::string FormatIdentifier(unsigned char identifier[16]) {
function BaseFileName (line 713) | std::string BaseFileName(const std::string &filename) {
type google_breakpad (line 723) | namespace google_breakpad {
function WriteSymbolFileInternal (line 728) | bool WriteSymbolFileInternal(uint8_t* obj_file,
function WriteSymbolFile (line 813) | bool WriteSymbolFile(const std::string &obj_file,
FILE: archive/spotify/breakpad/common/linux/dump_symbols.h
function namespace (line 41) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/linux/dump_symbols_unittest.cc
type google_breakpad (line 46) | namespace google_breakpad {
class DumpSymbols (line 65) | class DumpSymbols : public Test {
method GetElfContents (line 67) | void GetElfContents(ELF& elf) {
function TEST_F (line 81) | TEST_F(DumpSymbols, Invalid) {
function TEST_F (line 95) | TEST_F(DumpSymbols, SimplePublic32) {
function TEST_F (line 132) | TEST_F(DumpSymbols, SimplePublic64) {
FILE: archive/spotify/breakpad/common/linux/elf_core_dump.cc
type google_breakpad (line 38) | namespace google_breakpad {
function MemoryRange (line 60) | MemoryRange ElfCoreDump::Note::GetName() const {
function MemoryRange (line 68) | MemoryRange ElfCoreDump::Note::GetDescription() const {
FILE: archive/spotify/breakpad/common/linux/elf_core_dump.h
type Nhdr (line 55) | typedef ElfW(Nhdr) Nhdr;
type Phdr (line 56) | typedef ElfW(Phdr) Phdr;
type Word (line 57) | typedef ElfW(Word) Word;
type Addr (line 58) | typedef ElfW(Addr) Addr;
FILE: archive/spotify/breakpad/common/linux/elf_core_dump_unittest.cc
function TEST (line 52) | TEST(ElfCoreDumpTest, DefaultConstructor) {
function TEST (line 62) | TEST(ElfCoreDumpTest, TestElfHeader) {
function TEST (line 130) | TEST(ElfCoreDumpTest, ValidCoreFile) {
FILE: archive/spotify/breakpad/common/linux/elf_symbols_to_module.cc
type google_breakpad (line 41) | namespace google_breakpad {
class ELFSymbolIterator (line 43) | class ELFSymbolIterator {
type Symbol (line 47) | struct Symbol {
method ELFSymbolIterator (line 71) | ELFSymbolIterator(const ByteBuffer *buffer, bool big_endian,
method ELFSymbolIterator (line 83) | ELFSymbolIterator &operator++() { Fetch(); symbol_.index++; return *...
method Symbol (line 88) | const Symbol &operator*() const { return symbol_; }
method Symbol (line 89) | const Symbol *operator->() const { return &symbol_; }
method Fetch (line 93) | void Fetch() {
function ELFSymbolsToModule (line 136) | bool ELFSymbolsToModule(const uint8_t *symtab_section,
FILE: archive/spotify/breakpad/common/linux/elf_symbols_to_module.h
function namespace (line 43) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/linux/elf_symbols_to_module_unittest.cc
class ELFSymbolsToModuleTestFixture (line 58) | class ELFSymbolsToModuleTestFixture {
method ELFSymbolsToModuleTestFixture (line 60) | ELFSymbolsToModuleTestFixture(Endianness endianness,
method ProcessSection (line 66) | bool ProcessSection() {
class ELFSymbolsToModuleTest32 (line 92) | class ELFSymbolsToModuleTest32 : public ELFSymbolsToModuleTestFixture,
method ELFSymbolsToModuleTest32 (line 95) | ELFSymbolsToModuleTest32() : ELFSymbolsToModuleTestFixture(GetParam(),...
method AddElf32Sym (line 97) | void AddElf32Sym(const string& name, uint32_t value,
function TEST_P (line 109) | TEST_P(ELFSymbolsToModuleTest32, NoFuncs) {
function TEST_P (line 115) | TEST_P(ELFSymbolsToModuleTest32, OneFunc) {
function TEST_P (line 133) | TEST_P(ELFSymbolsToModuleTest32, NameOutOfBounds) {
function TEST_P (line 157) | TEST_P(ELFSymbolsToModuleTest32, NonTerminatedStringTable) {
function TEST_P (line 186) | TEST_P(ELFSymbolsToModuleTest32, MultipleFuncs) {
function TEST_P (line 224) | TEST_P(ELFSymbolsToModuleTest32, SkipStuff) {
class ELFSymbolsToModuleTest64 (line 262) | class ELFSymbolsToModuleTest64 : public ELFSymbolsToModuleTestFixture,
method ELFSymbolsToModuleTest64 (line 265) | ELFSymbolsToModuleTest64() : ELFSymbolsToModuleTestFixture(GetParam(),...
method AddElf64Sym (line 267) | void AddElf64Sym(const string& name, uint64_t value,
function TEST_P (line 279) | TEST_P(ELFSymbolsToModuleTest64, NoFuncs) {
function TEST_P (line 285) | TEST_P(ELFSymbolsToModuleTest64, OneFunc) {
function TEST_P (line 303) | TEST_P(ELFSymbolsToModuleTest64, MultipleFuncs) {
function TEST_P (line 341) | TEST_P(ELFSymbolsToModuleTest64, SkipStuff) {
FILE: archive/spotify/breakpad/common/linux/file_id.cc
type google_breakpad (line 54) | namespace google_breakpad {
type ElfClass32 (line 64) | struct ElfClass32 {
type ElfClass64 (line 71) | struct ElfClass64 {
function FindElfClassSection (line 81) | static void FindElfClassSection(const char *elf_base,
function FindElfSection (line 127) | static bool FindElfSection(const void *elf_mapped_base,
function ElfClassBuildIDNoteIdentifier (line 165) | static bool ElfClassBuildIDNoteIdentifier(const void *section,
function FindElfBuildIDNote (line 188) | static bool FindElfBuildIDNote(const void *elf_mapped_base,
function HashElfTextSection (line 209) | static bool HashElfTextSection(const void *elf_mapped_base,
FILE: archive/spotify/breakpad/common/linux/file_id.h
function namespace (line 40) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/linux/file_id_unittest.cc
function PopulateSection (line 54) | void PopulateSection(Section* section, int size, int prime_number) {
function TEST (line 61) | TEST(FileIDStripTest, StripSelf) {
class FileIDTest (line 92) | class FileIDTest : public testing::Test {
method GetElfContents (line 94) | void GetElfContents(ELF& elf) {
function TEST_F (line 108) | TEST_F(FileIDTest, ElfClass) {
function TEST_F (line 149) | TEST_F(FileIDTest, BuildID) {
function TEST_F (line 199) | TEST_F(FileIDTest, UniqueHashes32) {
function TEST_F (line 243) | TEST_F(FileIDTest, UniqueHashes64) {
FILE: archive/spotify/breakpad/common/linux/google_crashdump_uploader.cc
type google_breakpad (line 42) | namespace google_breakpad {
type stat (line 176) | struct stat
FILE: archive/spotify/breakpad/common/linux/google_crashdump_uploader.h
function namespace (line 34) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/linux/google_crashdump_uploader_test.cc
type google_breakpad (line 36) | namespace google_breakpad {
class MockLibcurlWrapper (line 41) | class MockLibcurlWrapper : public LibcurlWrapper {
class GoogleCrashdumpUploaderTest (line 54) | class GoogleCrashdumpUploaderTest : public ::testing::Test {
function TEST_F (line 57) | TEST_F(GoogleCrashdumpUploaderTest, InitFailsCausesUploadFailure) {
function TEST_F (line 75) | TEST_F(GoogleCrashdumpUploaderTest, TestSendRequestHappensWithValidPar...
function TEST_F (line 103) | TEST_F(GoogleCrashdumpUploaderTest, InvalidPathname) {
function TEST_F (line 122) | TEST_F(GoogleCrashdumpUploaderTest, TestRequiredParametersMustBePresen...
FILE: archive/spotify/breakpad/common/linux/guid_creator.cc
class GUIDGenerator (line 47) | class GUIDGenerator {
method u_int32_t (line 49) | static u_int32_t BytesToUInt32(const u_int8_t bytes[]) {
method UInt32ToBytes (line 56) | static void UInt32ToBytes(u_int8_t bytes[], u_int32_t n) {
method CreateGUID (line 63) | static bool CreateGUID(GUID *guid) {
method InitOnce (line 74) | static void InitOnce() {
method InitOnceImpl (line 78) | static void InitOnceImpl() {
function CreateGUID (line 87) | bool CreateGUID(GUID *guid) {
function GUIDToString (line 92) | bool GUIDToString(const GUID *guid, char *buf, int buf_len) {
FILE: archive/spotify/breakpad/common/linux/guid_creator.h
type MDGUID (line 35) | typedef MDGUID GUID;
FILE: archive/spotify/breakpad/common/linux/http_upload.cc
function WriteCallback (line 39) | static size_t WriteCallback(void *ptr, size_t size,
type google_breakpad (line 52) | namespace google_breakpad {
type curl_httppost (line 116) | struct curl_httppost
type curl_httppost (line 117) | struct curl_httppost
type curl_httppost (line 119) | struct curl_httppost
type curl_httppost (line 119) | struct curl_httppost
type curl_slist (line 137) | struct curl_slist
type curl_slist (line 139) | struct curl_slist
type curl_slist (line 139) | struct curl_slist
type curl_httppost (line 176) | struct curl_httppost
type curl_slist (line 181) | struct curl_slist
FILE: archive/spotify/breakpad/common/linux/http_upload.h
function namespace (line 40) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/linux/libcurl_wrapper.cc
type google_breakpad (line 39) | namespace google_breakpad {
function WriteCallback (line 99) | static size_t WriteCallback(void *ptr, size_t size,
FILE: archive/spotify/breakpad/common/linux/libcurl_wrapper.h
function namespace (line 38) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/linux/linux_libc_support.h
function my_strlen (line 43) | static inline size_t
function my_strcmp (line 50) | static inline int
function my_strncmp (line 64) | static inline int
function my_strtoui (line 84) | static inline bool
function my_int_len (line 107) | static inline unsigned
function my_itos (line 127) | static inline void
function my_memset (line 169) | static inline void
FILE: archive/spotify/breakpad/common/linux/linux_libc_support_unittest.cc
function TEST (line 37) | TEST(LinuxLibcSupportTest, strlen) {
function TEST (line 46) | TEST(LinuxLibcSupportTest, strcmp) {
function TEST (line 71) | TEST(LinuxLibcSupportTest, strtoui) {
function TEST (line 92) | TEST(LinuxLibcSupportTest, int_len) {
function TEST (line 104) | TEST(LinuxLibcSupportTest, itos) {
function TEST (line 123) | TEST(LinuxLibcSupportTest, strchr) {
function TEST (line 134) | TEST(LinuxLibcSupportTest, read_hex_ptr) {
FILE: archive/spotify/breakpad/common/linux/memory_mapped_file.cc
type stat (line 66) | struct stat
type kernel_stat (line 69) | struct kernel_stat
type kernel_stat64 (line 72) | struct kernel_stat64
FILE: archive/spotify/breakpad/common/linux/memory_mapped_file.h
function namespace (line 39) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/linux/memory_mapped_file_unittest.cc
class MemoryMappedFileTest (line 52) | class MemoryMappedFileTest : public testing::Test {
method ExpectNoMappedData (line 54) | void ExpectNoMappedData(const MemoryMappedFile& mapped_file) {
function TEST_F (line 63) | TEST_F(MemoryMappedFileTest, DefaultConstructor) {
function TEST_F (line 68) | TEST_F(MemoryMappedFileTest, UnmapWithoutMap) {
function TEST_F (line 73) | TEST_F(MemoryMappedFileTest, MapNonexistentFile) {
function TEST_F (line 85) | TEST_F(MemoryMappedFileTest, MapEmptyFile) {
function TEST_F (line 101) | TEST_F(MemoryMappedFileTest, MapNonEmptyFile) {
function TEST_F (line 129) | TEST_F(MemoryMappedFileTest, RemapAfterMap) {
FILE: archive/spotify/breakpad/common/linux/safe_readlink.cc
type google_breakpad (line 37) | namespace google_breakpad {
function SafeReadLink (line 39) | bool SafeReadLink(const char* path, char* buffer, size_t buffer_size) {
FILE: archive/spotify/breakpad/common/linux/safe_readlink.h
function namespace (line 38) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/linux/safe_readlink_unittest.cc
function TEST (line 37) | TEST(SafeReadLinkTest, ZeroBufferSize) {
function TEST (line 42) | TEST(SafeReadLinkTest, BufferSizeTooSmall) {
function TEST (line 47) | TEST(SafeReadLinkTest, BoundaryBufferSize) {
function TEST (line 64) | TEST(SafeReadLinkTest, NonexistentPath) {
function TEST (line 69) | TEST(SafeReadLinkTest, NonSymbolicLinkPath) {
function TEST (line 77) | TEST(SafeReadLinkTest, DeduceBufferSizeFromCharArray) {
FILE: archive/spotify/breakpad/common/linux/synth_elf.cc
type google_breakpad (line 8) | namespace google_breakpad {
type synth_elf (line 9) | namespace synth_elf {
FILE: archive/spotify/breakpad/common/linux/synth_elf.h
function namespace (line 46) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/linux/synth_elf_unittest.cc
class StringTableTest (line 50) | class StringTableTest : public Test {
method StringTableTest (line 52) | StringTableTest() : table(kLittleEndian) {}
function TEST_F (line 57) | TEST_F(StringTableTest, Empty) {
function TEST_F (line 69) | TEST_F(StringTableTest, Basic) {
function TEST_F (line 93) | TEST_F(StringTableTest, Duplicates) {
class SymbolTableTest (line 113) | class SymbolTableTest : public Test {}
function TEST_F (line 115) | TEST_F(SymbolTableTest, Simple32) {
class BasicElf (line 181) | class BasicElf : public Test {}
function TEST_F (line 187) | TEST_F(BasicElf, EmptyLE32) {
function TEST_F (line 226) | TEST_F(BasicElf, EmptyLE64) {
FILE: archive/spotify/breakpad/common/linux/tests/crash_generator.cc
type ThreadData (line 52) | struct ThreadData {
type google_breakpad (line 82) | namespace google_breakpad {
function pid_t (line 108) | pid_t CrashGenerator::GetThreadId(unsigned index) const {
function pid_t (line 112) | pid_t* CrashGenerator::GetThreadIdPointer(unsigned index) {
type rlimit (line 148) | struct rlimit
FILE: archive/spotify/breakpad/common/linux/tests/crash_generator.h
function namespace (line 42) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/mac/GTMDefines.h
type NSInteger (line 214) | typedef long NSInteger;
type NSUInteger (line 215) | typedef unsigned long NSUInteger;
type NSInteger (line 217) | typedef int NSInteger;
type NSUInteger (line 218) | typedef unsigned int NSUInteger;
type CGFloat (line 229) | typedef double CGFloat;
type CGFloat (line 234) | typedef float CGFloat;
FILE: archive/spotify/breakpad/common/mac/GTMGarbageCollection.h
function GTM_INLINE (line 41) | GTM_INLINE void GTMNSMakeUncollectable(id object) {
function GTM_INLINE (line 50) | GTM_INLINE BOOL GTMIsGarbageCollectionEnabled(void) {
function GTM_INLINE (line 58) | GTM_INLINE void GTMNSMakeUncollectable(id object) {
function GTM_INLINE (line 61) | GTM_INLINE BOOL GTMIsGarbageCollectionEnabled(void) {
FILE: archive/spotify/breakpad/common/mac/GTMLogger.h
function interface (line 215) | interface GTMLogger : NSObject {
type GTMLoggerLevel (line 343) | typedef enum {
FILE: archive/spotify/breakpad/common/mac/HTTPMultipartUpload.h
function interface (line 37) | interface HTTPMultipartUpload : NSObject {
FILE: archive/spotify/breakpad/common/mac/MachIPC.h
function namespace (line 97) | namespace google_breakpad {
function class (line 163) | class MachMessage {
function class (line 237) | class MachReceiveMessage : public MachMessage {
function class (line 243) | class MachSendMessage : public MachMessage {
function class (line 250) | class ReceivePort {
function class (line 280) | class MachPortSender {
FILE: archive/spotify/breakpad/common/mac/SimpleStringDictionary.h
function namespace (line 39) | namespace google_breakpad {
function class (line 126) | class SimpleStringDictionary {
FILE: archive/spotify/breakpad/common/mac/bootstrap_compat.cc
type breakpad (line 32) | namespace breakpad {
function kern_return_t (line 35) | kern_return_t BootstrapRegister(mach_port_t bp,
FILE: archive/spotify/breakpad/common/mac/bootstrap_compat.h
function namespace (line 35) | namespace breakpad {
FILE: archive/spotify/breakpad/common/mac/byteswap.h
function ByteSwap (line 41) | static inline uint16_t ByteSwap(uint16_t v) { return OSSwapInt16(v); }
function ByteSwap (line 42) | static inline uint32_t ByteSwap(uint32_t v) { return OSSwapInt32(v); }
function ByteSwap (line 43) | static inline uint64_t ByteSwap(uint64_t v) { return OSSwapInt64(v); }
function ByteSwap (line 44) | static inline int16_t ByteSwap(int16_t v) { return OSSwapInt16(v); }
function ByteSwap (line 45) | static inline int32_t ByteSwap(int32_t v) { return OSSwapInt32(v); }
function ByteSwap (line 46) | static inline int64_t ByteSwap(int64_t v) { return OSSwapInt64(v); }
FILE: archive/spotify/breakpad/common/mac/dump_syms.h
function namespace (line 51) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/mac/file_id.cc
type google_breakpad (line 45) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/mac/file_id.h
function namespace (line 39) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/mac/macho_id.cc
type MacFileUtilities (line 52) | namespace MacFileUtilities {
type breakpad_uuid_command (line 157) | struct breakpad_uuid_command
type dylib_command (line 173) | struct dylib_command
type segment_command (line 253) | struct segment_command
type mach_header_64 (line 261) | struct mach_header_64
type segment_command (line 269) | struct segment_command
type section (line 270) | struct section
type section (line 283) | struct section
type segment_command_64 (line 286) | struct segment_command_64
type mach_header_64 (line 294) | struct mach_header_64
type segment_command_64 (line 302) | struct segment_command_64
type section_64 (line 303) | struct section_64
type section_64 (line 318) | struct section_64
type breakpad_uuid_command (line 330) | struct breakpad_uuid_command
type breakpad_uuid_command (line 331) | struct breakpad_uuid_command
type breakpad_uuid_command (line 333) | struct breakpad_uuid_command
type dylib_command (line 351) | struct dylib_command
type dylib_command (line 351) | struct dylib_command
type dylib_command (line 353) | struct dylib_command
FILE: archive/spotify/breakpad/common/mac/macho_id.h
function namespace (line 43) | namespace MacFileUtilities {
FILE: archive/spotify/breakpad/common/mac/macho_reader.cc
type google_breakpad (line 46) | namespace google_breakpad {
type mach_o (line 47) | namespace mach_o {
type fat_arch (line 100) | struct fat_arch
class Reader::SegmentFinder (line 413) | class Reader::SegmentFinder : public LoadCommandHandler {
method SegmentFinder (line 417) | SegmentFinder(const string &name, Segment *segment)
method found (line 421) | bool found() const { return found_; }
method SegmentCommand (line 423) | bool SegmentCommand(const Segment &segment) {
class Reader::SectionMapper (line 508) | class Reader::SectionMapper: public SectionHandler {
method SectionMapper (line 512) | SectionMapper(SectionMap *map) : map_(map) { }
method HandleSection (line 513) | bool HandleSection(const Section §ion) {
FILE: archive/spotify/breakpad/common/mac/macho_reader.h
function namespace (line 51) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/mac/macho_reader_unittest.cc
class MockFatReaderReporter (line 76) | class MockFatReaderReporter: public FatReader::Reporter {
method MockFatReaderReporter (line 78) | MockFatReaderReporter(const string &filename)
class MockReaderReporter (line 85) | class MockReaderReporter: public Reader::Reporter {
method MockReaderReporter (line 87) | MockReaderReporter(const string &filename) : Reader::Reporter(filename...
class MockLoadCommandHandler (line 106) | class MockLoadCommandHandler: public Reader::LoadCommandHandler {
class MockSectionHandler (line 113) | class MockSectionHandler: public Reader::SectionHandler {
function TEST (line 123) | TEST(FatReaderReporter, BadHeader) {
function TEST (line 128) | TEST(FatReaderReporter, MisplacedObjectFile) {
function TEST (line 133) | TEST(FatReaderReporter, TooShort) {
function TEST (line 138) | TEST(MachOReaderReporter, BadHeader) {
function TEST (line 143) | TEST(MachOReaderReporter, CPUTypeMismatch) {
function TEST (line 149) | TEST(MachOReaderReporter, HeaderTruncated) {
function TEST (line 154) | TEST(MachOReaderReporter, LoadCommandRegionTruncated) {
function TEST (line 159) | TEST(MachOReaderReporter, LoadCommandsOverrun) {
function TEST (line 165) | TEST(MachOReaderReporter, LoadCommandTooShort) {
function TEST (line 170) | TEST(MachOReaderReporter, SectionsMissing) {
function TEST (line 175) | TEST(MachOReaderReporter, MisplacedSegmentData) {
function TEST (line 180) | TEST(MachOReaderReporter, MisplacedSectionData) {
function TEST (line 185) | TEST(MachOReaderReporter, MisplacedSymbolTable) {
function TEST (line 190) | TEST(MachOReaderReporter, UnsupportedCPUType) {
type FatReaderFixture (line 195) | struct FatReaderFixture {
method FatReaderFixture (line 196) | FatReaderFixture()
method AppendFatArch (line 207) | void AppendFatArch(cpu_type_t type, cpu_subtype_t subtype,
method AppendDummyArchEntries (line 218) | void AppendDummyArchEntries(int n) {
method ReadFat (line 222) | void ReadFat(bool expect_parse_success = true) {
type fat_arch (line 237) | struct fat_arch
class FatReaderTest (line 241) | class FatReaderTest: public FatReaderFixture, public Test { }
function TEST_F (line 243) | TEST_F(FatReaderTest, BadMagic) {
function TEST_F (line 252) | TEST_F(FatReaderTest, HeaderTooShort) {
function TEST_F (line 259) | TEST_F(FatReaderTest, ObjectListTooShort) {
function TEST_F (line 274) | TEST_F(FatReaderTest, DataTooShort) {
function TEST_F (line 287) | TEST_F(FatReaderTest, NoObjectFiles) {
function TEST_F (line 295) | TEST_F(FatReaderTest, OneObjectFile) {
function TEST_F (line 315) | TEST_F(FatReaderTest, ThreeObjectFiles) {
function TEST_F (line 361) | TEST_F(FatReaderTest, BigEndianMachO32) {
function TEST_F (line 383) | TEST_F(FatReaderTest, BigEndianMachO64) {
function TEST_F (line 405) | TEST_F(FatReaderTest, LittleEndianMachO32) {
function TEST_F (line 427) | TEST_F(FatReaderTest, LittleEndianMachO64) {
function TEST_F (line 449) | TEST_F(FatReaderTest, IncompleteMach) {
class WithConfiguration (line 465) | class WithConfiguration {
method WithConfiguration (line 469) | WithConfiguration(Endianness endianness, size_t word_size)
method Endianness (line 474) | static Endianness endianness() {
method word_size (line 478) | static size_t word_size() {
class SizedSection (line 500) | class SizedSection: public test_assembler::Section {
method SizedSection (line 503) | explicit SizedSection(Endianness endianness, size_t word_size)
method SizedSection (line 507) | SizedSection()
method word_size (line 514) | size_t word_size() const { return word_size_; }
method set_word_size (line 515) | void set_word_size(size_t word_size) {
method Label (line 522) | Label final_size() const { return final_size_; }
method SizedSection (line 526) | SizedSection &Place(SizedSection *section) {
method Finish (line 539) | virtual void Finish() {
class LoadedSection (line 553) | class LoadedSection: public SizedSection {
method LoadedSection (line 555) | explicit LoadedSection(Label address = Label()) : address_(address) { }
method Label (line 558) | Label address() const { return address_; }
method LoadedSection (line 562) | LoadedSection &Place(LoadedSection *section) {
class SegmentLoadCommand (line 574) | class SegmentLoadCommand: public SizedSection {
method SegmentLoadCommand (line 576) | SegmentLoadCommand() : section_count_(0) { }
method SegmentLoadCommand (line 582) | SegmentLoadCommand &Header(const string &name, const LoadedSection &co...
method Label (line 607) | Label &vmsize() { return vmsize_; }
method SegmentLoadCommand (line 613) | SegmentLoadCommand &AppendSectionEntry(const string §ion_name,
method Finish (line 637) | void Finish() {
class LoadCommands (line 662) | class LoadCommands: public SizedSection {
method LoadCommands (line 664) | LoadCommands() : command_count_(0) { }
method Label (line 667) | Label final_command_count() const { return final_command_count_; }
method LoadCommands (line 670) | LoadCommands &CountCommand() {
method LoadCommands (line 677) | LoadCommands &Place(SizedSection *section) {
method Finish (line 685) | void Finish() {
class MachOFile (line 700) | class MachOFile: public SizedSection {
method MachOFile (line 702) | MachOFile() {
method MachOFile (line 709) | MachOFile &Header(LoadCommands *commands,
type ReaderFixture (line 731) | struct ReaderFixture {
method ReaderFixture (line 732) | ReaderFixture()
method ReadFile (line 751) | void ReadFile(MachOFile *file,
class ReaderTest (line 778) | class ReaderTest: public ReaderFixture, public Test { }
function TEST_F (line 780) | TEST_F(ReaderTest, BadMagic) {
function TEST_F (line 798) | TEST_F(ReaderTest, MismatchedMagic) {
function TEST_F (line 817) | TEST_F(ReaderTest, ShortMagic) {
function TEST_F (line 827) | TEST_F(ReaderTest, ShortHeader) {
function TEST_F (line 843) | TEST_F(ReaderTest, MismatchedCPU) {
function TEST_F (line 864) | TEST_F(ReaderTest, LittleEndian32Bit) {
function TEST_F (line 887) | TEST_F(ReaderTest, LittleEndian64Bit) {
function TEST_F (line 910) | TEST_F(ReaderTest, BigEndian32Bit) {
function TEST_F (line 933) | TEST_F(ReaderTest, BigEndian64Bit) {
class LoadCommand (line 959) | class LoadCommand: public ReaderFixture, public Test { }
function TEST_F (line 961) | TEST_F(LoadCommand, RegionTruncated) {
function TEST_F (line 983) | TEST_F(LoadCommand, None) {
function TEST_F (line 1004) | TEST_F(LoadCommand, Unknown) {
function TEST_F (line 1037) | TEST_F(LoadCommand, TypeIncomplete) {
function TEST_F (line 1054) | TEST_F(LoadCommand, LengthIncomplete) {
function TEST_F (line 1071) | TEST_F(LoadCommand, ContentIncomplete) {
function TEST_F (line 1089) | TEST_F(LoadCommand, SegmentBE32) {
function TEST_F (line 1125) | TEST_F(LoadCommand, SegmentLE32) {
function TEST_F (line 1162) | TEST_F(LoadCommand, SegmentBE64) {
function TEST_F (line 1198) | TEST_F(LoadCommand, SegmentLE64) {
function TEST_F (line 1235) | TEST_F(LoadCommand, SegmentCommandTruncated) {
function TEST_F (line 1267) | TEST_F(LoadCommand, SegmentBadContentOffset) {
function TEST_F (line 1292) | TEST_F(LoadCommand, ThreeLoadCommands) {
function MatchSection (line 1342) | static inline Matcher<const Section &> MatchSection(
function MatchSection (line 1359) | static inline Matcher<const Section &> MatchSection(
function TEST_F (line 1370) | TEST_F(LoadCommand, OneSegmentTwoSections) {
function TEST_F (line 1433) | TEST_F(LoadCommand, MisplacedSectionBefore) {
function TEST_F (line 1474) | TEST_F(LoadCommand, MisplacedSectionAfter) {
function TEST_F (line 1515) | TEST_F(LoadCommand, MisplacedSectionTooBig) {
function TEST_F (line 1560) | TEST_F(LoadCommand, ZappedSegment) {
function TEST_F (line 1601) | TEST_F(LoadCommand, MapSegmentSections) {
function TEST_F (line 1674) | TEST_F(LoadCommand, FindSegment) {
class StringAssembler (line 1711) | class StringAssembler: public SizedSection {
method Add (line 1715) | size_t Add(const string &s) {
class SymbolAssembler (line 1724) | class SymbolAssembler: public SizedSection {
method SymbolAssembler (line 1727) | explicit SymbolAssembler(StringAssembler *string_assembler)
method SymbolAssembler (line 1736) | SymbolAssembler &Symbol(uint8_t type, uint8_t other, Label descriptor,
method SymbolAssembler (line 1748) | SymbolAssembler &Symbol(uint8_t type, uint8_t other, Label descriptor,
class Symtab (line 1761) | class Symtab: public ReaderFixture, public Test { }
function TEST_F (line 1763) | TEST_F(Symtab, Symtab32) {
function TEST_F (line 1800) | TEST_F(Symtab, Symtab64) {
function TEST_F (line 1837) | TEST_F(Symtab, SymtabMisplacedSymbols) {
function TEST_F (line 1868) | TEST_F(Symtab, SymtabMisplacedStrings) {
FILE: archive/spotify/breakpad/common/mac/macho_utilities.cc
function breakpad_swap_uuid_command (line 37) | void breakpad_swap_uuid_command(struct breakpad_uuid_command *uc,
function breakpad_swap_segment_command_64 (line 44) | void breakpad_swap_segment_command_64(struct segment_command_64 *sg,
function breakpad_swap_mach_header_64 (line 61) | void breakpad_swap_mach_header_64(struct mach_header_64 *mh,
function breakpad_swap_section_64 (line 74) | void breakpad_swap_section_64(struct section_64 *s,
FILE: archive/spotify/breakpad/common/mac/macho_utilities.h
type breakpad_uuid_command (line 67) | struct breakpad_uuid_command {
type breakpad_uuid_command (line 73) | struct breakpad_uuid_command
type NXByteOrder (line 74) | enum NXByteOrder
type natural_t (line 78) | typedef natural_t breakpad_thread_state_data_t[THREAD_STATE_MAX];
type segment_command_64 (line 82) | struct segment_command_64
type NXByteOrder (line 83) | enum NXByteOrder
type mach_header_64 (line 85) | struct mach_header_64
type NXByteOrder (line 86) | enum NXByteOrder
type section_64 (line 88) | struct section_64
type NXByteOrder (line 90) | enum NXByteOrder
FILE: archive/spotify/breakpad/common/mac/macho_walker.cc
type MacFileUtilities (line 50) | namespace MacFileUtilities {
type mach_header_64 (line 124) | struct mach_header_64
type fat_header (line 171) | struct fat_header
type fat_arch (line 181) | struct fat_arch
type mach_header (line 202) | struct mach_header
type mach_header_64 (line 212) | struct mach_header_64
type mach_header_64 (line 228) | struct mach_header_64
type load_command (line 250) | struct load_command
FILE: archive/spotify/breakpad/common/mac/macho_walker.h
function namespace (line 40) | namespace MacFileUtilities {
FILE: archive/spotify/breakpad/common/mac/scoped_task_suspend-inl.h
function namespace (line 38) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/mac/string_utilities.cc
type MacStringUtils (line 33) | namespace MacStringUtils {
function ConvertToString (line 37) | std::string ConvertToString(CFStringRef str) {
function IntegerValueAtIndex (line 56) | unsigned int IntegerValueAtIndex(string &str, unsigned int idx) {
FILE: archive/spotify/breakpad/common/mac/string_utilities.h
function namespace (line 39) | namespace MacStringUtils {
FILE: archive/spotify/breakpad/common/md5.cc
type google_breakpad (line 20) | namespace google_breakpad {
function byteReverse (line 28) | static void byteReverse(unsigned char *buf, unsigned longs)
function MD5Init (line 46) | void MD5Init(struct MD5Context *ctx)
function MD5Update (line 61) | void MD5Update(struct MD5Context *ctx, unsigned char const *buf, unsig...
function MD5Final (line 109) | void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
function MD5Transform (line 167) | static void MD5Transform(u32 buf[4], u32 const in[16])
FILE: archive/spotify/breakpad/common/md5.h
function namespace (line 8) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/memory.h
function namespace (line 47) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/memory_range.h
function namespace (line 41) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/memory_range_unittest.cc
function TEST (line 94) | TEST(MemoryRangeTest, DefaultConstructor) {
function TEST (line 100) | TEST(MemoryRangeTest, ConstructorWithDataAndLength) {
function TEST (line 106) | TEST(MemoryRangeTest, Reset) {
function TEST (line 121) | TEST(MemoryRangeTest, Set) {
function TEST (line 132) | TEST(MemoryRangeTest, SubrangeOfEmptyMemoryRange) {
function TEST (line 139) | TEST(MemoryRangeTest, SubrangeAndGetData) {
function TEST (line 164) | TEST(MemoryRangeTest, GetDataWithTemplateType) {
function TEST (line 172) | TEST(MemoryRangeTest, GetArrayElement) {
function TEST (line 187) | TEST(MemoryRangeTest, GetArrayElmentWithTemplateType) {
FILE: archive/spotify/breakpad/common/memory_unittest.cc
function TEST (line 39) | TEST(PageAllocatorTest, Setup) {
function TEST (line 43) | TEST(PageAllocatorTest, SmallObjects) {
function TEST (line 53) | TEST(PageAllocatorTest, LargeObject) {
function TEST (line 69) | TEST(WastefulVectorTest, Setup) {
function TEST (line 76) | TEST(WastefulVectorTest, Simple) {
FILE: archive/spotify/breakpad/common/module.cc
type google_breakpad (line 44) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/module.h
function namespace (line 49) | namespace google_breakpad {
type Extern (line 121) | struct Extern {
type map (line 130) | typedef map<string, string> RuleMap;
type map (line 134) | typedef map<Address, RuleMap> RuleChangeMap;
type StackFrameEntry (line 139) | struct StackFrameEntry {
type FunctionCompare (line 155) | struct FunctionCompare {
type ExternCompare (line 164) | struct ExternCompare {
type CompareStringPtrs (line 290) | struct CompareStringPtrs {
type map (line 296) | typedef map<const string *, File *, CompareStringPtrs> FileByNameMap;
type set (line 299) | typedef set<Function *, FunctionCompare> FunctionSet;
type set (line 302) | typedef set<Extern *, ExternCompare> ExternSet;
FILE: archive/spotify/breakpad/common/module_unittest.cc
function TEST (line 70) | TEST(Write, Header) {
function TEST (line 79) | TEST(Write, OneLineFunc) {
function TEST (line 104) | TEST(Write, RelativeLoadAddress) {
function TEST (line 162) | TEST(Write, OmitUnusedFiles) {
function TEST (line 212) | TEST(Write, NoCFI) {
function TEST (line 258) | TEST(Construct, AddFunctions) {
function TEST (line 299) | TEST(Construct, AddFrames) {
function TEST (line 386) | TEST(Construct, UniqueFiles) {
function TEST (line 399) | TEST(Construct, DuplicateFunctions) {
function TEST (line 418) | TEST(Construct, FunctionsWithSameAddress) {
function TEST (line 441) | TEST(Construct, Externs) {
function TEST (line 468) | TEST(Construct, DuplicateExterns) {
FILE: archive/spotify/breakpad/common/solaris/dump_symbols.cc
type slist (line 63) | struct slist {
type SymbolEntry (line 74) | struct SymbolEntry {
type LineInfo (line 82) | struct LineInfo {
type FuncInfo (line 98) | struct FuncInfo {
type LineInfo (line 112) | struct LineInfo
type SourceFileInfo (line 116) | struct SourceFileInfo {
type FuncInfo (line 124) | struct FuncInfo
type CompareString (line 127) | struct CompareString {
type SymbolEntry (line 133) | struct SymbolEntry
type SymbolInfo (line 137) | struct SymbolInfo {
type SourceFileInfo (line 138) | struct SourceFileInfo
function RecalculateOffset (line 163) | inline void RecalculateOffset(struct slist* cur_list, char *stabstr) {
function Demangle (line 177) | std::string Demangle(const char *mangled) {
function WriteFormat (line 200) | bool WriteFormat(int fd, const char *fmt, ...) {
function IsValidElf (line 212) | bool IsValidElf(const GElf_Ehdr *elf_header) {
function FindSectionByName (line 216) | static bool FindSectionByName(Elf *elf, const char *name,
function LoadStackParamSize (line 248) | int LoadStackParamSize(struct slist *list,
function LoadLineInfo (line 262) | int LoadLineInfo(struct slist *list,
function LoadFuncSymbols (line 291) | int LoadFuncSymbols(struct slist *list,
function ComputeSizeAndRVA (line 345) | bool ComputeSizeAndRVA(struct SymbolInfo *symbols) {
function LoadAllSymbols (line 395) | bool LoadAllSymbols(const GElf_Shdr *stab_section,
function LoadSymbols (line 434) | bool LoadSymbols(Elf *elf, GElf_Ehdr *elf_header, struct SymbolInfo *sym...
function WriteModuleInfo (line 482) | bool WriteModuleInfo(int fd, GElf_Half arch, const std::string &obj_file) {
function WriteSourceFileInfo (line 511) | bool WriteSourceFileInfo(int fd, const struct SymbolInfo &symbols) {
function WriteOneFunction (line 523) | bool WriteOneFunction(int fd, int source_id,
function WriteFunctionInfo (line 557) | bool WriteFunctionInfo(int fd, const struct SymbolInfo &symbols) {
function DumpStabSymbols (line 569) | bool DumpStabSymbols(int fd, const struct SymbolInfo &symbols) {
class FDWrapper (line 579) | class FDWrapper {
method FDWrapper (line 581) | explicit FDWrapper(int fd) :
method get (line 588) | int get() {
method release (line 591) | int release() {
class MmapWrapper (line 605) | class MmapWrapper {
method MmapWrapper (line 607) | MmapWrapper(void *mapped_address, size_t mapped_size) :
method release (line 616) | void release() {
type google_breakpad (line 628) | namespace google_breakpad {
class AutoElfEnder (line 630) | class AutoElfEnder {
method AutoElfEnder (line 632) | AutoElfEnder(Elf *elf) : elf_(elf) {}
type stat (line 649) | struct stat
type SymbolInfo (line 670) | struct SymbolInfo
FILE: archive/spotify/breakpad/common/solaris/dump_symbols.h
function namespace (line 39) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/solaris/file_id.cc
type google_breakpad (line 53) | namespace google_breakpad {
class AutoElfEnder (line 55) | class AutoElfEnder {
method AutoElfEnder (line 57) | AutoElfEnder(Elf *elf) : elf_(elf) {}
function FindElfTextSection (line 65) | static bool FindElfTextSection(int fd, const void *elf_base,
class AutoCloser (line 135) | class AutoCloser {
method AutoCloser (line 137) | AutoCloser(int fd) : fd_(fd) {}
type stat (line 149) | struct stat
FILE: archive/spotify/breakpad/common/solaris/file_id.h
function namespace (line 39) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/solaris/guid_creator.cc
class GUIDGenerator (line 48) | class GUIDGenerator {
method GUIDGenerator (line 50) | GUIDGenerator() {
method CreateGUID (line 54) | bool CreateGUID(GUID *guid) const {
function CreateGUID (line 67) | bool CreateGUID(GUID *guid) {
function GUIDToString (line 72) | bool GUIDToString(const GUID *guid, char *buf, int buf_len) {
FILE: archive/spotify/breakpad/common/solaris/guid_creator.h
type MDGUID (line 37) | typedef MDGUID GUID;
FILE: archive/spotify/breakpad/common/solaris/message_output.h
function namespace (line 35) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/stabs_reader.cc
type google_breakpad (line 42) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/stabs_reader.h
function class (line 72) | class StabsReader {
FILE: archive/spotify/breakpad/common/stabs_reader_unittest.cc
class StringAssembler (line 70) | class StringAssembler: public Section {
method StringAssembler (line 72) | StringAssembler() : in_cu_(false) { StartCU(); }
method Add (line 77) | size_t Add(const string &s) {
method StartCU (line 88) | void StartCU() {
method EndCU (line 106) | size_t EndCU() {
class StabsAssembler (line 126) | class StabsAssembler: public Section {
method StabsAssembler (line 129) | StabsAssembler(StringAssembler *string_assembler)
method value_size (line 138) | size_t value_size() const { return value_size_; }
method StabsAssembler (line 139) | StabsAssembler &set_value_size(size_t value_size) {
method StabsAssembler (line 149) | StabsAssembler &Stab(uint8_t type, uint8_t other, Label descriptor,
method StabsAssembler (line 161) | StabsAssembler &Stab(uint8_t type, uint8_t other, Label descriptor,
method StabsAssembler (line 169) | StabsAssembler &StartCU(const string &name) {
method StabsAssembler (line 182) | StabsAssembler &EndCU() {
type CUHeader (line 194) | struct CUHeader {
class MockStabsReaderHandler (line 216) | class MockStabsReaderHandler: public StabsHandler {
method Warning (line 225) | void Warning(const char *format, ...) { MockWarning(format); }
type StabsFixture (line 229) | struct StabsFixture {
method StabsFixture (line 230) | StabsFixture() : stabs(&strings), unitized(true) { }
method ApplyHandlerToMockStabsData (line 237) | bool ApplyHandlerToMockStabsData() {
class Stabs (line 260) | class Stabs: public StabsFixture, public Test { }
function TEST_F (line 262) | TEST_F(Stabs, MockStabsInput) {
function TEST_F (line 328) | TEST_F(Stabs, AbruptCU) {
function TEST_F (line 346) | TEST_F(Stabs, AbruptFunction) {
function TEST_F (line 370) | TEST_F(Stabs, NoCU) {
function TEST_F (line 383) | TEST_F(Stabs, NoCUEnd) {
function TEST_F (line 411) | TEST_F(Stabs, Unitized) {
function TEST_F (line 454) | TEST_F(Stabs, NonUnitized) {
function TEST_F (line 477) | TEST_F(Stabs, FunctionEnd) {
function TEST_F (line 522) | TEST_F(Stabs, LeadingLine) {
function TEST_F (line 563) | TEST_F(Stabs, OnePublicSymbol) {
function TEST_F (line 582) | TEST_F(Stabs, TwoPublicSymbols) {
FILE: archive/spotify/breakpad/common/stabs_to_module.cc
type google_breakpad (line 43) | namespace google_breakpad {
function string (line 49) | static string Demangle(const string &mangled) {
FILE: archive/spotify/breakpad/common/stabs_to_module.h
function namespace (line 49) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/stabs_to_module_unittest.cc
function TEST (line 43) | TEST(StabsToModule, SimpleCU) {
function TEST (line 80) | TEST(StabsToModule, Externs) {
function TEST (line 106) | TEST(StabsToModule, DuplicateFunctionNames) {
function TEST (line 138) | TEST(InferSizes, LineSize) {
function TEST (line 189) | TEST(FunctionNames, Mangled) {
function TEST (line 229) | TEST(Omitted, Function) {
FILE: archive/spotify/breakpad/common/string_conversion.cc
type google_breakpad (line 35) | namespace google_breakpad {
function UTF8ToUTF16 (line 40) | void UTF8ToUTF16(const char *in, vector<u_int16_t> *out) {
function UTF8ToUTF16Char (line 57) | int UTF8ToUTF16Char(const char *in, int in_length, u_int16_t out[2]) {
function UTF32ToUTF16 (line 84) | void UTF32ToUTF16(const wchar_t *in, vector<u_int16_t> *out) {
function UTF32ToUTF16Char (line 101) | void UTF32ToUTF16Char(wchar_t in, u_int16_t out[2]) {
function u_int16_t (line 116) | static inline u_int16_t Swap(u_int16_t value) {
function string (line 120) | string UTF16ToUTF8(const vector<u_int16_t> &in, bool swap) {
FILE: archive/spotify/breakpad/common/string_conversion.h
function namespace (line 39) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/test_assembler.cc
type google_breakpad (line 42) | namespace google_breakpad {
type test_assembler (line 43) | namespace test_assembler {
function Label (line 57) | Label &Label::operator=(u_int64_t value) {
function Label (line 62) | Label &Label::operator=(const Label &label) {
function Label (line 67) | Label Label::operator+(u_int64_t addend) const {
function Label (line 73) | Label Label::operator-(u_int64_t subtrahend) const {
function u_int64_t (line 92) | u_int64_t Label::operator-(const Label &label) const {
function u_int64_t (line 98) | u_int64_t Label::Value() const {
function InsertEndian (line 205) | static inline void InsertEndian(test_assembler::Endianness endianness,
function Section (line 221) | Section &Section::Append(Endianness endianness, size_t size, u_int64...
function Section (line 227) | Section &Section::Append(Endianness endianness, size_t size,
function Section (line 293) | Section &Section::Append(const Section §ion) {
function Section (line 303) | Section &Section::LEB128(long long value) {
function Section (line 315) | Section &Section::ULEB128(u_int64_t value) {
function Section (line 324) | Section &Section::Align(size_t alignment, u_int8_t pad_byte) {
FILE: archive/spotify/breakpad/common/test_assembler.h
function namespace (line 65) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/test_assembler_unittest.cc
function TEST (line 47) | TEST(ConstructLabel, Simple) {
function TEST (line 51) | TEST(ConstructLabel, Undefined) {
function TEST (line 56) | TEST(ConstructLabelDeathTest, Undefined) {
function TEST (line 61) | TEST(ConstructLabel, Constant) {
function TEST (line 69) | TEST(ConstructLabel, Copy) {
function TEST (line 80) | TEST(Assignment, UnconstrainedToUnconstrained) {
function TEST (line 91) | TEST(Assignment, UnconstrainedToRelated) {
function TEST (line 103) | TEST(Assignment, UnconstrainedToKnown) {
function TEST (line 116) | TEST(Assignment, RelatedToUnconstrained) {
function TEST (line 128) | TEST(Assignment, RelatedToRelated) {
function TEST (line 141) | TEST(Assignment, RelatedToKnown) {
function TEST (line 154) | TEST(Assignment, KnownToUnconstrained) {
function TEST (line 164) | TEST(Assignment, KnownToRelated) {
function TEST (line 177) | TEST(Assignment, KnownToKnown) {
function TEST (line 188) | TEST(Assignment, ConstantToUnconstrained) {
function TEST (line 195) | TEST(Assignment, ConstantToRelated) {
function TEST (line 205) | TEST(Assignment, ConstantToKnown) {
function TEST (line 213) | TEST(AssignmentDeathTest, Self) {
function TEST (line 218) | TEST(AssignmentDeathTest, IndirectCycle) {
function TEST (line 225) | TEST(AssignmentDeathTest, Cycle) {
function TEST (line 233) | TEST(Addition, LabelConstant) {
function TEST (line 243) | TEST(Addition, ConstantLabel) {
function TEST (line 253) | TEST(Addition, KnownLabelConstant) {
function TEST (line 265) | TEST(Addition, ConstantKnownLabel) {
function TEST (line 277) | TEST(Subtraction, LabelConstant) {
function TEST (line 287) | TEST(Subtraction, KnownLabelConstant) {
function TEST (line 299) | TEST(SubtractionDeathTest, LabelLabel) {
function TEST (line 304) | TEST(Subtraction, LabelLabel) {
function TEST (line 311) | TEST(IsKnownConstant, Undefined) {
function TEST (line 316) | TEST(IsKnownConstant, RelatedLabel) {
function TEST (line 323) | TEST(IsKnownConstant, Constant) {
function TEST (line 329) | TEST(IsKnownOffsetFrom, Unrelated) {
function TEST (line 334) | TEST(IsKnownOffsetFrom, Related) {
function TEST (line 371) | TEST(LabelChain, AssignStartRelationBeforeForward) {
function TEST (line 384) | TEST(LabelChain, AssignStartRelationBeforeBackward) {
function TEST (line 397) | TEST(LabelChain, AssignStartRelationAfterForward) {
function TEST (line 410) | TEST(LabelChain, AssignStartRelationAfterBackward) {
function TEST (line 423) | TEST(LabelChain, AssignStartValueBeforeForward) {
function TEST (line 435) | TEST(LabelChain, AssignStartValueBeforeBackward) {
function TEST (line 447) | TEST(LabelChain, AssignStartValueAfterForward) {
function TEST (line 459) | TEST(LabelChain, AssignStartValueAfterBackward) {
function TEST (line 471) | TEST(LabelChain, AssignEndRelationBeforeForward) {
function TEST (line 484) | TEST(LabelChain, AssignEndRelationBeforeBackward) {
function TEST (line 497) | TEST(LabelChain, AssignEndRelationAfterForward) {
function TEST (line 510) | TEST(LabelChain, AssignEndRelationAfterBackward) {
function TEST (line 523) | TEST(LabelChain, AssignEndValueBeforeForward) {
function TEST (line 535) | TEST(LabelChain, AssignEndValueBeforeBackward) {
function TEST (line 547) | TEST(LabelChain, AssignEndValueAfterForward) {
function TEST (line 559) | TEST(LabelChain, AssignEndValueAfterBackward) {
function TEST (line 571) | TEST(LabelChain, ConstructStartRelationBeforeForward) {
function TEST (line 583) | TEST(LabelChain, ConstructStartRelationAfterForward) {
function TEST (line 596) | TEST(LabelChain, ConstructStartValueBeforeForward) {
function TEST (line 607) | TEST(LabelChain, ConstructStartValueAfterForward) {
function TEST (line 619) | TEST(LabelChain, ConstructEndRelationAfterForward) {
function TEST (line 632) | TEST(LabelChain, ConstructEndValueAfterForward) {
function TEST (line 644) | TEST(LabelTree, KnownValue) {
function TEST (line 654) | TEST(LabelTree, Related) {
function TEST (line 663) | TEST(EquationDeathTest, EqualConstants) {
function TEST (line 669) | TEST(EquationDeathTest, EqualIndirectConstants) {
function TEST (line 677) | TEST(EquationDeathTest, ConstantClash) {
function TEST (line 683) | TEST(EquationDeathTest, IndirectConstantClash) {
function TEST (line 694) | TEST(LabelReferenceCount, AssignmentFree) {
function TEST (line 707) | TEST(LabelReferenceCount, FindValueFree) {
function TEST (line 722) | TEST(ConstructSection, Simple) {
function TEST (line 726) | TEST(ConstructSection, WithEndian) {
class SectionFixture (line 731) | class SectionFixture {
class Append (line 763) | class Append: public SectionFixture, public Test { }
function TEST_F (line 765) | TEST_F(Append, Bytes) {
function TEST_F (line 772) | TEST_F(Append, BytesTwice) {
function TEST_F (line 782) | TEST_F(Append, String) {
function TEST_F (line 791) | TEST_F(Append, CString) {
function TEST_F (line 799) | TEST_F(Append, CStringSize) {
function TEST_F (line 809) | TEST_F(Append, RepeatedBytes) {
function TEST_F (line 815) | TEST_F(Append, GeneralLE1) {
function TEST_F (line 821) | TEST_F(Append, GeneralLE2) {
function TEST_F (line 827) | TEST_F(Append, GeneralLE3) {
function TEST_F (line 833) | TEST_F(Append, GeneralLE4) {
function TEST_F (line 839) | TEST_F(Append, GeneralLE5) {
function TEST_F (line 845) | TEST_F(Append, GeneralLE6) {
function TEST_F (line 851) | TEST_F(Append, GeneralLE7) {
function TEST_F (line 857) | TEST_F(Append, GeneralLE8) {
function TEST_F (line 863) | TEST_F(Append, GeneralBE1) {
function TEST_F (line 869) | TEST_F(Append, GeneralBE2) {
function TEST_F (line 875) | TEST_F(Append, GeneralBE3) {
function TEST_F (line 881) | TEST_F(Append, GeneralBE4) {
function TEST_F (line 887) | TEST_F(Append, GeneralBE5) {
function TEST_F (line 893) | TEST_F(Append, GeneralBE6) {
function TEST_F (line 899) | TEST_F(Append, GeneralBE7) {
function TEST_F (line 905) | TEST_F(Append, GeneralBE8) {
function TEST_F (line 911) | TEST_F(Append, GeneralLE1Label) {
function TEST_F (line 919) | TEST_F(Append, GeneralLE2Label) {
function TEST_F (line 927) | TEST_F(Append, GeneralLE3Label) {
function TEST_F (line 935) | TEST_F(Append, GeneralLE4Label) {
function TEST_F (line 943) | TEST_F(Append, GeneralLE5Label) {
function TEST_F (line 951) | TEST_F(Append, GeneralLE6Label) {
function TEST_F (line 959) | TEST_F(Append, GeneralLE7Label) {
function TEST_F (line 967) | TEST_F(Append, GeneralLE8Label) {
function TEST_F (line 975) | TEST_F(Append, GeneralBE1Label) {
function TEST_F (line 983) | TEST_F(Append, GeneralBE2Label) {
function TEST_F (line 991) | TEST_F(Append, GeneralBE3Label) {
function TEST_F (line 999) | TEST_F(Append, GeneralBE4Label) {
function TEST_F (line 1007) | TEST_F(Append, GeneralBE5Label) {
function TEST_F (line 1015) | TEST_F(Append, GeneralBE6Label) {
function TEST_F (line 1023) | TEST_F(Append, GeneralBE7Label) {
function TEST_F (line 1031) | TEST_F(Append, GeneralBE8Label) {
function TEST_F (line 1039) | TEST_F(Append, B8) {
function TEST_F (line 1046) | TEST_F(Append, B8Label) {
function TEST_F (line 1055) | TEST_F(Append, B16) {
function TEST_F (line 1062) | TEST_F(Append, B16Label) {
function TEST_F (line 1071) | TEST_F(Append, B32) {
function TEST_F (line 1078) | TEST_F(Append, B32Label) {
function TEST_F (line 1087) | TEST_F(Append, B64) {
function TEST_F (line 1095) | TEST_F(Append, B64Label) {
function TEST_F (line 1105) | TEST_F(Append, L8) {
function TEST_F (line 1112) | TEST_F(Append, L8Label) {
function TEST_F (line 1121) | TEST_F(Append, L16) {
function TEST_F (line 1128) | TEST_F(Append, L16Label) {
function TEST_F (line 1137) | TEST_F(Append, L32) {
function TEST_F (line 1144) | TEST_F(Append, L32Label) {
function TEST_F (line 1153) | TEST_F(Append, L64) {
function TEST_F (line 1161) | TEST_F(Append, L64Label) {
function TEST_F (line 1171) | TEST_F(Append, D8Big) {
function TEST_F (line 1179) | TEST_F(Append, D8BigLabel) {
function TEST_F (line 1189) | TEST_F(Append, D16Big) {
function TEST_F (line 1197) | TEST_F(Append, D16BigLabel) {
function TEST_F (line 1207) | TEST_F(Append, D32Big) {
function TEST_F (line 1215) | TEST_F(Append, D32BigLabel) {
function TEST_F (line 1225) | TEST_F(Append, D64Big) {
function TEST_F (line 1234) | TEST_F(Append, D64BigLabel) {
function TEST_F (line 1245) | TEST_F(Append, D8Little) {
function TEST_F (line 1253) | TEST_F(Append, D8LittleLabel) {
function TEST_F (line 1263) | TEST_F(Append, D16Little) {
function TEST_F (line 1271) | TEST_F(Append, D16LittleLabel) {
function TEST_F (line 1281) | TEST_F(Append, D32Little) {
function TEST_F (line 1289) | TEST_F(Append, D32LittleLabel) {
function TEST_F (line 1299) | TEST_F(Append, D64Little) {
function TEST_F (line 1308) | TEST_F(Append, D64LittleLabel) {
function TEST_F (line 1319) | TEST_F(Append, Variety) {
function TEST_F (line 1386) | TEST_F(Append, Section) {
function TEST_F (line 1399) | TEST_F(Append, SectionRefs) {
function TEST_F (line 1415) | TEST_F(Append, LEB128_0) {
function TEST_F (line 1421) | TEST_F(Append, LEB128_0x3f) {
function TEST_F (line 1427) | TEST_F(Append, LEB128_0x40) {
function TEST_F (line 1433) | TEST_F(Append, LEB128_0x7f) {
function TEST_F (line 1439) | TEST_F(Append, LEB128_0x80) {
function TEST_F (line 1445) | TEST_F(Append, LEB128_0xff) {
function TEST_F (line 1451) | TEST_F(Append, LEB128_0x1fff) {
function TEST_F (line 1457) | TEST_F(Append, LEB128_0x2000) {
function TEST_F (line 1463) | TEST_F(Append, LEB128_n1) {
function TEST_F (line 1469) | TEST_F(Append, LEB128_n0x40) {
function TEST_F (line 1475) | TEST_F(Append, LEB128_n0x41) {
function TEST_F (line 1481) | TEST_F(Append, LEB128_n0x7f) {
function TEST_F (line 1487) | TEST_F(Append, LEB128_n0x80) {
function TEST_F (line 1493) | TEST_F(Append, LEB128_n0x2000) {
function TEST_F (line 1499) | TEST_F(Append, LEB128_n0x2001) {
function TEST_F (line 1505) | TEST_F(Append,ULEB128_0) {
function TEST_F (line 1511) | TEST_F(Append,ULEB128_1) {
function TEST_F (line 1517) | TEST_F(Append,ULEB128_0x3f) {
function TEST_F (line 1523) | TEST_F(Append,ULEB128_0x40) {
function TEST_F (line 1529) | TEST_F(Append,ULEB128_0x7f) {
function TEST_F (line 1535) | TEST_F(Append,ULEB128_0x80) {
function TEST_F (line 1541) | TEST_F(Append,ULEB128_0xff) {
function TEST_F (line 1547) | TEST_F(Append,ULEB128_0x100) {
function TEST_F (line 1553) | TEST_F(Append,ULEB128_0x1fff) {
function TEST_F (line 1559) | TEST_F(Append,ULEB128_0x2000) {
function TEST_F (line 1565) | TEST_F(Append,ULEB128_0x3fff) {
function TEST_F (line 1571) | TEST_F(Append,ULEB128_0x4000) {
function TEST_F (line 1577) | TEST_F(Append,ULEB128_12857) {
function TEST_F (line 1583) | TEST_F(Append, LEBChain) {
class GetContents (line 1590) | class GetContents: public SectionFixture, public Test { }
function TEST_F (line 1592) | TEST_F(GetContents, Undefined) {
function TEST_F (line 1598) | TEST_F(GetContents, ClearsContents) {
function TEST_F (line 1605) | TEST_F(GetContents, ClearsReferences) {
class Miscellanea (line 1614) | class Miscellanea: public SectionFixture, public Test { }
function TEST_F (line 1616) | TEST_F(Miscellanea, Clear) {
function TEST_F (line 1627) | TEST_F(Miscellanea, Align) {
function TEST_F (line 1636) | TEST_F(Miscellanea, AlignPad) {
function TEST_F (line 1647) | TEST_F(Miscellanea, StartHereMark) {
function TEST_F (line 1657) | TEST_F(Miscellanea, Endianness) {
FILE: archive/spotify/breakpad/common/windows/guid_string.cc
type google_breakpad (line 40) | namespace google_breakpad {
function wstring (line 43) | wstring GUIDString::GUIDToWString(GUID *guid) {
function wstring (line 60) | wstring GUIDString::GUIDToSymbolServerWString(GUID *guid) {
FILE: archive/spotify/breakpad/common/windows/guid_string.h
function namespace (line 39) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/windows/http_upload.cc
type google_breakpad (line 41) | namespace google_breakpad {
class HTTPUpload::AutoInternetHandle (line 49) | class HTTPUpload::AutoInternetHandle {
method AutoInternetHandle (line 51) | explicit AutoInternetHandle(HINTERNET handle) : handle_(handle) {}
method HINTERNET (line 58) | HINTERNET get() { return handle_; }
function wstring (line 245) | wstring HTTPUpload::GenerateMultipartBoundary() {
function wstring (line 264) | wstring HTTPUpload::GenerateRequestHeader(const wstring &boundary) {
function wstring (line 351) | wstring HTTPUpload::UTF8ToWide(const string &utf8) {
function string (line 372) | string HTTPUpload::WideToUTF8(const wstring &wide) {
FILE: archive/spotify/breakpad/common/windows/http_upload.h
function namespace (line 48) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/windows/pdb_source_line_writer.cc
type google_breakpad (line 46) | namespace google_breakpad {
class AutoImage (line 51) | class AutoImage {
method AutoImage (line 53) | explicit AutoImage(PLOADED_IMAGE img) : img_(img) {}
method PLOADED_IMAGE (line 60) | PLOADED_IMAGE operator->() { return img_; }
function wcstol_positive_strict (line 547) | static bool wcstol_positive_strict(wchar_t *string, int *result) {
FILE: archive/spotify/breakpad/common/windows/pdb_source_line_writer.h
type IDiaEnumLineNumbers (line 41) | struct IDiaEnumLineNumbers
type IDiaSession (line 42) | struct IDiaSession
type IDiaSymbol (line 43) | struct IDiaSymbol
function namespace (line 45) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/windows/string_utils-inl.h
function namespace (line 65) | namespace google_breakpad {
FILE: archive/spotify/breakpad/common/windows/string_utils.cc
type google_breakpad (line 35) | namespace google_breakpad {
function wstring (line 38) | wstring WindowsStringUtils::GetBaseName(const wstring &filename) {
FILE: archive/spotify/breakpad/google_breakpad/common/breakpad_types.h
type u_int8_t (line 52) | typedef uint8_t u_int8_t;
type u_int16_t (line 53) | typedef uint16_t u_int16_t;
type u_int32_t (line 54) | typedef uint32_t u_int32_t;
type u_int64_t (line 55) | typedef uint64_t u_int64_t;
type u_int8_t (line 62) | typedef unsigned __int8 u_int8_t;
type u_int16_t (line 63) | typedef unsigned __int16 u_int16_t;
type u_int32_t (line 64) | typedef unsigned __int32 u_int32_t;
type u_int64_t (line 65) | typedef unsigned __int64 u_int64_t;
type u_int128_t (line 69) | typedef struct {
type u_int64_t (line 74) | typedef u_int64_t breakpad_time_t;
FILE: archive/spotify/breakpad/google_breakpad/common/minidump_cpu_amd64.h
type MDXmmSaveArea32AMD64 (line 81) | typedef struct {
type MDRawContextAMD64 (line 102) | typedef struct {
FILE: archive/spotify/breakpad/google_breakpad/common/minidump_cpu_arm.h
type MDFloatingSaveAreaARM (line 79) | typedef struct {
type MDRawContextARM (line 91) | typedef struct {
type MDARMRegisterNumbers (line 122) | enum MDARMRegisterNumbers {
FILE: archive/spotify/breakpad/google_breakpad/common/minidump_cpu_ppc.h
type MDFloatingSaveAreaPPC (line 83) | typedef struct {
type MDVectorSaveAreaPPC (line 94) | typedef struct {
type MDRawContextPPC (line 116) | typedef struct {
FILE: archive/spotify/breakpad/google_breakpad/common/minidump_cpu_ppc64.h
type MDFloatingSaveAreaPPC (line 84) | typedef MDFloatingSaveAreaPPC MDFloatingSaveAreaPPC64;
type MDVectorSaveAreaPPC (line 85) | typedef MDVectorSaveAreaPPC MDVectorSaveAreaPPC64;
type MDRawContextPPC64 (line 89) | typedef struct {
FILE: archive/spotify/breakpad/google_breakpad/common/minidump_cpu_sparc.h
type MDFloatingSaveAreaSPARC (line 82) | typedef struct {
type MDRawContextSPARC (line 93) | typedef struct {
FILE: archive/spotify/breakpad/google_breakpad/common/minidump_cpu_x86.h
type MDFloatingSaveAreaX86 (line 78) | typedef struct {
type MDRawContextX86 (line 97) | typedef struct {
FILE: archive/spotify/breakpad/google_breakpad/common/minidump_exception_linux.h
type MDExceptionCodeLinux (line 49) | typedef enum {
FILE: archive/spotify/breakpad/google_breakpad/common/minidump_exception_mac.h
type MDExceptionMac (line 49) | typedef enum {
type MDExceptionCodeMac (line 75) | typedef enum {
FILE: archive/spotify/breakpad/google_breakpad/common/minidump_exception_solaris.h
type MDExceptionCodeSolaris (line 48) | typedef enum {
FILE: archive/spotify/breakpad/google_breakpad/common/minidump_exception_win32.h
type MDExceptionCodeWin (line 50) | typedef enum {
type MDAccessViolationTypeWin (line 110) | typedef enum {
FILE: archive/spotify/breakpad/google_breakpad/common/minidump_format.h
type MDGUID (line 81) | typedef struct {
type MDRawContextBase (line 112) | typedef struct {
type MDVSFixedFileInfo (line 128) | typedef struct {
type u_int32_t (line 234) | typedef u_int32_t MDRVA;
type MDLocationDescriptor (line 236) | typedef struct {
type MDMemoryDescriptor (line 242) | typedef struct {
type MDRawHeader (line 251) | typedef struct {
type MDType (line 272) | typedef enum {
type MDRawDirectory (line 304) | typedef struct {
type MDStreamType (line 310) | typedef enum {
type MDString (line 338) | typedef struct {
type MDRawThread (line 347) | typedef struct {
type MDRawThreadList (line 358) | typedef struct {
type MDRawModule (line 367) | typedef struct {
type MDCVHeader (line 411) | typedef struct {
type MDCVInfoPDB20 (line 416) | typedef struct {
type MDCVInfoPDB70 (line 428) | typedef struct {
type MDCVInfoELF (line 441) | typedef struct {
type MDImageDebugMisc (line 471) | typedef struct {
type MDRawModuleList (line 484) | typedef struct {
type MDRawMemoryList (line 493) | typedef struct {
type MDException (line 504) | typedef struct {
type MDRawExceptionStream (line 527) | typedef struct {
type MDCPUInformation (line 537) | typedef union {
type MDRawSystemInfo (line 550) | typedef struct {
type MDCPUArchitecture (line 582) | typedef enum {
type MDOSPlatform (line 602) | typedef enum {
type MDRawMiscInfo (line 618) | typedef struct {
type MDMiscInfoFlags1 (line 649) | typedef enum {
type MDRawMemoryInfoList (line 668) | typedef struct {
type MDRawMemoryInfo (line 674) | typedef struct {
type MDMemoryState (line 690) | typedef enum {
type MDMemoryProtection (line 697) | typedef enum {
type MDMemoryType (line 716) | typedef enum {
type MDRawBreakpadInfo (line 727) | typedef struct {
type MDBreakpadInfoValidity (line 755) | typedef enum {
type MDRawAssertionInfo (line 763) | typedef struct {
type MDAssertionInfoData (line 777) | typedef enum {
FILE: archive/spotify/breakpad/google_breakpad/common/minidump_size.h
function namespace (line 42) | namespace google_breakpad {
FILE: archive/spotify/breakpad/google_breakpad/processor/basic_source_line_resolver.h
function namespace (line 45) | namespace google_breakpad {
FILE: archive/spotify/breakpad/google_breakpad/processor/call_stack.h
function namespace (line 50) | namespace google_breakpad {
FILE: archive/spotify/breakpad/google_breakpad/processor/code_module.h
function namespace (line 41) | namespace google_breakpad {
FILE: archive/spotify/breakpad/google_breakpad/processor/code_modules.h
function namespace (line 40) | namespace google_breakpad {
FILE: archive/spotify/breakpad/google_breakpad/processor/exploitability.h
function namespace (line 47) | namespace google_breakpad {
FILE: archive/spotify/breakpad/google_breakpad/processor/fast_source_line_resolver.h
function namespace (line 53) | namespace google_breakpad {
FILE: archive/spotify/breakpad/google_breakpad/processor/memory_region.h
function namespace (line 45) | namespace google_breakpad {
FILE: archive/spotify/breakpad/google_breakpad/processor/minidump.h
function class (line 111) | class MinidumpObject {
function class (line 142) | class MinidumpStream : public MinidumpObject {
function set_max_bytes (line 241) | static void set_max_bytes(u_int32_t max_bytes) { max_bytes_ = max_bytes; }
function u_int32_t (line 242) | static u_int32_t max_bytes() { return max_bytes_; }
function u_int64_t (line 250) | u_int64_t GetBase() const;
function class (line 335) | class MinidumpThreadList : public MinidumpStream {
function set_max_cv_bytes (line 391) | static void set_max_cv_bytes(u_int32_t max_cv_bytes) {
function u_int32_t (line 394) | static u_int32_t max_cv_bytes() { return max_cv_bytes_; }
function set_max_misc_bytes (line 396) | static void set_max_misc_bytes(u_int32_t max_misc_bytes) {
function u_int32_t (line 399) | static u_int32_t max_misc_bytes() { return max_misc_bytes_; }
function MDRawModule (line 401) | const MDRawModule* module() const { return valid_ ? &module_ : NULL; }
function virtual (line 408) | virtual string code_file() const;
function class (line 557) | class MinidumpMemoryList : public MinidumpStream {
function class (line 615) | class MinidumpException : public MinidumpStream {
function class (line 649) | class MinidumpAssertion : public MinidumpStream {
function class (line 690) | class MinidumpSystemInfo : public MinidumpStream {
function class (line 744) | class MinidumpMiscInfo : public MinidumpStream {
function class (line 769) | class MinidumpBreakpadInfo : public MinidumpStream {
function IsExecutable (line 811) | bool IsExecutable() const;
function set_max_streams (line 885) | static void set_max_streams(u_int32_t max_streams) {
function u_int32_t (line 888) | static u_int32_t max_streams() { return max_streams_; }
function set_max_string_length (line 890) | static void set_max_string_length(u_int32_t max_string_length) {
function u_int32_t (line 893) | static u_int32_t max_string_length() { return max_string_length_; }
function virtual (line 895) | virtual const MDRawHeader* header() const { return valid_ ? &header_ : N...
FILE: archive/spotify/breakpad/google_breakpad/processor/minidump_processor.h
function namespace (line 37) | namespace google_breakpad {
FILE: archive/spotify/breakpad/google_breakpad/processor/process_state.h
function namespace (line 43) | namespace google_breakpad {
FILE: archive/spotify/breakpad/google_breakpad/processor/source_line_resolver_base.h
function namespace (line 49) | namespace google_breakpad {
FILE: archive/spotify/breakpad/google_breakpad/processor/source_line_resolver_interface.h
function namespace (line 41) | namespace google_breakpad {
FILE: archive/spotify/breakpad/google_breakpad/processor/stack_frame.h
function namespace (line 36) | namespace google_breakpad {
FILE: archive/spotify/breakpad/google_breakpad/processor/stack_frame_cpu.h
function namespace (line 47) | namespace google_breakpad {
FILE: archive/spotify/breakpad/google_breakpad/processor/stackwalker.h
function namespace (line 50) | namespace google_breakpad {
FILE: archive/spotify/breakpad/google_breakpad/processor/symbol_supplier.h
function namespace (line 38) | namespace google_breakpad {
FILE: archive/spotify/breakpad/google_breakpad/processor/system_info.h
function namespace (line 40) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/address_map-inl.h
function namespace (line 45) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/address_map.h
function namespace (line 43) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/address_map_unittest.cc
class CountedObject (line 58) | class CountedObject {
method CountedObject (line 60) | explicit CountedObject(int id) : id_(id) { ++count_; }
method count (line 63) | static int count() { return count_; }
method id (line 64) | int id() const { return id_; }
function DoAddressMapTest (line 76) | static bool DoAddressMapTest() {
function RunTests (line 180) | static bool RunTests() {
function main (line 192) | int main(int argc, char **argv) {
FILE: archive/spotify/breakpad/processor/basic_code_module.h
function namespace (line 48) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/basic_code_modules.cc
type google_breakpad (line 46) | namespace google_breakpad {
function CodeModule (line 84) | const CodeModule* BasicCodeModules::GetModuleForAddress(
function CodeModule (line 95) | const CodeModule* BasicCodeModules::GetMainModule() const {
function CodeModule (line 99) | const CodeModule* BasicCodeModules::GetModuleAtSequence(
function CodeModule (line 110) | const CodeModule* BasicCodeModules::GetModuleAtIndex(
function CodeModules (line 119) | const CodeModules* BasicCodeModules::Copy() const {
FILE: archive/spotify/breakpad/processor/basic_code_modules.h
function namespace (line 46) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/basic_source_line_resolver.cc
type google_breakpad (line 56) | namespace google_breakpad {
function WindowsFrameInfo (line 187) | WindowsFrameInfo *BasicSourceLineResolver::Module::FindWindowsFrameInfo(
function CFIFrameInfo (line 236) | CFIFrameInfo *BasicSourceLineResolver::Module::FindCFIFrameInfo(
FILE: archive/spotify/breakpad/processor/basic_source_line_resolver_types.h
function namespace (line 56) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/basic_source_line_resolver_unittest.cc
class TestCodeModule (line 57) | class TestCodeModule : public CodeModule {
method TestCodeModule (line 59) | TestCodeModule(string code_file) : code_file_(code_file) {}
method u_int64_t (line 62) | virtual u_int64_t base_address() const { return 0; }
method u_int64_t (line 63) | virtual u_int64_t size() const { return 0xb000; }
method string (line 64) | virtual string code_file() const { return code_file_; }
method string (line 65) | virtual string code_identifier() const { return ""; }
method string (line 66) | virtual string debug_file() const { return ""; }
method string (line 67) | virtual string debug_identifier() const { return ""; }
method string (line 68) | virtual string version() const { return ""; }
method CodeModule (line 69) | virtual const CodeModule* Copy() const {
class MockMemoryRegion (line 78) | class MockMemoryRegion: public MemoryRegion {
method u_int64_t (line 79) | u_int64_t GetBase() const { return 0x10000; }
method u_int32_t (line 80) | u_int32_t GetSize() const { return 0x01000; }
method GetMemoryAtAddress (line 81) | bool GetMemoryAtAddress(u_int64_t address, u_int8_t *value) const {
method GetMemoryAtAddress (line 85) | bool GetMemoryAtAddress(u_int64_t address, u_int16_t *value) const {
method GetMemoryAtAddress (line 89) | bool GetMemoryAtAddress(u_int64_t address, u_int32_t *value) const {
method GetMemoryAtAddress (line 100) | bool GetMemoryAtAddress(u_int64_t address, u_int64_t *value) const {
function VerifyRegisters (line 110) | static bool VerifyRegisters(
function VerifyEmpty (line 143) | static bool VerifyEmpty(const StackFrame &frame) {
function ClearSourceLineInfo (line 151) | static void ClearSourceLineInfo(StackFrame *frame) {
class TestBasicSourceLineResolver (line 158) | class TestBasicSourceLineResolver : public ::testing::Test {
method SetUp (line 160) | void SetUp() {
function TEST_F (line 169) | TEST_F(TestBasicSourceLineResolver, TestLoadAndResolve)
function TEST_F (line 376) | TEST_F(TestBasicSourceLineResolver, TestInvalidLoads)
function TEST_F (line 394) | TEST_F(TestBasicSourceLineResolver, TestUnload)
function main (line 408) | int main(int argc, char *argv[]) {
FILE: archive/spotify/breakpad/processor/binarystream.cc
type google_breakpad (line 37) | namespace google_breakpad {
function binarystream (line 41) | binarystream &binarystream::operator>>(std::string &str) {
function binarystream (line 57) | binarystream &binarystream::operator>>(u_int8_t &u8) {
function binarystream (line 62) | binarystream &binarystream::operator>>(u_int16_t &u16) {
function binarystream (line 70) | binarystream &binarystream::operator>>(u_int32_t &u32) {
function binarystream (line 78) | binarystream &binarystream::operator>>(u_int64_t &u64) {
function binarystream (line 86) | binarystream &binarystream::operator<<(const std::string &str) {
function binarystream (line 98) | binarystream &binarystream::operator<<(u_int8_t u8) {
function binarystream (line 103) | binarystream &binarystream::operator<<(u_int16_t u16) {
function binarystream (line 109) | binarystream &binarystream::operator<<(u_int32_t u32) {
function binarystream (line 115) | binarystream &binarystream::operator<<(u_int64_t u64) {
FILE: archive/spotify/breakpad/processor/binarystream.h
function namespace (line 42) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/binarystream_unittest.cc
class BinaryStreamBasicTest (line 44) | class BinaryStreamBasicTest : public ::testing::Test {
function TEST_F (line 49) | TEST_F(BinaryStreamBasicTest, ReadU8) {
function TEST_F (line 64) | TEST_F(BinaryStreamBasicTest, ReadU16) {
function TEST_F (line 79) | TEST_F(BinaryStreamBasicTest, ReadU32) {
function TEST_F (line 94) | TEST_F(BinaryStreamBasicTest, ReadU64) {
function TEST_F (line 109) | TEST_F(BinaryStreamBasicTest, ReadString) {
function TEST_F (line 132) | TEST_F(BinaryStreamBasicTest, ReadEmptyString) {
function TEST_F (line 139) | TEST_F(BinaryStreamBasicTest, ReadMultiU8) {
function TEST_F (line 169) | TEST_F(BinaryStreamBasicTest, ReadMultiU16) {
function TEST_F (line 199) | TEST_F(BinaryStreamBasicTest, ReadMultiU32) {
function TEST_F (line 229) | TEST_F(BinaryStreamBasicTest, ReadMultiU64) {
function TEST_F (line 260) | TEST_F(BinaryStreamBasicTest, ReadMixed) {
function TEST_F (line 281) | TEST_F(BinaryStreamBasicTest, ReadStringMissing) {
function TEST_F (line 292) | TEST_F(BinaryStreamBasicTest, ReadStringTruncated) {
function TEST_F (line 304) | TEST_F(BinaryStreamBasicTest, StreamByteLength) {
function TEST_F (line 312) | TEST_F(BinaryStreamBasicTest, AppendStreamResultsByteLength) {
function TEST_F (line 325) | TEST_F(BinaryStreamBasicTest, StreamSetStr) {
class BinaryStreamU8Test (line 342) | class BinaryStreamU8Test : public ::testing::Test {
method SetUp (line 346) | void SetUp() {
function TEST_F (line 351) | TEST_F(BinaryStreamU8Test, ReadU16) {
function TEST_F (line 359) | TEST_F(BinaryStreamU8Test, ReadU32) {
function TEST_F (line 367) | TEST_F(BinaryStreamU8Test, ReadU64) {
function TEST_F (line 375) | TEST_F(BinaryStreamU8Test, ReadString) {
function TEST (line 384) | TEST(BinaryStreamTest, InitWithData) {
function TEST (line 396) | TEST(BinaryStreamTest, InitWithDataLeadingNull) {
function TEST (line 409) | TEST(BinaryStreamTest, InitWithDataVector) {
function main (line 429) | int main(int argc, char *argv[]) {
FILE: archive/spotify/breakpad/processor/call_stack.cc
type google_breakpad (line 39) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/cfi_frame_info-inl.h
function namespace (line 41) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/cfi_frame_info.cc
type google_breakpad (line 44) | namespace google_breakpad {
function string (line 100) | string CFIFrameInfo::Serialize() const {
FILE: archive/spotify/breakpad/processor/cfi_frame_info.h
function namespace (line 46) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/cfi_frame_info_unittest.cc
class MockMemoryRegion (line 55) | class MockMemoryRegion: public MemoryRegion {
type CFIFixture (line 66) | struct CFIFixture {
method ExpectNoMemoryReferences (line 69) | void ExpectNoMemoryReferences() {
class Simple (line 83) | class Simple: public CFIFixture, public Test { }
function TEST_F (line 86) | TEST_F(Simple, NoCFA) {
function TEST_F (line 96) | TEST_F(Simple, NoRA) {
function TEST_F (line 105) | TEST_F(Simple, SetCFAAndRARule) {
function TEST_F (line 120) | TEST_F(Simple, SetManyRules) {
function TEST_F (line 147) | TEST_F(Simple, RulesOverride) {
class Scope (line 162) | class Scope: public CFIFixture, public Test { }
function TEST_F (line 165) | TEST_F(Scope, CFALacksCFA) {
function TEST_F (line 175) | TEST_F(Scope, CFALacksRA) {
function TEST_F (line 186) | TEST_F(Scope, CFASeesCurrentRegs) {
function TEST_F (line 201) | TEST_F(Scope, RASeesCFA) {
function TEST_F (line 213) | TEST_F(Scope, RALacksRA) {
function TEST_F (line 224) | TEST_F(Scope, RASeesCurrentRegs) {
function TEST_F (line 237) | TEST_F(Scope, RegistersSeeCFA) {
function TEST_F (line 250) | TEST_F(Scope, RegsLackRA) {
function TEST_F (line 261) | TEST_F(Scope, RegsSeeRegs) {
function TEST_F (line 278) | TEST_F(Scope, SeparateTempsRA) {
class MockCFIRuleParserHandler (line 292) | class MockCFIRuleParserHandler: public CFIRuleParser::Handler {
class CFIParserFixture (line 300) | class CFIParserFixture {
method CFIParserFixture (line 302) | CFIParserFixture() : parser(&mock_handler) {
class Parser (line 314) | class Parser: public CFIParserFixture, public Test { }
function TEST_F (line 316) | TEST_F(Parser, Empty) {
function TEST_F (line 320) | TEST_F(Parser, LoneColon) {
function TEST_F (line 324) | TEST_F(Parser, CFANoExpr) {
function TEST_F (line 328) | TEST_F(Parser, CFANoColonNoExpr) {
function TEST_F (line 332) | TEST_F(Parser, RANoExpr) {
function TEST_F (line 336) | TEST_F(Parser, RANoColonNoExpr) {
function TEST_F (line 340) | TEST_F(Parser, RegNoExpr) {
function TEST_F (line 344) | TEST_F(Parser, NoName) {
function TEST_F (line 348) | TEST_F(Parser, NoNameTwo) {
function TEST_F (line 352) | TEST_F(Parser, StartsWithExpr) {
function TEST_F (line 356) | TEST_F(Parser, CFA) {
function TEST_F (line 361) | TEST_F(Parser, RA) {
function TEST_F (line 366) | TEST_F(Parser, Reg) {
function TEST_F (line 372) | TEST_F(Parser, CFARARegs) {
function TEST_F (line 383) | TEST_F(Parser, Whitespace) {
function TEST_F (line 392) | TEST_F(Parser, WhitespaceLoneColon) {
function TEST_F (line 396) | TEST_F(Parser, EmptyName) {
function TEST_F (line 403) | TEST_F(Parser, RuleLoneColon) {
function TEST_F (line 410) | TEST_F(Parser, RegNoExprRule) {
class ParseHandlerFixture (line 417) | class ParseHandlerFixture: public CFIFixture {
method ParseHandlerFixture (line 419) | ParseHandlerFixture() : CFIFixture(), handler(&cfi) { }
class ParseHandler (line 423) | class ParseHandler: public ParseHandlerFixture, public Test { }
function TEST_F (line 425) | TEST_F(ParseHandler, CFARARule) {
function TEST_F (line 436) | TEST_F(ParseHandler, RegisterRules) {
type SimpleCFIWalkerFixture (line 453) | struct SimpleCFIWalkerFixture {
type RawContext (line 454) | struct RawContext {
type Validity (line 457) | enum Validity {
method SimpleCFIWalkerFixture (line 468) | SimpleCFIWalkerFixture()
class SimpleWalker (line 490) | class SimpleWalker: public SimpleCFIWalkerFixture, public Test { }
function TEST_F (line 492) | TEST_F(SimpleWalker, Walk) {
FILE: archive/spotify/breakpad/processor/contained_range_map-inl.h
function namespace (line 46) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/contained_range_map.h
function namespace (line 67) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/contained_range_map_unittest.cc
function RunTests (line 56) | static bool RunTests() {
function main (line 259) | int main(int argc, char **argv) {
FILE: archive/spotify/breakpad/processor/disassembler_x86.cc
type google_breakpad (line 32) | namespace google_breakpad {
function u_int32_t (line 57) | u_int32_t DisassemblerX86::NextInstruction() {
FILE: archive/spotify/breakpad/processor/disassembler_x86.h
function namespace (line 43) | namespace libdis {
function namespace (line 47) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/disassembler_x86_unittest.cc
function TEST (line 92) | TEST(DisassemblerX86Test, SimpleReturnInstruction) {
function TEST (line 107) | TEST(DisassemblerX86Test, SimpleInvalidInstruction) {
function TEST (line 113) | TEST(DisassemblerX86Test, BadReadLeadsToBranch) {
function TEST (line 133) | TEST(DisassemblerX86Test, BadWriteLeadsToPushedArg) {
function TEST (line 159) | TEST(DisassemblerX86Test, BadReadLeadsToBlockWrite) {
function TEST (line 179) | TEST(DisassemblerX86Test, BadReadClobberThenWrite) {
function TEST (line 199) | TEST(DisassemblerX86Test, BadReadXCHGThenWrite) {
function TEST (line 224) | TEST(DisassemblerX86Test, BadReadThenCMP) {
FILE: archive/spotify/breakpad/processor/exploitability.cc
type google_breakpad (line 46) | namespace google_breakpad {
function ExploitabilityRating (line 53) | ExploitabilityRating Exploitability::CheckExploitability() {
function Exploitability (line 57) | Exploitability *Exploitability::ExploitabilityForPlatform(
FILE: archive/spotify/breakpad/processor/exploitability_unittest.cc
type google_breakpad (line 56) | namespace google_breakpad {
class MockMinidump (line 57) | class MockMinidump : public Minidump {
method MockMinidump (line 59) | MockMinidump() : Minidump("") {
class TestSymbolSupplier (line 83) | class TestSymbolSupplier : public SymbolSupplier {
method TestSymbolSupplier (line 85) | TestSymbolSupplier() : interrupt_(false) {}
method FreeSymbolData (line 101) | virtual void FreeSymbolData(const CodeModule *module) { }
method set_interrupt (line 103) | void set_interrupt(bool interrupt) { interrupt_ = interrupt; }
function TEST (line 137) | TEST(ExploitabilityTest, TestWindowsEngine) {
FILE: archive/spotify/breakpad/processor/exploitability_win.cc
type google_breakpad (line 49) | namespace google_breakpad {
function ExploitabilityRating (line 76) | ExploitabilityRating ExploitabilityWin::CheckPlatformExploitability() {
FILE: archive/spotify/breakpad/processor/exploitability_win.h
function namespace (line 43) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/fast_source_line_resolver.cc
type google_breakpad (line 52) | namespace google_breakpad {
function WindowsFrameInfo (line 109) | WindowsFrameInfo FastSourceLineResolver::CopyWFI(const char *raw) {
function WindowsFrameInfo (line 179) | WindowsFrameInfo *FastSourceLineResolver::Module::FindWindowsFrameInfo(
function CFIFrameInfo (line 232) | CFIFrameInfo *FastSourceLineResolver::Module::FindCFIFrameInfo(
FILE: archive/spotify/breakpad/processor/fast_source_line_resolver_types.h
function namespace (line 54) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/fast_source_line_resolver_unittest.cc
class TestCodeModule (line 69) | class TestCodeModule : public CodeModule {
method TestCodeModule (line 71) | explicit TestCodeModule(string code_file) : code_file_(code_file) {}
method u_int64_t (line 74) | virtual u_int64_t base_address() const { return 0; }
method u_int64_t (line 75) | virtual u_int64_t size() const { return 0xb000; }
method string (line 76) | virtual string code_file() const { return code_file_; }
method string (line 77) | virtual string code_identifier() const { return ""; }
method string (line 78) | virtual string debug_file() const { return ""; }
method string (line 79) | virtual string debug_identifier() const { return ""; }
method string (line 80) | virtual string version() const { return ""; }
method CodeModule (line 81) | virtual const CodeModule* Copy() const {
class MockMemoryRegion (line 90) | class MockMemoryRegion: public MemoryRegion {
method u_int64_t (line 91) | u_int64_t GetBase() const { return 0x10000; }
method u_int32_t (line 92) | u_int32_t GetSize() const { return 0x01000; }
method GetMemoryAtAddress (line 93) | bool GetMemoryAtAddress(u_int64_t address, u_int8_t *value) const {
method GetMemoryAtAddress (line 97) | bool GetMemoryAtAddress(u_int64_t address, u_int16_t *value) const {
method GetMemoryAtAddress (line 101) | bool GetMemoryAtAddress(u_int64_t address, u_int32_t *value) const {
method GetMemoryAtAddress (line 112) | bool GetMemoryAtAddress(u_int64_t address, u_int64_t *value) const {
function VerifyRegisters (line 122) | static bool VerifyRegisters(
function VerifyEmpty (line 154) | static bool VerifyEmpty(const StackFrame &frame) {
function ClearSourceLineInfo (line 162) | static void ClearSourceLineInfo(StackFrame *frame) {
class TestFastSourceLineResolver (line 169) | class TestFastSourceLineResolver : public ::testing::Test {
method SetUp (line 171) | void SetUp() {
method string (line 176) | string symbol_file(int file_index) {
function TEST_F (line 191) | TEST_F(TestFastSourceLineResolver, TestLoadAndResolve) {
function TEST_F (line 404) | TEST_F(TestFastSourceLineResolver, TestInvalidLoads) {
function TEST_F (line 434) | TEST_F(TestFastSourceLineResolver, TestUnload) {
function TEST_F (line 458) | TEST_F(TestFastSourceLineResolver, CompareModule) {
function main (line 477) | int main(int argc, char *argv[]) {
FILE: archive/spotify/breakpad/processor/linked_ptr.h
function namespace (line 56) | namespace google_breakpad {
function T (line 125) | T* get() const { return value_; }
function depart (line 155) | void depart() {
function capture (line 159) | void capture(T* ptr) {
FILE: archive/spotify/breakpad/processor/logging.cc
type google_breakpad (line 49) | namespace google_breakpad {
type tm (line 56) | struct tm
function HexString (line 83) | std::string HexString(u_int32_t number) {
function HexString (line 89) | std::string HexString(u_int64_t number) {
function HexString (line 95) | std::string HexString(int number) {
function ErrnoString (line 101) | int ErrnoString(std::string *error_string) {
FILE: archive/spotify/breakpad/processor/logging.h
function namespace (line 69) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/map_serializers-inl.h
function namespace (line 52) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/map_serializers.h
function namespace (line 48) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/map_serializers_unittest.cc
class TestStdMapSerializer (line 54) | class TestStdMapSerializer : public ::testing::Test {
method SetUp (line 56) | void SetUp() {
method TearDown (line 61) | void TearDown() {
function TEST_F (line 71) | TEST_F(TestStdMapSerializer, EmptyMapTestCase) {
function TEST_F (line 82) | TEST_F(TestStdMapSerializer, MapWithTwoElementsTestCase) {
function TEST_F (line 104) | TEST_F(TestStdMapSerializer, MapWithFiveElementsTestCase) {
class TestAddressMapSerializer (line 126) | class TestAddressMapSerializer : public ::testing::Test {
method SetUp (line 128) | void SetUp() {
method TearDown (line 133) | void TearDown() {
function TEST_F (line 143) | TEST_F(TestAddressMapSerializer, EmptyMapTestCase) {
function TEST_F (line 154) | TEST_F(TestAddressMapSerializer, MapWithTwoElementsTestCase) {
function TEST_F (line 176) | TEST_F(TestAddressMapSerializer, MapWithFourElementsTestCase) {
class TestRangeMapSerializer (line 201) | class TestRangeMapSerializer : public ::testing::Test {
method SetUp (line 203) | void SetUp() {
method TearDown (line 208) | void TearDown() {
function TEST_F (line 218) | TEST_F(TestRangeMapSerializer, EmptyMapTestCase) {
function TEST_F (line 229) | TEST_F(TestRangeMapSerializer, MapWithOneRangeTestCase) {
function TEST_F (line 250) | TEST_F(TestRangeMapSerializer, MapWithThreeRangesTestCase) {
class TestContainedRangeMapSerializer (line 274) | class TestContainedRangeMapSerializer : public ::testing::Test {
method SetUp (line 276) | void SetUp() {
method TearDown (line 281) | void TearDown() {
function TEST_F (line 291) | TEST_F(TestContainedRangeMapSerializer, EmptyMapTestCase) {
function TEST_F (line 307) | TEST_F(TestContainedRangeMapSerializer, MapWithOneRangeTestCase) {
function TEST_F (line 332) | TEST_F(TestContainedRangeMapSerializer, MapWithTwoLevelsTestCase) {
function main (line 384) | int main(int argc, char *argv[]) {
FILE: archive/spotify/breakpad/processor/minidump.cc
type google_breakpad (line 69) | namespace google_breakpad {
function Swap (line 90) | static inline void Swap(u_int8_t* value) {
function Swap (line 101) | static inline void Swap(u_int16_t* value) {
function Swap (line 107) | static inline void Swap(u_int32_t* value) {
function Swap (line 115) | static inline void Swap(u_int64_t* value) {
function Normalize128 (line 127) | static void Normalize128(u_int128_t* value, bool is_big_endian) {
function Swap (line 139) | static void Swap(u_int128_t* value) {
function Swap (line 145) | static inline void Swap(MDLocationDescriptor* location_descriptor) {
function Swap (line 151) | static inline void Swap(MDMemoryDescriptor* memory_descriptor) {
function Swap (line 157) | static inline void Swap(MDGUID* guid) {
function string (line 179) | static string* UTF16ToUTF8(const vector<u_int16_t>& in,
function UTF16codeunits (line 253) | static size_t UTF16codeunits(const u_int16_t *string, size_t maxlen) {
function u_int32_t (line 707) | u_int32_t MinidumpContext::GetContextCPU() const {
function MDRawContextX86 (line 718) | const MDRawContextX86* MinidumpContext::GetContextX86() const {
function MDRawContextPPC (line 728) | const MDRawContextPPC* MinidumpContext::GetContextPPC() const {
function MDRawContextAMD64 (line 737) | const MDRawContextAMD64* MinidumpContext::GetContextAMD64() const {
function MDRawContextSPARC (line 746) | const MDRawContextSPARC* MinidumpContext::GetContextSPARC() const {
function MDRawContextARM (line 755) | const MDRawContextARM* MinidumpContext::GetContextARM() const {
function u_int8_t (line 1121) | const u_int8_t* MinidumpMemoryRegion::GetMemory() const {
function u_int64_t (line 1160) | u_int64_t MinidumpMemoryRegion::GetBase() const {
function u_int32_t (line 1170) | u_int32_t MinidumpMemoryRegion::GetSize() const {
function MinidumpMemoryRegion (line 1336) | MinidumpMemoryRegion* MinidumpThread::GetMemory() {
function MinidumpContext (line 1346) | MinidumpContext* MinidumpThread::GetContext() {
function MinidumpThread (line 1548) | MinidumpThread* MinidumpThreadList::GetThreadAtIndex(unsigned int index)
function MinidumpThread (line 1565) | MinidumpThread* MinidumpThreadList::GetThreadByID(u_int32_t thread_id) {
function string (line 1714) | string MinidumpModule::code_file() const {
function string (line 1724) | string MinidumpModule::code_identifier() const {
function string (line 1784) | string MinidumpModule::debug_file() const {
function string (line 1864) | string MinidumpModule::debug_identifier() const {
function string (line 1933) | string MinidumpModule::version() const {
function CodeModule (line 1965) | const CodeModule* MinidumpModule::Copy() const {
function u_int8_t (line 1970) | const u_int8_t* MinidumpModule::GetCVRecord(u_int32_t* size) {
function MDImageDebugMisc (line 2092) | const MDImageDebugMisc* MinidumpModule::GetMiscRecord(u_int32_t* size) {
function MinidumpModule (line 2460) | const MinidumpModule* MinidumpModuleList::GetModuleForAddress(
function MinidumpModule (line 2478) | const MinidumpModule* MinidumpModuleList::GetMainModule() const {
function MinidumpModule (line 2490) | const MinidumpModule* MinidumpModuleList::GetModuleAtSequence(
function MinidumpModule (line 2513) | const MinidumpModule* MinidumpModuleList::GetModuleAtIndex(
function CodeModules (line 2530) | const CodeModules* MinidumpModuleList::Copy() const {
function MinidumpMemoryRegion (line 2693) | MinidumpMemoryRegion* MinidumpMemoryList::GetMemoryRegionAtIndex(
function MinidumpMemoryRegion (line 2710) | MinidumpMemoryRegion* MinidumpMemoryList::GetMemoryRegionForAddress(
function MinidumpContext (line 2835) | MinidumpContext* MinidumpException::GetContext() {
function string (line 3081) | string MinidumpSystemInfo::GetOS() {
function string (line 3121) | string MinidumpSystemInfo::GetCPU() {
function string (line 3161) | const string* MinidumpSystemInfo::GetCSDVersion() {
function string (line 3177) | const string* MinidumpSystemInfo::GetCPUVendor() {
function MinidumpMemoryInfo (line 3660) | const MinidumpMemoryInfo* MinidumpMemoryInfoList::GetMemoryInfoAtIndex(
function MinidumpMemoryInfo (line 3677) | const MinidumpMemoryInfo* MinidumpMemoryInfoList::GetMemoryInfoForAddr...
function MinidumpThreadList (line 3912) | MinidumpThreadList* Minidump::GetThreadList() {
function MinidumpModuleList (line 3918) | MinidumpModuleList* Minidump::GetModuleList() {
function MinidumpMemoryList (line 3924) | MinidumpMemoryList* Minidump::GetMemoryList() {
function MinidumpException (line 3930) | MinidumpException* Minidump::GetException() {
function MinidumpAssertion (line 3935) | MinidumpAssertion* Minidump::GetAssertion() {
function MinidumpSystemInfo (line 3941) | MinidumpSystemInfo* Minidump::GetSystemInfo() {
function MinidumpMiscInfo (line 3947) | MinidumpMiscInfo* Minidump::GetMiscInfo() {
function MinidumpBreakpadInfo (line 3953) | MinidumpBreakpadInfo* Minidump::GetBreakpadInfo() {
function MinidumpMemoryInfoList (line 3958) | MinidumpMemoryInfoList* Minidump::GetMemoryInfoList() {
type tm (line 3976) | struct tm
function MDRawDirectory (line 4015) | const MDRawDirectory* Minidump::GetDirectoryEntryAtIndex(unsigned int ...
function off_t (line 4070) | off_t Minidump::Tell() {
function string (line 4079) | string* Minidump::ReadString(off_t offset) {
function T (line 4167) | T* Minidump::GetStream(T** stream) {
FILE: archive/spotify/breakpad/processor/minidump_dump.cc
function DumpRawStream (line 56) | static void DumpRawStream(Minidump *minidump,
function PrintMinidumpDump (line 95) | static bool PrintMinidumpDump(const char *minidump_file) {
function main (line 205) | int main(int argc, char **argv) {
FILE: archive/spotify/breakpad/processor/minidump_processor.cc
type google_breakpad (line 43) | namespace google_breakpad {
function ProcessResult (line 61) | ProcessResult MinidumpProcessor::Process(
function ProcessResult (line 262) | ProcessResult MinidumpProcessor::Process(
function MDRawSystemInfo (line 278) | static const MDRawSystemInfo* GetSystemInfo(Minidump *dump,
function string (line 431) | string MinidumpProcessor::GetCrashReason(Minidump *dump, u_int64_t *ad...
function string (line 1082) | string MinidumpProcessor::GetAssertion(Minidump *dump) {
FILE: archive/spotify/breakpad/processor/minidump_processor_unittest.cc
type google_breakpad (line 56) | namespace google_breakpad {
class MockMinidump (line 57) | class MockMinidump : public Minidump {
method MockMinidump (line 59) | MockMinidump() : Minidump("") {
class TestSymbolSupplier (line 104) | class TestSymbolSupplier : public SymbolSupplier {
method TestSymbolSupplier (line 106) | TestSymbolSupplier() : interrupt_(false) {}
method set_interrupt (line 125) | void set_interrupt(bool interrupt) { interrupt_ = interrupt; }
class MockSymbolSupplier (line 211) | class MockSymbolSupplier : public SymbolSupplier {
method MockSymbolSupplier (line 213) | MockSymbolSupplier() { }
class MinidumpProcessorTest (line 228) | class MinidumpProcessorTest : public ::testing::Test {
function TEST_F (line 231) | TEST_F(MinidumpProcessorTest, TestCorruptMinidumps) {
function TEST_F (line 259) | TEST_F(MinidumpProcessorTest, TestSymbolSupplierLookupCounts) {
function TEST_F (line 294) | TEST_F(MinidumpProcessorTest, TestBasicProcessing) {
function main (line 377) | int main(int argc, char *argv[]) {
FILE: archive/spotify/breakpad/processor/minidump_stackwalk.cc
function PrintRegister (line 87) | static int PrintRegister(const char *name, u_int32_t value, int start_co...
function PrintRegister64 (line 101) | static int PrintRegister64(const char *name, u_int64_t value, int start_...
function string (line 116) | static string StripSeparator(const string &original) {
function PrintStack (line 138) | static void PrintStack(const CallStack *stack, const string &cpu) {
function PrintStackMachineReadable (line 268) | static void PrintStackMachineReadable(int thread_num, const CallStack *s...
function PrintModules (line 318) | static void PrintModules(const CodeModules *modules) {
function PrintModulesMachineReadable (line 351) | static void PrintModulesMachineReadable(const CodeModules *modules) {
function PrintProcessState (line 382) | static void PrintProcessState(const ProcessState& process_state) {
function PrintProcessStateMachineReadable (line 437) | static void PrintProcessStateMachineReadable(const ProcessState& process...
function PrintMinidumpProcess (line 513) | static bool PrintMinidumpProcess(const string &minidump_file,
function usage (line 544) | static void usage(const char *program_name) {
function main (line 550) | int main(int argc, char **argv) {
FILE: archive/spotify/breakpad/processor/minidump_unittest.cc
class MinidumpTest (line 76) | class MinidumpTest : public ::testing::Test {
method SetUp (line 78) | void SetUp() {
function TEST_F (line 85) | TEST_F(MinidumpTest, TestMinidumpFromFile) {
function TEST_F (line 95) | TEST_F(MinidumpTest, TestMinidumpFromStream) {
function TEST (line 121) | TEST(Dump, ReadBackEmpty) {
function TEST (line 132) | TEST(Dump, ReadBackEmptyBigEndian) {
function TEST (line 143) | TEST(Dump, OneStream) {
function TEST (line 179) | TEST(Dump, OneMemory) {
function TEST (line 209) | TEST(Dump, OneThread) {
function TEST (line 294) | TEST(Dump, OneModule) {
function TEST (line 353) | TEST(Dump, OneSystemInfo) {
function TEST (line 381) | TEST(Dump, BigDump) {
function TEST (line 538) | TEST(Dump, OneMemoryInfo) {
function TEST (line 593) | TEST(Dump, OneExceptionX86) {
function TEST (line 666) | TEST(Dump, OneExceptionX86XState) {
function TEST (line 740) | TEST(Dump, OneExceptionARM) {
function TEST (line 823) | TEST(Dump, OneExceptionARMOldFlags) {
FILE: archive/spotify/breakpad/processor/module_comparer.cc
type google_breakpad (line 53) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/module_comparer.h
function namespace (line 51) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/module_factory.h
function namespace (line 43) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/module_serializer.cc
type google_breakpad (line 44) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/module_serializer.h
function namespace (line 52) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/pathname_stripper.cc
type google_breakpad (line 38) | namespace google_breakpad {
function string (line 41) | string PathnameStripper::File(const string &path) {
FILE: archive/spotify/breakpad/processor/pathname_stripper.h
function namespace (line 39) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/pathname_stripper_unittest.cc
function RunTests (line 47) | static bool RunTests() {
function main (line 83) | int main(int argc, char **argv) {
FILE: archive/spotify/breakpad/processor/postfix_evaluator-inl.h
function namespace (line 51) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/postfix_evaluator.h
function namespace (line 77) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/postfix_evaluator_unittest.cc
class FakeMemoryRegion (line 58) | class FakeMemoryRegion : public MemoryRegion {
method u_int64_t (line 60) | virtual u_int64_t GetBase() const { return 0; }
method u_int32_t (line 61) | virtual u_int32_t GetSize() const { return 0; }
method GetMemoryAtAddress (line 62) | virtual bool GetMemoryAtAddress(u_int64_t address, u_int8_t *value) c...
method GetMemoryAtAddress (line 66) | virtual bool GetMemoryAtAddress(u_int64_t address, u_int16_t *value) c...
method GetMemoryAtAddress (line 70) | virtual bool GetMemoryAtAddress(u_int64_t address, u_int32_t *value) c...
method GetMemoryAtAddress (line 74) | virtual bool GetMemoryAtAddress(u_int64_t address, u_int64_t *value) c...
type EvaluateTest (line 81) | struct EvaluateTest {
type EvaluateTestSet (line 91) | struct EvaluateTestSet {
type EvaluateForValueTest (line 107) | struct EvaluateForValueTest {
function RunTests (line 119) | static bool RunTests() {
function main (line 395) | int main(int argc, char **argv) {
FILE: archive/spotify/breakpad/processor/process_state.cc
type google_breakpad (line 40) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/range_map-inl.h
function namespace (line 46) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/range_map.h
function namespace (line 47) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/range_map_unittest.cc
class CountedObject (line 55) | class CountedObject {
method CountedObject (line 57) | explicit CountedObject(int id) : id_(id) { ++count_; }
method count (line 60) | static int count() { return count_; }
method id (line 61) | int id() const { return id_; }
type RangeTest (line 77) | struct RangeTest {
type RangeTestSet (line 94) | struct RangeTestSet {
function StoreTest (line 106) | static bool StoreTest(TestMap *range_map, const RangeTest *range_test) {
function RetrieveTest (line 130) | static bool RetrieveTest(TestMap *range_map, const RangeTest *range_test) {
function RetrieveIndexTest (line 270) | static bool RetrieveIndexTest(TestMap *range_map, int set) {
function RetriveAtIndexTest2 (line 332) | static bool RetriveAtIndexTest2() {
function RunTests (line 367) | static bool RunTests() {
function main (line 549) | int main(int argc, char **argv) {
FILE: archive/spotify/breakpad/processor/scoped_ptr.h
function namespace (line 56) | namespace google_breakpad {
function T (line 190) | T* get() const {
function swap (line 194) | void swap(scoped_array & b) {
function T (line 200) | T* release() {
function class (line 231) | class ScopedPtrMallocFree {
FILE: archive/spotify/breakpad/processor/simple_serializer-inl.h
function namespace (line 51) | namespace google_breakpad {
type BasicSourceLineResolver (line 182) | typedef BasicSourceLineResolver::Function Function;
type BasicSourceLineResolver (line 183) | typedef BasicSourceLineResolver::Line Line;
FILE: archive/spotify/breakpad/processor/simple_serializer.h
function namespace (line 43) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/simple_symbol_supplier.cc
type google_breakpad (line 52) | namespace google_breakpad {
function file_exists (line 54) | static bool file_exists(const string &file_name) {
FILE: archive/spotify/breakpad/processor/simple_symbol_supplier.h
function namespace (line 85) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/source_line_resolver_base.cc
type google_breakpad (line 51) | namespace google_breakpad {
type stat (line 87) | struct stat
function WindowsFrameInfo (line 277) | WindowsFrameInfo *SourceLineResolverBase::FindWindowsFrameInfo(
function CFIFrameInfo (line 288) | CFIFrameInfo *SourceLineResolverBase::FindCFIFrameInfo(
FILE: archive/spotify/breakpad/processor/source_line_resolver_base_types.h
function namespace (line 54) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/stackwalker.cc
type google_breakpad (line 57) | namespace google_breakpad {
function Stackwalker (line 146) | Stackwalker* Stackwalker::StackwalkerForCPU(
FILE: archive/spotify/breakpad/processor/stackwalker_amd64.cc
type google_breakpad (line 46) | namespace google_breakpad {
function StackFrame (line 105) | StackFrame* StackwalkerAMD64::GetContextFrame() {
function StackFrameAMD64 (line 123) | StackFrameAMD64 *StackwalkerAMD64::GetCallerByCFIFrameInfo(
function StackFrameAMD64 (line 145) | StackFrameAMD64 *StackwalkerAMD64::GetCallerByStackScan(
function StackFrame (line 194) | StackFrame* StackwalkerAMD64::GetCallerFrame(const CallStack *stack) {
FILE: archive/spotify/breakpad/processor/stackwalker_amd64.h
function namespace (line 48) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/stackwalker_amd64_unittest.cc
class StackwalkerAMD64Fixture (line 64) | class StackwalkerAMD64Fixture {
method StackwalkerAMD64Fixture (line 66) | StackwalkerAMD64Fixture()
method SetModuleSymbols (line 94) | void SetModuleSymbols(MockCodeModule *module, const string &info) {
method RegionFromSection (line 105) | void RegionFromSection() {
method BrandContext (line 112) | void BrandContext(MDRawContextAMD64 *raw_context) {
class GetContextFrame (line 131) | class GetContextFrame: public StackwalkerAMD64Fixture, public Test { }
class SanityCheck (line 133) | class SanityCheck: public StackwalkerAMD64Fixture, public Test { }
function TEST_F (line 135) | TEST_F(SanityCheck, NoResolver) {
function TEST_F (line 155) | TEST_F(GetContextFrame, Simple) {
class GetCallerFrame (line 174) | class GetCallerFrame: public StackwalkerAMD64Fixture, public Test { }
function TEST_F (line 176) | TEST_F(GetCallerFrame, ScanWithoutSymbols) {
function TEST_F (line 247) | TEST_F(GetCallerFrame, ScanWithFunctionSymbols) {
function TEST_F (line 309) | TEST_F(GetCallerFrame, CallerPushedRBP) {
type CFIFixture (line 374) | struct CFIFixture: public StackwalkerAMD64Fixture {
method CFIFixture (line 375) | CFIFixture() {
method CheckWalk (line 419) | void CheckWalk() {
class CFI (line 461) | class CFI: public CFIFixture, public Test { }
function TEST_F (line 463) | TEST_F(CFI, At4000) {
function TEST_F (line 472) | TEST_F(CFI, At4001) {
function TEST_F (line 483) | TEST_F(CFI, At4002) {
function TEST_F (line 495) | TEST_F(CFI, At4003) {
function TEST_F (line 512) | TEST_F(CFI, At4004) {
function TEST_F (line 528) | TEST_F(CFI, At4005) {
function TEST_F (line 544) | TEST_F(CFI, At4006) {
FILE: archive/spotify/breakpad/processor/stackwalker_arm.cc
type google_breakpad (line 45) | namespace google_breakpad {
function StackFrame (line 60) | StackFrame* StackwalkerARM::GetContextFrame() {
function StackFrameARM (line 78) | StackFrameARM *StackwalkerARM::GetCallerByCFIFrameInfo(
function StackFrameARM (line 162) | StackFrameARM *StackwalkerARM::GetCallerByStackScan(
function StackFrameARM (line 192) | StackFrameARM *StackwalkerARM::GetCallerByFramePointer(
function StackFrame (line 238) | StackFrame* StackwalkerARM::GetCallerFrame(const CallStack *stack) {
FILE: archive/spotify/breakpad/processor/stackwalker_arm.h
function namespace (line 47) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/stackwalker_arm_unittest.cc
class StackwalkerARMFixture (line 66) | class StackwalkerARMFixture {
method StackwalkerARMFixture (line 68) | StackwalkerARMFixture()
method SetModuleSymbols (line 96) | void SetModuleSymbols(MockCodeModule *module, const string &info) {
method RegionFromSection (line 107) | void RegionFromSection() {
method BrandContext (line 114) | void BrandContext(MDRawContextARM *raw_context) {
class SanityCheck (line 133) | class SanityCheck: public StackwalkerARMFixture, public Test { }
function TEST_F (line 135) | TEST_F(SanityCheck, NoResolver) {
class GetContextFrame (line 151) | class GetContextFrame: public StackwalkerARMFixture, public Test { }
function TEST_F (line 153) | TEST_F(GetContextFrame, Simple) {
class GetCallerFrame (line 168) | class GetCallerFrame: public StackwalkerARMFixture, public Test { }
function TEST_F (line 170) | TEST_F(GetCallerFrame, ScanWithoutSymbols) {
function TEST_F (line 232) | TEST_F(GetCallerFrame, ScanWithFunctionSymbols) {
type CFIFixture (line 291) | struct CFIFixture: public StackwalkerARMFixture {
method CFIFixture (line 292) | CFIFixture() {
method CheckWalk (line 373) | void CheckWalk() {
class CFI (line 434) | class CFI: public CFIFixture, public Test { }
function TEST_F (line 436) | TEST_F(CFI, At4000) {
function TEST_F (line 443) | TEST_F(CFI, At4001) {
function TEST_F (line 457) | TEST_F(CFI, At4001LimitedValidity) {
function TEST_F (line 475) | TEST_F(CFI, At4002) {
function TEST_F (line 495) | TEST_F(CFI, At4003) {
function TEST_F (line 513) | TEST_F(CFI, At4004) {
function TEST_F (line 530) | TEST_F(CFI, At4005) {
function TEST_F (line 547) | TEST_F(CFI, At4006) {
function TEST_F (line 565) | TEST_F(CFI, RejectBackwards) {
function TEST_F (line 577) | TEST_F(CFI, RejectBadExpressions) {
class StackwalkerARMFixtureIOS (line 587) | class StackwalkerARMFixtureIOS : public StackwalkerARMFixture {
method StackwalkerARMFixtureIOS (line 589) | StackwalkerARMFixtureIOS() {
class GetFramesByFramePointer (line 595) | class GetFramesByFramePointer: public StackwalkerARMFixtureIOS, public T...
function TEST_F (line 597) | TEST_F(GetFramesByFramePointer, OnlyFramePointer) {
function TEST_F (line 674) | TEST_F(GetFramesByFramePointer, FramePointerAndCFI) {
FILE: archive/spotify/breakpad/processor/stackwalker_ppc.cc
type google_breakpad (line 43) | namespace google_breakpad {
function StackFrame (line 66) | StackFrame* StackwalkerPPC::GetContextFrame() {
function StackFrame (line 85) | StackFrame* StackwalkerPPC::GetCallerFrame(const CallStack *stack) {
FILE: archive/spotify/breakpad/processor/stackwalker_ppc.h
function namespace (line 46) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/stackwalker_selftest.cc
class SelfMemoryRegion (line 101) | class SelfMemoryRegion : public MemoryRegion {
method u_int64_t (line 103) | virtual u_int64_t GetBase() { return 0; }
method u_int32_t (line 104) | virtual u_int32_t GetSize() { return 0xffffffff; }
method GetMemoryAtAddress (line 106) | bool GetMemoryAtAddress(u_int64_t address, u_int8_t* value) {
method GetMemoryAtAddress (line 108) | bool GetMemoryAtAddress(u_int64_t address, u_int16_t* value) {
method GetMemoryAtAddress (line 110) | bool GetMemoryAtAddress(u_int64_t address, u_int32_t* value) {
method GetMemoryAtAddress (line 112) | bool GetMemoryAtAddress(u_int64_t address, u_int64_t* value) {
method GetMemoryAtAddressInternal (line 116) | bool GetMemoryAtAddressInternal(u_int64_t address,
function u_int32_t (line 146) | static u_int32_t GetEBP() {
function u_int32_t (line 162) | static u_int32_t GetESP() {
function u_int32_t (line 183) | static u_int32_t GetEIP() {
function u_int32_t (line 203) | static u_int32_t GetSP() {
function u_int32_t (line 219) | static u_int32_t GetPC() {
function u_int32_t (line 240) | static u_int32_t GetSP() {
function u_int32_t (line 257) | static u_int32_t GetFP() {
function u_int32_t (line 272) | static u_int32_t GetPC() {
function CountCallerFrames (line 310) | static unsigned int CountCallerFrames() {
function Recursor (line 383) | static bool Recursor(unsigned int depth, unsigned int parent_callers) {
function main (line 404) | int main(int argc, char** argv) {
function main (line 415) | int main(int argc, char **argv) {
FILE: archive/spotify/breakpad/processor/stackwalker_sparc.cc
type google_breakpad (line 43) | namespace google_breakpad {
function StackFrame (line 57) | StackFrame* StackwalkerSPARC::GetContextFrame() {
function StackFrame (line 76) | StackFrame* StackwalkerSPARC::GetCallerFrame(const CallStack *stack) {
FILE: archive/spotify/breakpad/processor/stackwalker_sparc.h
function namespace (line 46) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/stackwalker_unittest_utils.h
function class (line 50) | class MockMemoryRegion: public google_breakpad::MemoryRegion {
function class (line 99) | class MockCodeModule: public google_breakpad::CodeModule {
function google_breakpad (line 112) | const google_breakpad::CodeModule *Copy() const {
function class (line 123) | class MockCodeModules: public google_breakpad::CodeModules {
function class (line 162) | class MockSymbolSupplier: public google_breakpad::SymbolSupplier {
FILE: archive/spotify/breakpad/processor/stackwalker_x86.cc
type google_breakpad (line 50) | namespace google_breakpad {
function StackFrame (line 109) | StackFrame *StackwalkerX86::GetContextFrame() {
function StackFrameX86 (line 127) | StackFrameX86 *StackwalkerX86::GetCallerByWindowsFrameInfo(
function StackFrameX86 (line 451) | StackFrameX86 *StackwalkerX86::GetCallerByCFIFrameInfo(
function StackFrameX86 (line 476) | StackFrameX86 *StackwalkerX86::GetCallerByEBPAtBase(
function StackFrame (line 549) | StackFrame *StackwalkerX86::GetCallerFrame(const CallStack *stack) {
FILE: archive/spotify/breakpad/processor/stackwalker_x86.h
function namespace (line 50) | namespace google_breakpad {
FILE: archive/spotify/breakpad/processor/stackwalker_x86_unittest.cc
class StackwalkerX86Fixture (line 65) | class StackwalkerX86Fixture {
method StackwalkerX86Fixture (line 67) | StackwalkerX86Fixture()
method SetModuleSymbols (line 103) | void SetModuleSymbols(MockCodeModule *module, const string &info) {
method RegionFromSection (line 114) | void RegionFromSection() {
method BrandContext (line 121) | void BrandContext(MDRawContextX86 *raw_context) {
class SanityCheck (line 144) | class SanityCheck: public StackwalkerX86Fixture, public Test { }
function TEST_F (line 146) | TEST_F(SanityCheck, NoResolver) {
class GetContextFrame (line 164) | class GetContextFrame: public StackwalkerX86Fixture, public Test { }
function TEST_F (line 166) | TEST_F(GetContextFrame, Simple) {
class GetCallerFrame (line 183) | class GetCallerFrame: public StackwalkerX86Fixture, public Test { }
function TEST_F (line 188) | TEST_F(GetCallerFrame, Traditional) {
function TEST_F (line 237) | TEST_F(GetCallerFrame, TraditionalScan) {
function TEST_F (line 297) | TEST_F(GetCallerFrame, TraditionalScanLongWay) {
function TEST_F (line 359) | TEST_F(GetCallerFrame, WindowsFrameData) {
function TEST_F (line 433) | TEST_F(GetCallerFrame, WindowsFrameDataAligned) {
function TEST_F (line 498) | TEST_F(GetCallerFrame, WindowsFrameDataParameterSize) {
function TEST_F (line 617) | TEST_F(GetCallerFrame, WindowsFrameDataScan) {
function TEST_F (line 678) | TEST_F(GetCallerFrame, WindowsFrameDataBadEIPScan) {
function TEST_F (line 760) | TEST_F(GetCallerFrame, WindowsFPOUnchangedEBP) {
function TEST_F (line 835) | TEST_F(GetCallerFrame, WindowsFPOUsedEBP) {
function TEST_F (line 914) | TEST_F(GetCallerFrame, WindowsFPOSystemCall) {
type CFIFixture (line 1055) | struct CFIFixture: public StackwalkerX86Fixture {
method CFIFixture (line 1056) | CFIFixture() {
method CheckWalk (line 1098) | void CheckWalk() {
class CFI (line 1144) | class CFI: public CFIFixture, public Test { }
function TEST_F (line 1146) | TEST_F(CFI, At4000) {
function TEST_F (line 1155) | TEST_F(CFI, At4001) {
function TEST_F (line 1166) | TEST_F(CFI, At4002) {
function TEST_F (line 1178) | TEST_F(CFI, At4003) {
function TEST_F (line 1196) | TEST_F(CFI, At4004) {
function TEST_F (line 1212) | TEST_F(CFI, At4005) {
function TEST_F (line 1228) | TEST_F(CFI, At4006) {
FILE: archive/spotify/breakpad/processor/static_address_map-inl.h
function namespace (line 43) | namespace google_br
Copy disabled (too large)
Download .json
Condensed preview — 1395 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (24,165K chars).
[
{
"path": ".gitignore",
"chars": 149,
"preview": ".directory\n*.a\n*.o\n._*\n*.user\nMakefile*\nmoc_*\n*~\n.DS_Store\nbuild\n*.axe\n*.md5\nnode_modules/\nmetadata.desktop\n\n###IntelliJ"
},
{
"path": "4shared/content/contents/code/4shared.js",
"chars": 3978,
"preview": "/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===\n *\n * Copyright 2011, lasconic <lasconi"
},
{
"path": "4shared/content/metadata.json",
"chars": 499,
"preview": "{\n \"name\": \"4Shared\",\n \"pluginName\": \"4shared\",\n \"author\": \"lasconic\",\n \"email\": \"lasconic@gmail.com\",\n \""
},
{
"path": "8tracks/content/contents/code/8tracks.js",
"chars": 3914,
"preview": "/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===\n *\n * Copyright 2011, Janez Troha (http"
},
{
"path": "8tracks/content/metadata.json",
"chars": 496,
"preview": "{\n \"name\": \"8tracks\",\n \"pluginName\": \"8tracks\",\n \"author\": \"Janez and Leo\",\n \"email\": \"lfranchi@kde.org\",\n "
},
{
"path": "HACKING.md",
"chars": 8186,
"preview": "# Tomahawk Resolvers Developer Documentation\n\n## Developing resolvers\n\nThe best way to get you started with writing your"
},
{
"path": "README.md",
"chars": 5923,
"preview": "# Tomahawk Resolvers\n\nSupported resolvers are distributed and updated automatically through Tomahawk's Settings dialog.\n"
},
{
"path": "admin/json2desktop.rb",
"chars": 3812,
"preview": "#!/usr/bin/env ruby\n# === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===\n#\n# Copyright 2013, "
},
{
"path": "admin/makeaxe.rb",
"chars": 5429,
"preview": "#!/usr/bin/env ruby\n# === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===\n#\n# Copyright 2013, "
},
{
"path": "admin/spotify-synchrotron/linux/create_synchrotron.rb",
"chars": 1844,
"preview": "#!/usr/bin/env ruby\n#\n# This takes a binary for 32bit or 64bit linux\n# the signed zip file + manifest suitable for "
},
{
"path": "admin/spotify-synchrotron/mac/create_synchrotron.rb",
"chars": 2329,
"preview": "#!/usr/bin/env ruby\n#\n# This takes a binary for osx and creates\n# the signed zip file + manifest suitable for uploa"
},
{
"path": "admin/spotify-synchrotron/win/create_synchrotron.rb",
"chars": 2139,
"preview": "#!/usr/bin/env ruby\n#\n# This takes a binary for windows and creates\n# the signed zip file + manifest suitable for u"
},
{
"path": "amazon/content/contents/code/amazon.js",
"chars": 25732,
"preview": "/* Amazon Music resolver for Tomahawk.\n *\n * Written in 2015 by Creepy Guy In The Corner\n *\n * To the extent possible un"
},
{
"path": "amazon/content/contents/code/config.ui",
"chars": 2299,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<ui version=\"4.0\">\n <class>Form</class>\n <widget class=\"QWidget\" name=\"Form\">\n <"
},
{
"path": "amazon/content/metadata.json",
"chars": 657,
"preview": "{\n \"name\": \"Amazon Music\",\n \"pluginName\": \"amazon\",\n \"author\": \"Creepy Guy In The Corner\",\n \"email\": \"\",\n "
},
{
"path": "ampache/content/contents/code/ampache.js",
"chars": 16826,
"preview": "/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===\n *\n * Copyright 2011, Dominik Schmidt <"
},
{
"path": "ampache/content/contents/code/config.ui",
"chars": 2697,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<ui version=\"4.0\">\n <class>Form</class>\n <widget class=\"QWidget\" name=\"Form\">\n <"
},
{
"path": "ampache/content/metadata.json",
"chars": 873,
"preview": "{\n \"name\": \"Ampache\",\n \"pluginName\": \"ampache\",\n \"author\": \"Dominik, Leo, Teo and Enno\",\n \"email\": \"teo@kde."
},
{
"path": "archive/README",
"chars": 177,
"preview": "Resolvers in this directory are not functional anymore because the used API\nis not available anymore. The resolver may s"
},
{
"path": "archive/dilandau/content/contents/code/dilandau.js",
"chars": 3979,
"preview": "/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===\n *\n * Copyright 2011, lasconic <lasconi"
},
{
"path": "archive/dilandau/content/metadata.json",
"chars": 519,
"preview": "{\n \"name\": \"Dilandau\",\n \"pluginName\": \"dilandau\",\n \"author\": \"lasconic\",\n \"email\": \"lasconic@gmail.com\",\n "
},
{
"path": "archive/exfm/content/contents/code/exfm.js",
"chars": 9590,
"preview": "/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===\n *\n * Copyright 2011, lasonic <lasconic@g"
},
{
"path": "archive/exfm/content/metadata.json",
"chars": 462,
"preview": "{\n \"name\": \"ex.fm\",\n \"pluginName\": \"ex.fm\",\n \"author\": \"Nicolas and Uwe\",\n \"email\": \"uwelk@xhochy.com\",\n "
},
{
"path": "archive/grooveshark/content/contents/code/config.ui",
"chars": 1921,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<ui version=\"4.0\">\n <class>Form</class>\n <widget class=\"QWidget\" name=\"Form\">\n <"
},
{
"path": "archive/grooveshark/content/contents/code/grooveshark.js",
"chars": 23021,
"preview": "/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===\n *\n * Copyright 2011-2012, Leo Franchi "
},
{
"path": "archive/grooveshark/content/metadata.json",
"chars": 851,
"preview": "{\n \"name\": \"Grooveshark\",\n \"pluginName\": \"grooveshark\",\n \"author\": \"Leo Franchi and Enno\",\n \"email\": \"lfranc"
},
{
"path": "archive/rdio/content/contents/code/rdio.js",
"chars": 13487,
"preview": "/*\n * Copyright 2013, Uwe L. Korn <uwelk@xhochy.com>\n * Copyright 2014, Enno Gottschalk <mrmaffen@googlema"
},
{
"path": "archive/rdio/content/metadata.json",
"chars": 610,
"preview": "{\n \"name\": \"Rdio\",\n \"pluginName\": \"rdio\",\n \"author\": \"Uwe and Enno\",\n \"email\": \"uwelk@xhochy.com\",\n \"vers"
},
{
"path": "archive/rdio-metadata/content/contents/code/rdio-metadata.js",
"chars": 5316,
"preview": "/*\n * Copyright 2013, Uwe L. Korn <uwelk@xhochy.com>\n *\n * Permission is hereby granted, free of charge, to any"
},
{
"path": "archive/rdio-metadata/content/metadata.json",
"chars": 646,
"preview": "{\n \"name\": \"Rdio Metadata\",\n \"pluginName\": \"rdio-metadata\",\n \"author\": \"Uwe L. Korn\",\n \"email\": \"uwelk@xhoch"
},
{
"path": "archive/spotify/BreakPad.cpp",
"chars": 4674,
"preview": "/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===\n *\n * Copyright 2010-2011, Christian Mu"
},
{
"path": "archive/spotify/BreakPad.h",
"chars": 1702,
"preview": "/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===\n *\n * Copyright 2010-2011, Christian Mu"
},
{
"path": "archive/spotify/CMakeLists.txt",
"chars": 2611,
"preview": "project(tomahawkspotify)\ncmake_minimum_required(VERSION 2.8.6)\nadd_definitions(-fexceptions)\nSET( CMAKE_MODULE_PATH \"${C"
},
{
"path": "archive/spotify/PlaylistClosure.cpp",
"chars": 2073,
"preview": "/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===\n *\n * Copyright 2010-2012, Leo Franchi "
},
{
"path": "archive/spotify/PlaylistClosure.h",
"chars": 3776,
"preview": "/* === This file is part of Tomahawk Player - <http://tomahawk-player.org> ===\n *\n * Copyright 2011, David Sansome <me"
},
{
"path": "archive/spotify/appkey.h",
"chars": 0,
"preview": ""
},
{
"path": "archive/spotify/audiohttpserver.cpp",
"chars": 9591,
"preview": "/*\n Copyright (c) 2011 Leo Franchi <leo@kdab.com>\n Copyright (c) 2012,Hugo Lindström <hugolm84@gmail.com>\n\n Per"
},
{
"path": "archive/spotify/audiohttpserver.h",
"chars": 2264,
"preview": "/*\n Copyright (c) 2011 Leo Franchi <leo@kdab.com>\n\n Permission is hereby granted, free of charge, to any person\n "
},
{
"path": "archive/spotify/breakpad/CMakeLists.txt",
"chars": 2967,
"preview": "PROJECT(breakpad)\ncmake_minimum_required(VERSION 2.8)\n\nset( CMAKE_MODULE_PATH\n ${CMAKE_MODULE_PATH}\n ${CMAKE_CUR"
},
{
"path": "archive/spotify/breakpad/client/apple/Framework/BreakpadDefines.h",
"chars": 3826,
"preview": "// Copyright (c) 2011, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/android_link.h",
"chars": 2173,
"preview": "// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/android_ucontext.h",
"chars": 2682,
"preview": "// Copyright (c) 2009, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/crash_generation/client_info.h",
"chars": 1862,
"preview": "// Copyright (c) 2010 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with "
},
{
"path": "archive/spotify/breakpad/client/linux/crash_generation/crash_generation_client.cc",
"chars": 3046,
"preview": "// Copyright (c) 2010 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with "
},
{
"path": "archive/spotify/breakpad/client/linux/crash_generation/crash_generation_client.h",
"chars": 2710,
"preview": "// Copyright (c) 2010 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with "
},
{
"path": "archive/spotify/breakpad/client/linux/crash_generation/crash_generation_server.cc",
"chars": 12255,
"preview": "// Copyright (c) 2010 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with "
},
{
"path": "archive/spotify/breakpad/client/linux/crash_generation/crash_generation_server.h",
"chars": 5148,
"preview": "// Copyright (c) 2010 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with "
},
{
"path": "archive/spotify/breakpad/client/linux/data/linux-gate-amd.sym",
"chars": 132,
"preview": "MODULE Linux x86 B8CFDE93002D54DA1900A40AA1BD67690 linux-gate.so\nPUBLIC 400 0 __kernel_vsyscall\nSTACK WIN 4 400 100 1 1 "
},
{
"path": "archive/spotify/breakpad/client/linux/data/linux-gate-intel.sym",
"chars": 131,
"preview": "MODULE Linux x86 4FBDA58B5A1DF5A379E3CF19A235EA090 linux-gate.so\nPUBLIC 400 0 __kernel_vsyscall\nSTACK WIN 4 400 200 3 3 "
},
{
"path": "archive/spotify/breakpad/client/linux/handler/exception_handler.cc",
"chars": 19024,
"preview": "// Copyright (c) 2010 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with "
},
{
"path": "archive/spotify/breakpad/client/linux/handler/exception_handler.h",
"chars": 11250,
"preview": "// Copyright (c) 2010 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with "
},
{
"path": "archive/spotify/breakpad/client/linux/handler/exception_handler_unittest.cc",
"chars": 26227,
"preview": "// Copyright (c) 2010 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with "
},
{
"path": "archive/spotify/breakpad/client/linux/log/log.cc",
"chars": 1946,
"preview": "// Copyright (c) 2012 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with "
},
{
"path": "archive/spotify/breakpad/client/linux/log/log.h",
"chars": 1770,
"preview": "// Copyright (c) 2012, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/minidump_writer/directory_reader.h",
"chars": 3352,
"preview": "// Copyright (c) 2009, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/minidump_writer/directory_reader_unittest.cc",
"chars": 2637,
"preview": "// Copyright (c) 2009, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/minidump_writer/line_reader.h",
"chars": 4305,
"preview": "// Copyright (c) 2009, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/minidump_writer/line_reader_unittest.cc",
"chars": 5396,
"preview": "// Copyright (c) 2009, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/minidump_writer/linux_core_dumper.cc",
"chars": 7994,
"preview": "// Copyright (c) 2012, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/minidump_writer/linux_core_dumper.h",
"chars": 5469,
"preview": "// Copyright (c) 2012, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/minidump_writer/linux_core_dumper_unittest.cc",
"chars": 4487,
"preview": "// Copyright (c) 2012, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/minidump_writer/linux_dumper.cc",
"chars": 12930,
"preview": "// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/minidump_writer/linux_dumper.h",
"chars": 8648,
"preview": "// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/minidump_writer/linux_dumper_unittest_helper.cc",
"chars": 3293,
"preview": "// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/minidump_writer/linux_ptrace_dumper.cc",
"chars": 9311,
"preview": "// Copyright (c) 2012, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/minidump_writer/linux_ptrace_dumper.h",
"chars": 4070,
"preview": "// Copyright (c) 2012, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/minidump_writer/linux_ptrace_dumper_unittest.cc",
"chars": 14521,
"preview": "// Copyright (c) 2009, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/minidump_writer/minidump_extension_linux.h",
"chars": 3053,
"preview": "/* Copyright (c) 2010, Google Inc.\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/minidump_writer/minidump_writer.cc",
"chars": 46758,
"preview": "// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/minidump_writer/minidump_writer.h",
"chars": 3170,
"preview": "// Copyright (c) 2009, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/linux/minidump_writer/minidump_writer_unittest.cc",
"chars": 12981,
"preview": "// Copyright (c) 2011 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with "
},
{
"path": "archive/spotify/breakpad/client/linux/sender/google_crash_report_sender.cc",
"chars": 4132,
"preview": "// Copyright (c) 2009, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/Breakpad.xcodeproj/project.pbxproj",
"chars": 147152,
"preview": "// !$*UTF8*$!\n{\n\tarchiveVersion = 1;\n\tclasses = {\n\t};\n\tobjectVersion = 45;\n\tobjects = {\n\n/* Begin PBXAggregateTarget sec"
},
{
"path": "archive/spotify/breakpad/client/mac/Framework/Breakpad.h",
"chars": 14197,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/Framework/Breakpad.mm",
"chars": 35441,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/Framework/Breakpad_Prefix.pch",
"chars": 151,
"preview": "//\n// Prefix header for all source files of the 'Breakpad' target in the\n// 'Breakpad' project.\n//\n\n#ifdef __OBJC__\n "
},
{
"path": "archive/spotify/breakpad/client/mac/Framework/Info.plist",
"chars": 777,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/P"
},
{
"path": "archive/spotify/breakpad/client/mac/Framework/OnDemandServer.h",
"chars": 5874,
"preview": "// Copyright (c) 2007, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/Framework/OnDemandServer.mm",
"chars": 7139,
"preview": "// Copyright (c) 2007, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/UnitTests-Info.plist",
"chars": 634,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/P"
},
{
"path": "archive/spotify/breakpad/client/mac/crash_generation/ConfigFile.h",
"chars": 2947,
"preview": "// Copyright (c) 2011, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/crash_generation/ConfigFile.mm",
"chars": 6539,
"preview": "// Copyright (c) 2011, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/crash_generation/Inspector.h",
"chars": 6149,
"preview": "// Copyright (c) 2007, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/crash_generation/Inspector.mm",
"chars": 15295,
"preview": "// Copyright (c) 2007, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/crash_generation/InspectorMain.mm",
"chars": 2386,
"preview": "// Copyright (c) 2007, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/crash_generation/client_info.h",
"chars": 1922,
"preview": "// Copyright (c) 2010 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with "
},
{
"path": "archive/spotify/breakpad/client/mac/crash_generation/crash_generation_client.cc",
"chars": 3116,
"preview": "// Copyright (c) 2010 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with "
},
{
"path": "archive/spotify/breakpad/client/mac/crash_generation/crash_generation_client.h",
"chars": 2603,
"preview": "// Copyright (c) 2010 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with "
},
{
"path": "archive/spotify/breakpad/client/mac/crash_generation/crash_generation_server.cc",
"chars": 5881,
"preview": "// Copyright (c) 2010 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with "
},
{
"path": "archive/spotify/breakpad/client/mac/crash_generation/crash_generation_server.h",
"chars": 5284,
"preview": "// Copyright (c) 2010 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with "
},
{
"path": "archive/spotify/breakpad/client/mac/handler/breakpad_nlist_64.cc",
"chars": 13727,
"preview": "/*\n * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.\n *\n * @APPLE_LICENSE_HEADER_START@\n * \n * This file c"
},
{
"path": "archive/spotify/breakpad/client/mac/handler/breakpad_nlist_64.h",
"chars": 2154,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/client/mac/handler/dynamic_images.cc",
"chars": 19686,
"preview": "// Copyright (c) 2007, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/handler/dynamic_images.h",
"chars": 11183,
"preview": "// Copyright (c) 2007, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/handler/exception_handler.cc",
"chars": 28464,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/handler/exception_handler.h",
"chars": 10744,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/handler/mach_vm_compat.h",
"chars": 2225,
"preview": "// Copyright (c) 2011, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/handler/minidump_generator.cc",
"chars": 44405,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/handler/minidump_generator.h",
"chars": 8697,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/handler/minidump_test.xcodeproj/project.pbxproj",
"chars": 49648,
"preview": "// !$*UTF8*$!\n{\n\tarchiveVersion = 1;\n\tclasses = {\n\t};\n\tobjectVersion = 46;\n\tobjects = {\n\n/* Begin PBXBuildFile section *"
},
{
"path": "archive/spotify/breakpad/client/mac/handler/minidump_tests32-Info.plist",
"chars": 628,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/P"
},
{
"path": "archive/spotify/breakpad/client/mac/handler/minidump_tests64-Info.plist",
"chars": 684,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/P"
},
{
"path": "archive/spotify/breakpad/client/mac/handler/obj-cTestCases-Info.plist",
"chars": 634,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/P"
},
{
"path": "archive/spotify/breakpad/client/mac/handler/protected_memory_allocator.cc",
"chars": 3679,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/handler/protected_memory_allocator.h",
"chars": 3670,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/handler/testcases/DynamicImagesTests.cc",
"chars": 3119,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/client/mac/handler/testcases/DynamicImagesTests.h",
"chars": 2151,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/client/mac/handler/testcases/breakpad_nlist_test.cc",
"chars": 3712,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/client/mac/handler/testcases/breakpad_nlist_test.h",
"chars": 2531,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/client/mac/handler/testcases/dwarftests.h",
"chars": 1826,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/client/mac/handler/testcases/dwarftests.mm",
"chars": 2594,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/client/mac/handler/testcases/testdata/dump_syms_i386_breakpad.sym",
"chars": 214862,
"preview": "MODULE mac x86 94BF873C47A73BC07125291390B4C5F10 dump_syms_dwarf_data\nFILE 1 /Developer/SDKs/MacOSX10.4u.sdk/usr/include"
},
{
"path": "archive/spotify/breakpad/client/mac/sender/Breakpad.xib",
"chars": 50052,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<archive type=\"com.apple.InterfaceBuilder3.Cocoa.XIB\" version=\"7.10\">\n\t<data>\n\t\t<"
},
{
"path": "archive/spotify/breakpad/client/mac/sender/ReporterIcon.graffle",
"chars": 134591,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/P"
},
{
"path": "archive/spotify/breakpad/client/mac/sender/crash_report_sender-Info.plist",
"chars": 990,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/P"
},
{
"path": "archive/spotify/breakpad/client/mac/sender/crash_report_sender.h",
"chars": 5345,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/sender/crash_report_sender.m",
"chars": 26411,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/sender/uploader.h",
"chars": 3674,
"preview": "// Copyright (c) 2011, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/sender/uploader.mm",
"chars": 21175,
"preview": "// Copyright (c) 2011, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/testapp/Controller.h",
"chars": 2267,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/testapp/Controller.m",
"chars": 7474,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/testapp/English.lproj/MainMenu.xib",
"chars": 177767,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<archive type=\"com.apple.InterfaceBuilder3.Cocoa.XIB\" version=\"7.10\">\n\t<data>\n\t\t<"
},
{
"path": "archive/spotify/breakpad/client/mac/testapp/Info.plist",
"chars": 1577,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/P"
},
{
"path": "archive/spotify/breakpad/client/mac/testapp/TestClass.h",
"chars": 1643,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/testapp/TestClass.mm",
"chars": 2589,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/testapp/main.m",
"chars": 1680,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/tests/BreakpadFramework_Test.mm",
"chars": 8566,
"preview": "// Copyright (c) 2009, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/tests/SimpleStringDictionaryTest.h",
"chars": 1794,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/tests/SimpleStringDictionaryTest.mm",
"chars": 9373,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/tests/crash_generation_server_test.cc",
"chars": 11882,
"preview": "// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/tests/exception_handler_test.cc",
"chars": 23972,
"preview": "// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/tests/minidump_generator_test.cc",
"chars": 10757,
"preview": "// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/tests/minidump_generator_test_helper.cc",
"chars": 2859,
"preview": "// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/tests/spawn_child_process.h",
"chars": 4536,
"preview": "// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/mac/tests/testlogging.h",
"chars": 274,
"preview": "// This file exists to override the processor logging for unit tests,\n// since it confuses XCode into thinking unit test"
},
{
"path": "archive/spotify/breakpad/client/minidump_file_writer-inl.h",
"chars": 3800,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/minidump_file_writer.cc",
"chars": 8289,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/minidump_file_writer.h",
"chars": 8865,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/minidump_file_writer_unittest.cc",
"chars": 6593,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/solaris/handler/exception_handler.cc",
"chars": 9166,
"preview": "// Copyright (c) 2007, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/solaris/handler/exception_handler.h",
"chars": 8935,
"preview": "// Copyright (c) 2007, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/solaris/handler/exception_handler_test.cc",
"chars": 3533,
"preview": "// Copyright (c) 2007, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/solaris/handler/minidump_generator.cc",
"chars": 25673,
"preview": "// Copyright (c) 2007, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/solaris/handler/minidump_generator.h",
"chars": 2720,
"preview": "// Copyright (c) 2007, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/solaris/handler/minidump_test.cc",
"chars": 2478,
"preview": "// Copyright (c) 2007, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/solaris/handler/solaris_lwp.cc",
"chars": 12882,
"preview": "// Copyright (c) 2007, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/solaris/handler/solaris_lwp.h",
"chars": 5293,
"preview": "// Copyright (c) 2007, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/breakpad_client.gyp",
"chars": 2501,
"preview": "# Copyright (c) 2010, Google Inc.\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/client/windows/common/auto_critical_section.h",
"chars": 2928,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/common/ipc_protocol.h",
"chars": 5727,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/crash_generation/ReadMe.txt",
"chars": 3481,
"preview": "=========================================================================\n State machine transitions for the Crash Gener"
},
{
"path": "archive/spotify/breakpad/client/windows/crash_generation/client_info.cc",
"chars": 7480,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/crash_generation/client_info.h",
"chars": 6374,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/crash_generation/crash_generation.gyp",
"chars": 2306,
"preview": "# Copyright (c) 2010, Google Inc.\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/client/windows/crash_generation/crash_generation_client.cc",
"chars": 11235,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/crash_generation/crash_generation_client.h",
"chars": 6194,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/crash_generation/crash_generation_server.cc",
"chars": 29833,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/crash_generation/crash_generation_server.h",
"chars": 11596,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/crash_generation/minidump_generator.cc",
"chars": 11031,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/crash_generation/minidump_generator.h",
"chars": 5405,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/handler/exception_handler.cc",
"chars": 35813,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/handler/exception_handler.gyp",
"chars": 1929,
"preview": "# Copyright (c) 2010, Google Inc.\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/client/windows/handler/exception_handler.h",
"chars": 19380,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/sender/crash_report_sender.cc",
"chars": 4404,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/sender/crash_report_sender.gyp",
"chars": 1859,
"preview": "# Copyright (c) 2010, Google Inc.\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/client/windows/sender/crash_report_sender.h",
"chars": 5231,
"preview": "// Copyright (c) 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/tests/crash_generation_app/abstract_class.cc",
"chars": 2027,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/tests/crash_generation_app/abstract_class.h",
"chars": 2137,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/tests/crash_generation_app/crash_generation_app.cc",
"chars": 16088,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/tests/crash_generation_app/crash_generation_app.gyp",
"chars": 2409,
"preview": "# Copyright (c) 2010, Google Inc.\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/client/windows/tests/crash_generation_app/crash_generation_app.h",
"chars": 1813,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/tests/crash_generation_app/crash_generation_app.rc",
"chars": 3523,
"preview": "// Microsoft Visual C++ generated resource script.\n//\n#include \"resource.h\"\n\n#define APSTUDIO_READONLY_SYMBOLS\n/////////"
},
{
"path": "archive/spotify/breakpad/client/windows/tests/crash_generation_app/resource.h",
"chars": 3168,
"preview": "// Copyright (c) 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/unittests/client_tests.gyp",
"chars": 2782,
"preview": "# Copyright (c) 2010, Google Inc.\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/client/windows/unittests/crash_generation_server_test.cc",
"chars": 10272,
"preview": "// Copyright 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/client/windows/unittests/dump_analysis.cc",
"chars": 6345,
"preview": "// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/unittests/dump_analysis.h",
"chars": 3729,
"preview": "// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/unittests/exception_handler_death_test.cc",
"chars": 20155,
"preview": "// Copyright 2009, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/client/windows/unittests/exception_handler_test.cc",
"chars": 14082,
"preview": "// Copyright 2009, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/client/windows/unittests/minidump_test.cc",
"chars": 12252,
"preview": "// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/client/windows/unittests/testing.gyp",
"chars": 2622,
"preview": "# Copyright (c) 2010, Google Inc.\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/common/basictypes.h",
"chars": 1908,
"preview": "// Copyright (c) 2011 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with "
},
{
"path": "archive/spotify/breakpad/common/byte_cursor.h",
"chars": 9549,
"preview": "// -*- mode: c++ -*-\n\n// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source "
},
{
"path": "archive/spotify/breakpad/common/byte_cursor_unittest.cc",
"chars": 24215,
"preview": "// Copyright (c) 2010 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with "
},
{
"path": "archive/spotify/breakpad/common/convert_UTF.c",
"chars": 19731,
"preview": "/*\n * Copyright 2001-2004 Unicode, Inc.\n *\n * Disclaimer\n *\n * This source code is provided as is by Unicode, Inc. No cl"
},
{
"path": "archive/spotify/breakpad/common/convert_UTF.h",
"chars": 5957,
"preview": "/*\n * Copyright 2001-2004 Unicode, Inc.\n *\n * Disclaimer\n *\n * This source code is provided as is by Unicode, Inc. No cl"
},
{
"path": "archive/spotify/breakpad/common/dwarf/bytereader-inl.h",
"chars": 5669,
"preview": "// Copyright 2006 Google Inc. All Rights Reserved.\n//\n// Redistribution and use in source and binary forms, with or with"
},
{
"path": "archive/spotify/breakpad/common/dwarf/bytereader.cc",
"chars": 8031,
"preview": "// Copyright (c) 2010 Google Inc. All Rights Reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/common/dwarf/bytereader.h",
"chars": 14601,
"preview": "// -*- mode: C++ -*-\n\n// Copyright (c) 2010 Google Inc. All Rights Reserved.\n//\n// Redistribution and use in source and "
},
{
"path": "archive/spotify/breakpad/common/dwarf/bytereader_unittest.cc",
"chars": 30907,
"preview": "// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/common/dwarf/cfi_assembler.cc",
"chars": 6988,
"preview": "// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/common/dwarf/cfi_assembler.h",
"chars": 11838,
"preview": "// -*- mode: C++ -*-\n\n// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source "
},
{
"path": "archive/spotify/breakpad/common/dwarf/dwarf2diehandler.cc",
"chars": 8285,
"preview": "// Copyright (c) 2010 Google Inc. All Rights Reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/common/dwarf/dwarf2diehandler.h",
"chars": 16297,
"preview": "// -*- mode: c++ -*-\n\n// Copyright (c) 2010 Google Inc. All Rights Reserved.\n//\n// Redistribution and use in source and "
},
{
"path": "archive/spotify/breakpad/common/dwarf/dwarf2diehandler_unittest.cc",
"chars": 24343,
"preview": "// -*- mode: c++ -*-\n\n// Copyright (c) 2010 Google Inc. All Rights Reserved.\n//\n// Redistribution and use in source and "
},
{
"path": "archive/spotify/breakpad/common/dwarf/dwarf2enums.h",
"chars": 23277,
"preview": "// -*- mode: c++ -*-\n\n// Copyright (c) 2010 Google Inc. All Rights Reserved.\n//\n// Redistribution and use in source and "
},
{
"path": "archive/spotify/breakpad/common/dwarf/dwarf2reader.cc",
"chars": 83747,
"preview": "// Copyright (c) 2010 Google Inc. All Rights Reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "archive/spotify/breakpad/common/dwarf/dwarf2reader.h",
"chars": 46381,
"preview": "// -*- mode: C++ -*-\n\n// Copyright (c) 2010 Google Inc. All Rights Reserved.\n//\n// Redistribution and use in source and "
},
{
"path": "archive/spotify/breakpad/common/dwarf/dwarf2reader_cfi_unittest.cc",
"chars": 88749,
"preview": "// Copyright (c) 2010, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
},
{
"path": "archive/spotify/breakpad/common/dwarf/dwarf2reader_die_unittest.cc",
"chars": 20475,
"preview": "// Copyright (c) 2012, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with"
}
]
// ... and 1195 more files (download for full content)
About this extraction
This page contains the full source code of the tomahawk-player/tomahawk-resolvers GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1395 files (21.9 MB), approximately 5.8M tokens, and a symbol index with 11179 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.