protocols: refactor class member vars (a-m) (#10265)

1 files changed, 31 insertions, 30 deletions

diff --git a/src/protocols/MesaDRM.cpp b/src/protocols/MesaDRM.cpp
index be5a02cd..c8532265 100644
--- a/src/protocols/MesaDRM.cpp
+++ b/src/protocols/MesaDRM.cpp
@@ -11,47 +11,48 @@ CMesaDRMBufferResource::CMesaDRMBufferResource(uint32_t id, wl_client* client, A
         LOGM(LOG, " | plane {}: mod {} fd {} stride {} offset {}", i, attrs_.modifier, attrs_.fds[i], attrs_.strides[i], attrs_.offsets[i]);
     }
 
-    buffer                       = makeShared<CDMABuffer>(id, client, attrs_);
-    buffer->m_resource->m_buffer = buffer;
+    m_buffer                       = makeShared<CDMABuffer>(id, client, attrs_);
+    m_buffer->m_resource->m_buffer = m_buffer;
 
-    listeners.bufferResourceDestroy = buffer->events.destroy.registerListener([this](std::any d) {
-        listeners.bufferResourceDestroy.reset();
+    m_listeners.bufferResourceDestroy = m_buffer->events.destroy.registerListener([this](std::any d) {
+        m_listeners.bufferResourceDestroy.reset();
         PROTO::mesaDRM->destroyResource(this);
     });
 
-    if (!buffer->m_success)
+    if (!m_buffer->m_success)
         LOGM(ERR, "Possibly compositor bug: buffer failed to create");
 }
 
 CMesaDRMBufferResource::~CMesaDRMBufferResource() {
-    if (buffer && buffer->m_resource)
-        buffer->m_resource->sendRelease();
-    buffer.reset();
-    listeners.bufferResourceDestroy.reset();
+    if (m_buffer && m_buffer->m_resource)
+        m_buffer->m_resource->sendRelease();
+    m_buffer.reset();
+    m_listeners.bufferResourceDestroy.reset();
 }
 
 bool CMesaDRMBufferResource::good() {
-    return buffer && buffer->good();
+    return m_buffer && m_buffer->good();
 }
 
-CMesaDRMResource::CMesaDRMResource(SP<CWlDrm> resource_) : resource(resource_) {
+CMesaDRMResource::CMesaDRMResource(SP<CWlDrm> resource_) : m_resource(resource_) {
     if UNLIKELY (!good())
         return;
 
-    resource->setOnDestroy([this](CWlDrm* r) { PROTO::mesaDRM->destroyResource(this); });
+    m_resource->setOnDestroy([this](CWlDrm* r) { PROTO::mesaDRM->destroyResource(this); });
 
-    resource->setAuthenticate([this](CWlDrm* r, uint32_t token) {
+    m_resource->setAuthenticate([this](CWlDrm* r, uint32_t token) {
         // we don't need this
-        resource->sendAuthenticated();
+        m_resource->sendAuthenticated();
     });
 
-    resource->setCreateBuffer([](CWlDrm* r, uint32_t, uint32_t, int32_t, int32_t, uint32_t, uint32_t) { r->error(WL_DRM_ERROR_INVALID_NAME, "Not supported, use prime instead"); });
+    m_resource->setCreateBuffer(
+        [](CWlDrm* r, uint32_t, uint32_t, int32_t, int32_t, uint32_t, uint32_t) { r->error(WL_DRM_ERROR_INVALID_NAME, "Not supported, use prime instead"); });
 
-    resource->setCreatePlanarBuffer([](CWlDrm* r, uint32_t, uint32_t, int32_t, int32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) {
+    m_resource->setCreatePlanarBuffer([](CWlDrm* r, uint32_t, uint32_t, int32_t, int32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) {
         r->error(WL_DRM_ERROR_INVALID_NAME, "Not supported, use prime instead");
     });
 
-    resource->setCreatePrimeBuffer(
+    m_resource->setCreatePrimeBuffer(
         [this](CWlDrm* r, uint32_t id, int32_t nameFd, int32_t w, int32_t h, uint32_t fmt, int32_t off0, int32_t str0, int32_t off1, int32_t str1, int32_t off2, int32_t str2) {
             if (off0 < 0 || w <= 0 || h <= 0) {
                 r->error(WL_DRM_ERROR_INVALID_FORMAT, "Invalid w, h, or offset");
@@ -85,29 +86,29 @@ CMesaDRMResource::CMesaDRMResource(SP<CWlDrm> resource_) : resource(resource_) {
             attrs.fds[0]     = nameFd;
             attrs.format     = fmt;
 
-            const auto RESOURCE = PROTO::mesaDRM->m_vBuffers.emplace_back(makeShared<CMesaDRMBufferResource>(id, resource->client(), attrs));
+            const auto RESOURCE = PROTO::mesaDRM->m_buffers.emplace_back(makeShared<CMesaDRMBufferResource>(id, m_resource->client(), attrs));
 
             if UNLIKELY (!RESOURCE->good()) {
                 r->noMemory();
-                PROTO::mesaDRM->m_vBuffers.pop_back();
+                PROTO::mesaDRM->m_buffers.pop_back();
                 return;
             }
 
             // append instance so that buffer knows its owner
-            RESOURCE->buffer->m_resource->m_buffer = RESOURCE->buffer;
+            RESOURCE->m_buffer->m_resource->m_buffer = RESOURCE->m_buffer;
         });
 
-    resource->sendDevice(PROTO::mesaDRM->nodeName.c_str());
-    resource->sendCapabilities(WL_DRM_CAPABILITY_PRIME);
+    m_resource->sendDevice(PROTO::mesaDRM->m_nodeName.c_str());
+    m_resource->sendCapabilities(WL_DRM_CAPABILITY_PRIME);
 
     auto fmts = g_pHyprOpenGL->getDRMFormats();
     for (auto const& fmt : fmts) {
-        resource->sendFormat(fmt.drmFormat);
+        m_resource->sendFormat(fmt.drmFormat);
     }
 }
 
 bool CMesaDRMResource::good() {
-    return resource->resource();
+    return m_resource->resource();
 }
 
 CMesaDRMProtocol::CMesaDRMProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) {
@@ -120,7 +121,7 @@ CMesaDRMProtocol::CMesaDRMProtocol(const wl_interface* iface, const int& ver, co
     }
 
     if (dev->available_nodes & (1 << DRM_NODE_RENDER)) {
-        nodeName = dev->nodes[DRM_NODE_RENDER];
+        m_nodeName = dev->nodes[DRM_NODE_RENDER];
     } else {
         ASSERT(dev->available_nodes & (1 << DRM_NODE_PRIMARY));
 
@@ -132,25 +133,25 @@ CMesaDRMProtocol::CMesaDRMProtocol(const wl_interface* iface, const int& ver, co
         }
 
         LOGM(WARN, "No DRM render node, falling back to primary {}", dev->nodes[DRM_NODE_PRIMARY]);
-        nodeName = dev->nodes[DRM_NODE_PRIMARY];
+        m_nodeName = dev->nodes[DRM_NODE_PRIMARY];
     }
     drmFreeDevice(&dev);
 }
 
 void CMesaDRMProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
-    const auto RESOURCE = m_vManagers.emplace_back(makeShared<CMesaDRMResource>(makeShared<CWlDrm>(client, ver, id)));
+    const auto RESOURCE = m_managers.emplace_back(makeShared<CMesaDRMResource>(makeShared<CWlDrm>(client, ver, id)));
 
     if UNLIKELY (!RESOURCE->good()) {
         wl_client_post_no_memory(client);
-        m_vManagers.pop_back();
+        m_managers.pop_back();
         return;
     }
 }
 
 void CMesaDRMProtocol::destroyResource(CMesaDRMResource* resource) {
-    std::erase_if(m_vManagers, [&](const auto& other) { return other.get() == resource; });
+    std::erase_if(m_managers, [&](const auto& other) { return other.get() == resource; });
 }
 
 void CMesaDRMProtocol::destroyResource(CMesaDRMBufferResource* resource) {
-    std::erase_if(m_vBuffers, [&](const auto& other) { return other.get() == resource; });
+    std::erase_if(m_buffers, [&](const auto& other) { return other.get() == resource; });
 }