Add a few missing overrides found by a new clang warning.

ui/base/ime/remote_input_method_win_unittest.cc

 // Copyright 2013 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 "ui/base/ime/remote_input_method_win.h"
 
 #include <InputScope.h>
 
 #include <vector>
 
@@ skipping 68 matching lines @@
   void set_composition_character_bounds(
       const std::vector<gfx::Rect>& composition_character_bounds) {
     composition_character_bounds_ = composition_character_bounds;
   }
   void set_emulate_pepper_flash(bool enabled) {
     emulate_pepper_flash_ = enabled;
   }
 
  private:
   // Overriden from DummyTextInputClient.
-  virtual void SetCompositionText(
-      const ui::CompositionText& composition) override {
+  void SetCompositionText(const ui::CompositionText& composition) override {
     ++call_count_set_composition_text_;
   }
-  virtual void InsertChar(base::char16 ch, int flags) override {
+  void InsertChar(base::char16 ch, int flags) override {
     inserted_text_.append(1, ch);
     ++call_count_insert_char_;
   }
-  virtual void InsertText(const base::string16& text) override {
+  void InsertText(const base::string16& text) override {
     inserted_text_.append(text);
     ++call_count_insert_text_;
   }
-  virtual ui::TextInputType GetTextInputType() const override {
+  ui::TextInputType GetTextInputType() const override {
     return text_input_type_;
   }
-  virtual ui::TextInputMode GetTextInputMode() const override {
+  ui::TextInputMode GetTextInputMode() const override {
     return text_input_mode_;
   }
-  virtual gfx::Rect GetCaretBounds() const {
-    return caret_bounds_;
-  }
-  virtual bool GetCompositionCharacterBounds(uint32 index,
-                                             gfx::Rect* rect) const override {
+  gfx::Rect GetCaretBounds() const override { return caret_bounds_; }
+  bool GetCompositionCharacterBounds(uint32 index,
+                                     gfx::Rect* rect) const override {
     // Emulate the situation of crbug.com/328237.
     if (emulate_pepper_flash_)
       return false;
     if (!rect || composition_character_bounds_.size() <= index)
       return false;
     *rect = composition_character_bounds_[index];
     return true;
   }
-  virtual bool HasCompositionText() const override {
+  bool HasCompositionText() const override {
     return !composition_character_bounds_.empty();
   }
-  virtual bool GetCompositionTextRange(gfx::Range* range) const override {
+  bool GetCompositionTextRange(gfx::Range* range) const override {
     if (composition_character_bounds_.empty())
       return false;
     *range = gfx::Range(0, composition_character_bounds_.size());
     return true;
   }
-  virtual void OnCandidateWindowShown() override {
+  void OnCandidateWindowShown() override {
     is_candidate_window_shown_called_ = true;
   }
-  virtual void OnCandidateWindowHidden() override {
+  void OnCandidateWindowHidden() override {
     is_candidate_window_hidden_called_ = true;
   }
 
   ui::TextInputType text_input_type_;
   ui::TextInputMode text_input_mode_;
   gfx::Rect caret_bounds_;
   std::vector<gfx::Rect> composition_character_bounds_;
   base::string16 inserted_text_;
   size_t call_count_set_composition_text_;
   size_t call_count_insert_char_;
   size_t call_count_insert_text_;
   bool emulate_pepper_flash_;
   bool is_candidate_window_shown_called_;
   bool is_candidate_window_hidden_called_;
   DISALLOW_COPY_AND_ASSIGN(MockTextInputClient);
 };
 
 class MockInputMethodDelegate : public internal::InputMethodDelegate {
  public:
   MockInputMethodDelegate() {}
 
   const std::vector<ui::KeyboardCode>& fabricated_key_events() const {
     return fabricated_key_events_;
   }
   void Reset() {
     fabricated_key_events_.clear();
   }
 
  private:
-  virtual bool DispatchKeyEventPostIME(const ui::KeyEvent& event) override {
+  bool DispatchKeyEventPostIME(const ui::KeyEvent& event) override {
     EXPECT_FALSE(event.HasNativeEvent());
     fabricated_key_events_.push_back(event.key_code());
     return true;
   }
 
   std::vector<ui::KeyboardCode> fabricated_key_events_;
   DISALLOW_COPY_AND_ASSIGN(MockInputMethodDelegate);
 };
 
 class MockRemoteInputMethodDelegateWin
@@ skipping 17 matching lines @@
     return composition_character_bounds_;
   }
   void Reset() {
     cancel_composition_called_ = false;
     text_input_client_updated_called_ = false;
     input_scopes_.clear();
     composition_character_bounds_.clear();
   }
 
  private:
-  virtual void CancelComposition() override {
-    cancel_composition_called_ = true;
-  }
+  void CancelComposition() override { cancel_composition_called_ = true; }
 
-  virtual void OnTextInputClientUpdated(
+  void OnTextInputClientUpdated(
       const std::vector<int32>& input_scopes,
       const std::vector<gfx::Rect>& composition_character_bounds) override {
     text_input_client_updated_called_ = true;
     input_scopes_ = input_scopes;
     composition_character_bounds_ = composition_character_bounds;
   }
 
   bool cancel_composition_called_;
   bool text_input_client_updated_called_;
   std::vector<int32> input_scopes_;
@@ skipping 15 matching lines @@
   }
   size_t on_text_input_state_changed() const {
     return on_text_input_state_changed_;
   }
   size_t on_input_method_destroyed_changed() const {
     return on_input_method_destroyed_changed_;
   }
 
  private:
   // Overriden from InputMethodObserver.
-  virtual void OnTextInputTypeChanged(const TextInputClient* client) override {
-  }
-  virtual void OnFocus() override {
-  }
-  virtual void OnBlur() override {
-  }
-  virtual void OnCaretBoundsChanged(const TextInputClient* client) override {
-  }
-  virtual void OnTextInputStateChanged(const TextInputClient* client) override {
+  void OnTextInputTypeChanged(const TextInputClient* client) override {}
+  void OnFocus() override {}
+  void OnBlur() override {}
+  void OnCaretBoundsChanged(const TextInputClient* client) override {}
+  void OnTextInputStateChanged(const TextInputClient* client) override {
     ++on_text_input_state_changed_;
   }
-  virtual void OnInputMethodDestroyed(const InputMethod* client) override {
+  void OnInputMethodDestroyed(const InputMethod* client) override {
     ++on_input_method_destroyed_changed_;
   }
-  virtual void OnShowImeIfNeeded() {
-  }
+  void OnShowImeIfNeeded() override {}
 
   size_t on_text_input_state_changed_;
   size_t on_input_method_destroyed_changed_;
   DISALLOW_COPY_AND_ASSIGN(MockInputMethodObserver);
 };
 
 typedef ScopedObserver<InputMethod, InputMethodObserver>
     InputMethodScopedObserver;
 
 TEST(RemoteInputMethodWinTest, RemoteInputMethodPrivateWin) {
@@ skipping 571 matching lines @@
   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
   input_method->AddObserver(&input_method_observer);
 
   EXPECT_EQ(0u, input_method_observer.on_input_method_destroyed_changed());
   input_method.reset();
   EXPECT_EQ(1u, input_method_observer.on_input_method_destroyed_changed());
 }
 
 }  // namespace
 }  // namespace ui