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

chrome/browser/chromeos/input_method/xkeyboard.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/xkeyboard.h"
 
 #include <cstdlib>
 #include <cstring>
 #include <queue>
 #include <set>
@@ skipping 163 matching lines @@
   const std::string layout_to_set = CreateFullXkbLayoutName(
       layout_name, modifier_map);
   if (layout_to_set.empty()) {
     return false;
   }
 
   if (!current_layout_name_.empty()) {
     const std::string current_layout = CreateFullXkbLayoutName(
         current_layout_name_, current_modifier_map_);
     if (!force && (current_layout == layout_to_set)) {
-      DLOG(INFO) << "The requested layout is already set: " << layout_to_set;
+      DVLOG(1) << "The requested layout is already set: " << layout_to_set;
       return true;
     }
   }
 
   // Turn off caps lock if there is no kCapsLockKey in the remapped keys.
   if (!ContainsModifierKeyAsReplacement(modifier_map, kCapsLockKey)) {
     SetCapsLockEnabled(false);
   }
 
-  VLOG(1) << (force ? "Reapply" : "Set") << " layout: " << layout_to_set;
+  DVLOG(1) << (force ? "Reapply" : "Set") << " layout: " << layout_to_set;
 
   const bool start_execution = execute_queue_.empty();
   // If no setxkbmap command is in flight (i.e. start_execution is true),
   // start the first one by explicitly calling MaybeExecuteSetLayoutCommand().
   // If one or more setxkbmap commands are already in flight, just push the
   // layout name to the queue. setxkbmap command for the layout will be called
   // via OnSetLayoutFinish() callback later.
   execute_queue_.push(layout_to_set);
   if (start_execution) {
     MaybeExecuteSetLayoutCommand();
@@ skipping 12 matching lines @@
 
   std::vector<std::string> argv;
   base::ProcessHandle handle = base::kNullProcessHandle;
 
   argv.push_back(kSetxkbmapCommand);
   argv.push_back("-layout");
   argv.push_back(layout_to_set);
   argv.push_back("-synch");
 
   if (!base::LaunchProcess(argv, base::LaunchOptions(), &handle)) {
-    LOG(ERROR) << "Failed to execute setxkbmap: " << layout_to_set;
+    DVLOG(1) << "Failed to execute setxkbmap: " << layout_to_set;
     execute_queue_ = std::queue<std::string>();  // clear the queue.
     return;
   }
 
   // g_child_watch_add is necessary to prevent the process from becoming a
   // zombie.
   const base::ProcessId pid = base::GetProcId(handle);
   g_child_watch_add(pid,
                     reinterpret_cast<GChildWatchFunc>(OnSetLayoutFinish),
                     this);
-  VLOG(1) << "ExecuteSetLayoutCommand: " << layout_to_set << ": pid=" << pid;
+  DVLOG(1) << "ExecuteSetLayoutCommand: " << layout_to_set << ": pid=" << pid;
 }
 
 bool XKeyboardImpl::NumLockIsEnabled() {
   bool num_lock_enabled = false;
   GetLockedModifiers(NULL /* Caps Lock */, &num_lock_enabled);
   return num_lock_enabled;
 }
 
 bool XKeyboardImpl::CapsLockIsEnabled() {
   bool caps_lock_enabled = false;
@@ skipping 15 matching lines @@
   if (xkb_desc->dpy && xkb_desc->names && xkb_desc->names->vmods) {
     const std::string string_to_find(kNumLockVirtualModifierString);
     for (size_t i = 0; i < XkbNumVirtualMods; ++i) {
       const unsigned int virtual_mod_mask = 1U << i;
       ui::XScopedString virtual_mod_str(
           XGetAtomName(xkb_desc->dpy, xkb_desc->names->vmods[i]));
       if (!virtual_mod_str.string())
         continue;
       if (string_to_find == virtual_mod_str.string()) {
         if (!XkbVirtualModsToReal(xkb_desc, virtual_mod_mask, &real_mask)) {
-          LOG(ERROR) << "XkbVirtualModsToReal failed";
+          DVLOG(1) << "XkbVirtualModsToReal failed";
           real_mask = kBadMask;  // reset the return value, just in case.
         }
         break;
       }
     }
   }
   XkbFreeKeyboard(xkb_desc, 0, True /* free all components */);
   return real_mask;
 }
 
 void XKeyboardImpl::GetLockedModifiers(bool* out_caps_lock_enabled,
                                        bool* out_num_lock_enabled) {
   CHECK(CurrentlyOnUIThread());
 
   if (out_num_lock_enabled && !num_lock_mask_) {
-    VLOG(1) << "Cannot get locked modifiers. Num Lock mask unknown.";
+    DVLOG(1) << "Cannot get locked modifiers. Num Lock mask unknown.";
     if (out_caps_lock_enabled) {
       *out_caps_lock_enabled = false;
     }
     if (out_num_lock_enabled) {
       *out_num_lock_enabled = false;
     }
     return;
   }
 
   XkbStateRec status;
   XkbGetState(ui::GetXDisplay(), XkbUseCoreKbd, &status);
   if (out_caps_lock_enabled) {
     *out_caps_lock_enabled = status.locked_mods & LockMask;
   }
   if (out_num_lock_enabled) {
     *out_num_lock_enabled = status.locked_mods & num_lock_mask_;
   }
 }
 
 std::string XKeyboardImpl::CreateFullXkbLayoutName(
     const std::string& layout_name,
     const ModifierMap& modifier_map) {
   static const char kValidLayoutNameCharacters[] =
       "abcdefghijklmnopqrstuvwxyz0123456789()-_";
 
   if (layout_name.empty()) {
-    LOG(ERROR) << "Invalid layout_name: " << layout_name;
+    DVLOG(1) << "Invalid layout_name: " << layout_name;
     return "";
   }
 
   if (layout_name.find_first_not_of(kValidLayoutNameCharacters) !=
       std::string::npos) {
-    LOG(ERROR) << "Invalid layout_name: " << layout_name;
+    DVLOG(1) << "Invalid layout_name: " << layout_name;
     return "";
   }
 
   std::string use_search_key_as_str;
   std::string use_left_control_key_as_str;
   std::string use_left_alt_key_as_str;
 
   for (size_t i = 0; i < modifier_map.size(); ++i) {
     std::string* target = NULL;
     switch (modifier_map[i].original) {
       case kSearchKey:
         target = &use_search_key_as_str;
         break;
       case kLeftControlKey:
         target = &use_left_control_key_as_str;
         break;
       case kLeftAltKey:
         target = &use_left_alt_key_as_str;
         break;
       default:
         break;
     }
     if (!target) {
-      LOG(ERROR) << "We don't support remaping "
-                 << ModifierKeyToString(modifier_map[i].original);
+      DVLOG(1) << "We don't support remaping "
+               << ModifierKeyToString(modifier_map[i].original);
       return "";
     }
     if (!(target->empty())) {
-      LOG(ERROR) << ModifierKeyToString(modifier_map[i].original)
-                 << " appeared twice";
+      DVLOG(1) << ModifierKeyToString(modifier_map[i].original)
+               << " appeared twice";
       return "";
     }
     *target = ModifierKeyToString(modifier_map[i].replacement);
   }
 
   if (use_search_key_as_str.empty() ||
       use_left_control_key_as_str.empty() ||
       use_left_alt_key_as_str.empty()) {
-    LOG(ERROR) << "Incomplete ModifierMap: size=" << modifier_map.size();
+    DVLOG(1) << "Incomplete ModifierMap: size=" << modifier_map.size();
     return "";
   }
 
   if (KeepCapsLock(layout_name)) {
     use_search_key_as_str = ModifierKeyToString(kSearchKey);
   }
 
   std::string full_xkb_layout_name =
       base::StringPrintf("%s+chromeos(%s_%s_%s%s)",
                          layout_name.c_str(),
                          use_search_key_as_str.c_str(),
                          use_left_control_key_as_str.c_str(),
                          use_left_alt_key_as_str.c_str(),
                          (KeepRightAlt(layout_name) ? "_keepralt" : ""));
 
   return full_xkb_layout_name;
 }
 
 void XKeyboardImpl::SetLockedModifiers(ModifierLockStatus new_caps_lock_status,
                                        ModifierLockStatus new_num_lock_status) {
   CHECK(CurrentlyOnUIThread());
   if (!num_lock_mask_) {
-    LOG(ERROR) << "Cannot set locked modifiers. Num Lock mask unknown.";
+    DVLOG(1) << "Cannot set locked modifiers. Num Lock mask unknown.";
     return;
   }
 
   unsigned int affect_mask = 0;
   unsigned int value_mask = 0;
   if (new_caps_lock_status != kDontChange) {
     affect_mask |= LockMask;
     value_mask |= ((new_caps_lock_status == kEnableLock) ? LockMask : 0);
     current_caps_lock_status_ = (new_caps_lock_status == kEnableLock);
   }
@@ skipping 22 matching lines @@
     const std::string& layout_name) {
   if (SetLayoutInternal(layout_name, current_modifier_map_, false)) {
     current_layout_name_ = layout_name;
     return true;
   }
   return false;
 }
 
 bool XKeyboardImpl::ReapplyCurrentKeyboardLayout() {
   if (current_layout_name_.empty()) {
-    LOG(ERROR) << "Can't reapply XKB layout: layout unknown";
+    DVLOG(1) << "Can't reapply XKB layout: layout unknown";
     return false;
   }
   return SetLayoutInternal(
       current_layout_name_, current_modifier_map_, true /* force */);
 }
 
 void XKeyboardImpl::ReapplyCurrentModifierLockStatus() {
   SetLockedModifiers(current_caps_lock_status_ ? kEnableLock : kDisableLock,
                      current_num_lock_status_ ? kEnableLock : kDisableLock);
 }
