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

chrome/browser/chromeos/input_method/ibus_ui_controller.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_ui_controller.h"
 
 #if defined(HAVE_IBUS)
 #include <ibus.h>
 #endif
 
@@ skipping 114 matching lines @@
     if (ibus_) {
       return true;
     }
     ibus_init();
     ibus_ = ibus_bus_new();
     CHECK(ibus_) << "ibus_bus_new() failed. Out of memory?";
 
     bool result = false;
     // Check the IBus connection status.
     if (ibus_bus_is_connected(ibus_)) {
-      LOG(INFO) << "ibus_bus_is_connected(). IBus connection is ready.";
+      DVLOG(1) << "ibus_bus_is_connected(). IBus connection is ready.";
       FOR_EACH_OBSERVER(Observer, observers_, OnConnectionChange(true));
       result = true;
     }
 
     // Start listening the gobject signals regardless of the bus connection
     // status.
     ConnectIBusSignals();
     return result;
   }
 
   // Creates IBusPanelService object if |ibus_| is already connected.
   bool MaybeRestorePanelService() {
     if (!ibus_ || !ibus_bus_is_connected(ibus_)) {
       return false;
     }
 
     if (ibus_panel_service_) {
-      LOG(ERROR) << "IBusPanelService is already available. Remove it first.";
+      DVLOG(1) << "IBusPanelService is already available. Remove it first.";
       g_object_set_data(G_OBJECT(ibus_), kPanelObjectKey, NULL);
       g_object_unref(ibus_panel_service_);
       ibus_panel_service_ = NULL;
     }
 
     // Create an IBusPanelService object.
     GDBusConnection* ibus_connection = ibus_bus_get_connection(ibus_);
     if (!ibus_connection) {
-      LOG(ERROR) << "ibus_bus_get_connection() failed";
+      DVLOG(1) << "ibus_bus_get_connection() failed";
       return false;
     }
     ibus_panel_service_ = ibus_panel_service_new(ibus_connection);
     if (!ibus_panel_service_) {
-      LOG(ERROR) << "ibus_chromeos_panel_service_new() failed";
+      DVLOG(1) << "ibus_chromeos_panel_service_new() failed";
       return false;
     }
     ConnectPanelServiceSignals();
     g_object_set_data(G_OBJECT(ibus_), kPanelObjectKey, ibus_panel_service_);
-    LOG(INFO) << "IBusPanelService object is successfully (re-)created.";
+    DVLOG(1) << "IBusPanelService object is successfully (re-)created.";
 
     // Request the well-known name *asynchronously*.
     ibus_bus_request_name_async(ibus_,
                                 IBUS_SERVICE_PANEL,
                                 0  /* flags */,
                                 -1  /* timeout */,
                                 NULL  /* cancellable */,
                                 RequestNameCallback,
                                 g_object_ref(ibus_));
     return true;
   }
 
   // IBusUiController override.
   virtual void NotifyCandidateClicked(int index,
                                       int button,
                                       int flags) OVERRIDE {
     if (!ibus_ || !ibus_bus_is_connected(ibus_)) {
-      LOG(ERROR) << "NotifyCandidateClicked: bus is not connected.";
+      DVLOG(1) << "NotifyCandidateClicked: bus is not connected.";
       return;
     }
     if (!ibus_panel_service_) {
-      LOG(ERROR) << "NotifyCandidateClicked: panel service is not available.";
+      DVLOG(1) << "NotifyCandidateClicked: panel service is not available.";
       return;
     }
 
     /* Send a D-Bus signal to ibus-daemon *asynchronously*. */
     ibus_panel_service_candidate_clicked(ibus_panel_service_,
                                          index,
                                          button,
                                          flags);
   }
 
   // IBusUiController override.
   virtual void NotifyCursorUp() OVERRIDE {
     if (!ibus_ || !ibus_bus_is_connected(ibus_)) {
-      LOG(ERROR) << "NotifyCursorUp: bus is not connected.";
+      DVLOG(1) << "NotifyCursorUp: bus is not connected.";
       return;
     }
     if (!ibus_panel_service_) {
-      LOG(ERROR) << "NotifyCursorUp: panel service is not available.";
+      DVLOG(1) << "NotifyCursorUp: panel service is not available.";
       return;
     }
 
     /* Send a D-Bus signal to ibus-daemon *asynchronously*. */
     ibus_panel_service_cursor_up(ibus_panel_service_);
   }
 
   // IBusUiController override.
   virtual void NotifyCursorDown() OVERRIDE {
     if (!ibus_ || !ibus_bus_is_connected(ibus_)) {
-      LOG(ERROR) << "NotifyCursorDown: bus is not connected.";
+      DVLOG(1) << "NotifyCursorDown: bus is not connected.";
       return;
     }
     if (!ibus_panel_service_) {
-      LOG(ERROR) << "NotifyCursorDown: panel service is not available.";
+      DVLOG(1) << "NotifyCursorDown: panel service is not available.";
       return;
     }
-     /* Send a D-Bus signal to ibus-daemon *asynchronously*. */
+    /* Send a D-Bus signal to ibus-daemon *asynchronously*. */
     ibus_panel_service_cursor_down(ibus_panel_service_);
   }
 
   // IBusUiController override.
   virtual void NotifyPageUp() OVERRIDE {
     if (!ibus_ || !ibus_bus_is_connected(ibus_)) {
-      LOG(ERROR) << "NotifyPageUp: bus is not connected.";
+      DVLOG(1) << "NotifyPageUp: bus is not connected.";
       return;
     }
     if (!ibus_panel_service_) {
-      LOG(ERROR) << "NotifyPageUp: panel service is not available.";
+      DVLOG(1) << "NotifyPageUp: panel service is not available.";
       return;
     }
 
     /* Send a D-Bus signal to ibus-daemon *asynchronously*. */
     ibus_panel_service_page_up(ibus_panel_service_);
   }
 
   // IBusUiController override.
   virtual void NotifyPageDown() OVERRIDE {
     if (!ibus_ || !ibus_bus_is_connected(ibus_)) {
-      LOG(ERROR) << "NotifyPageDown: bus is not connected.";
+      DVLOG(1) << "NotifyPageDown: bus is not connected.";
       return;
     }
     if (!ibus_panel_service_) {
-      LOG(ERROR) << "NotifyPageDown: panel service is not available.";
+      DVLOG(1) << "NotifyPageDown: panel service is not available.";
       return;
     }
 
     /* Send a D-Bus signal to ibus-daemon *asynchronously*. */
     ibus_panel_service_page_down(ibus_panel_service_);
   }
 
   // IBusUiController override.
   virtual void Connect() OVERRIDE {
     // It's totally fine if ConnectToIBus() fails here, as we'll get
@@ skipping 230 matching lines @@
         reinterpret_cast<gpointer>(UpdatePreeditTextThunk),
         this);
     g_signal_handlers_disconnect_by_func(
         ibus_panel_service_,
         reinterpret_cast<gpointer>(HidePreeditTextThunk),
         this);
   }
 
   // Handles "connected" signal from ibus-daemon.
   void IBusBusConnected(IBusBus* bus) {
-    LOG(WARNING) << "IBus connection is recovered.";
+    DVLOG(1) << "IBus connection is recovered.";
     if (!MaybeRestorePanelService()) {
-      LOG(ERROR) << "MaybeRestorePanelService() failed";
+      DVLOG(1) << "MaybeRestorePanelService() failed";
       return;
     }
 
     FOR_EACH_OBSERVER(Observer, observers_, OnConnectionChange(true));
   }
 
   // Handles "disconnected" signal from ibus-daemon. Releases the
   // |ibus_panel_service_| object since the connection the service has will be
   // destroyed soon.
   void IBusBusDisconnected(IBusBus* bus) {
-    LOG(WARNING) << "IBus connection is terminated.";
+    DVLOG(1) << "IBus connection is terminated.";
     if (ibus_panel_service_) {
       DisconnectPanelServiceSignals();
       // Since the connection being disconnected is currently mutex-locked,
       // we can't unref the panel service object directly here. Because when the
       // service object is deleted, the connection, which the service also has,
       // will be locked again. To avoid deadlock, we use g_idle_add instead.
       g_object_set_data(G_OBJECT(ibus_), kPanelObjectKey, NULL);
       g_idle_add(ReleasePanelService, ibus_panel_service_);
       ibus_panel_service_ = NULL;
     }
@@ skipping 78 matching lines @@
     GVariant* variant = ibus_serializable_get_attachment(
         IBUS_SERIALIZABLE(table), "mozc.candidates");
     if (variant != NULL) {
       gconstpointer ptr = g_variant_get_data(variant);
       if (ptr != NULL) {
         gsize size = g_variant_get_size(variant);
         GByteArray* bytearray = g_byte_array_sized_new(size);
         g_byte_array_append(
             bytearray, reinterpret_cast<const guint8*>(ptr), size);
         if (!lookup_table.mozc_candidates.ParseFromArray(
-               bytearray->data, bytearray->len)) {
+                bytearray->data, bytearray->len)) {
           lookup_table.mozc_candidates.Clear();
         }
         g_byte_array_unref(bytearray);
       }
     }
 
     // Copy candidates and annotations to |lookup_table|.
     for (int i = 0; ; i++) {
       IBusText *text = ibus_lookup_table_get_candidate(table, i);
       if (!text) {
@@ skipping 22 matching lines @@
         break;
       }
       lookup_table.labels.push_back(text->text);
     }
 
     lookup_table.cursor_absolute_index =
         ibus_lookup_table_get_cursor_pos(table);
     lookup_table.page_size = ibus_lookup_table_get_page_size(table);
     // Ensure that the page_size is non-zero to avoid div-by-zero error.
     if (lookup_table.page_size <= 0) {
-      LOG(DFATAL) << "Invalid page size: " << lookup_table.page_size;
+      DVLOG(1) << "Invalid page size: " << lookup_table.page_size;
       lookup_table.page_size = 1;
     }
 
     FOR_EACH_OBSERVER(Observer, observers_,
                       OnUpdateLookupTable(lookup_table));
   }
 
   // A callback function that will be called when ibus_bus_request_name_async()
   // request is finished.
   static void RequestNameCallback(GObject* source_object,
                                   GAsyncResult* res,
                                   gpointer user_data) {
     IBusBus* bus = IBUS_BUS(user_data);
     g_return_if_fail(bus);
 
     GError* error = NULL;
     const guint service_id =
         ibus_bus_request_name_async_finish(bus, res, &error);
 
     if (!service_id) {
       std::string message = "(unknown error)";
       if (error && error->message) {
         message = error->message;
       }
-      LOG(ERROR) << "Failed to register the panel service: " << message;
+      DVLOG(1) << "Failed to register the panel service: " << message;
     } else {
-      LOG(INFO) << "The panel service is registered: ID=" << service_id;
+      DVLOG(1) << "The panel service is registered: ID=" << service_id;
     }
 
     if (error) {
       g_error_free(error);
     }
     g_object_unref(bus);
   }
 
   IBusBus* ibus_;
   IBusPanelService* ibus_panel_service_;
@@ skipping 47 matching lines @@
 IBusUiController::~IBusUiController() {
 }
 
 bool IsActiveForTesting(const std::string& input_method_id,
                         const InputMethodDescriptors* descriptors) {
   return IsActive(input_method_id, descriptors);
 }
 
 }  // namespace input_method
 }  // namespace chromeos