Replace all LOGs in input_method/, except two user-facing errors, to DVLOG(1).

chrome/browser/chromeos/input_method/ibus_controller_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/input_method/ibus_controller_impl.h"
 
 #include <algorithm>  // for std::reverse.
 #include <cstdio>
 #include <cstring>  // for std::strcmp.
 #include <set>
@@ skipping 60 matching lines @@
       return true;
   }
   return false;
 }
 
 // Returns IBusInputContext for |input_context_path|. NULL on errors.
 IBusInputContext* GetInputContext(const std::string& input_context_path,
                                   IBusBus* ibus) {
   GDBusConnection* connection = ibus_bus_get_connection(ibus);
   if (!connection) {
-    LOG(ERROR) << "IBusConnection is null";
+    DVLOG(1) << "IBusConnection is null";
     return NULL;
   }
   // This function does not issue an IBus IPC.
   IBusInputContext* context = ibus_input_context_get_input_context(
       input_context_path.c_str(), connection);
   if (!context)
-    LOG(ERROR) << "IBusInputContext is null: " << input_context_path;
+    DVLOG(1) << "IBusInputContext is null: " << input_context_path;
   return context;
 }
 
 // Returns true if |prop| has children.
 bool PropertyHasChildren(IBusProperty* prop) {
   return prop && ibus_property_get_sub_props(prop) &&
       ibus_prop_list_get(ibus_property_get_sub_props(prop), 0);
 }
 
 // This function is called by and FlattenProperty() and converts IBus
 // representation of a property, |ibus_prop|, to our own and push_back the
 // result to |out_prop_list|. This function returns true on success, and
 // returns false if sanity checks for |ibus_prop| fail.
 bool ConvertProperty(IBusProperty* ibus_prop,
                      int selection_item_id,
                      InputMethodPropertyList* out_prop_list) {
   DCHECK(ibus_prop);
   DCHECK(out_prop_list);
 
   const IBusPropType type = ibus_property_get_prop_type(ibus_prop);
   const IBusPropState state = ibus_property_get_state(ibus_prop);
   const IBusText* tooltip = ibus_property_get_tooltip(ibus_prop);
   const IBusText* label = ibus_property_get_label(ibus_prop);
   const gchar* key = ibus_property_get_key(ibus_prop);
   DCHECK(key);
 
   // Sanity checks.
   const bool has_sub_props = PropertyHasChildren(ibus_prop);
   if (has_sub_props && (type != PROP_TYPE_MENU)) {
-    LOG(ERROR) << "The property has sub properties, "
-               << "but the type of the property is not PROP_TYPE_MENU";
+    DVLOG(1) << "The property has sub properties, "
+             << "but the type of the property is not PROP_TYPE_MENU";
     return false;
   }
   if ((!has_sub_props) && (type == PROP_TYPE_MENU)) {
     // This is usually not an error. ibus-daemon sometimes sends empty props.
-    VLOG(1) << "Property list is empty";
+    DVLOG(1) << "Property list is empty";
     return false;
   }
   if (type == PROP_TYPE_SEPARATOR || type == PROP_TYPE_MENU) {
     // This is not an error, but we don't push an item for these types.
     return true;
   }
 
   const bool is_selection_item = (type == PROP_TYPE_RADIO);
   selection_item_id = is_selection_item ?
       selection_item_id : InputMethodProperty::kInvalidSelectionItemId;
 
   bool is_selection_item_checked = false;
   if (state == PROP_STATE_INCONSISTENT) {
-    LOG(WARNING) << "The property is in PROP_STATE_INCONSISTENT, "
-                 << "which is not supported.";
+    DVLOG(1) << "The property is in PROP_STATE_INCONSISTENT, "
+             << "which is not supported.";
   } else if ((!is_selection_item) && (state == PROP_STATE_CHECKED)) {
-    LOG(WARNING) << "PROP_STATE_CHECKED is meaningful only if the type is "
-                 << "PROP_TYPE_RADIO.";
+    DVLOG(1) << "PROP_STATE_CHECKED is meaningful only if the type is "
+             << "PROP_TYPE_RADIO.";
   } else {
     is_selection_item_checked = (state == PROP_STATE_CHECKED);
   }
 
   if (!key)
-    LOG(ERROR) << "key is NULL";
+    DVLOG(1) << "key is NULL";
   if (tooltip && !tooltip->text) {
-    LOG(ERROR) << "tooltip is NOT NULL, but tooltip->text IS NULL: key="
-               << Or(key, "");
+    DVLOG(1) << "tooltip is NOT NULL, but tooltip->text IS NULL: key="
+             << Or(key, "");
   }
   if (label && !label->text) {
-    LOG(ERROR) << "label is NOT NULL, but label->text IS NULL: key="
-               << Or(key, "");
+    DVLOG(1) << "label is NOT NULL, but label->text IS NULL: key="
+             << Or(key, "");
   }
 
   // This label will be localized later.
   // See chrome/browser/chromeos/input_method/input_method_util.cc.
   std::string label_to_use = (tooltip && tooltip->text) ? tooltip->text : "";
   if (label_to_use.empty()) {
     // Usually tooltips are more descriptive than labels.
     label_to_use = (label && label->text) ? label->text : "";
   }
   if (label_to_use.empty()) {
-    LOG(ERROR) << "The tooltip and label are both empty. Use " << key;
+    DVLOG(1) << "The tooltip and label are both empty. Use " << key;
     label_to_use = Or(key, "");
   }
 
   out_prop_list->push_back(InputMethodProperty(key,
                                                label_to_use,
                                                is_selection_item,
                                                is_selection_item_checked,
                                                selection_item_id));
   return true;
 }