@@ skipping 47 matching lines @@
       break;
   }
   return "";
 }
 
 // static
 void XKeyboardImpl::OnSetLayoutFinish(pid_t pid,
                                       int status,
                                       XKeyboardImpl* self) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  VLOG(1) << "OnSetLayoutFinish: pid=" << pid;
+  DVLOG(1) << "OnSetLayoutFinish: pid=" << pid;
   if (self->execute_queue_.empty()) {
-    LOG(ERROR) << "OnSetLayoutFinish: execute_queue_ is empty. "
-               << "base::LaunchProcess failed? pid=" << pid;
+    DVLOG(1) << "OnSetLayoutFinish: execute_queue_ is empty. "
+             << "base::LaunchProcess failed? pid=" << pid;
     return;
   }
   self->execute_queue_.pop();
   self->MaybeExecuteSetLayoutCommand();
 }
 
 }  // namespace
 
 // static
 bool XKeyboard::SetAutoRepeatEnabled(bool enabled) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (enabled) {
     XAutoRepeatOn(ui::GetXDisplay());
   } else {
     XAutoRepeatOff(ui::GetXDisplay());
   }
-  DLOG(INFO) << "Set auto-repeat mode to: " << (enabled ? "on" : "off");
+  DVLOG(1) << "Set auto-repeat mode to: " << (enabled ? "on" : "off");
   return true;
 }
 
 // static
 bool XKeyboard::SetAutoRepeatRate(const AutoRepeatRate& rate) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DLOG(INFO) << "Set auto-repeat rate to: "
-             << rate.initial_delay_in_ms << " ms delay, "
-             << rate.repeat_interval_in_ms << " ms interval";
+  DVLOG(1) << "Set auto-repeat rate to: "
+           << rate.initial_delay_in_ms << " ms delay, "
+           << rate.repeat_interval_in_ms << " ms interval";
   if (XkbSetAutoRepeatRate(ui::GetXDisplay(), XkbUseCoreKbd,
                            rate.initial_delay_in_ms,
                            rate.repeat_interval_in_ms) != True) {
-    LOG(ERROR) << "Failed to set auto-repeat rate";
+    DVLOG(1) << "Failed to set auto-repeat rate";
     return false;
   }
   return true;
 }
 
 // static
 bool XKeyboard::GetAutoRepeatEnabledForTesting() {
   XKeyboardState state = {};
   XGetKeyboardControl(ui::GetXDisplay(), &state);
   return state.global_auto_repeat != AutoRepeatModeOff;
@@ skipping 18 matching lines @@
   return false;
 }
 
 // static
 XKeyboard* XKeyboard::Create(const InputMethodUtil& util) {
   return new XKeyboardImpl(util);
 }
 
 }  // namespace input_method
 }  // namespace chromeos