Minor refactoring.

internal/platform/implementation/linux/device_info.h

@@ -34,15 +34,19 @@
 namespace nearby {
 namespace linux {
 
-class CurrentUserSession
+class CurrentUserSession final
     : public sdbus::ProxyInterfaces<org::freedesktop::login1::Session_proxy> {
-public:
-  CurrentUserSession(sdbus::IConnection &system_bus)
+ public:
+  CurrentUserSession(const CurrentUserSession &) = delete;
+  CurrentUserSession(CurrentUserSession &&) = delete;
+  CurrentUserSession &operator=(const CurrentUserSession &) = delete;
+  CurrentUserSession &operator=(CurrentUserSession &&) = delete;
+  ~CurrentUserSession() { unregisterProxy(); }
+  explicit CurrentUserSession(sdbus::IConnection &system_bus)
       : ProxyInterfaces(system_bus, "org.freedesktop.login1",
                         "/org/freedesktop/login1/session/auto") {
     registerProxy();
   }
-  ~CurrentUserSession() { unregisterProxy(); }
 
   void RegisterScreenLockedListener(
       absl::string_view listener_name,
@@ -51,7 +55,7 @@ public:
   void UnregisterScreenLockedListener(absl::string_view listener_name)
       ABSL_LOCKS_EXCLUDED(screen_lock_listeners_mutex_);
 
-protected:
+ protected:
   void onPauseDevice(const uint32_t &major, const uint32_t &minor,
                      const std::string &type) override {}
   void onResumeDevice(const uint32_t &major, const uint32_t &minor,
@@ -60,7 +64,7 @@ protected:
   void onLock() override ABSL_LOCKS_EXCLUDED(screen_lock_listeners_mutex_);
   void onUnlock() override ABSL_LOCKS_EXCLUDED(screen_lock_listeners_mutex_);
 
-private:
+ private:
   absl::Mutex screen_lock_listeners_mutex_;
   absl::flat_hash_map<std::string,
                       std::function<void(api::DeviceInfo::ScreenStatus)>>
@@ -69,26 +73,33 @@ private:
 
 class Hostnamed
     : public sdbus::ProxyInterfaces<org::freedesktop::hostname1_proxy> {
-public:
-  Hostnamed(sdbus::IConnection &system_bus)
+ public:
+  Hostnamed(const Hostnamed &) = delete;
+  Hostnamed(Hostnamed &&) = delete;
+  Hostnamed &operator=(const Hostnamed &) = delete;
+  Hostnamed &operator=(Hostnamed &&) = delete;
+  explicit Hostnamed(sdbus::IConnection &system_bus)
       : ProxyInterfaces(system_bus, "org.freedesktop.hostname1",
                         "/org/freedesktop/hostname1") {
     registerProxy();
   }
-  ~Hostnamed() { unregisterProxy(); }
+  ~Hostnamed() { unregisterProxy(); }  
 };
 
-class LoginManager
+class LoginManager final
     : public sdbus::ProxyInterfaces<org::freedesktop::login1::Manager_proxy> {
-public:
-  LoginManager(sdbus::IConnection &system_bus)
-      : ProxyInterfaces("org.freedesktop.login1",
-                        "/org/freedesktop/login1") {
+ public:
+  LoginManager(const LoginManager &) = delete;
+  LoginManager(LoginManager &&) = delete;
+  LoginManager &operator=(const LoginManager &) = delete;
+  LoginManager &operator=(LoginManager &&) = delete;
+  explicit LoginManager(sdbus::IConnection &system_bus)
+      : ProxyInterfaces(system_bus, "org.freedesktop.login1", "/org/freedesktop/login1") {
     registerProxy();
   }
   ~LoginManager() { unregisterProxy(); }
 
-protected:
+ protected:
   void onSessionNew(const std::string &session_id,
                     const sdbus::ObjectPath &object_path) override {}
   void onSessionRemoved(const std::string &session_id,
@@ -105,15 +116,14 @@ protected:
   void onPrepareForSleep(const bool &start) override {}
 };
 
-class DeviceInfo : public api::DeviceInfo {
-public:
-  DeviceInfo(sdbus::IConnection &system_bus);
-  ~DeviceInfo() override = default;
+class DeviceInfo final : public api::DeviceInfo {
+ public:
+  explicit DeviceInfo(sdbus::IConnection &system_bus);
 
   std::optional<std::u16string> GetOsDeviceName() const override;
   api::DeviceInfo::DeviceType GetDeviceType() const override;
   api::DeviceInfo::OsType GetOsType() const override {
-    return api::DeviceInfo::OsType::kWindows; // Or ChromeOS?
+    return api::DeviceInfo::OsType::kWindows;  // Or ChromeOS?
   }
   std::optional<std::u16string> GetFullName() const override;
   std::optional<std::u16string> GetGivenName() const override {
@@ -138,23 +148,23 @@ public:
       absl::string_view listener_name,
       std::function<void(api::DeviceInfo::ScreenStatus)> callback) override {
     current_user_session_->RegisterScreenLockedListener(listener_name,
-                                                        std::move(callback));    
+                                                        std::move(callback));
   }
-  void
-  UnregisterScreenLockedListener(absl::string_view listener_name) override {
+  void UnregisterScreenLockedListener(
+      absl::string_view listener_name) override {
     current_user_session_->UnregisterScreenLockedListener(listener_name);
   }
 
   bool PreventSleep() override;
   bool AllowSleep() override;
 
-private:
+ private:
   sdbus::IConnection &system_bus_;
   std::unique_ptr<CurrentUserSession> current_user_session_;
   std::unique_ptr<LoginManager> login_manager_;
   std::optional<sdbus::UnixFd> inhibit_fd_;
 };
-} // namespace linux
-} // namespace nearby
+}  // namespace linux
+}  // namespace nearby
 
-#endif // PLATFORM_IMPL_LINUX_DEVICE_INFO_H_
+#endif  // PLATFORM_IMPL_LINUX_DEVICE_INFO_H_