LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-09-17 16:28:06 +03:00
Code Issues Packages Projects Releases Wiki Activity

LibCore+AK: Move MappedFile from AK to LibCore

Browse Source 
MappedFile is strictly a userspace thing, so it doesn't belong in AK
(which is supposed to be user/kernel agnostic.)
This commit is contained in:
Andreas Kling 2021-11-23 11:32:25 +01:00
parent c1c9da6c35
commit 58fb3ebf66
Notes: sideshowbarker 2024-07-18 00:49:12 +09:00 
Author: https://github.com/awesomekling
Commit: https://github.com/SerenityOS/serenity/commit/58fb3ebf660
48 changed files with 101 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
Tests/LibGfx/TestImageDecoder.cpp
View File

@ -5,8 +5,8 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/MappedFile.h>
#include <AK/String.h>
#include <LibCore/MappedFile.h>
#include <LibGfx/BMPLoader.h>
#include <LibGfx/GIFLoader.h>
#include <LibGfx/ICOLoader.h>
@ -23,7 +23,7 @@
TEST_CASE(test_bmp)
{
auto file = MappedFile::map("/res/html/misc/bmpsuite_files/rgba32-1.bmp").release_value();
auto file = Core::MappedFile::map("/res/html/misc/bmpsuite_files/rgba32-1.bmp").release_value();
auto bmp = Gfx::BMPImageDecoderPlugin((u8 const*)file->data(), file->size());
EXPECT(bmp.frame_count());
@ -37,7 +37,7 @@ TEST_CASE(test_bmp)
TEST_CASE(test_gif)
{
auto file = MappedFile::map("/res/graphics/download-animation.gif").release_value();
auto file = Core::MappedFile::map("/res/graphics/download-animation.gif").release_value();
auto gif = Gfx::GIFImageDecoderPlugin((u8 const*)file->data(), file->size());
EXPECT(gif.frame_count());
@ -52,7 +52,7 @@ TEST_CASE(test_gif)
TEST_CASE(test_ico)
{
// FIXME: Use an ico file
auto file = MappedFile::map("/res/graphics/buggie.png").release_value();
auto file = Core::MappedFile::map("/res/graphics/buggie.png").release_value();
auto ico = Gfx::ICOImageDecoderPlugin((u8 const*)file->data(), file->size());
EXPECT(ico.frame_count());
@ -65,7 +65,7 @@ TEST_CASE(test_ico)
TEST_CASE(test_jpg)
{
auto file = MappedFile::map("/res/html/misc/bmpsuite_files/rgb24.jpg").release_value();
auto file = Core::MappedFile::map("/res/html/misc/bmpsuite_files/rgb24.jpg").release_value();
auto jpg = Gfx::JPGImageDecoderPlugin((u8 const*)file->data(), file->size());
EXPECT(jpg.frame_count());
@ -79,7 +79,7 @@ TEST_CASE(test_jpg)
TEST_CASE(test_pbm)
{
auto file = MappedFile::map("/res/html/misc/pbmsuite_files/buggie-raw.pbm").release_value();
auto file = Core::MappedFile::map("/res/html/misc/pbmsuite_files/buggie-raw.pbm").release_value();
auto pbm = Gfx::PBMImageDecoderPlugin((u8 const*)file->data(), file->size());
EXPECT(pbm.frame_count());
@ -93,7 +93,7 @@ TEST_CASE(test_pbm)
TEST_CASE(test_pgm)
{
auto file = MappedFile::map("/res/html/misc/pgmsuite_files/buggie-raw.pgm").release_value();
auto file = Core::MappedFile::map("/res/html/misc/pgmsuite_files/buggie-raw.pgm").release_value();
auto pgm = Gfx::PGMImageDecoderPlugin((u8 const*)file->data(), file->size());
EXPECT(pgm.frame_count());
@ -107,7 +107,7 @@ TEST_CASE(test_pgm)
TEST_CASE(test_png)
{
auto file = MappedFile::map("/res/graphics/buggie.png").release_value();
auto file = Core::MappedFile::map("/res/graphics/buggie.png").release_value();
auto png = Gfx::PNGImageDecoderPlugin((u8 const*)file->data(), file->size());
EXPECT(png.frame_count());
@ -121,7 +121,7 @@ TEST_CASE(test_png)
TEST_CASE(test_ppm)
{
auto file = MappedFile::map("/res/html/misc/ppmsuite_files/buggie-raw.ppm").release_value();
auto file = Core::MappedFile::map("/res/html/misc/ppmsuite_files/buggie-raw.ppm").release_value();
auto ppm = Gfx::PPMImageDecoderPlugin((u8 const*)file->data(), file->size());
EXPECT(ppm.frame_count());

2
Userland/Applications/Help/ManualModel.cpp
View File

@ -72,7 +72,7 @@ ErrorOr<StringView> ManualModel::page_view(String const& path) const
return StringView { mapped_file.value()->bytes() };
}
auto file = TRY(MappedFile::map(path));
auto file = TRY(Core::MappedFile::map(path));
StringView view { file->bytes() };
m_mapped_files.set(path, move(file));

2
Userland/Applications/Help/ManualModel.h
View File

@ -41,5 +41,5 @@ private:
GUI::Icon m_section_open_icon;
GUI::Icon m_section_icon;
GUI::Icon m_page_icon;
mutable HashMap<String, NonnullRefPtr<MappedFile>> m_mapped_files;
mutable HashMap<String, NonnullRefPtr<Core::MappedFile>> m_mapped_files;
};

4
Userland/Applications/ImageViewer/ViewWidget.cpp
View File

@ -8,10 +8,10 @@
#include "ViewWidget.h"
#include <AK/LexicalPath.h>
#include <AK/MappedFile.h>
#include <AK/StringBuilder.h>
#include <LibCore/DirIterator.h>
#include <LibCore/File.h>
#include <LibCore/MappedFile.h>
#include <LibCore/Timer.h>
#include <LibGUI/MessageBox.h>
#include <LibGUI/Painter.h>
@ -243,7 +243,7 @@ void ViewWidget::load_from_file(const String& path)
GUI::MessageBox::show(window(), String::formatted("Failed to open {}", path), "Cannot open image", GUI::MessageBox::Type::Error);
};
auto file_or_error = MappedFile::map(path);
auto file_or_error = Core::MappedFile::map(path);
if (file_or_error.is_error()) {
show_error();
return;

2
Userland/Applications/PixelPaint/Image.cpp
View File

@ -14,8 +14,8 @@
#include <AK/JsonObjectSerializer.h>
#include <AK/JsonValue.h>
#include <AK/LexicalPath.h>
#include <AK/MappedFile.h>
#include <AK/StringBuilder.h>
#include <LibCore/MappedFile.h>
#include <LibGUI/Painter.h>
#include <LibGfx/BMPWriter.h>
#include <LibGfx/Bitmap.h>

4
Userland/Applications/PixelPaint/ProjectLoader.cpp
View File

@ -8,10 +8,10 @@
#include "Image.h"
#include "Layer.h"
#include <AK/JsonObject.h>
#include <AK/MappedFile.h>
#include <AK/Result.h>
#include <AK/String.h>
#include <LibCore/File.h>
#include <LibCore/MappedFile.h>
#include <LibImageDecoderClient/Client.h>
namespace PixelPaint {
@ -29,7 +29,7 @@ ErrorOr<void> ProjectLoader::try_load_from_fd_and_close(int fd, StringView path)
if (json_or_error.is_error()) {
m_is_raw_image = true;
auto mapped_file = TRY(MappedFile::map_from_fd_and_close(fd, path));
auto mapped_file = TRY(Core::MappedFile::map_from_fd_and_close(fd, path));
// FIXME: Find a way to avoid the memory copy here.
auto bitmap = TRY(Image::try_decode_bitmap(mapped_file->bytes()));

4
Userland/DevTools/HackStudio/Debugger/DisassemblyModel.cpp
View File

@ -5,8 +5,8 @@
*/
#include "DisassemblyModel.h"
#include <AK/MappedFile.h>
#include <AK/StringBuilder.h>
#include <LibCore/MappedFile.h>
#include <LibDebug/DebugSession.h>
#include <LibELF/Image.h>
#include <LibSymbolication/Symbolication.h>
@ -33,7 +33,7 @@ DisassemblyModel::DisassemblyModel(const Debug::DebugSession& debug_session, con
auto maybe_kernel_base = Symbolication::kernel_base();
if (maybe_kernel_base.has_value() && containing_function.value().address_low >= maybe_kernel_base.value()) {
auto file_or_error = MappedFile::map("/boot/Kernel.debug");
auto file_or_error = Core::MappedFile::map("/boot/Kernel.debug");
if (file_or_error.is_error())
return;
kernel_elf = make<ELF::Image>(file_or_error.value()->bytes());

4
Userland/DevTools/Profiler/DisassemblyModel.cpp
View File

@ -6,7 +6,7 @@
#include "DisassemblyModel.h"
#include "Profile.h"
#include <AK/MappedFile.h>
#include <LibCore/MappedFile.h>
#include <LibDebug/DebugInfo.h>
#include <LibELF/Image.h>
#include <LibGUI/Painter.h>
@ -40,7 +40,7 @@ static ELF::Image* try_load_kernel_binary()
{
if (s_kernel_binary.has_value())
return &s_kernel_binary->elf;
auto kernel_binary_or_error = MappedFile::map("/boot/Kernel");
auto kernel_binary_or_error = Core::MappedFile::map("/boot/Kernel");
if (!kernel_binary_or_error.is_error()) {
auto kernel_binary = kernel_binary_or_error.release_value();
s_kernel_binary = { { kernel_binary, ELF::Image(kernel_binary->bytes()) } };

2
Userland/DevTools/Profiler/Process.cpp
View File

@ -48,7 +48,7 @@ static MappedObject* get_or_create_mapped_object(const String& path)
if (auto it = g_mapped_object_cache.find(path); it != g_mapped_object_cache.end())
return it->value.ptr();
auto file_or_error = MappedFile::map(path);
auto file_or_error = Core::MappedFile::map(path);
if (file_or_error.is_error()) {
g_mapped_object_cache.set(path, {});
return nullptr;

4
Userland/DevTools/Profiler/Process.h
View File

@ -8,16 +8,16 @@
#include "EventSerialNumber.h"
#include <AK/HashMap.h>
#include <AK/MappedFile.h>
#include <AK/OwnPtr.h>
#include <AK/Vector.h>
#include <LibCore/MappedFile.h>
#include <LibDebug/DebugInfo.h>
#include <LibELF/Image.h>
namespace Profiler {
struct MappedObject {
NonnullRefPtr<MappedFile> file;
NonnullRefPtr<Core::MappedFile> file;
ELF::Image elf;
};

4
Userland/DevTools/Profiler/Profile.cpp
View File

@ -10,12 +10,12 @@
#include "SamplesModel.h"
#include <AK/HashTable.h>
#include <AK/LexicalPath.h>
#include <AK/MappedFile.h>
#include <AK/NonnullOwnPtrVector.h>
#include <AK/QuickSort.h>
#include <AK/RefPtr.h>
#include <AK/Try.h>
#include <LibCore/File.h>
#include <LibCore/MappedFile.h>
#include <LibELF/Image.h>
#include <LibSymbolication/Symbolication.h>
#include <sys/stat.h>
@ -226,7 +226,7 @@ ErrorOr<NonnullOwnPtr<Profile>> Profile::load_from_perfcore_file(StringView path
auto& object = json.value().as_object();
if (!g_kernel_debuginfo_object.has_value()) {
auto debuginfo_file_or_error = MappedFile::map("/boot/Kernel.debug");
auto debuginfo_file_or_error = Core::MappedFile::map("/boot/Kernel.debug");
if (!debuginfo_file_or_error.is_error()) {
auto debuginfo_file = debuginfo_file_or_error.release_value();
auto debuginfo_image = ELF::Image(debuginfo_file->bytes());

2
Userland/DevTools/Profiler/Profile.h
View File

@ -17,10 +17,10 @@
#include <AK/JsonArray.h>
#include <AK/JsonObject.h>
#include <AK/JsonValue.h>
#include <AK/MappedFile.h>
#include <AK/NonnullRefPtrVector.h>
#include <AK/OwnPtr.h>
#include <AK/Variant.h>
#include <LibCore/MappedFile.h>
#include <LibELF/Image.h>
#include <LibGUI/Forward.h>
#include <LibGUI/ModelIndex.h>

8
Userland/DevTools/UserspaceEmulator/Emulator.cpp
View File

@ -13,9 +13,9 @@
#include <AK/FileStream.h>
#include <AK/Format.h>
#include <AK/LexicalPath.h>
#include <AK/MappedFile.h>
#include <AK/StringUtils.h>
#include <LibCore/File.h>
#include <LibCore/MappedFile.h>
#include <LibELF/AuxiliaryVector.h>
#include <LibELF/Image.h>
#include <LibELF/Validation.h>
@ -149,7 +149,7 @@ void Emulator::setup_stack(Vector<ELF::AuxiliaryValue> aux_vector)
bool Emulator::load_elf()
{
auto file_or_error = MappedFile::map(m_executable_path);
auto file_or_error = Core::MappedFile::map(m_executable_path);
if (file_or_error.is_error()) {
reportln("Unable to map {}: {}", m_executable_path, file_or_error.error());
return false;
@ -172,7 +172,7 @@ bool Emulator::load_elf()
VERIFY(!interpreter_path.is_null());
dbgln("interpreter: {}", interpreter_path);
auto interpreter_file_or_error = MappedFile::map(interpreter_path);
auto interpreter_file_or_error = Core::MappedFile::map(interpreter_path);
VERIFY(!interpreter_file_or_error.is_error());
auto interpreter_image_data = interpreter_file_or_error.value()->bytes();
ELF::Image interpreter_image(interpreter_image_data);
@ -400,7 +400,7 @@ MmapRegion const* Emulator::load_library_from_address(FlatPtr address)
lib_path = String::formatted("/usr/lib/{}", lib_path);
if (!m_dynamic_library_cache.contains(lib_path)) {
auto file_or_error = MappedFile::map(lib_path);
auto file_or_error = Core::MappedFile::map(lib_path);
if (file_or_error.is_error())
return {};

4
Userland/DevTools/UserspaceEmulator/Emulator.h
View File

@ -13,8 +13,8 @@
#include "SoftCPU.h"
#include "SoftMMU.h"
#include <AK/FileStream.h>
#include <AK/MappedFile.h>
#include <AK/Types.h>
#include <LibCore/MappedFile.h>
#include <LibDebug/DebugInfo.h>
#include <LibELF/AuxiliaryVector.h>
#include <LibELF/Image.h>
@ -273,7 +273,7 @@ private:
Optional<size_t> m_loader_text_size;
struct CachedELF {
NonnullRefPtr<MappedFile> mapped_file;
NonnullRefPtr<Core::MappedFile> mapped_file;
NonnullOwnPtr<Debug::DebugInfo> debug_info;
NonnullOwnPtr<ELF::Image> image;
};

1
Userland/Libraries/LibCore/CMakeLists.txt
View File

@ -16,6 +16,7 @@ set(SOURCES
LocalServer.cpp
LocalSocket.cpp
LockFile.cpp
MappedFile.cpp
MimeData.cpp
NetworkJob.cpp
NetworkResponse.cpp

4
AK/MappedFile.cpp → Userland/Libraries/LibCore/MappedFile.cpp
View File

@ -4,16 +4,16 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/MappedFile.h>
#include <AK/ScopeGuard.h>
#include <AK/String.h>
#include <LibCore/MappedFile.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
namespace AK {
namespace Core {
ErrorOr<NonnullRefPtr<MappedFile>> MappedFile::map(String const& path)
{

6
AK/MappedFile.h → Userland/Libraries/LibCore/MappedFile.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
@ -12,7 +12,7 @@
#include <AK/RefCounted.h>
#include <AK/Result.h>
namespace AK {
namespace Core {
class MappedFile : public RefCounted<MappedFile> {
AK_MAKE_NONCOPYABLE(MappedFile);
@ -38,5 +38,3 @@ private:
};
}
using AK::MappedFile;

4
Userland/Libraries/LibCoredump/Backtrace.cpp
View File

@ -5,11 +5,11 @@
*/
#include <AK/LexicalPath.h>
#include <AK/MappedFile.h>
#include <AK/Platform.h>
#include <AK/StringBuilder.h>
#include <AK/Types.h>
#include <LibCore/File.h>
#include <LibCore/MappedFile.h>
#include <LibCoredump/Backtrace.h>
#include <LibCoredump/Reader.h>
#include <LibELF/Core.h>
@ -30,7 +30,7 @@ ELFObjectInfo const* Backtrace::object_info_for_region(ELF::Core::MemoryRegionIn
if (!Core::File::exists(path))
return nullptr;
auto file_or_error = MappedFile::map(path);
auto file_or_error = Core::MappedFile::map(path);
if (file_or_error.is_error())
return nullptr;

4
Userland/Libraries/LibCoredump/Backtrace.h
View File

@ -14,14 +14,14 @@
namespace Coredump {
struct ELFObjectInfo {
ELFObjectInfo(NonnullRefPtr<MappedFile> file, NonnullOwnPtr<Debug::DebugInfo>&& debug_info, NonnullOwnPtr<ELF::Image> image)
ELFObjectInfo(NonnullRefPtr<Core::MappedFile> file, NonnullOwnPtr<Debug::DebugInfo>&& debug_info, NonnullOwnPtr<ELF::Image> image)
: file(move(file))
, debug_info(move(debug_info))
, image(move(image))
{
}
NonnullRefPtr<MappedFile> file;
NonnullRefPtr<Core::MappedFile> file;
NonnullOwnPtr<Debug::DebugInfo> debug_info;
NonnullOwnPtr<ELF::Image> image;
};

2
Userland/Libraries/LibCoredump/Inspector.cpp
View File

@ -41,7 +41,7 @@ void Inspector::parse_loaded_libraries(Function<void(float)> on_progress)
if (on_progress)
on_progress(library_index / (float)number_of_libraries);
auto file_or_error = MappedFile::map(library.path);
auto file_or_error = Core::MappedFile::map(library.path);
if (file_or_error.is_error())
return;

7
Userland/Libraries/LibCoredump/Reader.cpp
View File

@ -17,7 +17,7 @@ namespace Coredump {
OwnPtr<Reader> Reader::create(StringView path)
{
auto file_or_error = MappedFile::map(path);
auto file_or_error = Core::MappedFile::map(path);
if (file_or_error.is_error())
return {};
@ -38,7 +38,7 @@ Reader::Reader(ByteBuffer buffer)
m_coredump_buffer = move(buffer);
}
Reader::Reader(NonnullRefPtr<MappedFile> file)
Reader::Reader(NonnullRefPtr<Core::MappedFile> file)
: Reader(file->bytes())
{
m_mapped_file = move(file);
@ -261,7 +261,6 @@ HashMap<String, String> Reader::metadata() const
struct LibraryData {
String name;
OwnPtr<MappedFile> file;
ELF::Image lib_elf;
};
@ -282,7 +281,7 @@ const Reader::LibraryData* Reader::library_containing(FlatPtr address) const
}
if (!cached_libs.contains(path)) {
auto file_or_error = MappedFile::map(path);
auto file_or_error = Core::MappedFile::map(path);
if (file_or_error.is_error())
return {};
auto image = ELF::Image(file_or_error.value()->bytes());

8
Userland/Libraries/LibCoredump/Reader.h
View File

@ -7,9 +7,9 @@
#pragma once
#include <AK/HashMap.h>
#include <AK/MappedFile.h>
#include <AK/Noncopyable.h>
#include <AK/OwnPtr.h>
#include <LibCore/MappedFile.h>
#include <LibELF/Core.h>
#include <LibELF/Image.h>
@ -46,7 +46,7 @@ public:
struct LibraryData {
String name;
FlatPtr base_address { 0 };
NonnullRefPtr<MappedFile> file;
NonnullRefPtr<Core::MappedFile> file;
ELF::Image lib_elf;
};
const LibraryData* library_containing(FlatPtr address) const;
@ -61,7 +61,7 @@ public:
private:
explicit Reader(ReadonlyBytes);
explicit Reader(ByteBuffer);
explicit Reader(NonnullRefPtr<MappedFile>);
explicit Reader(NonnullRefPtr<Core::MappedFile>);
static Optional<ByteBuffer> decompress_coredump(ReadonlyBytes);
@ -86,7 +86,7 @@ private:
const JsonObject process_info() const;
// For uncompressed coredumps, we keep the MappedFile
RefPtr<MappedFile> m_mapped_file;
RefPtr<Core::MappedFile> m_mapped_file;
// For compressed coredumps, we decompress them into a ByteBuffer
ByteBuffer m_coredump_buffer;

2
Userland/Libraries/LibDebug/DebugSession.cpp
View File

@ -452,7 +452,7 @@ void DebugSession::update_loaded_libs()
return IterationDecision::Continue;
}
auto file_or_error = MappedFile::map(object_path.value());
auto file_or_error = Core::MappedFile::map(object_path.value());
if (file_or_error.is_error())
return IterationDecision::Continue;

2
Userland/Libraries/LibDebug/DebugSession.h
View File

@ -8,12 +8,12 @@
#include <AK/Demangle.h>
#include <AK/HashMap.h>
#include <AK/MappedFile.h>
#include <AK/NonnullRefPtr.h>
#include <AK/Optional.h>
#include <AK/OwnPtr.h>
#include <AK/String.h>
#include <LibC/sys/arch/i386/regs.h>
#include <LibCore/MappedFile.h>
#include <LibDebug/DebugInfo.h>
#include <LibDebug/ProcessInspector.h>
#include <signal.h>

6
Userland/Libraries/LibDebug/LoadedLibrary.h
View File

@ -7,19 +7,19 @@
#pragma once
#include "DebugInfo.h"
#include <AK/MappedFile.h>
#include <AK/Types.h>
#include <LibCore/MappedFile.h>
#include <LibELF/Image.h>
namespace Debug {
struct LoadedLibrary {
String name;
NonnullRefPtr<MappedFile> file;
NonnullRefPtr<Core::MappedFile> file;
NonnullOwnPtr<ELF::Image> image;
NonnullOwnPtr<DebugInfo> debug_info;
FlatPtr base_address {};
LoadedLibrary(String const& name, NonnullRefPtr<MappedFile> file, NonnullOwnPtr<ELF::Image> image, NonnullOwnPtr<DebugInfo>&& debug_info, FlatPtr base_address)
LoadedLibrary(String const& name, NonnullRefPtr<Core::MappedFile> file, NonnullOwnPtr<ELF::Image> image, NonnullOwnPtr<DebugInfo>&& debug_info, FlatPtr base_address)
: name(name)
, file(move(file))
, image(move(image))

4
Userland/Libraries/LibGUI/FileIconProvider.cpp
View File

@ -5,10 +5,10 @@
*/
#include <AK/LexicalPath.h>
#include <AK/MappedFile.h>
#include <AK/String.h>
#include <LibCore/ConfigFile.h>
#include <LibCore/File.h>
#include <LibCore/MappedFile.h>
#include <LibCore/StandardPaths.h>
#include <LibELF/Image.h>
#include <LibGUI/FileIconProvider.h>
@ -147,7 +147,7 @@ Icon FileIconProvider::icon_for_executable(const String& path)
// If the icon for an app isn't in the cache we attempt to load the file as an ELF image and extract
// the serenity_app_icon_* sections which should contain the icons as raw PNG data. In the future it would
// be better if the binary signalled the image format being used or we deduced it, e.g. using magic bytes.
auto file_or_error = MappedFile::map(path);
auto file_or_error = Core::MappedFile::map(path);
if (file_or_error.is_error()) {
app_icon_cache.set(path, s_executable_icon);
return s_executable_icon;

4
Userland/Libraries/LibGUI/ImageWidget.cpp
View File

@ -4,7 +4,7 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/MappedFile.h>
#include <LibCore/MappedFile.h>
#include <LibGUI/ImageWidget.h>
#include <LibGUI/Painter.h>
#include <LibGfx/Bitmap.h>
@ -73,7 +73,7 @@ void ImageWidget::animate()
void ImageWidget::load_from_file(StringView path)
{
auto file_or_error = MappedFile::map(path);
auto file_or_error = Core::MappedFile::map(path);
if (file_or_error.is_error())
return;

4
Userland/Libraries/LibGfx/Bitmap.cpp
View File

@ -6,13 +6,13 @@
#include <AK/Checked.h>
#include <AK/LexicalPath.h>
#include <AK/MappedFile.h>
#include <AK/Memory.h>
#include <AK/MemoryStream.h>
#include <AK/Optional.h>
#include <AK/ScopeGuard.h>
#include <AK/String.h>
#include <AK/Try.h>
#include <LibCore/MappedFile.h>
#include <LibGfx/Bitmap.h>
#include <LibGfx/ImageDecoder.h>
#include <LibGfx/ShareableBitmap.h>
@ -134,7 +134,7 @@ ErrorOr<NonnullRefPtr<Bitmap>> Bitmap::try_load_from_file(String const& path, in
ErrorOr<NonnullRefPtr<Bitmap>> Bitmap::try_load_from_fd_and_close(int fd, String const& path)
{
auto file = TRY(MappedFile::map_from_fd_and_close(fd, path));
auto file = TRY(Core::MappedFile::map_from_fd_and_close(fd, path));
if (auto decoder = ImageDecoder::try_create(file->bytes())) {
auto frame = TRY(decoder->frame(0));
if (auto& bitmap = frame.image)

2
Userland/Libraries/LibGfx/BitmapFont.cpp
View File

@ -202,7 +202,7 @@ RefPtr<BitmapFont> BitmapFont::load_from_file(String const& path)
if (Core::File::is_device(path))
return nullptr;
auto file_or_error = MappedFile::map(path);
auto file_or_error = Core::MappedFile::map(path);
if (file_or_error.is_error())
return nullptr;

4
Userland/Libraries/LibGfx/BitmapFont.h
View File

@ -7,12 +7,12 @@
#pragma once
#include <AK/CharacterTypes.h>
#include <AK/MappedFile.h>
#include <AK/RefCounted.h>
#include <AK/RefPtr.h>
#include <AK/String.h>
#include <AK/Types.h>
#include <AK/Vector.h>
#include <LibCore/MappedFile.h>
#include <LibGfx/Font.h>
#include <LibGfx/Size.h>
@ -128,7 +128,7 @@ private:
u8* m_rows { nullptr };
u8* m_glyph_widths { nullptr };
RefPtr<MappedFile> m_mapped_file;
RefPtr<Core::MappedFile> m_mapped_file;
u8 m_glyph_width { 0 };
u8 m_glyph_height { 0 };

2
Userland/Libraries/LibGfx/Font.h
View File

@ -8,11 +8,11 @@
#include <AK/Bitmap.h>
#include <AK/ByteReader.h>
#include <AK/MappedFile.h>
#include <AK/RefCounted.h>
#include <AK/RefPtr.h>
#include <AK/String.h>
#include <AK/Types.h>
#include <LibCore/MappedFile.h>
#include <LibGfx/Bitmap.h>
#include <LibGfx/Size.h>

4
Userland/Libraries/LibGfx/TrueTypeFont/Font.cpp
View File

@ -6,11 +6,11 @@
*/
#include <AK/Checked.h>
#include <AK/MappedFile.h>
#include <AK/Try.h>
#include <AK/Utf32View.h>
#include <AK/Utf8View.h>
#include <LibCore/File.h>
#include <LibCore/MappedFile.h>
#include <LibGfx/TrueTypeFont/Cmap.h>
#include <LibGfx/TrueTypeFont/Font.h>
#include <LibGfx/TrueTypeFont/Glyf.h>
@ -227,7 +227,7 @@ GlyphHorizontalMetrics Hmtx::get_glyph_horizontal_metrics(u32 glyph_id) const
ErrorOr<NonnullRefPtr<Font>> Font::try_load_from_file(String path, unsigned index)
{
auto file = TRY(MappedFile::map(path));
auto file = TRY(Core::MappedFile::map(path));
auto font = TRY(try_load_from_externally_owned_memory(file->bytes(), index));
font->m_mapped_file = move(file);
return font;

2
Userland/Libraries/LibGfx/TrueTypeFont/Font.h
View File

@ -87,7 +87,7 @@ private:
{
}
RefPtr<MappedFile> m_mapped_file;
RefPtr<Core::MappedFile> m_mapped_file;
ReadonlyBytes m_buffer;

2
Userland/Libraries/LibPCIDB/Database.cpp
View File

@ -14,7 +14,7 @@ namespace PCIDB {
RefPtr<Database> Database::open(const String& filename)
{
auto file_or_error = MappedFile::map(filename);
auto file_or_error = Core::MappedFile::map(filename);
if (file_or_error.is_error())
return nullptr;
auto res = adopt_ref(*new Database(file_or_error.release_value()));

6
Userland/Libraries/LibPCIDB/Database.h
View File

@ -7,12 +7,12 @@
#pragma once
#include <AK/HashMap.h>
#include <AK/MappedFile.h>
#include <AK/NonnullOwnPtr.h>
#include <AK/RefCounted.h>
#include <AK/RefPtr.h>
#include <AK/String.h>
#include <AK/StringView.h>
#include <LibCore/MappedFile.h>
namespace PCIDB {
@ -64,7 +64,7 @@ public:
const StringView get_programming_interface(u8 class_id, u8 subclass_id, u8 programming_interface_id) const;
private:
explicit Database(NonnullRefPtr<MappedFile> file)
explicit Database(NonnullRefPtr<Core::MappedFile> file)
: m_file(move(file))
{
}
@ -77,7 +77,7 @@ private:
ClassMode,
};
NonnullRefPtr<MappedFile> m_file;
NonnullRefPtr<Core::MappedFile> m_file;
StringView m_view {};
HashMap<int, NonnullOwnPtr<Vendor>> m_vendors;
HashMap<int, NonnullOwnPtr<Class>> m_classes;

6
Userland/Libraries/LibSymbolication/Symbolication.cpp
View File

@ -10,15 +10,15 @@
#include <AK/JsonObject.h>
#include <AK/JsonValue.h>
#include <AK/LexicalPath.h>
#include <AK/MappedFile.h>
#include <LibCore/File.h>
#include <LibCore/MappedFile.h>
#include <LibDebug/DebugInfo.h>
#include <LibSymbolication/Symbolication.h>
namespace Symbolication {
struct CachedELF {
NonnullRefPtr<MappedFile> mapped_file;
NonnullRefPtr<Core::MappedFile> mapped_file;
NonnullOwnPtr<Debug::DebugInfo> debug_info;
NonnullOwnPtr<ELF::Image> image;
};
@ -81,7 +81,7 @@ Optional<Symbol> symbolicate(String const& path, FlatPtr address, IncludeSourceP
}
}
if (!s_cache.contains(full_path)) {
auto mapped_file = MappedFile::map(full_path);
auto mapped_file = Core::MappedFile::map(full_path);
if (mapped_file.is_error()) {
dbgln("Failed to map {}: {}", full_path, mapped_file.error());
s_cache.set(full_path, {});

2
Userland/Libraries/LibUSBDB/Database.cpp
View File

@ -14,7 +14,7 @@ namespace USBDB {
RefPtr<Database> Database::open(const String& filename)
{
auto file_or_error = MappedFile::map(filename);
auto file_or_error = Core::MappedFile::map(filename);
if (file_or_error.is_error())
return nullptr;
auto res = adopt_ref(*new Database(file_or_error.release_value()));

6
Userland/Libraries/LibUSBDB/Database.h
View File

@ -7,12 +7,12 @@
#pragma once
#include <AK/HashMap.h>
#include <AK/MappedFile.h>
#include <AK/NonnullOwnPtr.h>
#include <AK/RefCounted.h>
#include <AK/RefPtr.h>
#include <AK/String.h>
#include <AK/StringView.h>
#include <LibCore/MappedFile.h>
namespace USBDB {
@ -63,7 +63,7 @@ public:
const StringView get_protocol(u8 class_id, u8 subclass_id, u8 protocol_id) const;
private:
explicit Database(NonnullRefPtr<MappedFile> file)
explicit Database(NonnullRefPtr<Core::MappedFile> file)
: m_file(move(file))
{
}
@ -76,7 +76,7 @@ private:
ClassMode,
};
NonnullRefPtr<MappedFile> m_file;
NonnullRefPtr<Core::MappedFile> m_file;
StringView m_view {};
HashMap<int, NonnullOwnPtr<Vendor>> m_vendors;
HashMap<int, NonnullOwnPtr<Class>> m_classes;

4
Userland/Libraries/LibVideo/MatroskaReader.cpp
View File

@ -6,9 +6,9 @@
#include "MatroskaReader.h"
#include <AK/Function.h>
#include <AK/MappedFile.h>
#include <AK/Optional.h>
#include <AK/Utf8View.h>
#include <LibCore/MappedFile.h>
namespace Video {
@ -43,7 +43,7 @@ constexpr u32 TIMESTAMP_ID = 0xE7;
OwnPtr<MatroskaDocument> MatroskaReader::parse_matroska_from_file(StringView path)
{
auto mapped_file_result = MappedFile::map(path);
auto mapped_file_result = Core::MappedFile::map(path);
if (mapped_file_result.is_error())
return {};

4
Userland/Services/CrashDaemon/main.cpp
View File

@ -5,9 +5,9 @@
*/
#include <AK/LexicalPath.h>
#include <AK/MappedFile.h>
#include <Kernel/API/InodeWatcherEvent.h>
#include <LibCore/FileWatcher.h>
#include <LibCore/MappedFile.h>
#include <serenity.h>
#include <spawn.h>
#include <sys/stat.h>
@ -72,7 +72,7 @@ int main()
dbgln("New coredump file: {}", coredump_path);
wait_until_coredump_is_ready(coredump_path);
auto file_or_error = MappedFile::map(coredump_path);
auto file_or_error = Core::MappedFile::map(coredump_path);
if (file_or_error.is_error()) {
dbgln("Unable to map coredump {}: {}", coredump_path, file_or_error.error());
continue;

6
Userland/Services/WebServer/Client.cpp
View File

@ -8,7 +8,6 @@
#include <AK/Base64.h>
#include <AK/Debug.h>
#include <AK/LexicalPath.h>
#include <AK/MappedFile.h>
#include <AK/MemoryStream.h>
#include <AK/QuickSort.h>
#include <AK/StringBuilder.h>
@ -17,6 +16,7 @@
#include <LibCore/DirIterator.h>
#include <LibCore/File.h>
#include <LibCore/FileStream.h>
#include <LibCore/MappedFile.h>
#include <LibCore/MimeData.h>
#include <LibHTTP/HttpRequest.h>
#include <LibHTTP/HttpResponse.h>
@ -177,7 +177,7 @@ static String folder_image_data()
{
static String cache;
if (cache.is_empty()) {
auto file_or_error = MappedFile::map("/res/icons/16x16/filetype-folder.png");
auto file_or_error = Core::MappedFile::map("/res/icons/16x16/filetype-folder.png");
VERIFY(!file_or_error.is_error());
cache = encode_base64(file_or_error.value()->bytes());
}
@ -188,7 +188,7 @@ static String file_image_data()
{
static String cache;
if (cache.is_empty()) {
auto file_or_error = MappedFile::map("/res/icons/16x16/filetype-unknown.png");
auto file_or_error = Core::MappedFile::map("/res/icons/16x16/filetype-unknown.png");
VERIFY(!file_or_error.is_error());
cache = encode_base64(file_or_error.value()->bytes());
}

2
Userland/Services/WebServer/main.cpp
View File

@ -5,10 +5,10 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/MappedFile.h>
#include <LibCore/ArgsParser.h>
#include <LibCore/EventLoop.h>
#include <LibCore/File.h>
#include <LibCore/MappedFile.h>
#include <LibCore/TCPServer.h>
#include <LibHTTP/HttpRequest.h>
#include <WebServer/Client.h>

4
Userland/Utilities/disasm.cpp
View File

@ -5,11 +5,11 @@
*/
#include <AK/Debug.h>
#include <AK/MappedFile.h>
#include <AK/OwnPtr.h>
#include <AK/QuickSort.h>
#include <AK/Vector.h>
#include <LibCore/ArgsParser.h>
#include <LibCore/MappedFile.h>
#include <LibELF/Image.h>
#include <LibX86/Disassembler.h>
#include <LibX86/ELFSymbolProvider.h>
@ -26,7 +26,7 @@ int main(int argc, char** argv)
args_parser.add_positional_argument(path, "Path to i386 binary file", "path");
args_parser.parse(argc, argv);
auto file_or_error = MappedFile::map(path);
auto file_or_error = Core::MappedFile::map(path);
if (file_or_error.is_error()) {
warnln("Could not map file: {}", file_or_error.error());
return 1;

4
Userland/Utilities/fdtdump.cpp
View File

@ -4,9 +4,9 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/MappedFile.h>
#include <AK/String.h>
#include <LibCore/ArgsParser.h>
#include <LibCore/MappedFile.h>
#include <LibDeviceTree/Validation.h>
#include <serenity.h>
@ -24,7 +24,7 @@ int main(int argc, char* argv[])
args.parse(argc, argv);
// FIXME: Figure out how to do this sanely from stdin
auto maybe_file = MappedFile::map(filename);
auto maybe_file = Core::MappedFile::map(filename);
if (maybe_file.is_error()) {
warnln("Unable to dump device tree from file {}: {}", filename, maybe_file.error());
return 1;

8
Userland/Utilities/file.cpp
View File

@ -4,11 +4,11 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/MappedFile.h>
#include <AK/Vector.h>
#include <LibCompress/Gzip.h>
#include <LibCore/ArgsParser.h>
#include <LibCore/FileStream.h>
#include <LibCore/MappedFile.h>
#include <LibCore/MimeData.h>
#include <LibELF/Image.h>
#include <LibELF/Validation.h>
@ -25,7 +25,7 @@ static Optional<String> description_only(String description, [[maybe_unused]] co
// FIXME: Ideally Gfx::ImageDecoder could tell us the image type directly.
static Optional<String> image_details(const String& description, const String& path)
{
auto file_or_error = MappedFile::map(path);
auto file_or_error = Core::MappedFile::map(path);
if (file_or_error.is_error())
return {};
@ -39,7 +39,7 @@ static Optional<String> image_details(const String& description, const String& p
static Optional<String> gzip_details(String description, const String& path)
{
auto file_or_error = MappedFile::map(path);
auto file_or_error = Core::MappedFile::map(path);
if (file_or_error.is_error())
return {};
@ -56,7 +56,7 @@ static Optional<String> gzip_details(String description, const String& path)
static Optional<String> elf_details(String description, const String& path)
{
auto file_or_error = MappedFile::map(path);
auto file_or_error = Core::MappedFile::map(path);
if (file_or_error.is_error())
return {};
auto& mapped_file = *file_or_error.value();

4
Userland/Utilities/gzip.cpp
View File

@ -4,10 +4,10 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/MappedFile.h>
#include <LibCompress/Gzip.h>
#include <LibCore/ArgsParser.h>
#include <LibCore/FileStream.h>
#include <LibCore/MappedFile.h>
#include <unistd.h>
int main(int argc, char** argv)
@ -41,7 +41,7 @@ int main(int argc, char** argv)
// We map the whole file instead of streaming to reduce size overhead (gzip header) and increase the deflate block size (better compression)
// TODO: automatically fallback to buffered streaming for very large files
auto file_or_error = MappedFile::map(input_filename);
auto file_or_error = Core::MappedFile::map(input_filename);
if (file_or_error.is_error()) {
warnln("Failed opening input file for reading: {}", file_or_error.error());
return 1;

6
Userland/Utilities/readelf.cpp
View File

@ -4,12 +4,12 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/MappedFile.h>
#include <AK/String.h>
#include <AK/StringBuilder.h>
#include <AK/StringView.h>
#include <LibCore/ArgsParser.h>
#include <LibCore/File.h>
#include <LibCore/MappedFile.h>
#include <LibELF/DynamicLoader.h>
#include <LibELF/DynamicObject.h>
#include <LibELF/Image.h>
@ -283,7 +283,7 @@ int main(int argc, char** argv)
display_hardening = true;
}
auto file_or_error = MappedFile::map(path);
auto file_or_error = Core::MappedFile::map(path);
if (file_or_error.is_error()) {
warnln("Unable to map file {}: {}", path, file_or_error.error());
@ -315,7 +315,7 @@ int main(int argc, char** argv)
warnln("Warning: Dynamic ELF object has no interpreter path. Using: {}", interpreter_path);
}
auto interpreter_file_or_error = MappedFile::map(interpreter_path);
auto interpreter_file_or_error = Core::MappedFile::map(interpreter_path);
if (interpreter_file_or_error.is_error()) {
warnln("Unable to map interpreter file {}: {}", interpreter_path, interpreter_file_or_error.error());

4
Userland/Utilities/unzip.cpp
View File

@ -5,12 +5,12 @@
*/
#include <AK/Assertions.h>
#include <AK/MappedFile.h>
#include <AK/NumberFormat.h>
#include <LibArchive/Zip.h>
#include <LibCompress/Deflate.h>
#include <LibCore/ArgsParser.h>
#include <LibCore/File.h>
#include <LibCore/MappedFile.h>
#include <sys/stat.h>
#include <unistd.h>
@ -104,7 +104,7 @@ int main(int argc, char** argv)
return 1;
}
auto file_or_error = MappedFile::map(zip_file_path);
auto file_or_error = Core::MappedFile::map(zip_file_path);
if (file_or_error.is_error()) {
warnln("Failed to open {}: {}", zip_file_path, file_or_error.error());
return 1;