Cpufreq code style

- tabs to spaces
- 4 spaces at the beginning of a line

1 files changed, 366 insertions, 366 deletions

diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-service.c b/cpufreq/src/cpufreq-selector/cpufreq-selector-service.c
index e2962e16..6ce03984 100644
--- a/cpufreq/src/cpufreq-selector/cpufreq-selector-service.c
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-service.c
@@ -29,19 +29,19 @@
 #define MAX_CPUS 255
 
 struct _CPUFreqSelectorService {
-        GObject parent;
+    GObject parent;
 
-	CPUFreqSelector *selectors[MAX_CPUS];
-	gint             selectors_max;
+    CPUFreqSelector *selectors[MAX_CPUS];
+    gint             selectors_max;
 
-	DBusGConnection *system_bus;
-	
-	/* PolicyKit */
-	PolkitAuthority   *authority;
+    DBusGConnection *system_bus;
+
+    /* PolicyKit */
+    PolkitAuthority   *authority;
 };
 
 struct _CPUFreqSelectorServiceClass {
-        GObjectClass parent_class;
+    GObjectClass parent_class;
 };
 
 G_DEFINE_TYPE (CPUFreqSelectorService, cpufreq_selector_service, G_TYPE_OBJECT)
@@ -51,437 +51,437 @@ G_DEFINE_TYPE (CPUFreqSelectorService, cpufreq_selector_service, G_TYPE_OBJECT)
 GType
 cpufreq_selector_service_error_get_type (void)
 {
-	static GType etype = 0;
-
-	if (G_UNLIKELY (etype == 0)) {
-		static const GEnumValue values[] = {
-			{ SERVICE_ERROR_GENERAL,            "SERVICE_ERROR_GENERAL",            "GeneralError" },
-			{ SERVICE_ERROR_DBUS,               "SERVICE_ERROR_DBUS",               "DBUSError" },
-			{ SERVICE_ERROR_ALREADY_REGISTERED, "SERVICE_ERROR_ALREADY_REGISTERED", "AlreadyRegistered" },
-			{ SERVICE_ERROR_NOT_AUTHORIZED,     "SERVICE_ERROR_NOT_AUTHORIZED",     "NotAuthorized"},
-			{ 0, NULL, NULL}
-		};
-		
-		etype = g_enum_register_static ("CPUFreqSelectorServiceError", values);
-	}
-
-	return etype;
+    static GType etype = 0;
+
+    if (G_UNLIKELY (etype == 0)) {
+        static const GEnumValue values[] = {
+            { SERVICE_ERROR_GENERAL,            "SERVICE_ERROR_GENERAL",            "GeneralError" },
+            { SERVICE_ERROR_DBUS,               "SERVICE_ERROR_DBUS",               "DBUSError" },
+            { SERVICE_ERROR_ALREADY_REGISTERED, "SERVICE_ERROR_ALREADY_REGISTERED", "AlreadyRegistered" },
+            { SERVICE_ERROR_NOT_AUTHORIZED,     "SERVICE_ERROR_NOT_AUTHORIZED",     "NotAuthorized"},
+            { 0, NULL, NULL}
+        };
+
+        etype = g_enum_register_static ("CPUFreqSelectorServiceError", values);
+    }
+
+    return etype;
 }
 
 GQuark
 cpufreq_selector_service_error_quark (void)
 {
-	static GQuark error_quark = 0;
+    static GQuark error_quark = 0;
+
+    if (G_UNLIKELY (error_quark == 0))
+        error_quark =
+            g_quark_from_static_string ("cpufreq-selector-service-error-quark");
 
-	if (G_UNLIKELY (error_quark == 0))
-		error_quark =
-			g_quark_from_static_string ("cpufreq-selector-service-error-quark");
-	
-	return error_quark;
+    return error_quark;
 }
 
 static void
 cpufreq_selector_service_finalize (GObject *object)
 {
-	CPUFreqSelectorService *service = CPUFREQ_SELECTOR_SERVICE (object);
-	gint i;
-
-	service->system_bus = NULL;
-	
-	if (service->selectors_max >= 0) {
-		for (i = 0; i < service->selectors_max; i++) {
-			if (service->selectors[i]) {
-				g_object_unref (service->selectors[i]);
-				service->selectors[i] = NULL;
-			}
-		}
-
-		service->selectors_max = -1;
-	}
-
-	if (service->authority) {
-		g_object_unref (service->authority);
-		service->authority = NULL;
-	}
-
-	G_OBJECT_CLASS (cpufreq_selector_service_parent_class)->finalize (object);
+    CPUFreqSelectorService *service = CPUFREQ_SELECTOR_SERVICE (object);
+    gint i;
+
+    service->system_bus = NULL;
+
+    if (service->selectors_max >= 0) {
+        for (i = 0; i < service->selectors_max; i++) {
+            if (service->selectors[i]) {
+                g_object_unref (service->selectors[i]);
+                service->selectors[i] = NULL;
+            }
+        }
+
+        service->selectors_max = -1;
+    }
+
+    if (service->authority) {
+        g_object_unref (service->authority);
+        service->authority = NULL;
+    }
+
+    G_OBJECT_CLASS (cpufreq_selector_service_parent_class)->finalize (object);
 }
 
 static void
 cpufreq_selector_service_class_init (CPUFreqSelectorServiceClass *klass)
 {
-	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+    GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-	object_class->finalize = cpufreq_selector_service_finalize;
+    object_class->finalize = cpufreq_selector_service_finalize;
 }
 
 static void
 cpufreq_selector_service_init (CPUFreqSelectorService *service)
 {
-	service->selectors_max = -1;
+    service->selectors_max = -1;
 }
 
 CPUFreqSelectorService *
 cpufreq_selector_service_get_instance (void)
 {
-	static CPUFreqSelectorService *service = NULL;
+    static CPUFreqSelectorService *service = NULL;
 
-	if (!service)
-		service = CPUFREQ_SELECTOR_SERVICE (g_object_new (CPUFREQ_TYPE_SELECTOR_SERVICE, NULL));
+    if (!service)
+        service = CPUFREQ_SELECTOR_SERVICE (g_object_new (CPUFREQ_TYPE_SELECTOR_SERVICE, NULL));
 
-	return service;
+    return service;
 }
 
 static gboolean
 service_shutdown (gpointer user_data)
 {
-	g_object_unref (SELECTOR_SERVICE);
+    g_object_unref (SELECTOR_SERVICE);
 
-	return FALSE;
+    return FALSE;
 }
 
 static void
 reset_killtimer (void)
 {
-	static guint timer_id = 0;
+    static guint timer_id = 0;
 
-	if (timer_id > 0)
-		g_source_remove (timer_id);
+    if (timer_id > 0)
+        g_source_remove (timer_id);
 
-	timer_id = g_timeout_add_seconds (30,
-					  (GSourceFunc) service_shutdown,
-					  NULL);
+    timer_id = g_timeout_add_seconds (30,
+                                      (GSourceFunc) service_shutdown,
+                                      NULL);
 }
 
 gboolean
 cpufreq_selector_service_register (CPUFreqSelectorService *service,
-				   GError                **error)
+                                   GError                **error)
 {
-	DBusGConnection *connection;
-	DBusGProxy      *bus_proxy;
-	gboolean         res;
-	guint            result;
-	GError          *err = NULL;
-
-	if (service->system_bus) {
-		g_set_error (error,
-			     CPUFREQ_SELECTOR_SERVICE_ERROR,
-			     SERVICE_ERROR_ALREADY_REGISTERED,
-			     "Service %s already registered", BUS_NAME);
-		return FALSE;
-	}
-
-	connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &err);
-	if (!connection) {
-		g_set_error (error,
-			     CPUFREQ_SELECTOR_SERVICE_ERROR,
-			     SERVICE_ERROR_DBUS,
-			     "Couldn't connect to system bus: %s",
-			     err->message);
-		g_error_free (err);
-
-		return FALSE;
-	}
-
-	bus_proxy = dbus_g_proxy_new_for_name (connection,
-					       DBUS_SERVICE_DBUS,
-					       DBUS_PATH_DBUS,
-					       DBUS_INTERFACE_DBUS);
-	if (!bus_proxy) {
-		g_set_error (error,
-			     CPUFREQ_SELECTOR_SERVICE_ERROR,
-			     SERVICE_ERROR_DBUS,
-			     "Could not construct bus_proxy object");
-		return FALSE;
-	}
-
-	res = dbus_g_proxy_call (bus_proxy,
-				 "RequestName",
-				 &err,
-				 G_TYPE_STRING, BUS_NAME,
-				 G_TYPE_UINT, DBUS_NAME_FLAG_DO_NOT_QUEUE,
-				 G_TYPE_INVALID,
-				 G_TYPE_UINT, &result,
-				 G_TYPE_INVALID);
-	g_object_unref (bus_proxy);
-	
-	if (!res) {
-		if (err) {
-			g_set_error (error,
-				     CPUFREQ_SELECTOR_SERVICE_ERROR,
-				     SERVICE_ERROR_DBUS,
-				     "Failed to acquire %s: %s",
-				     BUS_NAME, err->message);
-			g_error_free (err);
-		} else {
-			g_set_error (error,
-				     CPUFREQ_SELECTOR_SERVICE_ERROR,
-				     SERVICE_ERROR_DBUS,
-				     "Failed to acquire %s", BUS_NAME);
-		}
-
-		return FALSE;
-	}
-
-	if (result == DBUS_REQUEST_NAME_REPLY_EXISTS) {
-		g_set_error (error,
-			     CPUFREQ_SELECTOR_SERVICE_ERROR,
-			     SERVICE_ERROR_ALREADY_REGISTERED,
-			     "Service %s already registered", BUS_NAME);
-		return FALSE;
-	}
-
-	service->authority = polkit_authority_get_sync (NULL, NULL);
-
-	service->system_bus = connection;
-
-	dbus_g_object_type_install_info (CPUFREQ_TYPE_SELECTOR_SERVICE,
-					 &dbus_glib_cpufreq_selector_service_object_info);
-	dbus_g_connection_register_g_object (connection,
-					     "/org/mate/cpufreq_selector/selector",
-					     G_OBJECT (service));
-	dbus_g_error_domain_register (CPUFREQ_SELECTOR_SERVICE_ERROR, NULL,
-				      CPUFREQ_TYPE_SELECTOR_SERVICE_ERROR);
-
-	reset_killtimer ();
-
-	return TRUE;
+    DBusGConnection *connection;
+    DBusGProxy      *bus_proxy;
+    gboolean         res;
+    guint            result;
+    GError          *err = NULL;
+
+    if (service->system_bus) {
+        g_set_error (error,
+                     CPUFREQ_SELECTOR_SERVICE_ERROR,
+                     SERVICE_ERROR_ALREADY_REGISTERED,
+                     "Service %s already registered", BUS_NAME);
+        return FALSE;
+    }
+
+    connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &err);
+    if (!connection) {
+        g_set_error (error,
+                     CPUFREQ_SELECTOR_SERVICE_ERROR,
+                     SERVICE_ERROR_DBUS,
+                     "Couldn't connect to system bus: %s",
+                     err->message);
+        g_error_free (err);
+
+        return FALSE;
+    }
+
+    bus_proxy = dbus_g_proxy_new_for_name (connection,
+                                           DBUS_SERVICE_DBUS,
+                                           DBUS_PATH_DBUS,
+                                           DBUS_INTERFACE_DBUS);
+    if (!bus_proxy) {
+        g_set_error (error,
+                     CPUFREQ_SELECTOR_SERVICE_ERROR,
+                     SERVICE_ERROR_DBUS,
+                     "Could not construct bus_proxy object");
+        return FALSE;
+    }
+
+    res = dbus_g_proxy_call (bus_proxy,
+                             "RequestName",
+                             &err,
+                             G_TYPE_STRING, BUS_NAME,
+                             G_TYPE_UINT, DBUS_NAME_FLAG_DO_NOT_QUEUE,
+                             G_TYPE_INVALID,
+                             G_TYPE_UINT, &result,
+                             G_TYPE_INVALID);
+    g_object_unref (bus_proxy);
+
+    if (!res) {
+        if (err) {
+            g_set_error (error,
+                         CPUFREQ_SELECTOR_SERVICE_ERROR,
+                         SERVICE_ERROR_DBUS,
+                         "Failed to acquire %s: %s",
+                         BUS_NAME, err->message);
+            g_error_free (err);
+        } else {
+            g_set_error (error,
+                         CPUFREQ_SELECTOR_SERVICE_ERROR,
+                         SERVICE_ERROR_DBUS,
+                         "Failed to acquire %s", BUS_NAME);
+        }
+
+        return FALSE;
+    }
+
+    if (result == DBUS_REQUEST_NAME_REPLY_EXISTS) {
+        g_set_error (error,
+                     CPUFREQ_SELECTOR_SERVICE_ERROR,
+                     SERVICE_ERROR_ALREADY_REGISTERED,
+                     "Service %s already registered", BUS_NAME);
+        return FALSE;
+    }
+
+    service->authority = polkit_authority_get_sync (NULL, NULL);
+
+    service->system_bus = connection;
+
+    dbus_g_object_type_install_info (CPUFREQ_TYPE_SELECTOR_SERVICE,
+                                     &dbus_glib_cpufreq_selector_service_object_info);
+    dbus_g_connection_register_g_object (connection,
+                                         "/org/mate/cpufreq_selector/selector",
+                                         G_OBJECT (service));
+    dbus_g_error_domain_register (CPUFREQ_SELECTOR_SERVICE_ERROR, NULL,
+                                  CPUFREQ_TYPE_SELECTOR_SERVICE_ERROR);
+
+    reset_killtimer ();
+
+    return TRUE;
 }
 
 static CPUFreqSelector *
 get_selector_for_cpu (CPUFreqSelectorService *service,
-		      guint                   cpu)
+                      guint                   cpu)
 {
-	if (!service->selectors[cpu]) {
-		service->selectors[cpu] = cpufreq_selector_factory_create_selector (cpu);
-		if (!service->selectors[cpu])
-			return NULL;
-		
-		if (service->selectors_max < cpu)
-			service->selectors_max = cpu;
-	}
-	
-	return service->selectors[cpu];
+    if (!service->selectors[cpu]) {
+        service->selectors[cpu] = cpufreq_selector_factory_create_selector (cpu);
+        if (!service->selectors[cpu])
+            return NULL;
+
+        if (service->selectors_max < cpu)
+            service->selectors_max = cpu;
+    }
+
+    return service->selectors[cpu];
 }
 
 /* PolicyKit */
 static gboolean
 cpufreq_selector_service_check_policy (CPUFreqSelectorService *service,
-				       DBusGMethodInvocation  *context,
-				       GError                **error)
+                                       DBusGMethodInvocation  *context,
+                                       GError                **error)
 {
-	PolkitSubject             *subject;
-	PolkitAuthorizationResult *result;
-	gchar                     *sender;
-	gboolean                   ret;
-
-	sender = dbus_g_method_get_sender (context);
-	subject = polkit_system_bus_name_new (sender);
-	g_free (sender);
-
-	result = polkit_authority_check_authorization_sync (service->authority,
-                                                            subject,
-                                                            "org.mate.cpufreqselector",
-                                                            NULL,
-                                                            POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION,
-                                                            NULL, error);
-        g_object_unref (subject);
-
-        if (*error) {
-		g_warning ("Check policy: %s", (*error)->message);
-		g_object_unref (result);
-
-		return FALSE;
-	}
-
-	ret = polkit_authorization_result_get_is_authorized (result);
-	if (!ret) {
-		g_set_error (error,
-			     CPUFREQ_SELECTOR_SERVICE_ERROR,
-			     SERVICE_ERROR_NOT_AUTHORIZED,
-			     "Caller is not authorized");
-	}
-
-	g_object_unref (result);
-
-	return ret;
+    PolkitSubject             *subject;
+    PolkitAuthorizationResult *result;
+    gchar                     *sender;
+    gboolean                   ret;
+
+    sender = dbus_g_method_get_sender (context);
+    subject = polkit_system_bus_name_new (sender);
+    g_free (sender);
+
+    result = polkit_authority_check_authorization_sync (service->authority,
+                                                        subject,
+                                                        "org.mate.cpufreqselector",
+                                                        NULL,
+                                                        POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION,
+                                                        NULL, error);
+    g_object_unref (subject);
+
+    if (*error) {
+        g_warning ("Check policy: %s", (*error)->message);
+        g_object_unref (result);
+
+        return FALSE;
+    }
+
+    ret = polkit_authorization_result_get_is_authorized (result);
+    if (!ret) {
+        g_set_error (error,
+                     CPUFREQ_SELECTOR_SERVICE_ERROR,
+                     SERVICE_ERROR_NOT_AUTHORIZED,
+                     "Caller is not authorized");
+    }
+
+    g_object_unref (result);
+
+    return ret;
 }
 
 /* D-BUS interface */
 gboolean
 cpufreq_selector_service_set_frequency (CPUFreqSelectorService *service,
-					guint                   cpu,
-					guint                   frequency,
-					DBusGMethodInvocation  *context)
+                                        guint                   cpu,
+                                        guint                   frequency,
+                                        DBusGMethodInvocation  *context)
 {
-	CPUFreqSelector *selector;
-	GError          *error = NULL;
-
-	reset_killtimer ();
-
-	if (!cpufreq_selector_service_check_policy (service, context, &error)) {
-		dbus_g_method_return_error (context, error);
-		g_error_free (error);
-
-		return FALSE;
-	}
-
-	if (cpu > MAX_CPUS) {
-		GError *err;
-		
-		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
-				   SERVICE_ERROR_DBUS,
-				   "Error setting frequency on cpu %d: Invalid cpu",
-				   cpu);
-		dbus_g_method_return_error (context, err);
-		g_error_free (err);
-
-		return FALSE;
-	}
-
-	selector = get_selector_for_cpu (service, cpu);
-	if (!selector) {
-		GError *err;
-
-		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
-				   SERVICE_ERROR_DBUS,
-				   "Error setting frequency on cpu %d: No cpufreq support",
-				   cpu);
-		dbus_g_method_return_error (context, err);
-		g_error_free (err);
-
-		return FALSE;
-	}
-
-	cpufreq_selector_set_frequency (selector, frequency, &error);
-	if (error) {
-		GError *err;
-
-		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
-				   SERVICE_ERROR_DBUS,
-				   "Error setting frequency %d on cpu %d: %s",
-				   frequency, cpu, error->message);
-		dbus_g_method_return_error (context, err);
-		g_error_free (err);
-		g_error_free (error);
-
-		return FALSE;
-	}
-	
-	dbus_g_method_return (context);
-	
-	return TRUE;
+    CPUFreqSelector *selector;
+    GError          *error = NULL;
+
+    reset_killtimer ();
+
+    if (!cpufreq_selector_service_check_policy (service, context, &error)) {
+        dbus_g_method_return_error (context, error);
+        g_error_free (error);
+
+        return FALSE;
+    }
+
+    if (cpu > MAX_CPUS) {
+        GError *err;
+
+        err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+                           SERVICE_ERROR_DBUS,
+                           "Error setting frequency on cpu %d: Invalid cpu",
+                           cpu);
+        dbus_g_method_return_error (context, err);
+        g_error_free (err);
+
+        return FALSE;
+    }
+
+    selector = get_selector_for_cpu (service, cpu);
+    if (!selector) {
+        GError *err;
+
+        err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+                           SERVICE_ERROR_DBUS,
+                           "Error setting frequency on cpu %d: No cpufreq support",
+                           cpu);
+        dbus_g_method_return_error (context, err);
+        g_error_free (err);
+
+        return FALSE;
+    }
+
+    cpufreq_selector_set_frequency (selector, frequency, &error);
+    if (error) {
+        GError *err;
+
+        err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+                           SERVICE_ERROR_DBUS,
+                           "Error setting frequency %d on cpu %d: %s",
+                           frequency, cpu, error->message);
+        dbus_g_method_return_error (context, err);
+        g_error_free (err);
+        g_error_free (error);
+
+        return FALSE;
+    }
+
+    dbus_g_method_return (context);
+
+    return TRUE;
 }
 
 gboolean
 cpufreq_selector_service_set_governor (CPUFreqSelectorService *service,
-				       guint                   cpu,
-				       const gchar            *governor,
-				       DBusGMethodInvocation  *context)
+                                       guint                   cpu,
+                                       const gchar            *governor,
+                                       DBusGMethodInvocation  *context)
 {
-	CPUFreqSelector *selector;
-	GError          *error = NULL;
-
-	reset_killtimer ();
-
-	if (!cpufreq_selector_service_check_policy (service, context, &error)) {
-		dbus_g_method_return_error (context, error);
-		g_error_free (error);
-
-		return FALSE;
-	}
-	
-	if (cpu > MAX_CPUS) {
-		GError *err;
-
-		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
-				   SERVICE_ERROR_DBUS,
-				   "Error setting governor on cpu %d: Invalid cpu",
-				   cpu);
-		dbus_g_method_return_error (context, err);
-		g_error_free (err);
-
-		return FALSE;
-	}
-
-	selector = get_selector_for_cpu (service, cpu);
-	if (!selector) {
-		GError *err;
-
-		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
-				   SERVICE_ERROR_DBUS,
-				   "Error setting governor on cpu %d: No cpufreq support",
-				   cpu);
-		dbus_g_method_return_error (context, err);
-		g_error_free (err);
-
-		return FALSE;
-	}
-
-	cpufreq_selector_set_governor (selector, governor, &error);
-	if (error) {
-		GError *err;
-
-		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
-				   SERVICE_ERROR_DBUS,
-				   "Error setting governor %s on cpu %d: %s",
-				   governor, cpu, error->message);
-		dbus_g_method_return_error (context, err);
-		g_error_free (err);
-		g_error_free (error);
-
-		return FALSE;
-	}
-
-	dbus_g_method_return (context);
-	
-	return TRUE;
+    CPUFreqSelector *selector;
+    GError          *error = NULL;
+
+    reset_killtimer ();
+
+    if (!cpufreq_selector_service_check_policy (service, context, &error)) {
+        dbus_g_method_return_error (context, error);
+        g_error_free (error);
+
+        return FALSE;
+    }
+
+    if (cpu > MAX_CPUS) {
+        GError *err;
+
+        err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+                           SERVICE_ERROR_DBUS,
+                           "Error setting governor on cpu %d: Invalid cpu",
+                           cpu);
+        dbus_g_method_return_error (context, err);
+        g_error_free (err);
+
+        return FALSE;
+    }
+
+    selector = get_selector_for_cpu (service, cpu);
+    if (!selector) {
+        GError *err;
+
+        err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+                           SERVICE_ERROR_DBUS,
+                           "Error setting governor on cpu %d: No cpufreq support",
+                           cpu);
+        dbus_g_method_return_error (context, err);
+        g_error_free (err);
+
+        return FALSE;
+    }
+
+    cpufreq_selector_set_governor (selector, governor, &error);
+    if (error) {
+        GError *err;
+
+        err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+                           SERVICE_ERROR_DBUS,
+                           "Error setting governor %s on cpu %d: %s",
+                           governor, cpu, error->message);
+        dbus_g_method_return_error (context, err);
+        g_error_free (err);
+        g_error_free (error);
+
+        return FALSE;
+    }
+
+    dbus_g_method_return (context);
+
+    return TRUE;
 }
 
 
 gboolean
 cpufreq_selector_service_can_set (CPUFreqSelectorService *service,
-				  DBusGMethodInvocation  *context)
+                                  DBusGMethodInvocation  *context)
 {
-	PolkitSubject             *subject;
-	PolkitAuthorizationResult *result;
-	gchar                     *sender;
-	gboolean                   ret;
-        GError                    *error = NULL;
-
-	reset_killtimer ();
-
-	sender = dbus_g_method_get_sender (context);
-	subject = polkit_system_bus_name_new (sender);
-	g_free (sender);
-
-	result = polkit_authority_check_authorization_sync (service->authority,
-                                                            subject,
-                                                            "org.mate.cpufreqselector",
-                                                            NULL,
-                                                            0,
-                                                            NULL,
-							    &error);
-        g_object_unref (subject);
-
-	if (error) {
-		dbus_g_method_return_error (context, error);
-		g_error_free (error);
-
-		return FALSE;
-	}
-
-        if (polkit_authorization_result_get_is_authorized (result)) {
-		ret = TRUE;
-	} else if (polkit_authorization_result_get_is_challenge (result)) {
-		ret = TRUE;
-	} else {
-		ret = FALSE;
-	}
-
-	g_object_unref (result);
-
-        dbus_g_method_return (context, ret);
-
-	return TRUE;
+    PolkitSubject             *subject;
+    PolkitAuthorizationResult *result;
+    gchar                     *sender;
+    gboolean                   ret;
+    GError                    *error = NULL;
+
+    reset_killtimer ();
+
+    sender = dbus_g_method_get_sender (context);
+    subject = polkit_system_bus_name_new (sender);
+    g_free (sender);
+
+    result = polkit_authority_check_authorization_sync (service->authority,
+                                                        subject,
+                                                        "org.mate.cpufreqselector",
+                                                        NULL,
+                                                        0,
+                                                        NULL,
+                                                        &error);
+    g_object_unref (subject);
+
+    if (error) {
+        dbus_g_method_return_error (context, error);
+        g_error_free (error);
+
+        return FALSE;
+    }
+
+    if (polkit_authorization_result_get_is_authorized (result)) {
+        ret = TRUE;
+    } else if (polkit_authorization_result_get_is_challenge (result)) {
+        ret = TRUE;
+    } else {
+        ret = FALSE;
+    }
+
+    g_object_unref (result);
+
+    dbus_g_method_return (context, ret);
+
+    return TRUE;
 }