@@ skipping 243 matching lines @@
                         NULL  /* callback */,
                         NULL  /* user_data */);
     if (ibus_config_) {
       // Release |ibus_config_| unconditionally to make sure next
       // IBusConnectionsAreAlive() call will return false.
       g_object_unref(ibus_config_);
       ibus_config_ = NULL;
     }
   } else if (process_handle_ != base::kNullProcessHandle) {
     base::KillProcess(process_handle_, -1, false /* wait */);
-    LOG(ERROR) << "Killing ibus-daemon. PID="
-               << base::GetProcId(process_handle_);
+    DVLOG(1) << "Killing ibus-daemon. PID="
+             << base::GetProcId(process_handle_);
   } else {
     // The daemon hasn't been started yet.
   }
 
   process_handle_ = base::kNullProcessHandle;
   should_launch_daemon_ = false;
   return true;
 }
 
 bool IBusControllerImpl::ChangeInputMethod(const std::string& id) {
@@ skipping 22 matching lines @@
   // 3. Switch to "xkb:us::eng". No function in this file is called.
   // 4. Switch back to "mozc". ChangeInputMethod("mozc") is called, but it's
   //    basically NOP since ibus-daemon's current IME is already "mozc".
   //    IME properties are not sent to Chrome for the same reason.
   if (id != current_input_method_id_)
     RegisterProperties(NULL, NULL);
 
   current_input_method_id_ = id;
 
   if (!IBusConnectionsAreAlive()) {
-    LOG(INFO) << "ChangeInputMethod: IBus connection is not alive (yet).";
+    DVLOG(1) << "ChangeInputMethod: IBus connection is not alive (yet).";
     // |id| will become usable shortly since Start() has already been called.
     // Just return true.
   } else {
     SendChangeInputMethodRequest(id);
   }
 
   return true;
 }
 
 bool IBusControllerImpl::ActivateInputMethodProperty(const std::string& key) {
   if (!IBusConnectionsAreAlive()) {
-    LOG(ERROR) << "ActivateInputMethodProperty: IBus connection is not alive";
+    DVLOG(1) << "ActivateInputMethodProperty: IBus connection is not alive";
     return false;
   }
   if (current_input_context_path_.empty()) {
-    LOG(ERROR) << "Input context is unknown";
+    DVLOG(1) << "Input context is unknown";
     return false;
   }
 
   // The third parameter of ibus_input_context_property_activate() has to be
   // true when the |key| points to a radio button. false otherwise.
   bool is_radio = true;
   size_t i;
   for (i = 0; i < current_property_list_.size(); ++i) {
     if (current_property_list_[i].key == key) {
       is_radio = current_property_list_[i].is_selection_item;
       break;
     }
   }
   if (i == current_property_list_.size()) {
-    LOG(ERROR) << "ActivateInputMethodProperty: unknown key: " << key;
+    DVLOG(1) << "ActivateInputMethodProperty: unknown key: " << key;
     return false;
   }
 
   IBusInputContext* context =
       GetInputContext(current_input_context_path_, ibus_);
   if (!context)
     return false;
 
   // Activate the property *asynchronously*.
   ibus_input_context_property_activate(context, key.c_str(), is_radio);
 
   // We don't have to call ibus_proxy_destroy(context) explicitly here,
   // i.e. we can just call g_object_unref(context), since g_object_unref can
   // trigger both dispose, which is overridden by src/ibusproxy.c, and
   // finalize functions. For details, see
   // http://library.gnome.org/devel/gobject/stable/gobject-memory.html
   g_object_unref(context);
 
   return true;
 }
 
 #if defined(USE_VIRTUAL_KEYBOARD)
 // IBusController override.
 void IBusControllerImpl::SendHandwritingStroke(
     const HandwritingStroke& stroke) {
   if (stroke.size() < 2) {
-    LOG(WARNING) << "Empty stroke data or a single dot is passed.";
+    DVLOG(1) << "Empty stroke data or a single dot is passed.";
     return;
   }
 
   IBusInputContext* context =
       GetInputContext(current_input_context_path_, ibus_);
   if (!context)
     return;
 
   const size_t raw_stroke_size = stroke.size() * 2;
   scoped_array<double> raw_stroke(new double[raw_stroke_size]);
@@ skipping 20 matching lines @@
 bool IBusControllerImpl::IBusConnectionsAreAlive() {
   return (process_handle_ != base::kNullProcessHandle) &&
       ibus_ && ibus_bus_is_connected(ibus_) && ibus_config_;
 }
 
 void IBusControllerImpl::MaybeRestoreConnections() {
   if (IBusConnectionsAreAlive())
     return;
   MaybeRestoreIBusConfig();
   if (IBusConnectionsAreAlive()) {
-    LOG(INFO) << "ibus-daemon and ibus-memconf processes are ready.";
+    DVLOG(1) << "ibus-daemon and ibus-memconf processes are ready.";
     ConnectPanelServiceSignals();
     SendAllInputMethodConfigs();
     if (!current_input_method_id_.empty())
       SendChangeInputMethodRequest(current_input_method_id_);
   }
 }
 
 void IBusControllerImpl::MaybeInitializeIBusBus() {
   if (ibus_)
     return;
 
   ibus_init();
   // Establish IBus connection between ibus-daemon to change the current input
   // method engine, properties, and so on.
   ibus_ = ibus_bus_new();
   DCHECK(ibus_);
 
   // Register callback functions for IBusBus signals.
   ConnectBusSignals();
 
   // Ask libibus to watch the NameOwnerChanged signal *asynchronously*.
   ibus_bus_set_watch_dbus_signal(ibus_, TRUE);
 
   if (ibus_bus_is_connected(ibus_)) {
-    LOG(ERROR) << "IBus connection is ready: ibus-daemon is already running?";
+    DVLOG(1) << "IBus connection is ready: ibus-daemon is already running?";
     BusConnected(ibus_);
   }
 }
 
 void IBusControllerImpl::MaybeRestoreIBusConfig() {
   if (!ibus_)
     return;
 
   // Destroy the current |ibus_config_| object. No-op if it's NULL.
   MaybeDestroyIBusConfig();
 
   if (ibus_config_)
     return;
 
   GDBusConnection* ibus_connection = ibus_bus_get_connection(ibus_);
   if (!ibus_connection) {
-    VLOG(1) << "Couldn't create an ibus config object since "
-            << "IBus connection is not ready.";
+    DVLOG(1) << "Couldn't create an ibus config object since "
+             << "IBus connection is not ready.";
     return;
   }
 
   const gboolean disconnected
       = g_dbus_connection_is_closed(ibus_connection);
   if (disconnected) {
     // |ibus_| object is not NULL, but the connection between ibus-daemon
     // is not yet established. In this case, we don't create |ibus_config_|
     // object.
-    LOG(ERROR) << "Couldn't create an ibus config object since "
-               << "IBus connection is closed.";
+    DVLOG(1) << "Couldn't create an ibus config object since "
+             << "IBus connection is closed.";
     return;
   }
   // If memconf is not successfully started yet, ibus_config_new() will
   // return NULL. Otherwise, it returns a transfer-none and non-floating
   // object. ibus_config_new() sometimes issues a D-Bus *synchronous* IPC
   // to check if the org.freedesktop.IBus.Config service is available.
   ibus_config_ = ibus_config_new(ibus_connection,
                                  NULL /* do not cancel the operation */,
                                  NULL /* do not get error information */);
   if (!ibus_config_) {
-    LOG(ERROR) << "ibus_config_new() failed. ibus-memconf is not ready?";
+    DVLOG(1) << "ibus_config_new() failed. ibus-memconf is not ready?";
     return;
   }
 
   // TODO(yusukes): g_object_weak_ref might be better since it allows
   // libcros to detect the delivery of the "destroy" glib signal the
   // |ibus_config_| object.
   g_object_ref(ibus_config_);
-  VLOG(1) << "ibus_config_ is ready.";
+  DVLOG(1) << "ibus_config_ is ready.";
 }
 
 void IBusControllerImpl::MaybeDestroyIBusConfig() {
   if (!ibus_) {
-    LOG(ERROR) << "MaybeDestroyIBusConfig: ibus_ is NULL";
+    DVLOG(1) << "MaybeDestroyIBusConfig: ibus_ is NULL";
     return;
   }
   if (ibus_config_ && !ibus_bus_is_connected(ibus_)) {
     g_object_unref(ibus_config_);
     ibus_config_ = NULL;
   }
 }
 
 void IBusControllerImpl::SendChangeInputMethodRequest(const std::string& id) {
   // Change the global engine *asynchronously*.
@@ skipping 41 matching lines @@
       for (size_t i = 0; i < size; ++i) {
         g_variant_builder_add(&variant_builder,
                               "s",
                               value.string_list_value[i].c_str());
       }
       variant = g_variant_builder_end(&variant_builder);
       break;
   }
 
   if (!variant) {
-    LOG(ERROR) << "SendInputMethodConfig: unknown value.type";
+    DVLOG(1) << "SendInputMethodConfig: unknown value.type";
     return false;
   }
   DCHECK(g_variant_is_floating(variant));
   DCHECK(ibus_config_);
 
   // Set an ibus configuration value *asynchronously*.
   ibus_config_set_value_async(ibus_config_,
                               key.first.c_str(),
                               key.second.c_str(),
                               variant,
@@ skipping 31 matching lines @@
                    this);
 }
 
 void IBusControllerImpl::ConnectPanelServiceSignals() {
   if (!ibus_)
     return;
 
   IBusPanelService* ibus_panel_service = IBUS_PANEL_SERVICE(
       g_object_get_data(G_OBJECT(ibus_), kPanelObjectKey));
   if (!ibus_panel_service) {
-    LOG(ERROR) << "IBusPanelService is NOT available.";
+    DVLOG(1) << "IBusPanelService is NOT available.";
     return;
   }
   // We don't _ref() or _weak_ref() the panel service object, since we're not
   // interested in the life time of the object.
 
   g_signal_connect(ibus_panel_service,
                    "focus-in",
                    G_CALLBACK(FocusInThunk),
                    this);
   g_signal_connect(ibus_panel_service,
                    "register-properties",
                    G_CALLBACK(RegisterPropertiesThunk),
                    this);
   g_signal_connect(ibus_panel_service,
                    "update-property",
                    G_CALLBACK(UpdatePropertyThunk),
                    this);
 }
 
 void IBusControllerImpl::BusConnected(IBusBus* bus) {
-  LOG(INFO) << "IBus connection is established.";
+  DVLOG(1) << "IBus connection is established.";
   MaybeRestoreConnections();
 }
 
 void IBusControllerImpl::BusDisconnected(IBusBus* bus) {
-  LOG(INFO) << "IBus connection is terminated.";
+  DVLOG(1) << "IBus connection is terminated.";
   // ibus-daemon might be terminated. Since |ibus_| object will automatically
   // connect to the daemon if it restarts, we don't have to set NULL on ibus_.
   // Call MaybeDestroyIBusConfig() to set |ibus_config_| to NULL temporarily.
   MaybeDestroyIBusConfig();
 }
 
 void IBusControllerImpl::BusNameOwnerChanged(IBusBus* bus,
                                              const gchar* name,
                                              const gchar* old_name,
                                              const gchar* new_name) {
   DCHECK(name);
   DCHECK(old_name);
   DCHECK(new_name);
 
   if (name != std::string("org.freedesktop.IBus.Config")) {
     // Not a signal for ibus-memconf.
     return;
   }
 
   const std::string empty_string;
   if (old_name != empty_string || new_name == empty_string) {
     // ibus-memconf died?
-    LOG(WARNING) << "Unexpected name owner change: name=" << name
-                 << ", old_name=" << old_name << ", new_name=" << new_name;
+    DVLOG(1) << "Unexpected name owner change: name=" << name
+             << ", old_name=" << old_name << ", new_name=" << new_name;
     // TODO(yusukes): it might be nice to set |ibus_config_| to NULL and call
     // a new callback function like OnDisconnect() here to allow Chrome to
     // recover all input method configurations when ibus-memconf is
     // automatically restarted by ibus-daemon. Though ibus-memconf is pretty
     // stable and unlikely crashes.
     return;
   }
-  VLOG(1) << "IBus config daemon is started. Recovering ibus_config_";
+  DVLOG(1) << "IBus config daemon is started. Recovering ibus_config_";
 
   // Try to recover |ibus_config_|. If the |ibus_config_| object is
   // successfully created, |OnConnectionChange| will be called to
   // notify Chrome that IBus is ready.
   MaybeRestoreConnections();
 }
 
 void IBusControllerImpl::FocusIn(IBusPanelService* panel,
                                  const gchar* input_context_path) {
   if (!input_context_path)
-    LOG(ERROR) << "NULL context passed";
+    DVLOG(1) << "NULL context passed";
   else
-    VLOG(1) << "FocusIn: " << input_context_path;
+    DVLOG(1) << "FocusIn: " << input_context_path;
   // Remember the current ic path.
   current_input_context_path_ = Or(input_context_path, "");
 }
 
 void IBusControllerImpl::RegisterProperties(IBusPanelService* panel,
                                             IBusPropList* ibus_prop_list) {
   // Note: |panel| can be NULL. See ChangeInputMethod().
-  VLOG(1) << "RegisterProperties" << (ibus_prop_list ? "" : " (clear)");
+  DVLOG(1) << "RegisterProperties" << (ibus_prop_list ? "" : " (clear)");
 
   current_property_list_.clear();
   if (ibus_prop_list) {
     // You can call
-    //   LOG(INFO) << "\n" << PrintPropList(ibus_prop_list, 0);
+    //   DVLOG(1) << "\n" << PrintPropList(ibus_prop_list, 0);
     // here to dump |ibus_prop_list|.
     if (!FlattenPropertyList(ibus_prop_list, &current_property_list_)) {
       // Clear properties on errors.
       current_property_list_.clear();
     }
   }
   FOR_EACH_OBSERVER(Observer, observers_, PropertyChanged());
 }
 
 void IBusControllerImpl::UpdateProperty(IBusPanelService* panel,
                                         IBusProperty* ibus_prop) {
-  VLOG(1) << "UpdateProperty";
+  DVLOG(1) << "UpdateProperty";
   DCHECK(ibus_prop);
 
   // You can call
-  //   LOG(INFO) << "\n" << PrintProp(ibus_prop, 0);
+  //   DVLOG(1) << "\n" << PrintProp(ibus_prop, 0);
   // here to dump |ibus_prop|.
 
   InputMethodPropertyList prop_list;  // our representation.
   if (!FlattenProperty(ibus_prop, &prop_list)) {
     // Don't update the UI on errors.
-    LOG(ERROR) << "Malformed properties are detected";
+    DVLOG(1) << "Malformed properties are detected";
     return;
   }
 
   // Notify the change.
   if (!prop_list.empty()) {
     for (size_t i = 0; i < prop_list.size(); ++i) {
       FindAndUpdateProperty(prop_list[i], &current_property_list_);
     }
     FOR_EACH_OBSERVER(Observer, observers_, PropertyChanged());
   }
 }
 
 bool IBusControllerImpl::MaybeLaunchIBusDaemon() {
   static const char kIBusDaemonPath[] = "/usr/bin/ibus-daemon";
 
   if (process_handle_ != base::kNullProcessHandle) {
-    LOG(ERROR) << "MaybeLaunchIBusDaemon: ibus-daemon is already running.";
+    DVLOG(1) << "MaybeLaunchIBusDaemon: ibus-daemon is already running.";
     return false;
   }
   if (!should_launch_daemon_)
     return false;
 
   // TODO(zork): Send output to /var/log/ibus.log
   const std::string ibus_daemon_command_line =
       base::StringPrintf("%s --panel=disable --cache=none --restart --replace",
                          kIBusDaemonPath);
   if (!LaunchProcess(ibus_daemon_command_line,
                      &process_handle_,
                      reinterpret_cast<GChildWatchFunc>(OnIBusDaemonExit))) {
-    LOG(ERROR) << "Failed to launch " << ibus_daemon_command_line;
+    DVLOG(1) << "Failed to launch " << ibus_daemon_command_line;
     return false;
   }
   return true;
 }
 
 bool IBusControllerImpl::LaunchProcess(const std::string& command_line,
                                        base::ProcessHandle* process_handle,
                                        GChildWatchFunc watch_func) {
   std::vector<std::string> argv;
   base::ProcessHandle handle = base::kNullProcessHandle;
 
   base::SplitString(command_line, ' ', &argv);
 
   if (!base::LaunchProcess(argv, base::LaunchOptions(), &handle)) {
-    LOG(ERROR) << "Could not launch: " << command_line;
+    DVLOG(1) << "Could not launch: " << command_line;
     return false;
   }
 
   // g_child_watch_add is necessary to prevent the process from becoming a
   // zombie.
   // TODO(yusukes): port g_child_watch_add to base/process_utils_posix.cc.
   const base::ProcessId pid = base::GetProcId(handle);
   g_child_watch_add(pid, watch_func, this);
 
   *process_handle = handle;
-  VLOG(1) << command_line << "is started. PID=" << pid;
+  DVLOG(1) << command_line << "is started. PID=" << pid;
   return true;
 }
 
 // static
 void IBusControllerImpl::SetInputMethodConfigCallback(GObject* source_object,
                                                       GAsyncResult* res,
                                                       gpointer user_data) {
   IBusConfig* config = IBUS_CONFIG(user_data);
   g_return_if_fail(config);
 
   GError* error = NULL;
   const gboolean result =
       ibus_config_set_value_async_finish(config, res, &error);
 
   if (!result) {
     std::string message = "(unknown error)";
     if (error && error->message) {
       message = error->message;
     }
-    LOG(ERROR) << "ibus_config_set_value_async failed: " << message;
+    DVLOG(1) << "ibus_config_set_value_async failed: " << message;
   }
 
   if (error)
     g_error_free(error);
   g_object_unref(config);
 }
 
 // static
 void IBusControllerImpl::OnIBusDaemonExit(GPid pid,
                                           gint status,
                                           IBusControllerImpl* controller) {
   if (controller->process_handle_ != base::kNullProcessHandle &&
       base::GetProcId(controller->process_handle_) == pid) {
     controller->process_handle_ = base::kNullProcessHandle;
   }
   // Restart the daemon if needed.
   controller->MaybeLaunchIBusDaemon();
 }
 #endif  // defined(HAVE_IBUS)
 
 // static
 bool IBusControllerImpl::FindAndUpdatePropertyForTesting(
     const chromeos::input_method::InputMethodProperty& new_prop,
     chromeos::input_method::InputMethodPropertyList* prop_list) {
   return FindAndUpdateProperty(new_prop, prop_list);
 }
 
 }  // namespace input_method
 }  // namespace chromeos