Add api to ibus for retreiving unused config values.

memconf/config.cc

 /* ibus - The Input Bus
  *
  * Copyright (C) 2008-2010 Red Hat, Inc.
  * Copyright (c) 2010, Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 24 matching lines @@
                                               IBusError** error);
 static gboolean ibus_config_memconf_get_value(IBusConfigService* config,
                                               const gchar* section,
                                               const gchar* name,
                                               GValue* value,
                                               IBusError** error);
 static gboolean ibus_config_memconf_unset(IBusConfigService* config,
                                           const gchar* section,
                                           const gchar* name,
                                           IBusError** error);
+static gboolean ibus_config_memconf_get_unused(IBusConfigService* config,
+                                               GValue* unread,
+                                               GValue* unwritten,
+                                               IBusError** error);
 
 // Copied from gconf/config.c.
 static IBusConfigServiceClass* parent_class = NULL;
 
 // Copied from gconf/config.c.
 GType ibus_config_memconf_get_type() {
   static GType type = 0;
 
   static const GTypeInfo type_info = {
     sizeof(IBusConfigMemConfClass),
@@ skipping 24 matching lines @@
   parent_class = reinterpret_cast<IBusConfigServiceClass*>(
       g_type_class_peek_parent(klass));
 
   IBUS_OBJECT_CLASS(object_class)->destroy
       = reinterpret_cast<IBusObjectDestroyFunc>(ibus_config_memconf_destroy);
   IBUS_CONFIG_SERVICE_CLASS(object_class)->set_value
       = ibus_config_memconf_set_value;
   IBUS_CONFIG_SERVICE_CLASS(object_class)->get_value
       = ibus_config_memconf_get_value;
   IBUS_CONFIG_SERVICE_CLASS(object_class)->unset = ibus_config_memconf_unset;
+  IBUS_CONFIG_SERVICE_CLASS(object_class)->get_unused
+      = ibus_config_memconf_get_unused;
 }
 
 static void ibus_config_memconf_init(IBusConfigMemConf* config) {
   config->entries = new std::map<std::string, GValue*>;
+  config->unread = new std::set<std::string>;
+  config->unwritten = new std::set<std::string>;
 }
 
 static void ibus_config_memconf_destroy(IBusConfigMemConf* config) {
   if (config) {
     std::map<std::string, GValue*>::iterator iter;
     for (iter = config->entries->begin();
          iter != config->entries->end();
          ++iter) {
       g_value_unset(iter->second);      
       g_free(iter->second);
     }
     delete config->entries;
+    delete config->unread;
+    delete config->unwritten;
   }
   IBUS_OBJECT_CLASS(parent_class)->destroy(
       reinterpret_cast<IBusObject*>(config));
 }
 
 // Remove an entry associated with |key| from the on-memory config database.
 static gboolean do_unset(IBusConfigMemConf* memconf, const std::string& key) {
   std::map<std::string, GValue*>::iterator iter = memconf->entries->find(key);
   if (iter != memconf->entries->end()) {
     g_value_unset(iter->second);
@@ skipping 16 matching lines @@
   g_return_val_if_fail(name, FALSE);
   g_return_val_if_fail(value, FALSE);
   g_return_val_if_fail(error, FALSE);
 
   const std::string key = std::string(section) + name;
   IBusConfigMemConf* memconf = reinterpret_cast<IBusConfigMemConf*>(config);
 
   GValue* new_entry = g_new0(GValue, 1);
   g_value_init(new_entry, G_VALUE_TYPE(value));
   g_value_copy(value, new_entry);
-  
-  do_unset(memconf, key);  // remove an existing entry (if any) first.
+
+  // remove an existing entry (if any) first.
+  if (!do_unset(memconf, key)) {
+    memconf->unread->insert(key);
+  }
   bool result = memconf->entries->insert(std::make_pair(key, new_entry)).second;
   if (!result) {
     g_value_unset(new_entry);
     g_free(new_entry);
     *error = ibus_error_new_from_printf(
         DBUS_ERROR_FAILED, "Can not set value [%s->%s]", section, name);
   }
 
   // Let ibus-daemon know that a new value is set to ibus-memconf. Note that
   // _config_value_changed_cb() function in bus/ibusimpl.c will handle this RPC.
@@ skipping 15 matching lines @@
   g_return_val_if_fail(error, FALSE);
 
   const std::string key = std::string(section) + name;
   IBusConfigMemConf* memconf = reinterpret_cast<IBusConfigMemConf*>(config);
 
   std::map<std::string, GValue*>::const_iterator iter
       = memconf->entries->find(key);
   if (iter == memconf->entries->end()) {
     *error = ibus_error_new_from_printf(
         DBUS_ERROR_FAILED, "Can not get value [%s->%s]", section, name);
+    memconf->unwritten->insert(key);
     return FALSE;
   }
 
+  memconf->unread->erase(key);
   const GValue* entry = iter->second;
   g_value_init(value, G_VALUE_TYPE(entry));
   g_value_copy(entry, value);
 
   // |value| will be g_value_unset() in the super class after the value is sent
   // to ibus-daemon. See src/ibusconfigservice.c for details.
   return TRUE;
 }
 
 // Server side implementation of ibus_config_unset_value.
 static gboolean ibus_config_memconf_unset(IBusConfigService* config,
                                           const gchar* section,
                                           const gchar* name,
                                           IBusError** error) {
   g_return_val_if_fail(config, FALSE);
   g_return_val_if_fail(section, FALSE);
   g_return_val_if_fail(name, FALSE);
   g_return_val_if_fail(error, FALSE);
 
   const std::string key = std::string(section) + name;
   IBusConfigMemConf* memconf = reinterpret_cast<IBusConfigMemConf*>(config);
 
   if (!do_unset(memconf, key)) {
     *error = ibus_error_new_from_printf(
         DBUS_ERROR_FAILED, "Can not unset value [%s->%s]", section, name);
     return FALSE;
   }
+  memconf->unread->erase(key);
 
   // Note: It is not allowed to call ibus_config_service_value_changed function
   // with zero-cleared GValue, so we don't call the function here.
   // See src/ibusconfigservice.c for details.
   return TRUE;
 }
 
+static gboolean ibus_config_memconf_get_unused(IBusConfigService* config,
+                                               GValue* unread,
+                                               GValue* unwritten,
+                                               IBusError** error) {
+  IBusConfigMemConf* memconf = reinterpret_cast<IBusConfigMemConf*>(config);
+
+  {
+    g_value_init(unread, G_TYPE_VALUE_ARRAY);
+    GValueArray* array = g_value_array_new(memconf->unread->size());
+    for (std::set<std::string>::const_iterator current =
+         memconf->unread->begin();
+         current != memconf->unread->end(); ++current) {
+      GValue array_element = {0};
+      g_value_init(&array_element, G_TYPE_STRING);
+      g_value_set_string(&array_element, current->c_str());
+      g_value_array_append(array, &array_element);
+    }
+    g_value_take_boxed(unread, array);
+  }
+
+  {
+    g_value_init(unwritten, G_TYPE_VALUE_ARRAY);
+    GValueArray* array = g_value_array_new(memconf->unwritten->size());
+    for (std::set<std::string>::const_iterator current =
+         memconf->unwritten->begin();
+         current != memconf->unwritten->end(); ++current) {
+      GValue array_element = {0};
+      g_value_init(&array_element, G_TYPE_STRING);
+      g_value_set_string(&array_element, current->c_str());
+      g_value_array_append(array, &array_element);
+    }
+    g_value_take_boxed(unwritten, array);
+  }
+  return TRUE;
+}
+
 // Copied from gconf/config.c.
 IBusConfigMemConf* ibus_config_memconf_new(IBusConnection* connection) {
   IBusConfigMemConf* config = reinterpret_cast<IBusConfigMemConf*>(
       g_object_new(ibus_config_memconf_get_type(),
                    "path", IBUS_PATH_CONFIG,
                    "connection", connection,
                    NULL));
   return config;
 }
 // TODO(yusukes): Upstream memconf/ code if possible. We might have to rewrite
 // the code to C and have to change the coding style though.