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

chrome/browser/chromeos/input_method/input_method_manager_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/input_method_manager_impl.h"
 
 #include <algorithm>  // std::find
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 88 matching lines @@
     const InputMethodDescriptor* descriptor =
         util_.GetInputMethodDescriptorFromId(input_method_id);
     if (descriptor) {
       result->push_back(*descriptor);
     } else {
       std::map<std::string, InputMethodDescriptor>::const_iterator ix =
           extra_input_methods_.find(input_method_id);
       if (ix != extra_input_methods_.end())
         result->push_back(ix->second);
       else
-        LOG(ERROR) << "Descriptor is not found for: " << input_method_id;
+        DVLOG(1) << "Descriptor is not found for: " << input_method_id;
     }
   }
   if (result->empty()) {
     // Initially |active_input_method_ids_| is empty. browser_tests might take
     // this path.
     result->push_back(
         InputMethodDescriptor::GetFallbackInputMethodDescriptor());
   }
   return result;
 }
@@ skipping 17 matching lines @@
   candidates.push_back(util_.GetHardwareInputMethodId());
 
   std::vector<std::string> layouts;
   // First, add the initial input method ID, if it's requested, to
   // layouts, so it appears first on the list of active input
   // methods at the input language status menu.
   if (util_.IsValidInputMethodId(initial_layout) &&
       InputMethodUtil::IsKeyboardLayout(initial_layout)) {
     layouts.push_back(initial_layout);
   } else if (!initial_layout.empty()) {
-    LOG(ERROR) << "EnableLayouts: ignoring non-keyboard or invalid ID: "
-               << initial_layout;
+    DVLOG(1) << "EnableLayouts: ignoring non-keyboard or invalid ID: "
+             << initial_layout;
   }
 
   // Add candidates to layouts, while skipping duplicates.
   for (size_t i = 0; i < candidates.size(); ++i) {
     const std::string& candidate = candidates[i];
     // Not efficient, but should be fine, as the two vectors are very
     // short (2-5 items).
     if (!Contains(layouts, candidate))
       layouts.push_back(candidate);
   }
 
   active_input_method_ids_.swap(layouts);
   ChangeInputMethod(initial_layout);  // you can pass empty |initial_layout|.
 }
 
 bool InputMethodManagerImpl::EnableInputMethods(
     const std::vector<std::string>& new_active_input_method_ids) {
   if (state_ == STATE_TERMINATING)
     return false;
 
   // Filter unknown or obsolete IDs.
   std::vector<std::string> new_active_input_method_ids_filtered;
 
   for (size_t i = 0; i < new_active_input_method_ids.size(); ++i) {
     const std::string& input_method_id = new_active_input_method_ids[i];
     if (util_.IsValidInputMethodId(input_method_id))
       new_active_input_method_ids_filtered.push_back(input_method_id);
     else
-      LOG(ERROR) << "EnableInputMethods: Invalid ID: " << input_method_id;
+      DVLOG(1) << "EnableInputMethods: Invalid ID: " << input_method_id;
   }
 
   if (new_active_input_method_ids_filtered.empty()) {
-    LOG(ERROR) << "EnableInputMethods: No valid input method ID";
+    DVLOG(1) << "EnableInputMethods: No valid input method ID";
     return false;
   }
 
   // Copy extension IDs to |new_active_input_method_ids_filtered|. We have to
   // keep relative order of the extension input method IDs.
   for (size_t i = 0; i < active_input_method_ids_.size(); ++i) {
     const std::string& input_method_id = active_input_method_ids_[i];
     if (InputMethodUtil::IsExtensionInputMethod(input_method_id))
       new_active_input_method_ids_filtered.push_back(input_method_id);
   }
@@ skipping 33 matching lines @@
     return;
 
   std::string input_method_id_to_switch = input_method_id;
 
   // Sanity check.
   if (!InputMethodIsActivated(input_method_id)) {
     scoped_ptr<InputMethodDescriptors> input_methods(GetActiveInputMethods());
     DCHECK(!input_methods->empty());
     input_method_id_to_switch = input_methods->at(0).id();
     if (!input_method_id.empty()) {
-      VLOG(1) << "Can't change the current input method to "
-              << input_method_id << " since the engine is not enabled. "
-              << "Switch to " << input_method_id_to_switch << " instead.";
+      DVLOG(1) << "Can't change the current input method to "
+               << input_method_id << " since the engine is not enabled. "
+               << "Switch to " << input_method_id_to_switch << " instead.";
     }
   }
 
   if (InputMethodUtil::IsKeyboardLayout(input_method_id_to_switch)) {
     FOR_EACH_OBSERVER(InputMethodManager::Observer,
                       observers_,
                       InputMethodPropertyChanged(this));
   } else {
     ibus_controller_->ChangeInputMethod(input_method_id_to_switch);
   }
@@ skipping 36 matching lines @@
 
 void InputMethodManagerImpl::AddInputMethodExtension(
     const std::string& id,
     const std::string& name,
     const std::vector<std::string>& layouts,
     const std::string& language) {
   if (state_ == STATE_TERMINATING)
     return;
 
   if (!InputMethodUtil::IsExtensionInputMethod(id)) {
-    LOG(ERROR) << id << " is not a valid extension input method ID.";
+    DVLOG(1) << id << " is not a valid extension input method ID.";
     return;
   }
 
   const std::string virtual_layouts = JoinString(layouts, ',');
   extra_input_methods_[id] = InputMethodDescriptor(
       whitelist_, id, name, virtual_layouts, language);
 
   if (!Contains(active_input_method_ids_, id)) {
     active_input_method_ids_.push_back(id);
   } else {
-    LOG(ERROR) << "AddInputMethodExtension: alread added: "
-               << id << ", " << name;
+    DVLOG(1) << "AddInputMethodExtension: alread added: "
+             << id << ", " << name;
     // Call Start() anyway, just in case.
   }
 
   // Ensure that the input method daemon is running.
   MaybeInitializeCandidateWindowController();
   ibus_controller_->Start();
 }
 
 void InputMethodManagerImpl::RemoveInputMethodExtension(const std::string& id) {
   if (!InputMethodUtil::IsExtensionInputMethod(id))
-    LOG(ERROR) << id << " is not a valid extension input method ID.";
+    DVLOG(1) << id << " is not a valid extension input method ID.";
 
   std::vector<std::string>::iterator i = std::find(
       active_input_method_ids_.begin(), active_input_method_ids_.end(), id);
   if (i != active_input_method_ids_.end())
     active_input_method_ids_.erase(i);
   extra_input_methods_.erase(id);
 
   if (ContainOnlyKeyboardLayout(active_input_method_ids_)) {
     // Do NOT call ibus_controller_->Stop(); here to work around a crash issue
     // at crosbug.com/27051.
@@ skipping 13 matching lines @@
 void InputMethodManagerImpl::DisableHotkeys() {
   ignore_hotkeys_ = true;
 }
 
 bool InputMethodManagerImpl::SwitchToNextInputMethod() {
   if (ignore_hotkeys_)
     return false;
 
   // Sanity checks.
   if (active_input_method_ids_.empty()) {
-    LOG(ERROR) << "active input method is empty";
+    DVLOG(1) << "active input method is empty";
     return false;
   }
   if (current_input_method_.id().empty()) {
-    LOG(ERROR) << "current_input_method_ is unknown";
+    DVLOG(1) << "current_input_method_ is unknown";
     return false;
   }
 
   // Find the next input method and switch to it.
   SwitchToNextInputMethodInternal(active_input_method_ids_,
                                   current_input_method_.id());
   return true;
 }
 
 bool InputMethodManagerImpl::SwitchToPreviousInputMethod() {
   if (ignore_hotkeys_)
     return false;
 
   // Sanity check.
   if (active_input_method_ids_.empty()) {
-    LOG(ERROR) << "active input method is empty";
+    DVLOG(1) << "active input method is empty";
     return false;
   }
 
   if (previous_input_method_.id().empty() ||
       previous_input_method_.id() == current_input_method_.id()) {
     return SwitchToNextInputMethod();
   }
 
   std::vector<std::string>::const_iterator iter =
       std::find(active_input_method_ids_.begin(),
                 active_input_method_ids_.end(),
                 previous_input_method_.id());
   if (iter == active_input_method_ids_.end()) {
     // previous_input_method_ is not supported.
     return SwitchToNextInputMethod();
   }
   ChangeInputMethod(*iter);
   return true;
 }
 
 bool InputMethodManagerImpl::SwitchInputMethod(
     const ui::Accelerator& accelerator) {
   if (ignore_hotkeys_)
     return false;
 
   // Sanity check.
   if (active_input_method_ids_.empty()) {
-    LOG(ERROR) << "active input method is empty";
+    DVLOG(1) << "active input method is empty";
     return false;
   }
 
   // Get the list of input method ids for the |accelerator|. For example, get
   // { "mozc-hangul", "xkb:kr:kr104:kor" } for ui::VKEY_DBE_SBCSCHAR.
   std::vector<std::string> input_method_ids_to_switch;
   switch (accelerator.key_code()) {
     case ui::VKEY_CONVERT:  // Henkan key on JP106 keyboard
       input_method_ids_to_switch.push_back("mozc-jp");
       break;
     case ui::VKEY_NONCONVERT:  // Muhenkan key on JP106 keyboard
       input_method_ids_to_switch.push_back("xkb:jp::jpn");
       break;
     case ui::VKEY_DBE_SBCSCHAR:  // ZenkakuHankaku key on JP106 keyboard
     case ui::VKEY_DBE_DBCSCHAR:
       input_method_ids_to_switch.push_back("mozc-jp");
       input_method_ids_to_switch.push_back("xkb:jp::jpn");
       break;
     case ui::VKEY_HANGUL:  // Hangul (or right Alt) key on Korean keyboard
     case ui::VKEY_SPACE:  // Shift+Space
       input_method_ids_to_switch.push_back("mozc-hangul");
       input_method_ids_to_switch.push_back("xkb:kr:kr104:kor");
       break;
     default:
       NOTREACHED();
       break;
   }
   if (input_method_ids_to_switch.empty()) {
-    LOG(ERROR) << "Unexpected VKEY: " << accelerator.key_code();
+    DVLOG(1) << "Unexpected VKEY: " << accelerator.key_code();
     return false;
   }
 
   // Obtain the intersection of input_method_ids_to_switch and
   // active_input_method_ids_. The order of IDs in active_input_method_ids_ is
   // preserved.
   std::vector<std::string> ids;
   for (size_t i = 0; i < input_method_ids_to_switch.size(); ++i) {
     const std::string& id = input_method_ids_to_switch[i];
     if (Contains(active_input_method_ids_, id))
@@ skipping 143 matching lines @@
 void InputMethodManagerImpl::MaybeInitializeCandidateWindowController() {
 #if !defined(USE_VIRTUAL_KEYBOARD)
   if (candidate_window_controller_.get())
     return;
 
   candidate_window_controller_.reset(
       CandidateWindowController::CreateCandidateWindowController());
   if (candidate_window_controller_->Init())
     candidate_window_controller_->AddObserver(this);
   else
-    LOG(WARNING) << "Failed to initialize the candidate window controller";
+    DVLOG(1) << "Failed to initialize the candidate window controller";
 #endif
 }
 
 // static
 InputMethodManagerImpl* InputMethodManagerImpl::GetInstanceForTesting() {
   return new InputMethodManagerImpl;
 }
 
 }  // namespace input_method
 }  // namespace chromeos