From e3478450962b817e92a15d2b801b681b50420e2f Mon Sep 17 00:00:00 2001
From: Bastien Nocera <hadess@hadess.net>
Date: Mon, 10 Aug 2020 15:32:51 +0200
Subject: [PATCH] main: Rename Inhibited to PerformanceInhibited

Make it clear that we don't expect any profile to ever be inhibited,
apart from the performance profile.
---
 src/net.hadess.PowerProfiles.xml |  6 +++---
 src/power-profiles-daemon.c      | 32 ++++++++++++++++----------------
 src/ppd-driver-lenovo-dytc.c     |  2 +-
 src/ppd-driver.c                 | 32 ++++++++++++++++----------------
 src/ppd-driver.h                 |  4 ++--
 tests/integration-test           |  6 +++---
 6 files changed, 41 insertions(+), 41 deletions(-)

diff --git a/src/net.hadess.PowerProfiles.xml b/src/net.hadess.PowerProfiles.xml
index 4f52eda..604811e 100644
--- a/src/net.hadess.PowerProfiles.xml
+++ b/src/net.hadess.PowerProfiles.xml
@@ -33,16 +33,16 @@
     <property name="SelectedProfile" type="s" access="readwrite"/>
 
     <!--
-        Inhibited:
+        PerformanceInhibited:
 
-        This will be set if the user-selected power profile is unavailable, with
+        This will be set if the performance power profile is unavailable, with
         the value being used to identify the reason for unavailability. As new
         reasons can be added, it is recommended that front-ends show a generic
         reason if they do not recognise the value. Possible values are:
         - "lap-detected" (the computer is sitting on the user's lap)
         - "" (the empty string, if not inhibited)
     -->
-    <property name="Inhibited" type="s" access="read"/>
+    <property name="PerformanceInhibited" type="s" access="read"/>
 
     <!--
         Profiles:
diff --git a/src/power-profiles-daemon.c b/src/power-profiles-daemon.c
index 7502a23..428dead 100644
--- a/src/power-profiles-daemon.c
+++ b/src/power-profiles-daemon.c
@@ -94,13 +94,13 @@ get_selected_profile (PpdApp *data)
 }
 
 static const char *
-get_inhibited (PpdApp *data)
+get_performance_inhibited (PpdApp *data)
 {
   PpdDriver *driver;
   const char *ret;
 
   driver = SELECTED_DRIVER;
-  ret = ppd_driver_get_inhibited (driver);
+  ret = ppd_driver_get_performance_inhibited (driver);
   g_assert (ret != NULL);
   return ret;
 }
