LibCore: Put all classes in the Core namespace and remove the leading C

I've been wanting to do this for a long time. It's time we start being
consistent about how this stuff works.

The new convention is:

- "LibFoo" is a userspace library that provides the "Foo" namespace.

That's it :^) This was pretty tedious to convert and I didn't even
start on LibGUI yet. But it's coming up next.

Applications/ChanViewer/BoardListModel.cpp

@@ -44,7 +44,7 @@ BoardListModel::~BoardListModel()
 
 void BoardListModel::update()
 {
-    CHttpRequest request;
+    Core::HttpRequest request;
     request.set_url("http://a.4cdn.org/boards.json");
 
     if (m_pending_job)

Applications/ChanViewer/BoardListModel.h

@@ -51,5 +51,5 @@ private:
     BoardListModel();
 
     JsonArray m_boards;
-    RefPtr<CHttpJob> m_pending_job;
+    RefPtr<Core::HttpJob> m_pending_job;
 };

Applications/ChanViewer/ThreadCatalogModel.cpp

@@ -52,7 +52,7 @@ void ThreadCatalogModel::set_board(const String& board)
 
 void ThreadCatalogModel::update()
 {
-    CHttpRequest request;
+    Core::HttpRequest request;
     request.set_url(String::format("http://a.4cdn.org/%s/catalog.json", m_board.characters()));
 
     if (m_pending_job)

Applications/ChanViewer/ThreadCatalogModel.h

@@ -63,5 +63,5 @@ private:
 
     String m_board { "g" };
     JsonArray m_catalog;
-    RefPtr<CHttpJob> m_pending_job;
+    RefPtr<Core::HttpJob> m_pending_job;
 };

Applications/DisplayProperties/DisplayProperties.cpp

@@ -48,7 +48,7 @@
 #include <Servers/WindowServer/WSWindowManager.h>
 
 DisplayPropertiesWidget::DisplayPropertiesWidget()
-    : m_wm_config(CConfigFile::get_for_app("WindowManager"))
+    : m_wm_config(Core::ConfigFile::get_for_app("WindowManager"))
 {
     create_resolution_list();
     create_wallpaper_list();
@@ -114,7 +114,7 @@ void DisplayPropertiesWidget::create_wallpaper_list()
         m_selected_wallpaper = name_parts[2];
     }
 
