Android #49

src/core/hle/service/service.h

@@ -79,8 +79,8 @@ protected:
     using HandlerFnP = void (Self::*)(HLERequestContext&);
 
     /// Used to gain exclusive access to the service members, e.g. from CoreTiming thread.
-    [[nodiscard]] virtual std::unique_lock<std::mutex> LockService() {
+    [[nodiscard]] std::scoped_lock<std::mutex> LockService() {
-        return std::unique_lock{lock_service};
+        return std::scoped_lock{lock_service};
     }
 
     /// System context that the service operates under.

src/core/hle/service/sockets/bsd.cpp

@@ -1029,11 +1029,6 @@ BSD::~BSD() {
     }
 }
 
-std::unique_lock<std::mutex> BSD::LockService() {
-    // Do not lock socket IClient instances.
-    return {};
-}
-
 BSDCFG::BSDCFG(Core::System& system_) : ServiceFramework{system_, "bsdcfg"} {
     // clang-format off
     static const FunctionInfo functions[] = {

src/core/hle/service/sockets/bsd.h

@@ -186,9 +186,6 @@ private:
 
     // Callback identifier for the OnProxyPacketReceived event.
     Network::RoomMember::CallbackHandle<Network::ProxyPacket> proxy_packet_received;
-
-protected:
-    virtual std::unique_lock<std::mutex> LockService() override;
 };
 
 class BSDCFG final : public ServiceFramework<BSDCFG> {

src/yuzu/game_list_worker.cpp

@@ -191,9 +191,8 @@ QString FormatPatchNameVersions(const FileSys::PatchManager& patch_manager,
 }
 
 QList<QStandardItem*> MakeGameListEntry(const std::string& path, const std::string& name,
-                                        const std::size_t size, const std::vector<u8>& icon,
+                                        const std::vector<u8>& icon, Loader::AppLoader& loader,
-                                        Loader::AppLoader& loader, u64 program_id,
+                                        u64 program_id, const CompatibilityList& compatibility_list,
-                                        const CompatibilityList& compatibility_list,
                                         const FileSys::PatchManager& patch) {
     const auto it = FindMatchingCompatibilityEntry(compatibility_list, program_id);
 
@@ -211,7 +210,7 @@ QList<QStandardItem*> MakeGameListEntry(const std::string& path, const std::stri
                              file_type_string, program_id),
         new GameListItemCompat(compatibility),
         new GameListItem(file_type_string),
-        new GameListItemSize(size),
+        new GameListItemSize(Common::FS::GetSize(path)),
     };
 
     const auto patch_versions = GetGameListCachedObject(
@@ -279,8 +278,8 @@ void GameListWorker::AddTitlesToGameList(GameListDir* parent_dir) {
             GetMetadataFromControlNCA(patch, *control, icon, name);
         }
 
-        emit EntryReady(MakeGameListEntry(file->GetFullPath(), name, file->GetSize(), icon, *loader,
+        emit EntryReady(MakeGameListEntry(file->GetFullPath(), name, icon, *loader, program_id,
-                                          program_id, compatibility_list, patch),
+                                          compatibility_list, patch),
                         parent_dir);
     }
 }
@@ -355,9 +354,8 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa
                         const FileSys::PatchManager patch{id, system.GetFileSystemController(),
                                                           system.GetContentProvider()};
 
-                        emit EntryReady(MakeGameListEntry(physical_name, name,
+                        emit EntryReady(MakeGameListEntry(physical_name, name, icon, *loader, id,
-                                                          Common::FS::GetSize(physical_name), icon,
+                                                          compatibility_list, patch),
-                                                          *loader, id, compatibility_list, patch),
                                         parent_dir);
                     }
                 } else {
@@ -370,10 +368,9 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa
                     const FileSys::PatchManager patch{program_id, system.GetFileSystemController(),
                                                       system.GetContentProvider()};
 
-                    emit EntryReady(
+                    emit EntryReady(MakeGameListEntry(physical_name, name, icon, *loader,
-                        MakeGameListEntry(physical_name, name, Common::FS::GetSize(physical_name),
+                                                      program_id, compatibility_list, patch),
-                                          icon, *loader, program_id, compatibility_list, patch),
+                                    parent_dir);
-                        parent_dir);
                 }
             }
         } else if (is_dir) {