@@ -157,8 +157,8 @@ send_dbus_event (PpdApp     *data,
                            g_variant_new_string (get_selected_profile (data)));
   }
   if (mask & PROP_INHIBITED) {
-    g_variant_builder_add (&props_builder, "{sv}", "Inhibited",
-                           g_variant_new_string (get_inhibited (data)));
+    g_variant_builder_add (&props_builder, "{sv}", "PerformanceInhibited",
+                           g_variant_new_string (get_performance_inhibited (data)));
   }
   if (mask & PROP_PROFILES) {
     g_variant_builder_add (&props_builder, "{sv}", "Profiles",
@@ -252,7 +252,7 @@ set_selected_profile (PpdApp      *data,
   data->selected_profile = target_profile;
 
   if (target_profile == PPD_PROFILE_PERFORMANCE &&
-      ppd_driver_is_inhibited (SELECTED_DRIVER)) {
+      ppd_driver_is_performance_inhibited (SELECTED_DRIVER)) {
     send_dbus_event (data, PROP_SELECTED_PROFILE);
     g_debug ("Not transitioning active profile to '%s' as inhibited", profile);
     return TRUE;
@@ -266,33 +266,33 @@ set_selected_profile (PpdApp      *data,
 }
 
 static void
-driver_inhibited_changed_cb (GObject    *gobject,
-                             GParamSpec *pspec,
-                             gpointer    user_data)
+driver_performance_inhibited_changed_cb (GObject    *gobject,
+                                         GParamSpec *pspec,
+                                         gpointer    user_data)
 {
   PpdApp *data = user_data;
   PpdDriver *driver = PPD_DRIVER (gobject);
   const char *prop_str = pspec->name;
 
-  if (g_strcmp0 (prop_str, "inhibited") != 0) {
+  if (g_strcmp0 (prop_str, "performance-inhibited") != 0) {
     g_debug ("Ignoring '%s' property change on profile driver '%s'",
              prop_str, ppd_driver_get_driver_name (driver));
     return;
   }
 
   if (!(ppd_driver_get_profiles (driver) & PPD_PROFILE_PERFORMANCE)) {
-    g_warning ("Ignored 'inhibited' change on non-performance driver '%s'",
+    g_warning ("Ignored 'performance-inhibited' change on non-performance driver '%s'",
                ppd_driver_get_driver_name (driver));
     return;
   }
 
   if (data->selected_profile != PPD_PROFILE_PERFORMANCE) {
-    g_debug ("User didn't want the performance profile, so ignoring 'inhibited' change on '%s'",
+    g_debug ("User didn't want the performance profile, so ignoring 'performance-inhibited' change on '%s'",
              ppd_driver_get_driver_name (driver));
     return;
   }
 
-  set_active_profile (data, ppd_driver_is_inhibited (driver) ?
+  set_active_profile (data, ppd_driver_is_performance_inhibited (driver) ?
                       PPD_PROFILE_BALANCED : PPD_PROFILE_PERFORMANCE);
 }
 
@@ -313,8 +313,8 @@ handle_get_property (GDBusConnection *connection,
     return g_variant_new_string (get_active_profile (data));
   if (g_strcmp0 (property_name, "SelectedProfile") == 0)
     return g_variant_new_string (get_selected_profile (data));
-  if (g_strcmp0 (property_name, "Inhibited") == 0)
-    return g_variant_new_string (get_inhibited (data));
+  if (g_strcmp0 (property_name, "PerformanceInhibited") == 0)
+    return g_variant_new_string (get_performance_inhibited (data));
   if (g_strcmp0 (property_name, "Profiles") == 0)
     return get_profiles_variant (data);
   return NULL;
@@ -461,8 +461,8 @@ name_acquired_handler (GDBusConnection *connection,
 
       g_ptr_array_add (data->drivers, driver);
 
-      g_signal_connect (G_OBJECT (driver), "notify::inhibited",
-                        G_CALLBACK (driver_inhibited_changed_cb), data);
+      g_signal_connect (G_OBJECT (driver), "notify::performance-inhibited",
+                        G_CALLBACK (driver_performance_inhibited_changed_cb), data);
     } else if (PPD_IS_ACTION (object)) {
       PpdAction *action = PPD_ACTION (object);
 
diff --git a/src/ppd-driver-lenovo-dytc.c b/src/ppd-driver-lenovo-dytc.c
index d7af6c8..dbaf1b4 100644
--- a/src/ppd-driver-lenovo-dytc.c
+++ b/src/ppd-driver-lenovo-dytc.c
@@ -70,7 +70,7 @@ update_dytc_state (PpdDriverLenovoDytc *dytc)
              dytc->lapmode ? "on" : "off",
              dytc->lapmode ? "inhibited" : "uninhibited");
     g_object_set (G_OBJECT (dytc),
-                  "inhibited", dytc->lapmode ? "lap-detected" : NULL,
+                  "performance-inhibited", dytc->lapmode ? "lap-detected" : NULL,
                   NULL);
   }
 }
diff --git a/src/ppd-driver.c b/src/ppd-driver.c
index f1d7e3b..30aadfd 100644
--- a/src/ppd-driver.c
+++ b/src/ppd-driver.c
@@ -15,14 +15,14 @@ typedef struct
   char          *driver_name;
   PpdProfile     profiles;
   gboolean       selected;
-  char          *inhibited;
+  char          *performance_inhibited;
 } PpdDriverPrivate;
 
 enum {
   PROP_0,
   PROP_DRIVER_NAME,
   PROP_PROFILES,
-  PROP_INHIBITED
+  PROP_PERFORMANCE_INHIBITED
 };
 
 #define PPD_DRIVER_GET_PRIVATE(o) (ppd_driver_get_instance_private (o))
@@ -45,9 +45,9 @@ ppd_driver_set_property (GObject        *object,
   case PROP_PROFILES:
     priv->profiles = g_value_get_flags (value);
     break;
-  case PROP_INHIBITED:
-    g_clear_pointer (&priv->inhibited, g_free);
-    priv->inhibited = g_value_dup_string (value);
+  case PROP_PERFORMANCE_INHIBITED:
+    g_clear_pointer (&priv->performance_inhibited, g_free);
+    priv->performance_inhibited = g_value_dup_string (value);
     break;
   default:
     G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
@@ -70,8 +70,8 @@ ppd_driver_get_property (GObject        *object,
   case PROP_PROFILES:
     g_value_set_flags (value, priv->profiles);
     break;
-  case PROP_INHIBITED:
-    g_value_set_string (value, priv->inhibited);
+  case PROP_PERFORMANCE_INHIBITED:
+    g_value_set_string (value, priv->performance_inhibited);
     break;
   default:
     G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
@@ -85,7 +85,7 @@ ppd_driver_finalize (GObject *object)
 
   priv = PPD_DRIVER_GET_PRIVATE (PPD_DRIVER (object));
   g_clear_pointer (&priv->driver_name, g_free);
-  g_clear_pointer (&priv->inhibited, g_free);
+  g_clear_pointer (&priv->performance_inhibited, g_free);
 
   G_OBJECT_CLASS (ppd_driver_parent_class)->finalize (object);
 }
@@ -113,10 +113,10 @@ ppd_driver_class_init (PpdDriverClass *klass)
                                                       PPD_TYPE_PROFILE,
                                                       0,
                                                       G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
-  g_object_class_install_property (object_class, PROP_INHIBITED,
-                                   g_param_spec_string("inhibited",
-                                                       "Inhibited",
-                                                       "Why this profile is inhibited, if set",
+  g_object_class_install_property (object_class, PROP_PERFORMANCE_INHIBITED,
+                                   g_param_spec_string("performance-inhibited",
+                                                       "Performance Inhibited",
+                                                       "Why the performance profile is inhibited, if set",
                                                        NULL,
                                                        G_PARAM_READWRITE));
 }
@@ -185,18 +185,18 @@ ppd_driver_get_selected (PpdDriver *driver)
 }
 
 const char *
-ppd_driver_get_inhibited (PpdDriver *driver)
+ppd_driver_get_performance_inhibited (PpdDriver *driver)
 {
   PpdDriverPrivate *priv;
 
   g_return_val_if_fail (PPD_IS_DRIVER (driver), NULL);
 
   priv = PPD_DRIVER_GET_PRIVATE (driver);
-  return priv->inhibited ? priv->inhibited : "";
+  return priv->performance_inhibited ? priv->performance_inhibited : "";
 }
 
 gboolean
-ppd_driver_is_inhibited (PpdDriver *driver)
+ppd_driver_is_performance_inhibited (PpdDriver *driver)
 {
   PpdDriverPrivate *priv;
 
@@ -204,5 +204,5 @@ ppd_driver_is_inhibited (PpdDriver *driver)
 
   priv = PPD_DRIVER_GET_PRIVATE (driver);
 
-  return (priv->inhibited != NULL);
+  return (priv->performance_inhibited != NULL);
 }
diff --git a/src/ppd-driver.h b/src/ppd-driver.h
index 26eda17..cb38ad4 100644
--- a/src/ppd-driver.h
+++ b/src/ppd-driver.h
@@ -29,5 +29,5 @@ gboolean ppd_driver_probe (PpdDriver *driver);
 gboolean ppd_driver_activate_profile (PpdDriver *driver, PpdProfile profile, GError **error);
 const char *ppd_driver_get_driver_name (PpdDriver *driver);
 PpdProfile ppd_driver_get_profiles (PpdDriver *driver);
-const char *ppd_driver_get_inhibited (PpdDriver *driver);
-gboolean ppd_driver_is_inhibited (PpdDriver *driver);
+const char *ppd_driver_get_performance_inhibited (PpdDriver *driver);
+gboolean ppd_driver_is_performance_inhibited (PpdDriver *driver);
diff --git a/tests/integration-test b/tests/integration-test
index 56b2af3..3150a34 100755
--- a/tests/integration-test
+++ b/tests/integration-test
@@ -235,7 +235,7 @@ class Tests(dbusmock.DBusTestCase):
       self.start_daemon()
       self.assertEqual(self.get_dbus_property('ActiveProfile'), 'balanced')
       self.assertEqual(self.get_dbus_property('SelectedProfile'), 'balanced')
-      self.assertEqual(self.get_dbus_property('Inhibited'), '')
+      self.assertEqual(self.get_dbus_property('PerformanceInhibited'), '')
 
       profiles = self.get_dbus_property('Profiles')
       self.assertEqual(len(profiles), 2)
@@ -276,7 +276,7 @@ class Tests(dbusmock.DBusTestCase):
       self.testbed.set_attribute(tp_acpi, 'dytc_lapmode', '1')
       self.testbed.uevent(tp_acpi, 'change')
       self.assertEventually(lambda: self.have_text_in_log('dytc_lapmode is now on'))
-      self.assertEqual(self.get_dbus_property('Inhibited'), 'lap-detected')
+      self.assertEqual(self.get_dbus_property('PerformanceInhibited'), 'lap-detected')
       self.assertEqual(self.get_dbus_property('ActiveProfile'), 'balanced')
       self.assertEqual(self.get_dbus_property('SelectedProfile'), 'performance')
 
@@ -329,7 +329,7 @@ class Tests(dbusmock.DBusTestCase):
 
       self.assertEqual(self.get_dbus_property('ActiveProfile'), 'balanced')
       self.assertEqual(self.get_dbus_property('SelectedProfile'), 'performance')
-      self.assertEqual(self.get_dbus_property('Inhibited'), 'lap-detected')
+      self.assertEqual(self.get_dbus_property('PerformanceInhibited'), 'lap-detected')
 
     def test_trickle_charge_mode(self):
       '''Trickle power_supply charge type'''