-    CDirIterator iterator("/res/wallpapers/", CDirIterator::Flags::SkipDots);
+    Core::DirIterator iterator("/res/wallpapers/", Core::DirIterator::Flags::SkipDots);
 
     while (iterator.has_next()) {
         m_wallpapers.append(iterator.next_path());

Applications/DisplayProperties/DisplayProperties.h

@@ -65,7 +65,7 @@ private:
 
 private:
     String m_wallpaper_path;
-    RefPtr<CConfigFile> m_wm_config;
+    RefPtr<Core::ConfigFile> m_wm_config;
     RefPtr<GWidget> m_root_widget;
     Vector<Size> m_resolutions;
     Vector<String> m_wallpapers;

Applications/FileManager/FileUtils.cpp

@@ -37,7 +37,7 @@ namespace FileUtils {
 
 int delete_directory(String directory, String& file_that_caused_error)
 {
-    CDirIterator iterator(directory, CDirIterator::SkipDots);
+    Core::DirIterator iterator(directory, Core::DirIterator::SkipDots);
     if (iterator.has_error()) {
         file_that_caused_error = directory;
         return -1;
@@ -104,7 +104,7 @@ bool copy_directory(const String& src_path, const String& dst_path)
     if (rc < 0) {
         return false;
     }
-    CDirIterator di(src_path, CDirIterator::SkipDots);
+    Core::DirIterator di(src_path, Core::DirIterator::SkipDots);
     if (di.has_error()) {
         return false;
     }

Applications/FileManager/PropertiesDialog.cpp

@@ -35,7 +35,7 @@
 #include <stdio.h>
 #include <unistd.h>
 
-PropertiesDialog::PropertiesDialog(GFileSystemModel& model, String path, bool disable_rename, CObject* parent)
+PropertiesDialog::PropertiesDialog(GFileSystemModel& model, String path, bool disable_rename, Core::Object* parent)
     : GDialog(parent)
     , m_model(model)
 {

Applications/FileManager/PropertiesDialog.h

@@ -40,7 +40,7 @@ public:
     virtual ~PropertiesDialog() override;
 
 private:
-    PropertiesDialog(GFileSystemModel&, String, bool disable_rename, CObject* parent = nullptr);
+    PropertiesDialog(GFileSystemModel&, String, bool disable_rename, Core::Object* parent = nullptr);
 
     struct PropertyValuePair {
         String property;

Applications/FileManager/main.cpp

@@ -72,7 +72,7 @@ int main(int argc, char** argv)
         return 1;
     }
 
-    RefPtr<CConfigFile> config = CConfigFile::get_for_app("FileManager");
+    RefPtr<Core::ConfigFile> config = Core::ConfigFile::get_for_app("FileManager");
 
     GApplication app(argc, argv);
 

Applications/Help/ManualSectionNode.cpp

@@ -41,7 +41,7 @@ void ManualSectionNode::reify_if_needed() const
         return;
     m_reified = true;
 
-    CDirIterator dir_iter { path(), CDirIterator::Flags::SkipDots };
+    Core::DirIterator dir_iter { path(), Core::DirIterator::Flags::SkipDots };
 
     while (dir_iter.has_next()) {
         FileSystemPath file_path(dir_iter.next_path());

Applications/Help/main.cpp

@@ -113,10 +113,10 @@ int main(int argc, char* argv[])
 
         dbg() << "Opening page at " << path;
 
-        auto file = CFile::construct();
+        auto file = Core::File::construct();
         file->set_filename(path);
 
-        if (!file->open(CIODevice::OpenMode::ReadOnly)) {
+        if (!file->open(Core::IODevice::OpenMode::ReadOnly)) {
             int saved_errno = errno;
             GMessageBox::show(strerror(saved_errno), "Failed to open man page", GMessageBox::Type::Error, GMessageBox::InputType::OK, window);
             return;

Applications/HexEditor/HexEditor.cpp

@@ -564,7 +564,7 @@ void HexEditor::paint_event(GPaintEvent& event)
     }
 }
 
-void HexEditor::leave_event(CEvent&)
+void HexEditor::leave_event(Core::Event&)
 {
     ASSERT(window());
     window()->set_override_cursor(GStandardCursor::None);

Applications/HexEditor/HexEditor.h

@@ -73,7 +73,7 @@ protected:
     virtual void mousemove_event(GMouseEvent&) override;
     virtual void keydown_event(GKeyEvent&) override;
     virtual bool accepts_focus() const override { return true; }
-    virtual void leave_event(CEvent&) override;
+    virtual void leave_event(Core::Event&) override;
 
 private:
     bool m_readonly { false };

Applications/HexEditor/HexEditorWidget.cpp

@@ -235,8 +235,8 @@ void HexEditorWidget::update_title()
 
 void HexEditorWidget::open_file(const String& path)
 {
-    auto file = CFile::construct(path);
-    if (!file->open(CIODevice::ReadOnly)) {
+    auto file = Core::File::construct(path);
+    if (!file->open(Core::IODevice::ReadOnly)) {
         GMessageBox::show(String::format("Opening \"%s\" failed: %s", path.characters(), strerror(errno)), "Error", GMessageBox::Type::Error, GMessageBox::InputType::OK, window());
         return;
     }

Applications/IRCClient/IRCClient.cpp

@@ -60,9 +60,9 @@ IRCClient::IRCClient()
     : m_nickname("seren1ty")
     , m_client_window_list_model(IRCWindowListModel::create(*this))
     , m_log(IRCLogBuffer::create())
-    , m_config(CConfigFile::get_for_app("IRCClient"))
+    , m_config(Core::ConfigFile::get_for_app("IRCClient"))
 {
-    m_socket = CTCPSocket::construct(this);
+    m_socket = Core::TCPSocket::construct(this);
     m_nickname = m_config->read_entry("User", "Nickname", "seren1ty");
     m_hostname = m_config->read_entry("Connection", "Server", "");
     m_port = m_config->read_num_entry("Connection", "Port", 6667);
@@ -83,7 +83,7 @@ void IRCClient::set_server(const String& hostname, int port)
 
 void IRCClient::on_socket_connected()
 {
-    m_notifier = CNotifier::construct(m_socket->fd(), CNotifier::Read);
+    m_notifier = Core::Notifier::construct(m_socket->fd(), Core::Notifier::Read);
     m_notifier->on_ready_to_read = [this] { receive_from_server(); };
 
     send_user();

Applications/IRCClient/IRCClient.h

@@ -38,9 +38,8 @@
 class IRCChannel;
 class IRCQuery;
 class IRCWindowListModel;
-class CNotifier;
 
-class IRCClient final : public CObject {
+class IRCClient final : public Core::Object {
     C_OBJECT(IRCClient)
     friend class IRCChannel;
     friend class IRCQuery;
@@ -162,10 +161,10 @@ private:
     String m_hostname;
     int m_port { 6667 };
 
-    RefPtr<CTCPSocket> m_socket;
+    RefPtr<Core::TCPSocket> m_socket;
 
     String m_nickname;
-    RefPtr<CNotifier> m_notifier;
+    RefPtr<Core::Notifier> m_notifier;
     HashMap<String, RefPtr<IRCChannel>, CaseInsensitiveStringTraits> m_channels;
     HashMap<String, RefPtr<IRCQuery>, CaseInsensitiveStringTraits> m_queries;
 
@@ -175,5 +174,5 @@ private:
 
     NonnullRefPtr<IRCWindowListModel> m_client_window_list_model;
     NonnullRefPtr<IRCLogBuffer> m_log;
-    NonnullRefPtr<CConfigFile> m_config;
+    NonnullRefPtr<Core::ConfigFile> m_config;
 };

Applications/PaintBrush/SprayTool.cpp

@@ -37,7 +37,7 @@
 
 SprayTool::SprayTool()
 {
-    m_timer = CTimer::construct();
+    m_timer = Core::Timer::construct();
     m_timer->on_timeout = [&]() {
         paint_it();
     };

Applications/PaintBrush/SprayTool.h

@@ -46,7 +46,7 @@ public:
 private:
     virtual const char* class_name() const override { return "SprayTool"; }
     void paint_it();
-    RefPtr<CTimer> m_timer;
+    RefPtr<Core::Timer> m_timer;
     Point m_last_pos;
     Color m_color;
     RefPtr<GMenu> m_context_menu;

Applications/Piano/MainWidget.cpp

@@ -70,7 +70,7 @@ MainWidget::~MainWidget()
 // FIXME: There are some unnecessary calls to update() throughout this program,
 // which are an easy target for optimization.
 
-void MainWidget::custom_event(CCustomEvent&)
+void MainWidget::custom_event(Core::CustomEvent&)
 {
     m_wave_widget->update();
 

Applications/Piano/MainWidget.h

@@ -27,8 +27,8 @@
 
 #pragma once
 
+#include "Music.h"
 #include <LibGUI/GWidget.h>
-#include <Music.h>
 
 class AudioEngine;
 class WaveWidget;
@@ -48,7 +48,7 @@ private:
 
     virtual void keydown_event(GKeyEvent&) override;
     virtual void keyup_event(GKeyEvent&) override;
-    virtual void custom_event(CCustomEvent&) override;
+    virtual void custom_event(Core::CustomEvent&) override;
 
     void note_key_action(int key_code, Switch);
     void special_key_action(int key_code);

Applications/Piano/main.cpp

@@ -55,8 +55,8 @@ int main(int argc, char** argv)
     window->show();
 
     LibThread::Thread audio_thread([&] {
-        auto audio = CFile::construct("/dev/audio");
-        if (!audio->open(CIODevice::WriteOnly)) {
+        auto audio = Core::File::construct("/dev/audio");
+        if (!audio->open(Core::IODevice::WriteOnly)) {
             dbgprintf("Can't open audio device: %s", audio->error_string());
             return 1;
         }
@@ -65,8 +65,8 @@ int main(int argc, char** argv)
         for (;;) {
             audio_engine.fill_buffer(buffer);
             audio->write(reinterpret_cast<u8*>(buffer.data()), buffer_size);
-            CEventLoop::current().post_event(*main_widget, make<CCustomEvent>(0));
-            CEventLoop::wake();
+            Core::EventLoop::current().post_event(*main_widget, make<Core::CustomEvent>(0));
+            Core::EventLoop::wake();
         }
     });
     audio_thread.start();

Applications/SoundPlayer/PlaybackManager.cpp

@@ -29,7 +29,7 @@
 PlaybackManager::PlaybackManager(NonnullRefPtr<AClientConnection> connection)
     : m_connection(connection)
 {
-    m_timer = CTimer::construct(100, [&]() {
+    m_timer = Core::Timer::construct(100, [&]() {
         if (!m_loader)
             return;
         next_buffer();

Applications/SoundPlayer/PlaybackManager.h

@@ -70,5 +70,5 @@ private:
     RefPtr<ABuffer> m_next_buffer;
     RefPtr<ABuffer> m_current_buffer;
     Vector<RefPtr<ABuffer>> m_buffers;
-    RefPtr<CTimer> m_timer;
+    RefPtr<Core::Timer> m_timer;
 };

Applications/SystemMonitor/DevicesModel.cpp

@@ -121,8 +121,8 @@ GVariant DevicesModel::data(const GModelIndex& index, Role) const
 
 void DevicesModel::update()
 {
-    auto proc_devices = CFile::construct("/proc/devices");
-    if (!proc_devices->open(CIODevice::OpenMode::ReadOnly))
+    auto proc_devices = Core::File::construct("/proc/devices");
+    if (!proc_devices->open(Core::IODevice::OpenMode::ReadOnly))
         ASSERT_NOT_REACHED();
 
     auto json = JsonValue::from_string(proc_devices->read_all()).as_array();
@@ -148,7 +148,7 @@ void DevicesModel::update()
     });
 
     auto fill_in_paths_from_dir = [this](const String& dir) {
-        CDirIterator dir_iter { dir, CDirIterator::Flags::SkipDots };
+        Core::DirIterator dir_iter { dir, Core::DirIterator::Flags::SkipDots };
         while (dir_iter.has_next()) {
             auto name = dir_iter.next_path();
             auto path = String::format("%s/%s", dir.characters(), name.characters());

Applications/SystemMonitor/MemoryStatsWidget.cpp

@@ -93,8 +93,8 @@ static inline size_t bytes_to_kb(size_t bytes)
 
 void MemoryStatsWidget::refresh()
 {
-    auto proc_memstat = CFile::construct("/proc/memstat");
-    if (!proc_memstat->open(CIODevice::OpenMode::ReadOnly))
+    auto proc_memstat = Core::File::construct("/proc/memstat");
+    if (!proc_memstat->open(Core::IODevice::OpenMode::ReadOnly))
         ASSERT_NOT_REACHED();
 
     auto file_contents = proc_memstat->read_all();

Applications/SystemMonitor/NetworkStatisticsWidget.cpp

@@ -81,7 +81,7 @@ NetworkStatisticsWidget::NetworkStatisticsWidget(GWidget* parent)
         net_tcp_fields.empend("bytes_out", "Bytes Out", TextAlignment::CenterRight);
         m_socket_table_view->set_model(GJsonArrayModel::create("/proc/net/tcp", move(net_tcp_fields)));
 
-        m_update_timer = CTimer::construct(
+        m_update_timer = Core::Timer::construct(
             1000, [this] {
                 update_models();
             },

Applications/SystemMonitor/NetworkStatisticsWidget.h

@@ -42,5 +42,5 @@ private:
 
     RefPtr<GTableView> m_adapter_table_view;
     RefPtr<GTableView> m_socket_table_view;
-    RefPtr<CTimer> m_update_timer;
+    RefPtr<Core::Timer> m_update_timer;
 };

Applications/SystemMonitor/ProcessMemoryMapWidget.cpp

@@ -73,7 +73,7 @@ ProcessMemoryMapWidget::ProcessMemoryMapWidget(GWidget* parent)
     m_json_model = GJsonArrayModel::create({}, move(pid_vm_fields));
     m_table_view->set_model(GSortingProxyModel::create(*m_json_model));
     m_table_view->model()->set_key_column_and_sort_order(0, GSortOrder::Ascending);
-    m_timer = CTimer::construct(1000, [this] { refresh(); }, this);
+    m_timer = Core::Timer::construct(1000, [this] { refresh(); }, this);
 }
 
 ProcessMemoryMapWidget::~ProcessMemoryMapWidget()

Applications/SystemMonitor/ProcessMemoryMapWidget.h

@@ -28,7 +28,10 @@
 
 #include <LibGUI/GWidget.h>
 
-class CTimer;
+namespace Core {
+class Timer;
+}
+
 class GJsonArrayModel;
 class GTableView;
 
@@ -45,5 +48,5 @@ private:
     RefPtr<GTableView> m_table_view;
     RefPtr<GJsonArrayModel> m_json_model;
     pid_t m_pid { -1 };
-    RefPtr<CTimer> m_timer;
+    RefPtr<Core::Timer> m_timer;
 };

Applications/SystemMonitor/ProcessModel.cpp

@@ -335,7 +335,7 @@ GVariant ProcessModel::data(const GModelIndex& index, Role role) const
 
 void ProcessModel::update()
 {
-    auto all_processes = CProcessStatisticsReader::get_all();
+    auto all_processes = Core::ProcessStatisticsReader::get_all();
 
     unsigned last_sum_times_scheduled = 0;
     for (auto& it : m_threads)

Applications/SystemMonitor/ProcessStacksWidget.cpp

@@ -37,7 +37,7 @@ ProcessStacksWidget::ProcessStacksWidget(GWidget* parent)
     m_stacks_editor = GTextEditor::construct(GTextEditor::Type::MultiLine, this);
     m_stacks_editor->set_readonly(true);
 
-    m_timer = CTimer::construct(1000, [this] { refresh(); }, this);
+    m_timer = Core::Timer::construct(1000, [this] { refresh(); }, this);
 }
 
 ProcessStacksWidget::~ProcessStacksWidget()
@@ -54,8 +54,8 @@ void ProcessStacksWidget::set_pid(pid_t pid)
 
 void ProcessStacksWidget::refresh()
 {
-    auto file = CFile::construct(String::format("/proc/%d/stack", m_pid));
-    if (!file->open(CIODevice::ReadOnly)) {
+    auto file = Core::File::construct(String::format("/proc/%d/stack", m_pid));
+    if (!file->open(Core::IODevice::ReadOnly)) {
         m_stacks_editor->set_text(String::format("Unable to open %s", file->filename().characters()));
         return;
     }

Applications/SystemMonitor/ProcessStacksWidget.h

@@ -29,7 +29,9 @@
 #include <LibGUI/GTextEditor.h>
 #include <LibGUI/GWidget.h>
 
-class CTimer;
+namespace Core {
+class Timer;
+}
 
 class ProcessStacksWidget final : public GWidget {
     C_OBJECT(ProcessStacksWidget)
@@ -43,5 +45,5 @@ public:
 private:
     pid_t m_pid { -1 };
     RefPtr<GTextEditor> m_stacks_editor;
-    RefPtr<CTimer> m_timer;
+    RefPtr<Core::Timer> m_timer;
 };

Applications/SystemMonitor/main.cpp

@@ -146,7 +146,7 @@ int main(int argc, char** argv)
     toolbar->set_has_frame(false);
     auto process_table_view = ProcessTableView::construct(process_table_container);
 
-    auto refresh_timer = CTimer::construct(1000, [&] {
+    auto refresh_timer = Core::Timer::construct(1000, [&] {
         process_table_view->refresh();
         if (auto* memory_stats_widget = MemoryStatsWidget::the())
             memory_stats_widget->refresh();

Applications/Taskbar/TaskbarWindow.cpp

@@ -81,15 +81,15 @@ void TaskbarWindow::create_quick_launch_bar()
     int total_width = 6;
     bool first = true;
 
-    auto config = CConfigFile::get_for_app("Taskbar");
+    auto config = Core::ConfigFile::get_for_app("Taskbar");
     constexpr const char* quick_launch = "QuickLaunch";
 
-    // FIXME: CConfigFile does not keep the order of the entries.
+    // FIXME: Core::ConfigFile does not keep the order of the entries.
     for (auto& name : config->keys(quick_launch)) {
         auto af_name = config->read_entry(quick_launch, name);
         ASSERT(!af_name.is_null());
         auto af_path = String::format("/res/apps/%s", af_name.characters());
-        auto af = CConfigFile::open(af_path);
+        auto af = Core::ConfigFile::open(af_path);
         auto app_executable = af->read_entry("App", "Executable");
         auto app_icon_path = af->read_entry("Icons", "16x16");
 

Applications/Terminal/main.cpp

@@ -195,7 +195,7 @@ int main(int argc, char** argv)
 
     const char* command_to_execute = "/bin/Shell";
 
-    CArgsParser args_parser;
+    Core::ArgsParser args_parser;
     args_parser.add_option(command_to_execute, "Execute this command inside the terminal", nullptr, 'e', "command");
     args_parser.parse(argc, argv);
 
@@ -215,7 +215,7 @@ int main(int argc, char** argv)
     window->set_background_color(Color::Black);
     window->set_double_buffering_enabled(false);
 
-    RefPtr<CConfigFile> config = CConfigFile::get_for_app("Terminal");
+    RefPtr<Core::ConfigFile> config = Core::ConfigFile::get_for_app("Terminal");
     auto terminal = TerminalWidget::construct(ptm_fd, true, config);
     terminal->on_command_exit = [&] {
         app.quit(0);

Applications/TextEditor/TextEditorWidget.cpp

@@ -431,8 +431,8 @@ void TextEditorWidget::update_title()
 
 void TextEditorWidget::open_sesame(const String& path)
 {
-    auto file = CFile::construct(path);
-    if (!file->open(CIODevice::ReadOnly)) {
+    auto file = Core::File::construct(path);
+    if (!file->open(Core::IODevice::ReadOnly)) {
         GMessageBox::show(String::format("Opening \"%s\" failed: %s", path.characters(), strerror(errno)), "Error", GMessageBox::Type::Error, GMessageBox::InputType::OK, window());
         return;
     }

Demos/Fire/Fire.cpp

@@ -101,7 +101,7 @@ private:
     GLabel* stats;
 
     virtual void paint_event(GPaintEvent&) override;
-    virtual void timer_event(CTimerEvent&) override;
+    virtual void timer_event(Core::TimerEvent&) override;
     virtual void mousedown_event(GMouseEvent& event) override;
     virtual void mousemove_event(GMouseEvent& event) override;
     virtual void mouseup_event(GMouseEvent& event) override;
@@ -148,7 +148,7 @@ Fire::~Fire()
 
 void Fire::paint_event(GPaintEvent& event)
 {
-    CElapsedTimer timer;
+    Core::ElapsedTimer timer;
     timer.start();
 
     GPainter painter(*this);
@@ -161,7 +161,7 @@ void Fire::paint_event(GPaintEvent& event)
     cycles++;
 }
 
-void Fire::timer_event(CTimerEvent&)
+void Fire::timer_event(Core::TimerEvent&)
 {
     /* Update only even or odd columns per frame... */
     phase++;

Demos/WidgetGallery/main.cpp

@@ -70,7 +70,7 @@ int main(int argc, char** argv)
     button2->set_enabled(false);
 
     auto progress1 = GProgressBar::construct(main_widget);
-    auto timer = CTimer::construct(100, [&] {
+    auto timer = Core::Timer::construct(100, [&] {
         progress1->set_value(progress1->value() + 1);
         if (progress1->value() == progress1->max())
             progress1->set_value(progress1->min());

DevTools/FormCompiler/main.cpp

@@ -39,8 +39,8 @@ int main(int argc, char** argv)
         return 0;
     }
 
-    auto file = CFile::construct(argv[1]);
-    if (!file->open(CIODevice::ReadOnly)) {
+    auto file = Core::File::construct(argv[1]);
+    if (!file->open(Core::IODevice::ReadOnly)) {
         fprintf(stderr, "Error: Cannot open %s: %s\n", argv[1], file->error_string());
         return 1;
     }

DevTools/HackStudio/Editor.cpp

@@ -67,7 +67,7 @@ const EditorWrapper& Editor::wrapper() const
     return static_cast<const EditorWrapper&>(*parent());
 }
 
-void Editor::focusin_event(CEvent& event)
+void Editor::focusin_event(Core::Event& event)
 {
     wrapper().set_editor_has_focus({}, true);
     if (on_focus)
@@ -75,7 +75,7 @@ void Editor::focusin_event(CEvent& event)
     GTextEditor::focusin_event(event);
 }
 
-void Editor::focusout_event(CEvent& event)
+void Editor::focusout_event(Core::Event& event)
 {
     wrapper().set_editor_has_focus({}, false);
     GTextEditor::focusout_event(event);
@@ -103,7 +103,7 @@ static HashMap<String, String>& man_paths()
     static HashMap<String, String> paths;
     if (paths.is_empty()) {
         // FIXME: This should also search man3, possibly other places..
-        CDirIterator it("/usr/share/man/man2", CDirIterator::Flags::SkipDots);
+        Core::DirIterator it("/usr/share/man/man2", Core::DirIterator::Flags::SkipDots);
         while (it.has_next()) {
             auto path = String::format("/usr/share/man/man2/%s", it.next_path().characters());
             auto title = FileSystemPath(path).title();
@@ -132,8 +132,8 @@ void Editor::show_documentation_tooltip_if_available(const String& hovered_token
 #ifdef EDITOR_DEBUG
     dbg() << "opening " << it->value;
 #endif
-    auto file = CFile::construct(it->value);
-    if (!file->open(CFile::ReadOnly)) {
+    auto file = Core::File::construct(it->value);
+    if (!file->open(Core::File::ReadOnly)) {
         dbg() << "failed to open " << it->value << " " << file->error_string();
         return;
     }

DevTools/HackStudio/Editor.h

@@ -44,8 +44,8 @@ public:
     void notify_did_rehighlight();
 
 private:
-    virtual void focusin_event(CEvent&) override;
-    virtual void focusout_event(CEvent&) override;
+    virtual void focusin_event(Core::Event&) override;
+    virtual void focusout_event(Core::Event&) override;
     virtual void paint_event(GPaintEvent&) override;
     virtual void mousemove_event(GMouseEvent&) override;
     virtual void cursor_did_change() override;

DevTools/HackStudio/EditorWrapper.h

@@ -52,7 +52,7 @@ private:
 };
 
 template<>
-inline bool is<EditorWrapper>(const CObject& object)
+inline bool Core::is<EditorWrapper>(const Core::Object& object)
 {
     return !strcmp(object.class_name(), "EditorWrapper");
 }

DevTools/HackStudio/ProcessStateWidget.cpp

@@ -57,7 +57,7 @@ ProcessStateWidget::ProcessStateWidget(GWidget* parent)
     memory_label_label->set_font(Font::default_bold_font());
     m_memory_label = GLabel::construct("", this);
 
-    m_timer = CTimer::construct(500, [this] {
+    m_timer = Core::Timer::construct(500, [this] {
         refresh();
     });
 }
@@ -70,7 +70,7 @@ void ProcessStateWidget::refresh()
 {
     pid_t pid = tcgetpgrp(m_tty_fd);
 
-    auto processes = CProcessStatisticsReader::get_all();
+    auto processes = Core::ProcessStatisticsReader::get_all();
     auto child_process_data = processes.get(pid);
 
     if (!child_process_data.has_value())

DevTools/HackStudio/ProcessStateWidget.h

@@ -28,7 +28,10 @@
 
 #include <LibGUI/GWidget.h>
 
-class CTimer;
+namespace Core {
+class Timer;
+}
+
 class GLabel;
 
 class ProcessStateWidget final : public GWidget {
@@ -48,7 +51,7 @@ private:
     RefPtr<GLabel> m_cpu_label;
     RefPtr<GLabel> m_memory_label;
 
-    RefPtr<CTimer> m_timer;
+    RefPtr<Core::Timer> m_timer;
 
     int m_tty_fd { -1 };
 };

DevTools/HackStudio/Project.cpp

@@ -190,8 +190,8 @@ Project::~Project()
 
 OwnPtr<Project> Project::load_from_file(const String& path)
 {
-    auto file = CFile::construct(path);
-    if (!file->open(CFile::ReadOnly))
+    auto file = Core::File::construct(path);
+    if (!file->open(Core::File::ReadOnly))
         return nullptr;
 
     Vector<String> files;
@@ -225,12 +225,12 @@ bool Project::remove_file(const String& filename)
 
 bool Project::save()
 {
-    auto project_file = CFile::construct(m_path);
-    if (!project_file->open(CFile::WriteOnly))
+    auto project_file = Core::File::construct(m_path);
+    if (!project_file->open(Core::File::WriteOnly))
         return false;
 
     for (auto& file : m_files) {
-        // FIXME: Check for error here. CIODevice::printf() needs some work on error reporting.
+        // FIXME: Check for error here. IODevice::printf() needs some work on error reporting.
         project_file->printf("%s\n", file.name().characters());
     }
 

DevTools/HackStudio/ProjectFile.cpp

@@ -32,8 +32,8 @@ const GTextDocument& ProjectFile::document() const
 {
     if (!m_document) {
         m_document = GTextDocument::create(nullptr);
-        auto file = CFile::construct(m_name);
-        if (!file->open(CFile::ReadOnly)) {
+        auto file = Core::File::construct(m_name);
+        if (!file->open(Core::File::ReadOnly)) {
             ASSERT_NOT_REACHED();
         }
         m_document->set_text(file->read_all());

DevTools/HackStudio/TerminalWrapper.cpp

@@ -163,7 +163,7 @@ TerminalWrapper::TerminalWrapper(GWidget* parent)
 {
     set_layout(make<GVBoxLayout>());
 
-    RefPtr<CConfigFile> config = CConfigFile::get_for_app("Terminal");
+    RefPtr<Core::ConfigFile> config = Core::ConfigFile::get_for_app("Terminal");
     m_terminal_widget = TerminalWidget::construct(-1, false, config);
     add_child(*m_terminal_widget);
 

DevTools/HackStudio/main.cpp

@@ -180,8 +180,8 @@ int main(int argc, char** argv)
         if (input_box->exec() == GInputBox::ExecCancel)
             return;
         auto filename = input_box->text_value();
-        auto file = CFile::construct(filename);
-        if (!file->open((CIODevice::OpenMode)(CIODevice::WriteOnly | CIODevice::MustBeNew))) {
+        auto file = Core::File::construct(filename);
+        if (!file->open((Core::IODevice::OpenMode)(Core::IODevice::WriteOnly | Core::IODevice::MustBeNew))) {
             GMessageBox::show(String::format("Failed to create '%s'", filename.characters()), "Error", GMessageBox::Type::Error, GMessageBox::InputType::OK, g_window);
             return;
         }

DevTools/IPCCompiler/main.cpp

@@ -66,8 +66,8 @@ int main(int argc, char** argv)
         return 0;
     }
 
-    auto file = CFile::construct(argv[1]);
-    if (!file->open(CIODevice::ReadOnly)) {
+    auto file = Core::File::construct(argv[1]);
+    if (!file->open(Core::IODevice::ReadOnly)) {
         fprintf(stderr, "Error: Cannot open %s: %s\n", argv[1], file->error_string());
         return 1;
     }

DevTools/Inspector/RemoteProcess.cpp

@@ -34,7 +34,7 @@
 RemoteProcess::RemoteProcess(pid_t pid)
     : m_pid(pid)
     , m_object_graph_model(RemoteObjectGraphModel::create(*this))
-    , m_socket(CLocalSocket::construct())
+    , m_socket(Core::LocalSocket::construct())
 {
 }
 
@@ -152,7 +152,7 @@ void RemoteProcess::update()
         }
     };
 
-    auto success = m_socket->connect(CSocketAddress::local(String::format("/tmp/rpc.%d", m_pid)));
+    auto success = m_socket->connect(Core::SocketAddress::local(String::format("/tmp/rpc.%d", m_pid)));
     if (!success) {
         fprintf(stderr, "Couldn't connect to PID %d\n", m_pid);
         exit(1);

DevTools/Inspector/RemoteProcess.h

@@ -58,6 +58,6 @@ private:
     pid_t m_pid { -1 };
     String m_process_name;
     NonnullRefPtr<RemoteObjectGraphModel> m_object_graph_model;
-    RefPtr<CLocalSocket> m_socket;
+    RefPtr<Core::LocalSocket> m_socket;
     NonnullOwnPtrVector<RemoteObject> m_roots;
 };

DevTools/ProfileViewer/Profile.cpp

@@ -157,8 +157,8 @@ void Profile::rebuild_tree()
 
 OwnPtr<Profile> Profile::load_from_file(const StringView& path)
 {
-    auto file = CFile::construct(path);
-    if (!file->open(CIODevice::ReadOnly)) {
+    auto file = Core::File::construct(path);
+    if (!file->open(Core::IODevice::ReadOnly)) {
         fprintf(stderr, "Unable to open %s, error: %s\n", String(path).characters(), file->error_string());
         return nullptr;
     }

DevTools/VisualBuilder/VBForm.cpp

@@ -381,8 +381,8 @@ void VBForm::mousemove_event(GMouseEvent& event)
 
 void VBForm::load_from_file(const String& path)
 {
-    auto file = CFile::construct(path);
-    if (!file->open(CIODevice::ReadOnly)) {
+    auto file = Core::File::construct(path);
+    if (!file->open(Core::IODevice::ReadOnly)) {
         GMessageBox::show(String::format("Could not open '%s' for reading", path.characters()), "Error", GMessageBox::Type::Error, GMessageBox::InputType::OK, window());
         return;
     }
@@ -417,8 +417,8 @@ void VBForm::load_from_file(const String& path)
 
 void VBForm::write_to_file(const String& path)
 {
-    auto file = CFile::construct(path);
-    if (!file->open(CIODevice::WriteOnly)) {
+    auto file = Core::File::construct(path);
+    if (!file->open(Core::IODevice::WriteOnly)) {
         GMessageBox::show(String::format("Could not open '%s' for writing", path.characters()), "Error", GMessageBox::Type::Error, GMessageBox::InputType::OK, window());
         return;
     }

DevTools/VisualBuilder/VBWidget.cpp

@@ -138,7 +138,7 @@ void VBWidget::add_property(const String& name, Function<GVariant(const GWidget&
 
 void VBWidget::setup_properties()
 {
-    VB_ADD_PROPERTY(CObject, "name", name, set_name, string);
+    VB_ADD_PROPERTY(Core::Object, "name", name, set_name, string);
 
     VB_ADD_PROPERTY(GWidget, "width", width, set_width, i32);
     VB_ADD_PROPERTY(GWidget, "height", height, set_height, i32);

Games/Minesweeper/Field.cpp

@@ -127,7 +127,7 @@ Field::Field(GLabel& flag_label, GLabel& time_label, GButton& face_button, GWidg
     , m_on_size_changed(move(on_size_changed))
 {
     srand(time(nullptr));
-    m_timer = CTimer::construct();
+    m_timer = Core::Timer::construct();
     m_timer->on_timeout = [this] {
         ++m_time_elapsed;
         m_time_label.set_text(String::format("%u.%u", m_time_elapsed / 10, m_time_elapsed % 10));
@@ -153,7 +153,7 @@ Field::Field(GLabel& flag_label, GLabel& time_label, GButton& face_button, GWidg
     set_face(Face::Default);
 
     {
-        auto config = CConfigFile::get_for_app("Minesweeper");
+        auto config = Core::ConfigFile::get_for_app("Minesweeper");
         bool single_chording = config->read_num_entry("Minesweeper", "SingleChording", false);
         int mine_count = config->read_num_entry("Game", "MineCount", 10);
         int rows = config->read_num_entry("Game", "Rows", 9);
@@ -497,7 +497,7 @@ void Field::set_field_size(int rows, int columns, int mine_count)
     if (m_rows == rows && m_columns == columns && m_mine_count == mine_count)
         return;
     {
-        auto config = CConfigFile::get_for_app("Minesweeper");
+        auto config = Core::ConfigFile::get_for_app("Minesweeper");
         config->write_num_entry("Game", "MineCount", mine_count);
         config->write_num_entry("Game", "Rows", rows);
         config->write_num_entry("Game", "Columns", columns);
@@ -511,7 +511,7 @@ void Field::set_field_size(int rows, int columns, int mine_count)
 }
 
 void Field::set_single_chording(bool enabled) {
-    auto config = CConfigFile::get_for_app("Minesweeper");
+    auto config = Core::ConfigFile::get_for_app("Minesweeper");
     m_single_chording = enabled;
     config->write_bool_entry("Minesweeper", "SingleChording", m_single_chording);
 }

Games/Minesweeper/Field.h

@@ -121,7 +121,7 @@ private:
     GButton& m_face_button;
     GLabel& m_flag_label;
     GLabel& m_time_label;
-    RefPtr<CTimer> m_timer;
+    RefPtr<Core::Timer> m_timer;
     int m_time_elapsed { 0 };
     int m_flags_left { 0 };
     Face m_face { Face::Default };

Games/Snake/SnakeGame.cpp

@@ -102,7 +102,7 @@ Rect SnakeGame::high_score_rect() const
     return { 2, height() - font().glyph_height() - 2, high_score_width, font().glyph_height() };
 }
 
-void SnakeGame::timer_event(CTimerEvent&)
+void SnakeGame::timer_event(Core::TimerEvent&)
 {
     Vector<Coordinate> dirty_cells;
 

Games/Snake/SnakeGame.h

@@ -41,7 +41,7 @@ private:
     explicit SnakeGame(GWidget* parent = nullptr);
     virtual void paint_event(GPaintEvent&) override;
     virtual void keydown_event(GKeyEvent&) override;
-    virtual void timer_event(CTimerEvent&) override;
+    virtual void timer_event(Core::TimerEvent&) override;
 
     struct Coordinate {
         int row { 0 };

Libraries/LibAudio/AWavLoader.cpp

@@ -31,9 +31,9 @@
 #include <limits>
 
 AWavLoader::AWavLoader(const StringView& path)
-    : m_file(CFile::construct(path))
+    : m_file(Core::File::construct(path))
 {
-    if (!m_file->open(CIODevice::ReadOnly)) {
+    if (!m_file->open(Core::IODevice::ReadOnly)) {
         m_error_string = String::format("Can't open file: %s", m_file->error_string());
         return;
     }
@@ -75,7 +75,7 @@ void AWavLoader::reset()
 
 bool AWavLoader::parse_header()
 {
-    CIODeviceStreamReader stream(*m_file);
+    Core::IODeviceStreamReader stream(*m_file);
 
 #define CHECK_OK(msg)                                                           \
     do {                                                                        \

Libraries/LibAudio/AWavLoader.h

@@ -56,11 +56,11 @@ public:
     u32 sample_rate() const { return m_sample_rate; }
     u16 num_channels() const { return m_num_channels; }
     u16 bits_per_sample() const { return m_bits_per_sample; }
-    RefPtr<CFile> file() const { return m_file; }
+    RefPtr<Core::File> file() const { return m_file; }
 
 private:
     bool parse_header();
-    RefPtr<CFile> m_file;
+    RefPtr<Core::File> m_file;
     String m_error_string;
     OwnPtr<AResampleHelper> m_resampler;
 

Libraries/LibCore/CArgsParser.cpp

@@ -30,12 +30,14 @@
 #include <limits.h>
 #include <stdio.h>
 
-CArgsParser::CArgsParser()
+namespace Core {
+
+ArgsParser::ArgsParser()
 {
     add_option(m_show_help, "Display this message", "help", 0);
 }
 
-void CArgsParser::parse(int argc, char** argv)
+void ArgsParser::parse(int argc, char** argv)
 {
     auto print_usage_and_exit = [this, argv] {
         print_usage(stderr, argv[0]);
@@ -148,7 +150,7 @@ void CArgsParser::parse(int argc, char** argv)
     }
 }
 
-void CArgsParser::print_usage(FILE* file, const char* argv0)
+void ArgsParser::print_usage(FILE* file, const char* argv0)
 {
     fprintf(file, "Usage:\n\t%s", argv0);
 
@@ -214,12 +216,12 @@ void CArgsParser::print_usage(FILE* file, const char* argv0)
     }
 }
 
-void CArgsParser::add_option(Option&& option)
+void ArgsParser::add_option(Option&& option)
 {
     m_options.append(move(option));
 }
 
-void CArgsParser::add_option(bool& value, const char* help_string, const char* long_name, char short_name)
+void ArgsParser::add_option(bool& value, const char* help_string, const char* long_name, char short_name)
 {
     Option option {
         false,
@@ -236,7 +238,7 @@ void CArgsParser::add_option(bool& value, const char* help_string, const char* l
     add_option(move(option));
 }
 
-void CArgsParser::add_option(const char*& value, const char* help_string, const char* long_name, char short_name, const char* value_name)
+void ArgsParser::add_option(const char*& value, const char* help_string, const char* long_name, char short_name, const char* value_name)
 {
     Option option {
         true,
@@ -252,7 +254,7 @@ void CArgsParser::add_option(const char*& value, const char* help_string, const
     add_option(move(option));
 }
 
-void CArgsParser::add_option(int& value, const char* help_string, const char* long_name, char short_name, const char* value_name)
+void ArgsParser::add_option(int& value, const char* help_string, const char* long_name, char short_name, const char* value_name)
 {
     Option option {
         true,
@@ -269,12 +271,12 @@ void CArgsParser::add_option(int& value, const char* help_string, const char* lo
     add_option(move(option));
 }
 
-void CArgsParser::add_positional_argument(Arg&& arg)
+void ArgsParser::add_positional_argument(Arg&& arg)
 {
     m_positional_args.append(move(arg));
 }
 
-void CArgsParser::add_positional_argument(const char*& value, const char* help_string, const char* name, Required required)
+void ArgsParser::add_positional_argument(const char*& value, const char* help_string, const char* name, Required required)
 {
     Arg arg {
         help_string,
@@ -289,7 +291,7 @@ void CArgsParser::add_positional_argument(const char*& value, const char* help_s
     add_positional_argument(move(arg));
 }
 
-void CArgsParser::add_positional_argument(int& value, const char* help_string, const char* name, Required required)
+void ArgsParser::add_positional_argument(int& value, const char* help_string, const char* name, Required required)
 {
     Arg arg {
         help_string,
@@ -305,7 +307,7 @@ void CArgsParser::add_positional_argument(int& value, const char* help_string, c
     add_positional_argument(move(arg));
 }
 
-void CArgsParser::add_positional_argument(Vector<const char*>& values, const char* help_string, const char* name, Required required)
+void ArgsParser::add_positional_argument(Vector<const char*>& values, const char* help_string, const char* name, Required required)
 {
     Arg arg {
         help_string,
@@ -319,3 +321,5 @@ void CArgsParser::add_positional_argument(Vector<const char*>& values, const cha
     };
     add_positional_argument(move(arg));
 }
+
+}

Libraries/LibCore/CArgsParser.h

@@ -31,9 +31,11 @@
 #include <AK/Vector.h>
 #include <stdio.h>
 
-class CArgsParser {
+namespace Core {
+
+class ArgsParser {
 public:
-    CArgsParser();
+    ArgsParser();
 
     enum class Required {
         Yes,
@@ -83,3 +85,5 @@ private:
 
     bool m_show_help { false };
 };
+
+}

Libraries/LibCore/CConfigFile.cpp

@@ -32,43 +32,45 @@
 #include <stdio.h>
 #include <unistd.h>
 
-NonnullRefPtr<CConfigFile> CConfigFile::get_for_app(const String& app_name)
+namespace Core {
+
+NonnullRefPtr<ConfigFile> ConfigFile::get_for_app(const String& app_name)
 {
     String home_path = get_current_user_home_path();
     if (home_path == "/")
         home_path = String::format("/tmp");
     auto path = String::format("%s/%s.ini", home_path.characters(), app_name.characters());
-    return adopt(*new CConfigFile(path));
+    return adopt(*new ConfigFile(path));
 }
 
-NonnullRefPtr<CConfigFile> CConfigFile::get_for_system(const String& app_name)
+NonnullRefPtr<ConfigFile> ConfigFile::get_for_system(const String& app_name)
 {
     auto path = String::format("/etc/%s.ini", app_name.characters());
-    return adopt(*new CConfigFile(path));
+    return adopt(*new ConfigFile(path));
 }
 
-NonnullRefPtr<CConfigFile> CConfigFile::open(const String& path)
+NonnullRefPtr<ConfigFile> ConfigFile::open(const String& path)
 {
-    return adopt(*new CConfigFile(path));
+    return adopt(*new ConfigFile(path));
 }
 
-CConfigFile::CConfigFile(const String& file_name)
+ConfigFile::ConfigFile(const String& file_name)
     : m_file_name(file_name)
 {
     reparse();
 }
 
-CConfigFile::~CConfigFile()
+ConfigFile::~ConfigFile()
 {
     sync();
 }
 
-void CConfigFile::reparse()
+void ConfigFile::reparse()
 {
     m_groups.clear();
 
-    auto file = CFile::construct(m_file_name);
-    if (!file->open(CIODevice::OpenMode::ReadOnly))
+    auto file = File::construct(m_file_name);
+    if (!file->open(IODevice::OpenMode::ReadOnly))
         return;
 
     HashMap<String, String>* current_group = nullptr;
@@ -111,10 +113,10 @@ void CConfigFile::reparse()
     }
 }
 
-String CConfigFile::read_entry(const String& group, const String& key, const String& default_value) const
+String ConfigFile::read_entry(const String& group, const String& key, const String& default_value) const
 {
     if (!has_key(group, key)) {
-        const_cast<CConfigFile&>(*this).write_entry(group, key, default_value);
+        const_cast<ConfigFile&>(*this).write_entry(group, key, default_value);
         return default_value;
     }
     auto it = m_groups.find(group);
@@ -122,10 +124,10 @@ String CConfigFile::read_entry(const String& group, const String& key, const Str
     return jt->value;
 }
 
-int CConfigFile::read_num_entry(const String& group, const String& key, int default_value) const
+int ConfigFile::read_num_entry(const String& group, const String& key, int default_value) const
 {
     if (!has_key(group, key)) {
-        const_cast<CConfigFile&>(*this).write_num_entry(group, key, default_value);
+        const_cast<ConfigFile&>(*this).write_num_entry(group, key, default_value);
         return default_value;
     }
 
@@ -136,31 +138,31 @@ int CConfigFile::read_num_entry(const String& group, const String& key, int defa
     return value;
 }
 
-bool CConfigFile::read_bool_entry(const String& group, const String& key, bool default_value) const
+bool ConfigFile::read_bool_entry(const String& group, const String& key, bool default_value) const
 {
     return read_entry(group, key, default_value ? "1" : "0") == "1";
 }
 
-void CConfigFile::write_entry(const String& group, const String& key, const String& value)
+void ConfigFile::write_entry(const String& group, const String& key, const String& value)
 {
     m_groups.ensure(group).ensure(key) = value;
     m_dirty = true;
 }
 
-void CConfigFile::write_num_entry(const String& group, const String& key, int value)
+void ConfigFile::write_num_entry(const String& group, const String& key, int value)
 {
     write_entry(group, key, String::number(value));
 }
-void CConfigFile::write_bool_entry(const String& group, const String& key, bool value)
+void ConfigFile::write_bool_entry(const String& group, const String& key, bool value)
 {
     write_entry(group, key, value ? "1" : "0");
 }
-void CConfigFile::write_color_entry(const String& group, const String& key, Color value)
+void ConfigFile::write_color_entry(const String& group, const String& key, Color value)
 {
     write_entry(group, key, String::format("%d,%d,%d,%d", value.red(), value.green(), value.blue(), value.alpha()));
 }
 
-bool CConfigFile::sync()
+bool ConfigFile::sync()
 {
     if (!m_dirty)
         return true;
@@ -182,7 +184,7 @@ bool CConfigFile::sync()
     return true;
 }
 
-void CConfigFile::dump() const
+void ConfigFile::dump() const
 {
     for (auto& it : m_groups) {
         printf("[%s]\n", it.key.characters());
@@ -192,12 +194,12 @@ void CConfigFile::dump() const
     }
 }
 
-Vector<String> CConfigFile::groups() const
+Vector<String> ConfigFile::groups() const
 {
     return m_groups.keys();
 }
 
-Vector<String> CConfigFile::keys(const String& group) const
+Vector<String> ConfigFile::keys(const String& group) const
 {
     auto it = m_groups.find(group);
     if (it == m_groups.end())
@@ -205,7 +207,7 @@ Vector<String> CConfigFile::keys(const String& group) const
     return it->value.keys();
 }
 
-bool CConfigFile::has_key(const String& group, const String& key) const
+bool ConfigFile::has_key(const String& group, const String& key) const
 {
     auto it = m_groups.find(group);
     if (it == m_groups.end())
@@ -213,18 +215,18 @@ bool CConfigFile::has_key(const String& group, const String& key) const
     return it->value.contains(key);
 }
 
-bool CConfigFile::has_group(const String& group) const
+bool ConfigFile::has_group(const String& group) const
 {
     return m_groups.contains(group);
 }
 
-void CConfigFile::remove_group(const String& group)
+void ConfigFile::remove_group(const String& group)
 {
     m_groups.remove(group);
     m_dirty = true;
 }
 
-void CConfigFile::remove_entry(const String& group, const String& key)
+void ConfigFile::remove_entry(const String& group, const String& key)
 {
     auto it = m_groups.find(group);
     if (it == m_groups.end())
@@ -232,3 +234,5 @@ void CConfigFile::remove_entry(const String& group, const String& key)
     it->value.remove(key);
     m_dirty = true;
 }
+
+}

Libraries/LibCore/CConfigFile.h

@@ -26,19 +26,21 @@
 
 #pragma once
 
-#include <AK/String.h>
 #include <AK/HashMap.h>
-#include <AK/RefPtr.h>
 #include <AK/RefCounted.h>
+#include <AK/RefPtr.h>
+#include <AK/String.h>
 #include <AK/Vector.h>
 #include <LibDraw/Color.h>
 
-class CConfigFile : public RefCounted<CConfigFile> {
+namespace Core {
+
+class ConfigFile : public RefCounted<ConfigFile> {
 public:
-    static NonnullRefPtr<CConfigFile> get_for_app(const String& app_name);
-    static NonnullRefPtr<CConfigFile> get_for_system(const String& app_name);
-    static NonnullRefPtr<CConfigFile> open(const String& path);
-    ~CConfigFile();
+    static NonnullRefPtr<ConfigFile> get_for_app(const String& app_name);
+    static NonnullRefPtr<ConfigFile> get_for_system(const String& app_name);
+    static NonnullRefPtr<ConfigFile> open(const String& path);
+    ~ConfigFile();
 
     bool has_group(const String&) const;
     bool has_key(const String& group, const String& key) const;
@@ -67,7 +69,7 @@ public:
     String file_name() const { return m_file_name; }
 
 private:
-    explicit CConfigFile(const String& file_name);
+    explicit ConfigFile(const String& file_name);
 
     void reparse();
 
@@ -75,3 +77,5 @@ private:
     HashMap<String, HashMap<String, String>> m_groups;
     bool m_dirty { false };
 };
+
+}

Libraries/LibCore/CDirIterator.cpp

@@ -25,9 +25,11 @@
  */
 
 #include "CDirIterator.h"
-#include <cerrno>
+#include <errno.h>
 
-CDirIterator::CDirIterator(const StringView& path, Flags flags)
+namespace Core {
+
+DirIterator::DirIterator(const StringView& path, Flags flags)
     : m_flags(flags)
 {
     m_dir = opendir(String(path).characters());
@@ -36,7 +38,7 @@ CDirIterator::CDirIterator(const StringView& path, Flags flags)
     }
 }
 
-CDirIterator::~CDirIterator()
+DirIterator::~DirIterator()
 {
     if (m_dir != nullptr) {
         closedir(m_dir);
@@ -44,7 +46,7 @@ CDirIterator::~CDirIterator()
     }
 }
 
-bool CDirIterator::advance_next()
+bool DirIterator::advance_next()
 {
     if (m_dir == nullptr)
         return false;
@@ -74,7 +76,7 @@ bool CDirIterator::advance_next()
     return m_next.length() > 0;
 }
 
-bool CDirIterator::has_next()
+bool DirIterator::has_next()
 {
     if (!m_next.is_null())
         return true;
@@ -82,7 +84,7 @@ bool CDirIterator::has_next()
     return advance_next();
 }
 
-String CDirIterator::next_path()
+String DirIterator::next_path()
 {
     if (m_next.is_null())
         advance_next();
@@ -91,3 +93,5 @@ String CDirIterator::next_path()
     m_next = String();
     return tmp;
 }
+
+}

Libraries/LibCore/CDirIterator.h

@@ -29,15 +29,17 @@
 #include <AK/String.h>
 #include <dirent.h>
 
-class CDirIterator {
+namespace Core {
+
+class DirIterator {
 public:
     enum Flags {
         NoFlags = 0x0,
         SkipDots = 0x1,
     };
 
-    CDirIterator(const StringView& path, Flags = Flags::NoFlags);
-    ~CDirIterator();
+    DirIterator(const StringView& path, Flags = Flags::NoFlags);
+    ~DirIterator();
 
     bool has_error() const { return m_error != 0; }
     int error() const { return m_error; }
@@ -53,3 +55,5 @@ private:
 
     bool advance_next();
 };
+
+}

Libraries/LibCore/CElapsedTimer.cpp

@@ -29,13 +29,15 @@
 #include <LibCore/CElapsedTimer.h>
 #include <sys/time.h>
 
-void CElapsedTimer::start()
+namespace Core {
+
+void ElapsedTimer::start()
 {
     m_valid = true;
     gettimeofday(&m_start_time, nullptr);
 }
 
-int CElapsedTimer::elapsed() const
+int ElapsedTimer::elapsed() const
 {
     ASSERT(is_valid());
     struct timeval now;
@@ -44,3 +46,5 @@ int CElapsedTimer::elapsed() const
     timeval_sub(now, m_start_time, diff);
     return diff.tv_sec * 1000 + diff.tv_usec / 1000;
 }
+
+}

Libraries/LibCore/CElapsedTimer.h

@@ -28,9 +28,11 @@
 
 #include <sys/time.h>
 
-class CElapsedTimer {
+namespace Core {
+
+class ElapsedTimer {
 public:
-    CElapsedTimer() {}
+    ElapsedTimer() {}
 
     bool is_valid() const { return m_valid; }
     void start();
@@ -42,3 +44,5 @@ private:
         0, 0
     };
 };
+
+}

Libraries/LibCore/CEvent.cpp

@@ -27,13 +27,17 @@
 #include <LibCore/CEvent.h>
 #include <LibCore/CObject.h>
 
-CChildEvent::CChildEvent(Type type, CObject& child, CObject* insertion_before_child)
-    : CEvent(type)
+namespace Core {
+
+ChildEvent::ChildEvent(Type type, Object& child, Object* insertion_before_child)
+    : Core::Event(type)
     , m_child(child.make_weak_ptr())
     , m_insertion_before_child(insertion_before_child ? insertion_before_child->make_weak_ptr() : nullptr)
 {
 }
 
-CChildEvent::~CChildEvent()
+ChildEvent::~ChildEvent()
 {
 }
+
+}

Libraries/LibCore/CEvent.h

@@ -26,14 +26,16 @@
 
 #pragma once
 
-#include <AK/String.h>
 #include <AK/Function.h>
+#include <AK/String.h>
 #include <AK/Types.h>
 #include <AK/WeakPtr.h>
 
-class CObject;
+namespace Core {
 
-class CEvent {
+class Object;
+
+class Event {
 public:
     enum Type {
         Invalid = 0,
@@ -47,12 +49,12 @@ public:
         Custom,
     };
 
-    CEvent() {}
-    explicit CEvent(unsigned type)
+    Event() {}
+    explicit Event(unsigned type)
         : m_type(type)
     {
     }
-    virtual ~CEvent() {}
+    virtual ~Event() {}
 
     unsigned type() const { return m_type; }
 
@@ -65,28 +67,28 @@ private:
     bool m_accepted { true };
 };
 
-class CDeferredInvocationEvent : public CEvent {
-    friend class CEventLoop;
+class DeferredInvocationEvent : public Event {
+    friend class EventLoop;
 
 public:
-    CDeferredInvocationEvent(Function<void(CObject&)> invokee)
-        : CEvent(CEvent::Type::DeferredInvoke)
+    DeferredInvocationEvent(Function<void(Object&)> invokee)
+        : Event(Event::Type::DeferredInvoke)
         , m_invokee(move(invokee))
     {
     }
 
 private:
-    Function<void(CObject&)> m_invokee;
+    Function<void(Object&)> m_invokee;
 };
 
-class CTimerEvent final : public CEvent {
+class TimerEvent final : public Event {
 public:
-    explicit CTimerEvent(int timer_id)
-        : CEvent(CEvent::Timer)
+    explicit TimerEvent(int timer_id)
+        : Event(Event::Timer)
         , m_timer_id(timer_id)
     {
     }
-    ~CTimerEvent() {}
+    ~TimerEvent() {}
 
     int timer_id() const { return m_timer_id; }
 
@@ -94,14 +96,14 @@ private:
     int m_timer_id;
 };
 
-class CNotifierReadEvent final : public CEvent {
+class NotifierReadEvent final : public Event {
 public:
-    explicit CNotifierReadEvent(int fd)
-        : CEvent(CEvent::NotifierRead)
+    explicit NotifierReadEvent(int fd)
+        : Event(Event::NotifierRead)
         , m_fd(fd)
     {
     }
-    ~CNotifierReadEvent() {}
+    ~NotifierReadEvent() {}
 
     int fd() const { return m_fd; }
 
@@ -109,14 +111,14 @@ private:
     int m_fd;
 };
 
-class CNotifierWriteEvent final : public CEvent {
+class NotifierWriteEvent final : public Event {
 public:
-    explicit CNotifierWriteEvent(int fd)
-        : CEvent(CEvent::NotifierWrite)
+    explicit NotifierWriteEvent(int fd)
+        : Event(Event::NotifierWrite)
         , m_fd(fd)
     {
     }
-    ~CNotifierWriteEvent() {}
+    ~NotifierWriteEvent() {}
 
     int fd() const { return m_fd; }
 
@@ -124,31 +126,31 @@ private:
     int m_fd;
 };
 
-class CChildEvent final : public CEvent {
+class ChildEvent final : public Event {
 public:
-    CChildEvent(Type, CObject& child, CObject* insertion_before_child = nullptr);
-    ~CChildEvent();
+    ChildEvent(Type, Object& child, Object* insertion_before_child = nullptr);
+    ~ChildEvent();
 
-    CObject* child() { return m_child.ptr(); }
-    const CObject* child() const { return m_child.ptr(); }
+    Object* child() { return m_child.ptr(); }
+    const Object* child() const { return m_child.ptr(); }
 
-    CObject* insertion_before_child() { return m_insertion_before_child.ptr(); }
-    const CObject* insertion_before_child() const { return m_insertion_before_child.ptr(); }
+    Object* insertion_before_child() { return m_insertion_before_child.ptr(); }
+    const Object* insertion_before_child() const { return m_insertion_before_child.ptr(); }
 
 private:
-    WeakPtr<CObject> m_child;
-    WeakPtr<CObject> m_insertion_before_child;
+    WeakPtr<Object> m_child;
+    WeakPtr<Object> m_insertion_before_child;
 };
 
-class CCustomEvent : public CEvent {
+class CustomEvent : public Event {
 public:
-    CCustomEvent(int custom_type, void* data = nullptr)
-        : CEvent(CEvent::Type::Custom)
+    CustomEvent(int custom_type, void* data = nullptr)
+        : Event(Event::Type::Custom)
         , m_custom_type(custom_type)
         , m_data(data)
     {
     }
-    ~CCustomEvent() {}
+    ~CustomEvent() {}
 
     int custom_type() const { return m_custom_type; }
     void* data() { return m_data; }
@@ -158,3 +160,5 @@ private:
     int m_custom_type { 0 };
     void* m_data { nullptr };
 };
+
+}

Libraries/LibCore/CEventLoop.cpp

@@ -49,21 +49,23 @@
 //#define CEVENTLOOP_DEBUG
 //#define DEFERRED_INVOKE_DEBUG
 
+namespace Core {
+
 class RPCClient;
 
-static CEventLoop* s_main_event_loop;
-static Vector<CEventLoop*>* s_event_loop_stack;
+static EventLoop* s_main_event_loop;
+static Vector<EventLoop*>* s_event_loop_stack;
 static IDAllocator s_id_allocator;
-HashMap<int, NonnullOwnPtr<CEventLoop::EventLoopTimer>>* CEventLoop::s_timers;
-HashTable<CNotifier*>* CEventLoop::s_notifiers;
-int CEventLoop::s_wake_pipe_fds[2];
-RefPtr<CLocalServer> CEventLoop::s_rpc_server;
+HashMap<int, NonnullOwnPtr<EventLoop::EventLoopTimer>>* EventLoop::s_timers;
+HashTable<Notifier*>* EventLoop::s_notifiers;
+int EventLoop::s_wake_pipe_fds[2];
+RefPtr<LocalServer> EventLoop::s_rpc_server;
 HashMap<int, RefPtr<RPCClient>> s_rpc_clients;
 
-class RPCClient : public CObject {
+class RPCClient : public Object {
     C_OBJECT(RPCClient)
 public:
-    explicit RPCClient(RefPtr<CLocalSocket> socket)
+    explicit RPCClient(RefPtr<LocalSocket> socket)
         : m_socket(move(socket))
         , m_client_id(s_id_allocator.allocate())
     {
@@ -131,7 +133,7 @@ public:
             JsonObject response;
             response.set("type", type);
             JsonArray objects;
-            for (auto& object : CObject::all_objects()) {
+            for (auto& object : Object::all_objects()) {
                 JsonObject json_object;
                 object.save_to(json_object);
                 objects.append(move(json_object));
@@ -154,16 +156,16 @@ public:
     }
 
 private:
-    RefPtr<CLocalSocket> m_socket;
+    RefPtr<LocalSocket> m_socket;
     int m_client_id { -1 };
 };
 
-CEventLoop::CEventLoop()
+EventLoop::EventLoop()
 {
     if (!s_event_loop_stack) {
-        s_event_loop_stack = new Vector<CEventLoop*>;
-        s_timers = new HashMap<int, NonnullOwnPtr<CEventLoop::EventLoopTimer>>;
-        s_notifiers = new HashTable<CNotifier*>;
+        s_event_loop_stack = new Vector<EventLoop*>;
+        s_timers = new HashMap<int, NonnullOwnPtr<EventLoop::EventLoopTimer>>;
+        s_notifiers = new HashTable<Notifier*>;
     }
 
     if (!s_main_event_loop) {
@@ -185,8 +187,8 @@ CEventLoop::CEventLoop()
             perror("unlink");
             ASSERT_NOT_REACHED();
         }
-        s_rpc_server = CLocalServer::construct();
-        s_rpc_server->set_name("CEventLoop_RPC_server");
+        s_rpc_server = LocalServer::construct();
+        s_rpc_server->set_name("Core::EventLoop_RPC_server");
         bool listening = s_rpc_server->listen(rpc_path);
         ASSERT(listening);
 
@@ -196,66 +198,66 @@ CEventLoop::CEventLoop()
     }
 
 #ifdef CEVENTLOOP_DEBUG
-    dbg() << getpid() << " CEventLoop constructed :)";
+    dbg() << getpid() << " Core::EventLoop constructed :)";
 #endif
 }
 
-CEventLoop::~CEventLoop()
+EventLoop::~EventLoop()
 {
 }
 
-CEventLoop& CEventLoop::main()
+EventLoop& EventLoop::main()
 {
     ASSERT(s_main_event_loop);
     return *s_main_event_loop;
 }
 
-CEventLoop& CEventLoop::current()
+EventLoop& EventLoop::current()
 {
-    CEventLoop* event_loop = s_event_loop_stack->last();
+    EventLoop* event_loop = s_event_loop_stack->last();
     ASSERT(event_loop != nullptr);
     return *event_loop;
 }
 
-void CEventLoop::quit(int code)
+void EventLoop::quit(int code)
 {
-    dbg() << "CEventLoop::quit(" << code << ")";
+    dbg() << "Core::EventLoop::quit(" << code << ")";
     m_exit_requested = true;
     m_exit_code = code;
 }
 
-void CEventLoop::unquit()
+void EventLoop::unquit()
 {
-    dbg() << "CEventLoop::unquit()";
+    dbg() << "Core::EventLoop::unquit()";
     m_exit_requested = false;
     m_exit_code = 0;
 }
 
-struct CEventLoopPusher {
+struct EventLoopPusher {
 public:
-    CEventLoopPusher(CEventLoop& event_loop)
+    EventLoopPusher(EventLoop& event_loop)
         : m_event_loop(event_loop)
     {
         if (&m_event_loop != s_main_event_loop) {
-            m_event_loop.take_pending_events_from(CEventLoop::current());
+            m_event_loop.take_pending_events_from(EventLoop::current());
             s_event_loop_stack->append(&event_loop);
         }
     }
-    ~CEventLoopPusher()
+    ~EventLoopPusher()
     {
         if (&m_event_loop != s_main_event_loop) {
             s_event_loop_stack->take_last();
-            CEventLoop::current().take_pending_events_from(m_event_loop);
+            EventLoop::current().take_pending_events_from(m_event_loop);
         }
     }
 
 private:
-    CEventLoop& m_event_loop;
+    EventLoop& m_event_loop;
 };
 
-int CEventLoop::exec()
+int EventLoop::exec()
 {
-    CEventLoopPusher pusher(*this);
+    EventLoopPusher pusher(*this);
     for (;;) {
         if (m_exit_requested)
             return m_exit_code;
@@ -264,7 +266,7 @@ int CEventLoop::exec()
     ASSERT_NOT_REACHED();
 }
 
-void CEventLoop::pump(WaitMode mode)
+void EventLoop::pump(WaitMode mode)
 {
     if (m_queued_events.is_empty())
         wait_for_event(mode);
@@ -284,30 +286,30 @@ void CEventLoop::pump(WaitMode mode)
         auto& event = *queued_event.event;
 #ifdef CEVENTLOOP_DEBUG
         if (receiver)
-            dbg() << "CEventLoop: " << *receiver << " event " << (int)event.type();
+            dbg() << "Core::EventLoop: " << *receiver << " event " << (int)event.type();
 #endif
         if (!receiver) {
             switch (event.type()) {
-            case CEvent::Quit:
+            case Event::Quit:
                 ASSERT_NOT_REACHED();
                 return;
             default:
                 dbg() << "Event type " << event.type() << " with no receiver :(";
             }
-        } else if (event.type() == CEvent::Type::DeferredInvoke) {
+        } else if (event.type() == Event::Type::DeferredInvoke) {
 #ifdef DEFERRED_INVOKE_DEBUG
             printf("DeferredInvoke: receiver=%s{%p}\n", receiver->class_name(), receiver);
 #endif
-            static_cast<CDeferredInvocationEvent&>(event).m_invokee(*receiver);
+            static_cast<DeferredInvocationEvent&>(event).m_invokee(*receiver);
         } else {
-            NonnullRefPtr<CObject> protector(*receiver);
+            NonnullRefPtr<Object> protector(*receiver);
             receiver->dispatch_event(event);
         }
 
         if (m_exit_requested) {
             LOCKER(m_lock);
 #ifdef CEVENTLOOP_DEBUG
-            dbg() << "CEventLoop: Exit requested. Rejigging " << (events.size() - i) << " events.";
+            dbg() << "Core::EventLoop: Exit requested. Rejigging " << (events.size() - i) << " events.";
 #endif
             decltype(m_queued_events) new_event_queue;
             new_event_queue.ensure_capacity(m_queued_events.size() + events.size());
@@ -320,16 +322,16 @@ void CEventLoop::pump(WaitMode mode)
     }
 }
 
-void CEventLoop::post_event(CObject& receiver, NonnullOwnPtr<CEvent>&& event)
+void EventLoop::post_event(Object& receiver, NonnullOwnPtr<Event>&& event)
 {
     LOCKER(m_lock);
 #ifdef CEVENTLOOP_DEBUG
-    dbg() << "CEventLoop::post_event: {" << m_queued_events.size() << "} << receiver=" << receiver << ", event=" << event;
+    dbg() << "Core::EventLoop::post_event: {" << m_queued_events.size() << "} << receiver=" << receiver << ", event=" << event;
 #endif
     m_queued_events.append({ receiver.make_weak_ptr(), move(event) });
 }
 
-void CEventLoop::wait_for_event(WaitMode mode)
+void EventLoop::wait_for_event(WaitMode mode)
 {
     fd_set rfds;
     fd_set wfds;
@@ -347,11 +349,11 @@ void CEventLoop::wait_for_event(WaitMode mode)
     add_fd_to_set(s_wake_pipe_fds[0], rfds);
     max_fd = max(max_fd, max_fd_added);
     for (auto& notifier : *s_notifiers) {
-        if (notifier->event_mask() & CNotifier::Read)
+        if (notifier->event_mask() & Notifier::Read)
             add_fd_to_set(notifier->fd(), rfds);
-        if (notifier->event_mask() & CNotifier::Write)
+        if (notifier->event_mask() & Notifier::Write)
             add_fd_to_set(notifier->fd(), wfds);
-        if (notifier->event_mask() & CNotifier::Exceptional)
+        if (notifier->event_mask() & Notifier::Exceptional)
             ASSERT_NOT_REACHED();
     }
 
@@ -401,9 +403,9 @@ void CEventLoop::wait_for_event(WaitMode mode)
             continue;
         }
 #ifdef CEVENTLOOP_DEBUG
-        dbg() << "CEventLoop: Timer " << timer.timer_id << " has expired, sending CTimerEvent to " << timer.owner;
+        dbg() << "Core::EventLoop: Timer " << timer.timer_id << " has expired, sending Core::TimerEvent to " << timer.owner;
 #endif
-        post_event(*timer.owner, make<CTimerEvent>(timer.timer_id));
+        post_event(*timer.owner, make<TimerEvent>(timer.timer_id));
         if (timer.should_reload) {
             timer.reload(now);
         } else {
@@ -418,28 +420,28 @@ void CEventLoop::wait_for_event(WaitMode mode)
     for (auto& notifier : *s_notifiers) {
         if (FD_ISSET(notifier->fd(), &rfds)) {
             if (notifier->on_ready_to_read)
-                post_event(*notifier, make<CNotifierReadEvent>(notifier->fd()));
+                post_event(*notifier, make<NotifierReadEvent>(notifier->fd()));
         }
         if (FD_ISSET(notifier->fd(), &wfds)) {
             if (notifier->on_ready_to_write)
-                post_event(*notifier, make<CNotifierWriteEvent>(notifier->fd()));
+                post_event(*notifier, make<NotifierWriteEvent>(notifier->fd()));
         }
     }
 }
 
-bool CEventLoop::EventLoopTimer::has_expired(const timeval& now) const
+bool EventLoop::EventLoopTimer::has_expired(const timeval& now) const
 {
     return now.tv_sec > fire_time.tv_sec || (now.tv_sec == fire_time.tv_sec && now.tv_usec >= fire_time.tv_usec);
 }
 
-void CEventLoop::EventLoopTimer::reload(const timeval& now)
+void EventLoop::EventLoopTimer::reload(const timeval& now)
 {
     fire_time = now;
     fire_time.tv_sec += interval / 1000;
     fire_time.tv_usec += (interval % 1000) * 1000;
 }
 
-void CEventLoop::get_next_timer_expiration(timeval& soonest)
+void EventLoop::get_next_timer_expiration(timeval& soonest)
 {
     ASSERT(!s_timers->is_empty());
     bool has_checked_any = false;
@@ -456,7 +458,7 @@ void CEventLoop::get_next_timer_expiration(timeval& soonest)
     }
 }
 
-int CEventLoop::register_timer(CObject& object, int milliseconds, bool should_reload, TimerShouldFireWhenNotVisible fire_when_not_visible)
+int EventLoop::register_timer(Object& object, int milliseconds, bool should_reload, TimerShouldFireWhenNotVisible fire_when_not_visible)
 {
     ASSERT(milliseconds >= 0);
     auto timer = make<EventLoopTimer>();
@@ -473,7 +475,7 @@ int CEventLoop::register_timer(CObject& object, int milliseconds, bool should_re
     return timer_id;
 }
 
-bool CEventLoop::unregister_timer(int timer_id)
+bool EventLoop::unregister_timer(int timer_id)
 {
     s_id_allocator.deallocate(timer_id);
     auto it = s_timers->find(timer_id);
@@ -483,22 +485,24 @@ bool CEventLoop::unregister_timer(int timer_id)
     return true;
 }
 
-void CEventLoop::register_notifier(Badge<CNotifier>, CNotifier& notifier)
+void EventLoop::register_notifier(Badge<Notifier>, Notifier& notifier)
 {
     s_notifiers->set(&notifier);
 }
 
-void CEventLoop::unregister_notifier(Badge<CNotifier>, CNotifier& notifier)
+void EventLoop::unregister_notifier(Badge<Notifier>, Notifier& notifier)
 {
     s_notifiers->remove(&notifier);
 }
 
-void CEventLoop::wake()
+void EventLoop::wake()
 {
     char ch = '!';
     int nwritten = write(s_wake_pipe_fds[1], &ch, 1);
     if (nwritten < 0) {
-        perror("CEventLoop::wake: write");
+        perror("EventLoop::wake: write");
         ASSERT_NOT_REACHED();
     }
 }
+
+}

Libraries/LibCore/CEventLoop.h

@@ -38,13 +38,15 @@
 #include <sys/time.h>
 #include <time.h>
 
-class CObject;
-class CNotifier;
+namespace Core {
 
-class CEventLoop {
+class Object;
+class Notifier;
+
+class EventLoop {
 public:
-    CEventLoop();
-    ~CEventLoop();
+    EventLoop();
+    ~EventLoop();
 
     int exec();
 
@@ -57,23 +59,23 @@ public:
     // this should really only be used for integrating with other event loops
     void pump(WaitMode = WaitMode::WaitForEvents);
 
-    void post_event(CObject& receiver, NonnullOwnPtr<CEvent>&&);
+    void post_event(Object& receiver, NonnullOwnPtr<Event>&&);
 
-    static CEventLoop& main();
-    static CEventLoop& current();
+    static EventLoop& main();
+    static EventLoop& current();
 
     bool was_exit_requested() const { return m_exit_requested; }
 
-    static int register_timer(CObject&, int milliseconds, bool should_reload, TimerShouldFireWhenNotVisible);
+    static int register_timer(Object&, int milliseconds, bool should_reload, TimerShouldFireWhenNotVisible);
     static bool unregister_timer(int timer_id);
 
-    static void register_notifier(Badge<CNotifier>, CNotifier&);
-    static void unregister_notifier(Badge<CNotifier>, CNotifier&);
+    static void register_notifier(Badge<Notifier>, Notifier&);
+    static void unregister_notifier(Badge<Notifier>, Notifier&);
 
     void quit(int);
     void unquit();
 
-    void take_pending_events_from(CEventLoop& other)
+    void take_pending_events_from(EventLoop& other)
     {
         m_queued_events.append(move(other.m_queued_events));
     }
@@ -85,8 +87,8 @@ private:
     void get_next_timer_expiration(timeval&);
 
     struct QueuedEvent {
-        WeakPtr<CObject> receiver;
-        NonnullOwnPtr<CEvent> event;
+        WeakPtr<Object> receiver;
+        NonnullOwnPtr<Event> event;
     };
 
     Vector<QueuedEvent, 64> m_queued_events;
@@ -104,7 +106,7 @@ private:
         timeval fire_time { 0, 0 };
         bool should_reload { false };
         TimerShouldFireWhenNotVisible fire_when_not_visible { TimerShouldFireWhenNotVisible::No };
-        WeakPtr<CObject> owner;
+        WeakPtr<Object> owner;
 
         void reload(const timeval& now);
         bool has_expired(const timeval& now) const;
@@ -112,7 +114,9 @@ private:
 
     static HashMap<int, NonnullOwnPtr<EventLoopTimer>>* s_timers;
 
-    static HashTable<CNotifier*>* s_notifiers;
+    static HashTable<Notifier*>* s_notifiers;
 
-    static RefPtr<CLocalServer> s_rpc_server;
+    static RefPtr<LocalServer> s_rpc_server;
 };
+
+}

Libraries/LibCore/CFile.cpp

@@ -30,19 +30,21 @@
 #include <stdio.h>
 #include <unistd.h>
 
-CFile::CFile(const StringView& filename, CObject* parent)
-    : CIODevice(parent)
+namespace Core {
+
+File::File(const StringView& filename, Object* parent)
+    : IODevice(parent)
     , m_filename(filename)
 {
 }
 
-CFile::~CFile()
+File::~File()
 {
     if (m_should_close_file_descriptor == ShouldCloseFileDescription::Yes && mode() != NotOpen)
         close();
 }
 
-bool CFile::open(int fd, CIODevice::OpenMode mode, ShouldCloseFileDescription should_close)
+bool File::open(int fd, IODevice::OpenMode mode, ShouldCloseFileDescription should_close)
 {
     set_fd(fd);
     set_mode(mode);
@@ -50,25 +52,25 @@ bool CFile::open(int fd, CIODevice::OpenMode mode, ShouldCloseFileDescription sh
     return true;
 }
 
-bool CFile::open(CIODevice::OpenMode mode)
+bool File::open(IODevice::OpenMode mode)
 {
     ASSERT(!m_filename.is_null());
     int flags = 0;
-    if ((mode & CIODevice::ReadWrite) == CIODevice::ReadWrite) {
+    if ((mode & IODevice::ReadWrite) == IODevice::ReadWrite) {
         flags |= O_RDWR | O_CREAT;
-    } else if (mode & CIODevice::ReadOnly) {
+    } else if (mode & IODevice::ReadOnly) {
         flags |= O_RDONLY;
-    } else if (mode & CIODevice::WriteOnly) {
+    } else if (mode & IODevice::WriteOnly) {
         flags |= O_WRONLY | O_CREAT;
-        bool should_truncate = !((mode & CIODevice::Append) || (mode & CIODevice::MustBeNew));
+        bool should_truncate = !((mode & IODevice::Append) || (mode & IODevice::MustBeNew));
         if (should_truncate)
             flags |= O_TRUNC;
     }
-    if (mode & CIODevice::Append)
+    if (mode & IODevice::Append)
         flags |= O_APPEND;
-    if (mode & CIODevice::Truncate)
+    if (mode & IODevice::Truncate)
         flags |= O_TRUNC;
-    if (mode & CIODevice::MustBeNew)
+    if (mode & IODevice::MustBeNew)
         flags |= O_EXCL;
     int fd = ::open(m_filename.characters(), flags, 0666);
     if (fd < 0) {
@@ -80,3 +82,5 @@ bool CFile::open(CIODevice::OpenMode mode)
     set_mode(mode);
     return true;
 }
+
+}

Libraries/LibCore/CFile.h

@@ -29,29 +29,33 @@
 #include <AK/String.h>
 #include <LibCore/CIODevice.h>
 
-class CFile final : public CIODevice {
-    C_OBJECT(CFile)
+namespace Core {
+
+class File final : public IODevice {
+    C_OBJECT(File)
 public:
-    virtual ~CFile() override;
+    virtual ~File() override;
 
     String filename() const { return m_filename; }
     void set_filename(const StringView& filename) { m_filename = filename; }
 
-    virtual bool open(CIODevice::OpenMode) override;
+    virtual bool open(IODevice::OpenMode) override;
 
     enum class ShouldCloseFileDescription {
         No = 0,
         Yes
     };
-    bool open(int fd, CIODevice::OpenMode, ShouldCloseFileDescription);
+    bool open(int fd, IODevice::OpenMode, ShouldCloseFileDescription);
 
 private:
-    CFile(CObject* parent = nullptr)
-        : CIODevice(parent)
+    File(Object* parent = nullptr)
+        : IODevice(parent)
     {
     }
-    explicit CFile(const StringView&, CObject* parent = nullptr);
+    explicit File(const StringView&, Object* parent = nullptr);
 
     String m_filename;
     ShouldCloseFileDescription m_should_close_file_descriptor { ShouldCloseFileDescription::Yes };
 };
+
+}

Libraries/LibCore/CHttpJob.cpp

@@ -33,6 +33,8 @@
 
 //#define CHTTPJOB_DEBUG
 
+namespace Core {
+
 static ByteBuffer handle_content_encoding(const ByteBuffer& buf, const String& content_encoding)
 {
 #ifdef CHTTPJOB_DEBUG
@@ -66,16 +68,16 @@ static ByteBuffer handle_content_encoding(const ByteBuffer& buf, const String& c
     return buf;
 }
 
-CHttpJob::CHttpJob(const CHttpRequest& request)
+HttpJob::HttpJob(const HttpRequest& request)
     : m_request(request)
 {
 }
 
-CHttpJob::~CHttpJob()
+HttpJob::~HttpJob()
 {
 }
 
-void CHttpJob::on_socket_connected()
+void HttpJob::on_socket_connected()
 {
     auto raw_request = m_request.to_raw_request();
 #if 0
@@ -85,7 +87,7 @@ void CHttpJob::on_socket_connected()
 
     bool success = m_socket->send(raw_request);
     if (!success)
-        return deferred_invoke([this](auto&) { did_fail(CNetworkJob::Error::TransmissionFailed); });
+        return deferred_invoke([this](auto&) { did_fail(NetworkJob::Error::TransmissionFailed); });
 
     m_socket->on_ready_to_read = [&] {
         if (is_cancelled())
@@ -96,18 +98,18 @@ void CHttpJob::on_socket_connected()
             auto line = m_socket->read_line(PAGE_SIZE);
             if (line.is_null()) {
                 fprintf(stderr, "CHttpJob: Expected HTTP status\n");
-                return deferred_invoke([this](auto&) { did_fail(CNetworkJob::Error::TransmissionFailed); });
+                return deferred_invoke([this](auto&) { did_fail(NetworkJob::Error::TransmissionFailed); });
             }
             auto parts = String::copy(line, Chomp).split(' ');
             if (parts.size() < 3) {
                 fprintf(stderr, "CHttpJob: Expected 3-part HTTP status, got '%s'\n", line.data());
-                return deferred_invoke([this](auto&) { did_fail(CNetworkJob::Error::ProtocolFailed); });
+                return deferred_invoke([this](auto&) { did_fail(NetworkJob::Error::ProtocolFailed); });
             }
             bool ok;
             m_code = parts[1].to_uint(ok);
             if (!ok) {
                 fprintf(stderr, "CHttpJob: Expected numeric HTTP status\n");
-                return deferred_invoke([this](auto&) { did_fail(CNetworkJob::Error::ProtocolFailed); });
+                return deferred_invoke([this](auto&) { did_fail(NetworkJob::Error::ProtocolFailed); });
             }
             m_state = State::InHeaders;
             return;
@@ -118,7 +120,7 @@ void CHttpJob::on_socket_connected()
             auto line = m_socket->read_line(PAGE_SIZE);
             if (line.is_null()) {
                 fprintf(stderr, "CHttpJob: Expected HTTP header\n");
-                return did_fail(CNetworkJob::Error::ProtocolFailed);
+                return did_fail(NetworkJob::Error::ProtocolFailed);
             }
             auto chomped_line = String::copy(line, Chomp);
             if (chomped_line.is_empty()) {
@@ -128,12 +130,12 @@ void CHttpJob::on_socket_connected()
             auto parts = chomped_line.split(':');
             if (parts.is_empty()) {
                 fprintf(stderr, "CHttpJob: Expected HTTP header with key/value\n");
-                return deferred_invoke([this](auto&) { did_fail(CNetworkJob::Error::ProtocolFailed); });
+                return deferred_invoke([this](auto&) { did_fail(NetworkJob::Error::ProtocolFailed); });
             }
             auto name = parts[0];
             if (chomped_line.length() < name.length() + 2) {
                 fprintf(stderr, "CHttpJob: Malformed HTTP header: '%s' (%zu)\n", chomped_line.characters(), chomped_line.length());
-                return deferred_invoke([this](auto&) { did_fail(CNetworkJob::Error::ProtocolFailed); });
+                return deferred_invoke([this](auto&) { did_fail(NetworkJob::Error::ProtocolFailed); });
             }
             auto value = chomped_line.substring(name.length() + 2, chomped_line.length() - name.length() - 2);
             m_headers.set(name, value);
@@ -148,7 +150,7 @@ void CHttpJob::on_socket_connected()
         if (!payload) {
             if (m_socket->eof())
                 return finish_up();
-            return deferred_invoke([this](auto&) { did_fail(CNetworkJob::Error::ProtocolFailed); });
+            return deferred_invoke([this](auto&) { did_fail(NetworkJob::Error::ProtocolFailed); });
         }
         m_received_buffers.append(payload);
         m_received_size += payload.size();
@@ -162,7 +164,7 @@ void CHttpJob::on_socket_connected()
     };
 }
 
-void CHttpJob::finish_up()
+void HttpJob::finish_up()
 {
     m_state = State::Finished;
     auto flattened_buffer = ByteBuffer::create_uninitialized(m_received_size);
@@ -178,16 +180,16 @@ void CHttpJob::finish_up()
         flattened_buffer = handle_content_encoding(flattened_buffer, content_encoding.value());
     }
 
-    auto response = CHttpResponse::create(m_code, move(m_headers), move(flattened_buffer));
+    auto response = HttpResponse::create(m_code, move(m_headers), move(flattened_buffer));
     deferred_invoke([this, response](auto&) {
         did_finish(move(response));
     });
 }
 
-void CHttpJob::start()
+void HttpJob::start()
 {
     ASSERT(!m_socket);
-    m_socket = CTCPSocket::construct(this);
+    m_socket = TCPSocket::construct(this);
     m_socket->on_connected = [this] {
 #ifdef CHTTPJOB_DEBUG
         dbg() << "CHttpJob: on_connected callback";
@@ -197,12 +199,12 @@ void CHttpJob::start()
     bool success = m_socket->connect(m_request.url().host(), m_request.url().port());
     if (!success) {
         deferred_invoke([this](auto&) {
-            return did_fail(CNetworkJob::Error::ConnectionFailed);
+            return did_fail(NetworkJob::Error::ConnectionFailed);
         });
     }
 }
 
-void CHttpJob::shutdown()
+void HttpJob::shutdown()
 {
     if (!m_socket)
         return;
@@ -211,3 +213,4 @@ void CHttpJob::shutdown()
     remove_child(*m_socket);
     m_socket = nullptr;
 }
+}

Libraries/LibCore/CHttpJob.h

@@ -31,19 +31,21 @@
 #include <LibCore/CHttpResponse.h>
 #include <LibCore/CNetworkJob.h>
 
-class CTCPSocket;
+namespace Core {
 
-class CHttpJob final : public CNetworkJob {
-    C_OBJECT(CHttpJob)
+class TCPSocket;
+
+class HttpJob final : public NetworkJob {
+    C_OBJECT(HttpJob)
 public:
-    explicit CHttpJob(const CHttpRequest&);
-    virtual ~CHttpJob() override;
+    explicit HttpJob(const HttpRequest&);
+    virtual ~HttpJob() override;
 
     virtual void start() override;
     virtual void shutdown() override;
 
-    CHttpResponse* response() { return static_cast<CHttpResponse*>(CNetworkJob::response()); }
-    const CHttpResponse* response() const { return static_cast<const CHttpResponse*>(CNetworkJob::response()); }
+    HttpResponse* response() { return static_cast<HttpResponse*>(NetworkJob::response()); }
+    const HttpResponse* response() const { return static_cast<const HttpResponse*>(NetworkJob::response()); }
 
 private:
     void on_socket_connected();
@@ -56,11 +58,13 @@ private:
         Finished,
     };
 
-    CHttpRequest m_request;
-    RefPtr<CTCPSocket> m_socket;
+    HttpRequest m_request;
+    RefPtr<TCPSocket> m_socket;
     State m_state { State::InStatus };
     int m_code { -1 };
     HashMap<String, String> m_headers;
     Vector<ByteBuffer> m_received_buffers;
     size_t m_received_size { 0 };
 };
+
+}

Libraries/LibCore/CHttpRequest.cpp

@@ -28,22 +28,24 @@
 #include <LibCore/CHttpJob.h>
 #include <LibCore/CHttpRequest.h>
 
-CHttpRequest::CHttpRequest()
+namespace Core {
+
+HttpRequest::HttpRequest()
 {
 }
 
-CHttpRequest::~CHttpRequest()
+HttpRequest::~HttpRequest()
 {
 }
 
-RefPtr<CNetworkJob> CHttpRequest::schedule()
+RefPtr<NetworkJob> HttpRequest::schedule()
 {
-    auto job = CHttpJob::construct(*this);
+    auto job = HttpJob::construct(*this);
     job->start();
     return job;
 }
 
-String CHttpRequest::method_name() const
+String HttpRequest::method_name() const
 {
     switch (m_method) {
     case Method::GET:
@@ -57,7 +59,7 @@ String CHttpRequest::method_name() const
     }
 }
 
-ByteBuffer CHttpRequest::to_raw_request() const
+ByteBuffer HttpRequest::to_raw_request() const
 {
     StringBuilder builder;
     builder.append(method_name());
@@ -68,3 +70,5 @@ ByteBuffer CHttpRequest::to_raw_request() const
     builder.append("\r\n\r\n");
     return builder.to_byte_buffer();
 }
+
+}

Libraries/LibCore/CHttpRequest.h

@@ -29,9 +29,11 @@
 #include <AK/String.h>
 #include <AK/URL.h>
 
-class CNetworkJob;
+namespace Core {
 
-class CHttpRequest {
+class NetworkJob;
+
+class HttpRequest {
 public:
     enum Method {
         Invalid,
@@ -40,8 +42,8 @@ public:
         POST
     };
 
-    CHttpRequest();
-    ~CHttpRequest();
+    HttpRequest();
+    ~HttpRequest();
 
     const URL& url() const { return m_url; }
     void set_url(const URL& url) { m_url = url; }
@@ -52,9 +54,11 @@ public:
     String method_name() const;
     ByteBuffer to_raw_request() const;
 
-    RefPtr<CNetworkJob> schedule();
+    RefPtr<NetworkJob> schedule();
 
 private:
     URL m_url;
     Method m_method { GET };
 };
+
+}

Libraries/LibCore/CHttpResponse.cpp

@@ -26,13 +26,17 @@
 
 #include <LibCore/CHttpResponse.h>
 
-CHttpResponse::CHttpResponse(int code, HashMap<String, String>&& headers, ByteBuffer&& payload)
-    : CNetworkResponse(move(payload))
+namespace Core {
+
+HttpResponse::HttpResponse(int code, HashMap<String, String>&& headers, ByteBuffer&& payload)
+    : NetworkResponse(move(payload))
     , m_code(code)
     , m_headers(move(headers))
 {
 }
 
-CHttpResponse::~CHttpResponse()
+HttpResponse::~HttpResponse()
 {
 }
+
+}

Libraries/LibCore/CHttpResponse.h

@@ -26,24 +26,28 @@
 
 #pragma once
 
-#include <AK/String.h>
 #include <AK/HashMap.h>
+#include <AK/String.h>
 #include <LibCore/CNetworkResponse.h>
 
-class CHttpResponse : public CNetworkResponse {
+namespace Core {
+
+class HttpResponse : public NetworkResponse {
 public:
-    virtual ~CHttpResponse() override;
-    static NonnullRefPtr<CHttpResponse> create(int code, HashMap<String, String>&& headers, ByteBuffer&& payload)
+    virtual ~HttpResponse() override;
+    static NonnullRefPtr<HttpResponse> create(int code, HashMap<String, String>&& headers, ByteBuffer&& payload)
     {
-        return adopt(*new CHttpResponse(code, move(headers), move(payload)));
+        return adopt(*new HttpResponse(code, move(headers), move(payload)));
     }
 
     int code() const { return m_code; }
     const HashMap<String, String>& headers() const { return m_headers; }
 
 private:
-    CHttpResponse(int code, HashMap<String, String>&&, ByteBuffer&&);
+    HttpResponse(int code, HashMap<String, String>&&, ByteBuffer&&);
 
     int m_code { 0 };
     HashMap<String, String> m_headers;
 };
+
+}

Libraries/LibCore/CIODevice.cpp

@@ -34,21 +34,23 @@
 #include <sys/time.h>
 #include <unistd.h>
 
-CIODevice::CIODevice(CObject* parent)
-    : CObject(parent)
+namespace Core {
+
+IODevice::IODevice(Object* parent)
+    : Object(parent)
 {
 }
 
-CIODevice::~CIODevice()
+IODevice::~IODevice()
 {
 }
 
-const char* CIODevice::error_string() const
+const char* IODevice::error_string() const
 {
     return strerror(m_error);
 }
 
-int CIODevice::read(u8* buffer, int length)
+int IODevice::read(u8* buffer, int length)
 {
     auto read_buffer = read(length);
     if (read_buffer.is_null())
@@ -57,7 +59,7 @@ int CIODevice::read(u8* buffer, int length)
     return read_buffer.size();
 }
 
-ByteBuffer CIODevice::read(int max_size)
+ByteBuffer IODevice::read(int max_size)
 {
     if (m_fd < 0)
         return {};
@@ -99,7 +101,7 @@ ByteBuffer CIODevice::read(int max_size)
     return buffer;
 }
 
-bool CIODevice::can_read_from_fd() const
+bool IODevice::can_read_from_fd() const
 {
     // FIXME: Can we somehow remove this once CSocket is implemented using non-blocking sockets?
     fd_set rfds;
@@ -111,13 +113,13 @@ bool CIODevice::can_read_from_fd() const
     int rc = CSyscallUtils::safe_syscall(select, m_fd + 1, &rfds, nullptr, nullptr, &timeout);
     if (rc < 0) {
         // NOTE: We don't set m_error here.
-        perror("CIODevice::can_read: select");
+        perror("IODevice::can_read: select");
         return false;
     }
     return FD_ISSET(m_fd, &rfds);
 }
 
-bool CIODevice::can_read_line()
+bool IODevice::can_read_line()
 {
     if (m_eof && !m_buffered_data.is_empty())
         return true;
@@ -129,12 +131,12 @@ bool CIODevice::can_read_line()
     return m_buffered_data.contains_slow('\n');
 }
 
-bool CIODevice::can_read() const
+bool IODevice::can_read() const
 {
     return !m_buffered_data.is_empty() || can_read_from_fd();
 }
 
-ByteBuffer CIODevice::read_all()
+ByteBuffer IODevice::read_all()
 {
     off_t file_size = 0;
     struct stat st;
@@ -168,7 +170,7 @@ ByteBuffer CIODevice::read_all()
     return ByteBuffer::copy(data.data(), data.size());
 }
 
-ByteBuffer CIODevice::read_line(int max_size)
+ByteBuffer IODevice::read_line(int max_size)
 {
     if (m_fd < 0)
         return {};
@@ -178,7 +180,7 @@ ByteBuffer CIODevice::read_line(int max_size)
         return {};
     if (m_eof) {
         if (m_buffered_data.size() > max_size) {
-            dbgprintf("CIODevice::read_line: At EOF but there's more than max_size(%d) buffered\n", max_size);
+            dbgprintf("IODevice::read_line: At EOF but there's more than max_size(%d) buffered\n", max_size);
             return {};
         }
         auto buffer = ByteBuffer::copy(m_buffered_data.data(), m_buffered_data.size());
@@ -202,7 +204,7 @@ ByteBuffer CIODevice::read_line(int max_size)
     return {};
 }
 
-bool CIODevice::populate_read_buffer()
+bool IODevice::populate_read_buffer()
 {
     if (m_fd < 0)
         return false;
@@ -220,7 +222,7 @@ bool CIODevice::populate_read_buffer()
     return true;
 }
 
-bool CIODevice::close()
+bool IODevice::close()
 {
     if (fd() < 0 || mode() == NotOpen)
         return false;
@@ -230,11 +232,11 @@ bool CIODevice::close()
         return false;
     }
     set_fd(-1);
-    set_mode(CIODevice::NotOpen);
+    set_mode(IODevice::NotOpen);
     return true;
 }
 
-bool CIODevice::seek(i64 offset, SeekMode mode, off_t* pos)
+bool IODevice::seek(i64 offset, SeekMode mode, off_t* pos)
 {
     int m = SEEK_SET;
     switch (mode) {
@@ -262,18 +264,18 @@ bool CIODevice::seek(i64 offset, SeekMode mode, off_t* pos)
     return true;
 }
 
-bool CIODevice::write(const u8* data, int size)
+bool IODevice::write(const u8* data, int size)
 {
     int rc = ::write(m_fd, data, size);
     if (rc < 0) {
-        perror("CIODevice::write: write");
+        perror("IODevice::write: write");
         set_error(errno);
         return false;
     }
     return rc == size;
 }
 
-int CIODevice::printf(const char* format, ...)
+int IODevice::printf(const char* format, ...)
 {
     va_list ap;
     va_start(ap, format);
@@ -286,7 +288,7 @@ int CIODevice::printf(const char* format, ...)
     return ret;
 }
 
-void CIODevice::set_fd(int fd)
+void IODevice::set_fd(int fd)
 {
     if (m_fd == fd)
         return;
@@ -294,3 +296,4 @@ void CIODevice::set_fd(int fd)
     m_fd = fd;
     did_update_fd(fd);
 }
+}

Libraries/LibCore/CIODevice.h

@@ -30,8 +30,10 @@
 #include <AK/StringView.h>
 #include <LibCore/CObject.h>
 
-class CIODevice : public CObject {
-    C_OBJECT_ABSTRACT(CIODevice)
+namespace Core {
+
+class IODevice : public Object {
+    C_OBJECT_ABSTRACT(IODevice)
 public:
     enum OpenMode {
         NotOpen = 0,
@@ -43,7 +45,7 @@ public:
         MustBeNew = 16,
     };
 
-    virtual ~CIODevice() override;
+    virtual ~IODevice() override;
 
     int fd() const { return m_fd; }
     unsigned mode() const { return m_mode; }
@@ -55,7 +57,6 @@ public:
 
     bool has_error() const { return m_error != 0; }
 
-
     int read(u8* buffer, int length);
 
     ByteBuffer read(int max_size);
@@ -78,13 +79,13 @@ public:
 
     bool seek(i64, SeekMode = SeekMode::SetPosition, off_t* = nullptr);
 
-    virtual bool open(CIODevice::OpenMode) = 0;
+    virtual bool open(IODevice::OpenMode) = 0;
     virtual bool close();
 
     int printf(const char*, ...);
 
 protected:
-    explicit CIODevice(CObject* parent = nullptr);
+    explicit IODevice(Object* parent = nullptr);
 
     void set_fd(int);
     void set_mode(OpenMode mode) { m_mode = mode; }
@@ -103,3 +104,5 @@ private:
     OpenMode m_mode { NotOpen };
     Vector<u8> m_buffered_data;
 };
+
+}

Libraries/LibCore/CIODeviceStreamReader.h

@@ -29,9 +29,11 @@
 #include <AK/StdLibExtras.h>
 #include <LibCore/CIODevice.h>
 
-class CIODeviceStreamReader {
+namespace Core {
+
+class IODeviceStreamReader {
 public:
-    CIODeviceStreamReader(CIODevice& device)
+    IODeviceStreamReader(IODevice& device)
         : m_device(device)
     {
     }
@@ -42,7 +44,7 @@ public:
     }
 
     template<typename T>
-    CIODeviceStreamReader& operator>>(T& value)
+    IODeviceStreamReader& operator>>(T& value)
     {
         int nread = m_device.read((u8*)&value, sizeof(T));
         ASSERT(nread == sizeof(T));
@@ -52,6 +54,8 @@ public:
     }
 
 private:
-    CIODevice& m_device;
+    IODevice& m_device;
     bool m_had_failure { false };
 };
+
+}

Libraries/LibCore/CLocalServer.cpp

@@ -35,16 +35,18 @@
 #include <sys/ioctl.h>
 #endif
 
-CLocalServer::CLocalServer(CObject* parent)
-    : CObject(parent)
+namespace Core {
+
+LocalServer::LocalServer(Object* parent)
+    : Object(parent)
 {
 }
 
-CLocalServer::~CLocalServer()
+LocalServer::~LocalServer()
 {
 }
 
-bool CLocalServer::take_over_from_system_server()
+bool LocalServer::take_over_from_system_server()
 {
     if (m_listening)
         return false;
@@ -84,16 +86,16 @@ bool CLocalServer::take_over_from_system_server()
     return false;
 }
 
-void CLocalServer::setup_notifier()
+void LocalServer::setup_notifier()
 {
-    m_notifier = CNotifier::construct(m_fd, CNotifier::Event::Read, this);
+    m_notifier = Notifier::construct(m_fd, Notifier::Event::Read, this);
     m_notifier->on_ready_to_read = [this] {
         if (on_ready_to_accept)
             on_ready_to_accept();
     };
 }
 
-bool CLocalServer::listen(const String& address)
+bool LocalServer::listen(const String& address)
 {
     if (m_listening)
         return false;
@@ -116,7 +118,7 @@ bool CLocalServer::listen(const String& address)
         ASSERT_NOT_REACHED();
     }
 
-    auto socket_address = CSocketAddress::local(address);
+    auto socket_address = SocketAddress::local(address);
     auto un = socket_address.to_sockaddr_un();
     rc = ::bind(m_fd, (const sockaddr*)&un, sizeof(un));
     if (rc < 0) {
@@ -135,7 +137,7 @@ bool CLocalServer::listen(const String& address)
     return true;
 }
 
-RefPtr<CLocalSocket> CLocalServer::accept()
+RefPtr<LocalSocket> LocalServer::accept()
 {
     ASSERT(m_listening);
     sockaddr_un un;
@@ -146,5 +148,7 @@ RefPtr<CLocalSocket> CLocalServer::accept()
         return nullptr;
     }
 
-    return CLocalSocket::construct(accepted_fd);
+    return LocalSocket::construct(accepted_fd);
+}
+
 }

Libraries/LibCore/CLocalServer.h

@@ -29,27 +29,31 @@
 #include <LibCore/CNotifier.h>
 #include <LibCore/CObject.h>
 
-class CLocalSocket;
+namespace Core {
 
-class CLocalServer : public CObject {
-    C_OBJECT(CLocalServer)
+class LocalSocket;
+
+class LocalServer : public Object {
+    C_OBJECT(LocalServer)
 public:
-    virtual ~CLocalServer() override;
+    virtual ~LocalServer() override;
 
     bool take_over_from_system_server();
     bool is_listening() const { return m_listening; }
     bool listen(const String& address);
 
-    RefPtr<CLocalSocket> accept();
+    RefPtr<LocalSocket> accept();
 
     Function<void()> on_ready_to_accept;
 
 private:
-    explicit CLocalServer(CObject* parent = nullptr);
+    explicit LocalServer(Object* parent = nullptr);
 
     void setup_notifier();
 
     int m_fd { -1 };
     bool m_listening { false };
-    RefPtr<CNotifier> m_notifier;
+    RefPtr<Notifier> m_notifier;
 };
+
+}

Libraries/LibCore/CLocalSocket.cpp

@@ -25,27 +25,29 @@
  */
 
 #include <LibCore/CLocalSocket.h>
-#include <sys/socket.h>
 #include <errno.h>
+#include <sys/socket.h>
 
 #ifndef SOCK_NONBLOCK
-#include <sys/ioctl.h>
+#    include <sys/ioctl.h>
 #endif
 
-CLocalSocket::CLocalSocket(int fd, CObject* parent)
-    : CSocket(CSocket::Type::Local, parent)
+namespace Core {
+
+LocalSocket::LocalSocket(int fd, Object* parent)
+    : Socket(Socket::Type::Local, parent)
 {
     // NOTE: This constructor is used by CLocalServer::accept(), so the socket is already connected.
     m_connected = true;
     set_fd(fd);
-    set_mode(CIODevice::ReadWrite);
+    set_mode(IODevice::ReadWrite);
     set_error(0);
 }
 
-CLocalSocket::CLocalSocket(CObject* parent)
-    : CSocket(CSocket::Type::Local, parent)
+LocalSocket::LocalSocket(Object* parent)
+    : Socket(Socket::Type::Local, parent)
 {
-    
+
 #ifdef SOCK_NONBLOCK
     int fd = socket(AF_LOCAL, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
 #else
@@ -59,11 +61,13 @@ CLocalSocket::CLocalSocket(CObject* parent)
         set_error(errno);
     } else {
         set_fd(fd);
-        set_mode(CIODevice::ReadWrite);
+        set_mode(IODevice::ReadWrite);
         set_error(0);
     }
 }
 
-CLocalSocket::~CLocalSocket()
+LocalSocket::~LocalSocket()
 {
 }
+
+}

Libraries/LibCore/CLocalSocket.h

@@ -29,14 +29,18 @@
 #include <AK/Badge.h>
 #include <LibCore/CSocket.h>
 
-class CLocalServer;
+namespace Core {
 
-class CLocalSocket final : public CSocket {
-    C_OBJECT(CLocalSocket)
+class LocalServer;
+
+class LocalSocket final : public Socket {
+    C_OBJECT(LocalSocket)
 public:
-    virtual ~CLocalSocket() override;
+    virtual ~LocalSocket() override;
 
 private:
-    explicit CLocalSocket(CObject* parent = nullptr);
-    CLocalSocket(int fd, CObject* parent = nullptr);
+    explicit LocalSocket(Object* parent = nullptr);
+    LocalSocket(int fd, Object* parent = nullptr);
 };
+
+}

Libraries/LibCore/CNetworkJob.cpp

@@ -30,19 +30,21 @@
 
 //#define CNETWORKJOB_DEBUG
 
-CNetworkJob::CNetworkJob()
+namespace Core {
+
+NetworkJob::NetworkJob()
 {
 }
 
-CNetworkJob::~CNetworkJob()
+NetworkJob::~NetworkJob()
 {
 }
 
-void CNetworkJob::did_finish(NonnullRefPtr<CNetworkResponse>&& response)
+void NetworkJob::did_finish(NonnullRefPtr<NetworkResponse>&& response)
 {
     // NOTE: We protect ourselves here, since the on_finish callback may otherwise
     //       trigger destruction of this job somehow.
-    NonnullRefPtr<CNetworkJob> protector(*this);
+    NonnullRefPtr<NetworkJob> protector(*this);
 
     m_response = move(response);
 #ifdef CNETWORKJOB_DEBUG
@@ -53,11 +55,11 @@ void CNetworkJob::did_finish(NonnullRefPtr<CNetworkResponse>&& response)
     shutdown();
 }
 
-void CNetworkJob::did_fail(Error error)
+void NetworkJob::did_fail(Error error)
 {
     // NOTE: We protect ourselves here, since the on_finish callback may otherwise
     //       trigger destruction of this job somehow.
-    NonnullRefPtr<CNetworkJob> protector(*this);
+    NonnullRefPtr<NetworkJob> protector(*this);
 
     m_error = error;
 #ifdef CNETWORKJOB_DEBUG
@@ -68,18 +70,20 @@ void CNetworkJob::did_fail(Error error)
     shutdown();
 }
 
-const char* to_string(CNetworkJob::Error error)
+const char* to_string(NetworkJob::Error error)
 {
     switch (error) {
-    case CNetworkJob::Error::ProtocolFailed:
+    case NetworkJob::Error::ProtocolFailed:
         return "ProtocolFailed";
-    case CNetworkJob::Error::ConnectionFailed:
+    case NetworkJob::Error::ConnectionFailed:
         return "ConnectionFailed";
-    case CNetworkJob::Error::TransmissionFailed:
+    case NetworkJob::Error::TransmissionFailed:
         return "TransmissionFailed";
-    case CNetworkJob::Error::Cancelled:
+    case NetworkJob::Error::Cancelled:
         return "Cancelled";
     default:
         return "(Unknown error)";
     }
 }
+
+}

Libraries/LibCore/CNetworkJob.h

@@ -29,10 +29,12 @@
 #include <AK/Function.h>
 #include <LibCore/CObject.h>
 
-class CNetworkResponse;
+namespace Core {
 
-class CNetworkJob : public CObject {
-    C_OBJECT(CNetworkJob)
+class NetworkResponse;
+
+class NetworkJob : public Object {
+    C_OBJECT_ABSTRACT(NetworkJob)
 public:
     enum class Error {
         None,
@@ -41,15 +43,15 @@ public:
         ProtocolFailed,
         Cancelled,
     };
-    virtual ~CNetworkJob() override;
+    virtual ~NetworkJob() override;
 
     Function<void(bool success)> on_finish;
 
     bool is_cancelled() const { return m_error == Error::Cancelled; }
     bool has_error() const { return m_error != Error::None; }
     Error error() const { return m_error; }
-    CNetworkResponse* response() { return m_response.ptr(); }
-    const CNetworkResponse* response() const { return m_response.ptr(); }
+    NetworkResponse* response() { return m_response.ptr(); }
+    const NetworkResponse* response() const { return m_response.ptr(); }
 
     virtual void start() = 0;
     virtual void shutdown() = 0;
@@ -61,13 +63,15 @@ public:
     }
 
 protected:
-    CNetworkJob();
-    void did_finish(NonnullRefPtr<CNetworkResponse>&&);
+    NetworkJob();
+    void did_finish(NonnullRefPtr<NetworkResponse>&&);
     void did_fail(Error);
 
 private:
-    RefPtr<CNetworkResponse> m_response;
+    RefPtr<NetworkResponse> m_response;
     Error m_error { Error::None };
 };
 
-const char* to_string(CNetworkJob::Error);
+const char* to_string(NetworkJob::Error);
+
+}

Libraries/LibCore/CNetworkResponse.cpp

@@ -26,11 +26,15 @@
 
 #include <LibCore/CNetworkResponse.h>
 
-CNetworkResponse::CNetworkResponse(ByteBuffer&& payload)
+namespace Core {
+
+NetworkResponse::NetworkResponse(ByteBuffer&& payload)
     : m_payload(payload)
 {
 }
 
-CNetworkResponse::~CNetworkResponse()
+NetworkResponse::~NetworkResponse()
 {
 }
+
+}

Libraries/LibCore/CNetworkResponse.h

@@ -29,16 +29,20 @@
 #include <AK/ByteBuffer.h>
 #include <AK/RefCounted.h>
 
-class CNetworkResponse : public RefCounted<CNetworkResponse> {
+namespace Core {
+
+class NetworkResponse : public RefCounted<NetworkResponse> {
 public:
-    virtual ~CNetworkResponse();
+    virtual ~NetworkResponse();
 
     bool is_error() const { return m_error; }
     const ByteBuffer& payload() const { return m_payload; }
 
 protected:
-    explicit CNetworkResponse(ByteBuffer&&);
+    explicit NetworkResponse(ByteBuffer&&);
 
     bool m_error { false };
     ByteBuffer m_payload;
 };
+
+}

Libraries/LibCore/CNotifier.cpp

@@ -28,34 +28,38 @@
 #include <LibCore/CEventLoop.h>
 #include <LibCore/CNotifier.h>
 
-CNotifier::CNotifier(int fd, unsigned event_mask, CObject* parent)
-    : CObject(parent)
+namespace Core {
+
+Notifier::Notifier(int fd, unsigned event_mask, Object* parent)
+    : Object(parent)
     , m_fd(fd)
     , m_event_mask(event_mask)
 {
     set_enabled(true);
 }
 
-CNotifier::~CNotifier()
+Notifier::~Notifier()
 {
     set_enabled(false);
 }
 
-void CNotifier::set_enabled(bool enabled)
+void Notifier::set_enabled(bool enabled)
 {
     if (enabled)
-        CEventLoop::register_notifier({}, *this);
+        Core::EventLoop::register_notifier({}, *this);
     else
-        CEventLoop::unregister_notifier({}, *this);
+        Core::EventLoop::unregister_notifier({}, *this);
 }
 
-void CNotifier::event(CEvent& event)
+void Notifier::event(Core::Event& event)
 {
-    if (event.type() == CEvent::NotifierRead && on_ready_to_read) {
+    if (event.type() == Core::Event::NotifierRead && on_ready_to_read) {
         on_ready_to_read();
-    } else if (event.type() == CEvent::NotifierWrite && on_ready_to_write) {
+    } else if (event.type() == Core::Event::NotifierWrite && on_ready_to_write) {
         on_ready_to_write();
     } else {
-        CObject::event(event);
+        Object::event(event);
     }
 }
+
+}

Libraries/LibCore/CNotifier.h

@@ -29,8 +29,10 @@
 #include <AK/Function.h>
 #include <LibCore/CObject.h>
 
-class CNotifier : public CObject {
-    C_OBJECT(CNotifier)
+namespace Core {
+
+class Notifier : public Object {
+    C_OBJECT(Notifier)
 public:
     enum Event {
         None = 0,
@@ -39,7 +41,7 @@ public:
         Exceptional = 4,
     };
 
-    virtual ~CNotifier() override;
+    virtual ~Notifier() override;
 
     void set_enabled(bool);
 
@@ -50,11 +52,13 @@ public:
     unsigned event_mask() const { return m_event_mask; }
     void set_event_mask(unsigned event_mask) { m_event_mask = event_mask; }
 
-    void event(CEvent&) override;
+    void event(Core::Event&) override;
 
 private:
-    CNotifier(int fd, unsigned event_mask, CObject* parent = nullptr);
+    Notifier(int fd, unsigned event_mask, Object* parent = nullptr);
 
     int m_fd { -1 };
     unsigned m_event_mask { 0 };
 };
+
+}

Libraries/LibCore/CObject.cpp

@@ -32,13 +32,15 @@
 #include <LibCore/CObject.h>
 #include <stdio.h>
 
-IntrusiveList<CObject, &CObject::m_all_objects_list_node>& CObject::all_objects()
+namespace Core {
+
+IntrusiveList<Object, &Object::m_all_objects_list_node>& Object::all_objects()
 {
-    static IntrusiveList<CObject, &CObject::m_all_objects_list_node> objects;
+    static IntrusiveList<Object, &Object::m_all_objects_list_node> objects;
     return objects;
 }
 
-CObject::CObject(CObject* parent, bool is_widget)
+Object::Object(Object* parent, bool is_widget)
     : m_parent(parent)
     , m_widget(is_widget)
 {
@@ -47,7 +49,7 @@ CObject::CObject(CObject* parent, bool is_widget)
         m_parent->add_child(*this);
 }
 
-CObject::~CObject()
+Object::~Object()
 {
     // NOTE: We move our children out to a stack vector to prevent other
     //       code from trying to iterate over them.
@@ -63,89 +65,89 @@ CObject::~CObject()
         m_parent->remove_child(*this);
 }
 
-void CObject::event(CEvent& event)
+void Object::event(Core::Event& event)
 {
     switch (event.type()) {
-    case CEvent::Timer:
-        return timer_event(static_cast<CTimerEvent&>(event));
-    case CEvent::ChildAdded:
-    case CEvent::ChildRemoved:
-        return child_event(static_cast<CChildEvent&>(event));
-    case CEvent::Invalid:
+    case Core::Event::Timer:
+        return timer_event(static_cast<TimerEvent&>(event));
+    case Core::Event::ChildAdded:
+    case Core::Event::ChildRemoved:
+        return child_event(static_cast<ChildEvent&>(event));
+    case Core::Event::Invalid:
         ASSERT_NOT_REACHED();
         break;
-    case CEvent::Custom:
-        return custom_event(static_cast<CCustomEvent&>(event));
+    case Core::Event::Custom:
+        return custom_event(static_cast<CustomEvent&>(event));
     default:
         break;
     }
 }
 
-void CObject::add_child(CObject& object)
+void Object::add_child(Object& object)
 {
     // FIXME: Should we support reparenting objects?
     ASSERT(!object.parent() || object.parent() == this);
     object.m_parent = this;
     m_children.append(object);
-    event(*make<CChildEvent>(CEvent::ChildAdded, object));
+    event(*make<Core::ChildEvent>(Core::Event::ChildAdded, object));
 }
 
-void CObject::insert_child_before(CObject& new_child, CObject& before_child)
+void Object::insert_child_before(Object& new_child, Object& before_child)
 {
     // FIXME: Should we support reparenting objects?
     ASSERT(!new_child.parent() || new_child.parent() == this);
     new_child.m_parent = this;
     m_children.insert_before_matching(new_child, [&](auto& existing_child) { return existing_child.ptr() == &before_child; });
-    event(*make<CChildEvent>(CEvent::ChildAdded, new_child, &before_child));
+    event(*make<Core::ChildEvent>(Core::Event::ChildAdded, new_child, &before_child));
 }
 
-void CObject::remove_child(CObject& object)
+void Object::remove_child(Object& object)
 {
     for (int i = 0; i < m_children.size(); ++i) {
         if (m_children.ptr_at(i).ptr() == &object) {
             // NOTE: We protect the child so it survives the handling of ChildRemoved.
-            NonnullRefPtr<CObject> protector = object;
+            NonnullRefPtr<Object> protector = object;
             object.m_parent = nullptr;
             m_children.remove(i);
-            event(*make<CChildEvent>(CEvent::ChildRemoved, object));
+            event(*make<Core::ChildEvent>(Core::Event::ChildRemoved, object));
             return;
         }
     }
     ASSERT_NOT_REACHED();
 }
 
-void CObject::timer_event(CTimerEvent&)
+void Object::timer_event(Core::TimerEvent&)
 {
 }
 
-void CObject::child_event(CChildEvent&)
+void Object::child_event(Core::ChildEvent&)
 {
 }
 
-void CObject::custom_event(CCustomEvent&)
+void Object::custom_event(CustomEvent&)
 {
 }
 
-void CObject::start_timer(int ms, TimerShouldFireWhenNotVisible fire_when_not_visible)
+void Object::start_timer(int ms, TimerShouldFireWhenNotVisible fire_when_not_visible)
 {
     if (m_timer_id) {
-        dbgprintf("CObject{%p} already has a timer!\n", this);
+        dbgprintf("Object{%p} already has a timer!\n", this);
         ASSERT_NOT_REACHED();
     }
 
-    m_timer_id = CEventLoop::register_timer(*this, ms, true, fire_when_not_visible);
+    m_timer_id = Core::EventLoop::register_timer(*this, ms, true, fire_when_not_visible);
 }
 
-void CObject::stop_timer()
+void Object::stop_timer()
 {
     if (!m_timer_id)
         return;
-    bool success = CEventLoop::unregister_timer(m_timer_id);
+    bool success = Core::EventLoop::unregister_timer(m_timer_id);
     ASSERT(success);
     m_timer_id = 0;
 }
 
-void CObject::dump_tree(int indent)
+void Object::dump_tree(int indent)
 {
     for (int i = 0; i < indent; ++i) {
         printf(" ");
@@ -158,12 +160,12 @@ void CObject::dump_tree(int indent)
     });
 }
 
-void CObject::deferred_invoke(Function<void(CObject&)> invokee)
+void Object::deferred_invoke(Function<void(Object&)> invokee)
 {
-    CEventLoop::current().post_event(*this, make<CDeferredInvocationEvent>(move(invokee)));
+    Core::EventLoop::current().post_event(*this, make<Core::DeferredInvocationEvent>(move(invokee)));
 }
 
-void CObject::save_to(JsonObject& json)
+void Object::save_to(JsonObject& json)
 {
     json.set("class_name", class_name());
     json.set("address", String::format("%p", this));
@@ -171,7 +173,7 @@ void CObject::save_to(JsonObject& json)
     json.set("parent", String::format("%p", parent()));
 }
 
-bool CObject::is_ancestor_of(const CObject& other) const
+bool Object::is_ancestor_of(const Object& other) const
 {
     if (&other == this)
         return false;
@@ -182,7 +184,7 @@ bool CObject::is_ancestor_of(const CObject& other) const
     return false;
 }
 
-void CObject::dispatch_event(CEvent& e, CObject* stay_within)
+void Object::dispatch_event(Core::Event& e, Object* stay_within)
 {
     ASSERT(!stay_within || stay_within == this || stay_within->is_ancestor_of(*this));
     auto* target = this;
@@ -197,9 +199,11 @@ void CObject::dispatch_event(CEvent& e, CObject* stay_within)
     } while (target && !e.is_accepted());
 }
 
-bool CObject::is_visible_for_timer_purposes() const
+bool Object::is_visible_for_timer_purposes() const
 {
     if (parent())
         return parent()->is_visible_for_timer_purposes();
     return true;
 }
+
+}

Libraries/LibCore/CObject.h

@@ -40,16 +40,18 @@ namespace AK {
 class JsonObject;
 }
 
+namespace Core {
+
 enum class TimerShouldFireWhenNotVisible {
     No = 0,
     Yes
 };
 
-class CEvent;
-class CEventLoop;
-class CChildEvent;
-class CCustomEvent;
-class CTimerEvent;
+class ChildEvent;
+class CustomEvent;
+class Event;
+class EventLoop;
+class TimerEvent;
 
 #define C_OBJECT(klass)                                                \
 public:                                                                \
@@ -64,26 +66,26 @@ public:                                                                \
 public:                          \
     virtual const char* class_name() const override { return #klass; }
 
-class CObject
-    : public RefCounted<CObject>
-    , public Weakable<CObject> {
-    // NOTE: No C_OBJECT macro for CObject itself.
+class Object
+    : public RefCounted<Object>
+    , public Weakable<Object> {
+    // NOTE: No C_OBJECT macro for Core::Object itself.
 
-    AK_MAKE_NONCOPYABLE(CObject)
-    AK_MAKE_NONMOVABLE(CObject)
+    AK_MAKE_NONCOPYABLE(Object)
+    AK_MAKE_NONMOVABLE(Object)
 public:
     IntrusiveListNode m_all_objects_list_node;
 
-    virtual ~CObject();
+    virtual ~Object();
 
     virtual const char* class_name() const = 0;
-    virtual void event(CEvent&);
+    virtual void event(Core::Event&);
 
     const String& name() const { return m_name; }
     void set_name(const StringView& name) { m_name = name; }
 
-    NonnullRefPtrVector<CObject>& children() { return m_children; }
-    const NonnullRefPtrVector<CObject>& children() const { return m_children; }
+    NonnullRefPtrVector<Object>& children() { return m_children; }
+    const NonnullRefPtrVector<Object>& children() const { return m_children; }
 
     template<typename Callback>
     void for_each_child(Callback callback)
@@ -97,22 +99,22 @@ public:
     template<typename T, typename Callback>
     void for_each_child_of_type(Callback callback);
 
-    bool is_ancestor_of(const CObject&) const;
+    bool is_ancestor_of(const Object&) const;
 
-    CObject* parent() { return m_parent; }
-    const CObject* parent() const { return m_parent; }
+    Object* parent() { return m_parent; }
+    const Object* parent() const { return m_parent; }
 
     void start_timer(int ms, TimerShouldFireWhenNotVisible = TimerShouldFireWhenNotVisible::No);
     void stop_timer();
     bool has_timer() const { return m_timer_id; }
 
-    void add_child(CObject&);
-    void insert_child_before(CObject& new_child, CObject& before_child);
-    void remove_child(CObject&);
+    void add_child(Object&);
+    void insert_child_before(Object& new_child, Object& before_child);
+    void remove_child(Object&);
 
     void dump_tree(int indent = 0);
 
-    void deferred_invoke(Function<void(CObject&)>);
+    void deferred_invoke(Function<void(Object&)>);
 
     bool is_widget() const { return m_widget; }
     virtual bool is_action() const { return false; }
@@ -120,9 +122,9 @@ public:
 
     virtual void save_to(AK::JsonObject&);
 
-    static IntrusiveList<CObject, &CObject::m_all_objects_list_node>& all_objects();
+    static IntrusiveList<Object, &Object::m_all_objects_list_node>& all_objects();
 
-    void dispatch_event(CEvent&, CObject* stay_within = nullptr);
+    void dispatch_event(Core::Event&, Object* stay_within = nullptr);
 
     void remove_from_parent()
     {
@@ -133,41 +135,41 @@ public:
     virtual bool is_visible_for_timer_purposes() const;
 
 protected:
-    explicit CObject(CObject* parent = nullptr, bool is_widget = false);
+    explicit Object(Object* parent = nullptr, bool is_widget = false);
 
-    virtual void timer_event(CTimerEvent&);
-    virtual void custom_event(CCustomEvent&);
+    virtual void timer_event(TimerEvent&);
+    virtual void custom_event(CustomEvent&);
 
     // NOTE: You may get child events for children that are not yet fully constructed!
-    virtual void child_event(CChildEvent&);
+    virtual void child_event(ChildEvent&);
 
 private:
-    CObject* m_parent { nullptr };
+    Object* m_parent { nullptr };
     String m_name;
     int m_timer_id { 0 };
     bool m_widget { false };
-    NonnullRefPtrVector<CObject> m_children;
+    NonnullRefPtrVector<Object> m_children;
 };
 
 template<typename T>
-inline bool is(const CObject&) { return false; }
+inline bool is(const Object&) { return false; }
 
 template<typename T>
-inline T& to(CObject& object)
+inline T& to(Object& object)
 {
     ASSERT(is<typename RemoveConst<T>::Type>(object));
     return static_cast<T&>(object);
 }
 
 template<typename T>
-inline const T& to(const CObject& object)
+inline const T& to(const Object& object)
 {
     ASSERT(is<typename RemoveConst<T>::Type>(object));
     return static_cast<const T&>(object);
 }
 
 template<typename T, typename Callback>
-inline void CObject::for_each_child_of_type(Callback callback)
+inline void Object::for_each_child_of_type(Callback callback)
 {
     for_each_child([&](auto& child) {
         if (is<T>(child))
@@ -176,7 +178,9 @@ inline void CObject::for_each_child_of_type(Callback callback)
     });
 }
 
-inline const LogStream& operator<<(const LogStream& stream, const CObject& object)
+inline const LogStream& operator<<(const LogStream& stream, const Object& object)
 {
     return stream << object.class_name() << '{' << &object << '}';
 }
+
+}

Libraries/LibCore/CProcessStatisticsReader.cpp

@@ -32,23 +32,25 @@
 #include <pwd.h>
 #include <stdio.h>
 
-HashMap<uid_t, String> CProcessStatisticsReader::s_usernames;
+namespace Core {
 
-HashMap<pid_t, CProcessStatistics> CProcessStatisticsReader::get_all()
+HashMap<uid_t, String> ProcessStatisticsReader::s_usernames;
+
+HashMap<pid_t, Core::ProcessStatistics> ProcessStatisticsReader::get_all()
 {
-    auto file = CFile::construct("/proc/all");
-    if (!file->open(CIODevice::ReadOnly)) {
+    auto file = Core::File::construct("/proc/all");
+    if (!file->open(Core::IODevice::ReadOnly)) {
         fprintf(stderr, "CProcessStatisticsReader: Failed to open /proc/all: %s\n", file->error_string());
         return {};
     }
 
-    HashMap<pid_t, CProcessStatistics> map;
+    HashMap<pid_t, Core::ProcessStatistics> map;
 
     auto file_contents = file->read_all();
     auto json = JsonValue::from_string({ file_contents.data(), (size_t)file_contents.size() });
     json.as_array().for_each([&](auto& value) {
         const JsonObject& process_object = value.as_object();
-        CProcessStatistics process;
+        Core::ProcessStatistics process;
 
         // kernel data first
         process.pid = process_object.get("pid").to_u32();
@@ -76,7 +78,7 @@ HashMap<pid_t, CProcessStatistics> CProcessStatisticsReader::get_all()
         process.threads.ensure_capacity(thread_array.size());
         thread_array.for_each([&](auto& value) {
             auto& thread_object = value.as_object();
-            CThreadStatistics thread;
+            Core::ThreadStatistics thread;
             thread.tid = thread_object.get("tid").to_u32();
             thread.times_scheduled = thread_object.get("times_scheduled").to_u32();
             thread.name = thread_object.get("name").to_string();
@@ -105,7 +107,7 @@ HashMap<pid_t, CProcessStatistics> CProcessStatisticsReader::get_all()
     return map;
 }
 
-String CProcessStatisticsReader::username_from_uid(uid_t uid)
+String ProcessStatisticsReader::username_from_uid(uid_t uid)
 {
     if (s_usernames.is_empty()) {
         setpwent();
@@ -119,3 +121,4 @@ String CProcessStatisticsReader::username_from_uid(uid_t uid)
         return (*it).value;
     return String::number(uid);
 }
+}

Libraries/LibCore/CProcessStatisticsReader.h

@@ -30,7 +30,9 @@
 #include <AK/String.h>
 #include <unistd.h>
 
-struct CThreadStatistics {
+namespace Core {
+
+struct ThreadStatistics {
     int tid;
     unsigned times_scheduled;
     unsigned ticks;
@@ -50,7 +52,7 @@ struct CThreadStatistics {
     String name;
 };
 
-struct CProcessStatistics {
+struct ProcessStatistics {
     // Keep this in sync with /proc/all.
     // From the kernel side:
     pid_t pid;
@@ -74,17 +76,19 @@ struct CProcessStatistics {
     size_t amount_purgeable_nonvolatile;
     int icon_id;
 
-    Vector<CThreadStatistics> threads;
+    Vector<Core::ThreadStatistics> threads;
 
     // synthetic
     String username;
 };
 
-class CProcessStatisticsReader {
+class ProcessStatisticsReader {
 public:
-    static HashMap<pid_t, CProcessStatistics> get_all();
+    static HashMap<pid_t, Core::ProcessStatistics> get_all();
 
 private:
     static String username_from_uid(uid_t);
     static HashMap<uid_t, String> s_usernames;
 };
+
+}

Libraries/LibCore/CSocket.cpp

@@ -38,33 +38,35 @@
 
 //#define CSOCKET_DEBUG
 
-CSocket::CSocket(Type type, CObject* parent)
-    : CIODevice(parent)
+namespace Core {
+
+Socket::Socket(Type type, Object* parent)
+    : IODevice(parent)
     , m_type(type)
 {
 }
 
-CSocket::~CSocket()
+Socket::~Socket()
 {
     close();
 }
 
-bool CSocket::connect(const String& hostname, int port)
+bool Socket::connect(const String& hostname, int port)
 {
     auto* hostent = gethostbyname(hostname.characters());
     if (!hostent) {
-        dbg() << "CSocket::connect: Unable to resolve '" << hostname << "'";
+        dbg() << "Socket::connect: Unable to resolve '" << hostname << "'";
         return false;
     }
 
     IPv4Address host_address((const u8*)hostent->h_addr_list[0]);
 #ifdef CSOCKET_DEBUG
-    dbg() << "CSocket::connect: Resolved '" << hostname << "' to " << host_address;
+    dbg() << "Socket::connect: Resolved '" << hostname << "' to " << host_address;
 #endif
     return connect(host_address, port);
 }
 
-void CSocket::set_blocking(bool blocking)
+void Socket::set_blocking(bool blocking)
 {
     int flags = fcntl(fd(), F_GETFL, 0);
     ASSERT(flags >= 0);
@@ -75,10 +77,10 @@ void CSocket::set_blocking(bool blocking)
     ASSERT(flags == 0);
 }
 
-bool CSocket::connect(const CSocketAddress& address, int port)
+bool Socket::connect(const SocketAddress& address, int port)
 {
     ASSERT(!is_connected());
-    ASSERT(address.type() == CSocketAddress::Type::IPv4);
+    ASSERT(address.type() == SocketAddress::Type::IPv4);
 #ifdef CSOCKET_DEBUG
     dbg() << *this << " connecting to " << address << "...";
 #endif
@@ -98,10 +100,10 @@ bool CSocket::connect(const CSocketAddress& address, int port)
     return common_connect((struct sockaddr*)&addr, sizeof(addr));
 }
 
-bool CSocket::connect(const CSocketAddress& address)
+bool Socket::connect(const SocketAddress& address)
 {
     ASSERT(!is_connected());
-    ASSERT(address.type() == CSocketAddress::Type::Local);
+    ASSERT(address.type() == SocketAddress::Type::Local);
 #ifdef CSOCKET_DEBUG
     dbg() << *this << " connecting to " << address << "...";
 #endif
@@ -113,7 +115,7 @@ bool CSocket::connect(const CSocketAddress& address)
     return common_connect((const sockaddr*)&saddr, sizeof(saddr));
 }
 
-bool CSocket::common_connect(const struct sockaddr* addr, socklen_t addrlen)
+bool Socket::common_connect(const struct sockaddr* addr, socklen_t addrlen)
 {
     int rc = ::connect(fd(), addr, addrlen);
     if (rc < 0) {
@@ -121,20 +123,20 @@ bool CSocket::common_connect(const struct sockaddr* addr, socklen_t addrlen)
 #ifdef CSOCKET_DEBUG
             dbg() << *this << " connection in progress (EINPROGRESS)";
 #endif
-            m_notifier = CNotifier::construct(fd(), CNotifier::Event::Write, this);
+            m_notifier = Notifier::construct(fd(), Notifier::Event::Write, this);
             m_notifier->on_ready_to_write = [this] {
 #ifdef CSOCKET_DEBUG
                 dbg() << *this << " connected!";
 #endif
                 m_connected = true;
                 ensure_read_notifier();
-                m_notifier->set_event_mask(CNotifier::Event::None);
+                m_notifier->set_event_mask(Notifier::Event::None);
                 if (on_connected)
                     on_connected();
             };
             return true;
         }
-        perror("CSocket::common_connect: connect");
+        perror("Socket::common_connect: connect");
         return false;
     }
 #ifdef CSOCKET_DEBUG
@@ -147,7 +149,7 @@ bool CSocket::common_connect(const struct sockaddr* addr, socklen_t addrlen)
     return true;
 }
 
-ByteBuffer CSocket::receive(int max_size)
+ByteBuffer Socket::receive(int max_size)
 {
     auto buffer = read(max_size);
     if (eof()) {
@@ -157,7 +159,7 @@ ByteBuffer CSocket::receive(int max_size)
     return buffer;
 }
 
-bool CSocket::send(const ByteBuffer& data)
+bool Socket::send(const ByteBuffer& data)
 {
     int nsent = ::send(fd(), data.data(), data.size(), 0);
     if (nsent < 0) {
@@ -168,7 +170,7 @@ bool CSocket::send(const ByteBuffer& data)
     return true;
 }
 
-void CSocket::did_update_fd(int fd)
+void Socket::did_update_fd(int fd)
 {
     if (fd < 0) {
         m_read_notifier = nullptr;
@@ -182,12 +184,14 @@ void CSocket::did_update_fd(int fd)
     }
 }
 
-void CSocket::ensure_read_notifier()
+void Socket::ensure_read_notifier()
 {
     ASSERT(m_connected);
-    m_read_notifier = CNotifier::construct(fd(), CNotifier::Event::Read, this);
+    m_read_notifier = Notifier::construct(fd(), Notifier::Event::Read, this);
     m_read_notifier->on_ready_to_read = [this] {
         if (on_ready_to_read)
             on_ready_to_read();
     };
 }
+
+}

Libraries/LibCore/CSocket.h

@@ -29,10 +29,12 @@
 #include <LibCore/CIODevice.h>
 #include <LibCore/CSocketAddress.h>
 
-class CNotifier;
+namespace Core {
 
-class CSocket : public CIODevice {
-    C_OBJECT(CSocket)
+class Notifier;
+
+class Socket : public IODevice {
+    C_OBJECT(Socket)
 public:
     enum class Type {
         Invalid,
@@ -40,13 +42,13 @@ public:
         UDP,
         Local,
     };
-    virtual ~CSocket() override;
+    virtual ~Socket() override;
 
     Type type() const { return m_type; }
 
     bool connect(const String& hostname, int port);
-    bool connect(const CSocketAddress&, int port);
-    bool connect(const CSocketAddress&);
+    bool connect(const SocketAddress&, int port);
+    bool connect(const SocketAddress&);
 
     ByteBuffer receive(int max_size);
     bool send(const ByteBuffer&);
@@ -54,20 +56,20 @@ public:
     bool is_connected() const { return m_connected; }
     void set_blocking(bool blocking);
 
-    CSocketAddress source_address() const { return m_source_address; }
+    SocketAddress source_address() const { return m_source_address; }
     int source_port() const { return m_source_port; }
 
-    CSocketAddress destination_address() const { return m_source_address; }
+    SocketAddress destination_address() const { return m_source_address; }
     int destination_port() const { return m_destination_port; }
 
     Function<void()> on_connected;
     Function<void()> on_ready_to_read;
 
 protected:
-    CSocket(Type, CObject* parent);
+    Socket(Type, Object* parent);
 
-    CSocketAddress m_source_address;
-    CSocketAddress m_destination_address;
+    SocketAddress m_source_address;
+    SocketAddress m_destination_address;
     int m_source_port { -1 };
     int m_destination_port { -1 };
     bool m_connected { false };
@@ -75,11 +77,13 @@ protected:
     virtual void did_update_fd(int) override;
 
 private:
-    virtual bool open(CIODevice::OpenMode) override { ASSERT_NOT_REACHED(); }
+    virtual bool open(IODevice::OpenMode) override { ASSERT_NOT_REACHED(); }
     bool common_connect(const struct sockaddr*, socklen_t);
     void ensure_read_notifier();
 
     Type m_type { Type::Invalid };
-    RefPtr<CNotifier> m_notifier;
-    RefPtr<CNotifier> m_read_notifier;
+    RefPtr<Notifier> m_notifier;
+    RefPtr<Notifier> m_read_notifier;
 };
+
+}