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

chrome/browser/chromeos/input_method/input_method_engine.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_engine.h"
 
 #include <map>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 330 matching lines @@
 
 bool InputMethodEngineImpl::SetMenuItems(const std::vector<MenuItem>& items) {
   std::vector<input_method::IBusEngineController::EngineProperty*> properties;
 
   for (std::vector<MenuItem>::const_iterator item = items.begin();
        item != items.end(); ++item) {
     input_method::IBusEngineController::EngineProperty* property =
         new input_method::IBusEngineController::EngineProperty;
     if (!MenuItemToProperty(*item, property)) {
       delete property;
-      LOG(ERROR) << "Bad menu item";
+      DVLOG(1) << "Bad menu item";
       return false;
     }
     properties.push_back(property);
   }
   return connection_->RegisterProperties(properties);
 }
 
 bool InputMethodEngineImpl::MenuItemToProperty(
     const MenuItem& item,
     input_method::IBusEngineController::EngineProperty* property) {
@@ skipping 47 matching lines @@
     property->modified |=
         input_method::IBusEngineController::PROPERTY_MODIFIED_CHECKED;
   }
 
   for (std::vector<MenuItem>::const_iterator child = item.children.begin();
        child != item.children.end(); ++child) {
     input_method::IBusEngineController::EngineProperty* new_property =
         new input_method::IBusEngineController::EngineProperty;
     if (!MenuItemToProperty(*child, new_property)) {
       delete new_property;
-      LOG(ERROR) << "Bad menu item child";
+      DVLOG(1) << "Bad menu item child";
       return false;
     }
     property->children.push_back(new_property);
   }
 
   return true;
 }
 
 bool InputMethodEngineImpl::UpdateMenuItems(
     const std::vector<MenuItem>& items) {
   std::vector<input_method::IBusEngineController::EngineProperty*> properties;
 
   for (std::vector<MenuItem>::const_iterator item = items.begin();
        item != items.end(); ++item) {
     input_method::IBusEngineController::EngineProperty* new_property =
         new input_method::IBusEngineController::EngineProperty();
     if (!MenuItemToProperty(*item, new_property)) {
-      LOG(ERROR) << "Bad menu item";
+      DVLOG(1) << "Bad menu item";
       delete new_property;
       return false;
     }
     properties.push_back(new_property);
   }
   return connection_->UpdateProperties(properties);
 }
 
 void InputMethodEngineImpl::KeyEventDone(input_method::KeyEventHandle* key_data,
                                          bool handled) {
@@ skipping 58 matching lines @@
   }
 
   MouseButtonEvent pressed_button;
   if (button & input_method::IBusEngineController::MOUSE_BUTTON_1_MASK) {
     pressed_button = MOUSE_BUTTON_LEFT;
   } else if (button & input_method::IBusEngineController::MOUSE_BUTTON_2_MASK) {
     pressed_button = MOUSE_BUTTON_MIDDLE;
   } else if (button & input_method::IBusEngineController::MOUSE_BUTTON_3_MASK) {
     pressed_button = MOUSE_BUTTON_RIGHT;
   } else {
-    LOG(ERROR) << "Unknown button: " << button;
+    DVLOG(1) << "Unknown button: " << button;
     pressed_button = MOUSE_BUTTON_LEFT;
   }
 
   observer_->OnCandidateClicked(
       engine_id_, candidate_ids_.at(index), pressed_button);
 }
 
 class InputMethodEngineStub : public InputMethodEngine {
  public:
   InputMethodEngineStub()
       : observer_(NULL), active_(false), next_context_id_(1),
         context_id_(-1) {}
 
   ~InputMethodEngineStub() {
   }
 
   bool Init(InputMethodEngine::Observer* observer,
             const char* engine_name,
             const char* extension_id,
             const char* engine_id,
             const char* description,
             const char* language,
             const std::vector<std::string>& layouts,
             std::string* error) {
-    VLOG(0) << "Init";
+    DVLOG(1) << "Init";
     return true;
   }
 
   virtual bool SetComposition(int context_id,
                               const char* text, int selection_start,
                               int selection_end, int cursor,
                               const std::vector<SegmentInfo>& segments,
                               std::string* error) {
-    VLOG(0) << "SetComposition";
+    DVLOG(1) << "SetComposition";
     return true;
   }
 
   virtual bool ClearComposition(int context_id, std::string* error) {
-    VLOG(0) << "ClearComposition";
+    DVLOG(1) << "ClearComposition";
     return true;
   }
 
   virtual bool CommitText(int context_id,
                           const char* text, std::string* error) {
-    VLOG(0) << "CommitText";
+    DVLOG(1) << "CommitText";
     return true;
   }
 
   virtual bool SetCandidateWindowVisible(bool visible, std::string* error) {
-    VLOG(0) << "SetCandidateWindowVisible";
+    DVLOG(1) << "SetCandidateWindowVisible";
     return true;
   }
 
   virtual void SetCandidateWindowCursorVisible(bool visible) {
-    VLOG(0) << "SetCandidateWindowCursorVisible";
+    DVLOG(1) << "SetCandidateWindowCursorVisible";
   }
 
   virtual void SetCandidateWindowVertical(bool vertical) {
-    VLOG(0) << "SetCandidateWindowVertical";
+    DVLOG(1) << "SetCandidateWindowVertical";
   }
 
   virtual void SetCandidateWindowPageSize(int size) {
-    VLOG(0) << "SetCandidateWindowPageSize";
+    DVLOG(1) << "SetCandidateWindowPageSize";
   }
 
   virtual void SetCandidateWindowAuxText(const char* text) {
-    VLOG(0) << "SetCandidateWindowAuxText";
+    DVLOG(1) << "SetCandidateWindowAuxText";
   }
 
   virtual void SetCandidateWindowAuxTextVisible(bool visible) {
-    VLOG(0) << "SetCandidateWindowAuxTextVisible";
+    DVLOG(1) << "SetCandidateWindowAuxTextVisible";
   }
 
   virtual bool SetCandidates(int context_id,
                              const std::vector<Candidate>& candidates,
                              std::string* error) {
-    VLOG(0) << "SetCandidates";
+    DVLOG(1) << "SetCandidates";
     return true;
   }
 
   virtual bool SetCursorPosition(int context_id, int candidate_id,
                                  std::string* error) {
-    VLOG(0) << "SetCursorPosition";
+    DVLOG(1) << "SetCursorPosition";
     return true;
   }
 
   virtual bool SetMenuItems(const std::vector<MenuItem>& items) {
-    VLOG(0) << "SetMenuItems";
+    DVLOG(1) << "SetMenuItems";
     return true;
   }
 
   virtual bool UpdateMenuItems(const std::vector<MenuItem>& items) {
-    VLOG(0) << "UpdateMenuItems";
+    DVLOG(1) << "UpdateMenuItems";
     return true;
   }
 
   virtual bool IsActive() const {
-    VLOG(0) << "IsActive";
+    DVLOG(1) << "IsActive";
     return active_;
   }
 
   virtual void KeyEventDone(input_method::KeyEventHandle* key_data,
                             bool handled) {
   }
 
  private:
   // Pointer to the object recieving events for this IME.
   InputMethodEngine::Observer* observer_;
@@ skipping 22 matching lines @@
     std::string* error) {
 
 #if defined(HAVE_IBUS)
   InputMethodEngineImpl* new_engine = new InputMethodEngineImpl();
 #else
   InputMethodEngineStub* new_engine = new InputMethodEngineStub();
 #endif
 
   if (!new_engine->Init(observer, engine_name, extension_id, engine_id,
                         description, language, layouts, error)) {
-    LOG(ERROR) << "Init() failed.";
+    DVLOG(1) << "Init() failed.";
     delete new_engine;
     new_engine = NULL;
   }
 
   return new_engine;
 }
 
 }  // namespace chromeos