Update {virtual,override,final} to follow C++11 style in ui.

ui/base/ime/input_method_chromeos_unittest.cc

 // Copyright 2014 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/input_method_chromeos.h"
 
 #include <X11/Xlib.h>
 #undef Bool
 #undef FocusIn
 #undef FocusOut
@@ skipping 62 matching lines @@
         process_key_event_post_ime_call_count_(0) {
   }
 
   struct ProcessKeyEventPostIMEArgs {
     ProcessKeyEventPostIMEArgs() : event(NULL), handled(false) {}
     const ui::KeyEvent* event;
     bool handled;
   };
 
   // Overridden from InputMethodChromeOS:
-  virtual void ProcessKeyEventPostIME(const ui::KeyEvent& key_event,
-                                      bool handled) override {
+  void ProcessKeyEventPostIME(const ui::KeyEvent& key_event,
+                              bool handled) override {
     process_key_event_post_ime_args_.event = &key_event;
     process_key_event_post_ime_args_.handled = handled;
     ++process_key_event_post_ime_call_count_;
   }
 
   void ResetCallCount() {
     process_key_event_post_ime_call_count_ = 0;
   }
 
   const ProcessKeyEventPostIMEArgs& process_key_event_post_ime_args() const {
@@ skipping 106 matching lines @@
 
 class InputMethodChromeOSTest : public internal::InputMethodDelegate,
                                 public testing::Test,
                                 public TextInputClient {
  public:
   InputMethodChromeOSTest()
       : dispatched_key_event_(ui::ET_UNKNOWN, ui::VKEY_UNKNOWN, ui::EF_NONE) {
     ResetFlags();
   }
 
-  virtual ~InputMethodChromeOSTest() {
-  }
+  ~InputMethodChromeOSTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     chromeos::IMEBridge::Initialize();
 
     mock_ime_engine_handler_.reset(
         new chromeos::MockIMEEngineHandler());
     chromeos::IMEBridge::Get()->SetCurrentEngineHandler(
         mock_ime_engine_handler_.get());
 
     mock_ime_candidate_window_handler_.reset(
         new chromeos::MockIMECandidateWindowHandler());
     chromeos::IMEBridge::Get()->SetCandidateWindowHandler(
         mock_ime_candidate_window_handler_.get());
 
     ime_.reset(new TestableInputMethodChromeOS(this));
     if (switches::IsTextInputFocusManagerEnabled())
       TextInputFocusManager::GetInstance()->FocusTextInputClient(this);
     else
       ime_->SetFocusedTextInputClient(this);
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     if (ime_.get()) {
       if (switches::IsTextInputFocusManagerEnabled())
         TextInputFocusManager::GetInstance()->BlurTextInputClient(this);
       else
         ime_->SetFocusedTextInputClient(NULL);
     }
     ime_.reset();
     chromeos::IMEBridge::Get()->SetCurrentEngineHandler(NULL);
     chromeos::IMEBridge::Get()->SetCandidateWindowHandler(NULL);
     mock_ime_engine_handler_.reset();
     mock_ime_candidate_window_handler_.reset();
     chromeos::IMEBridge::Shutdown();
   }
 
   // Overridden from ui::internal::InputMethodDelegate:
-  virtual bool DispatchKeyEventPostIME(const ui::KeyEvent& event) override {
+  bool DispatchKeyEventPostIME(const ui::KeyEvent& event) override {
     dispatched_key_event_ = event;
     return false;
   }
 
   // Overridden from ui::TextInputClient:
-  virtual void SetCompositionText(
-      const CompositionText& composition) override {
+  void SetCompositionText(const CompositionText& composition) override {
     composition_text_ = composition;
   }
-  virtual void ConfirmCompositionText() override {
+  void ConfirmCompositionText() override {
     confirmed_text_ = composition_text_;
     composition_text_.Clear();
   }
-  virtual void ClearCompositionText() override {
-    composition_text_.Clear();
-  }
-  virtual void InsertText(const base::string16& text) override {
+  void ClearCompositionText() override { composition_text_.Clear(); }
+  void InsertText(const base::string16& text) override {
     inserted_text_ = text;
   }
-  virtual void InsertChar(base::char16 ch, int flags) override {
+  void InsertChar(base::char16 ch, int flags) override {
     inserted_char_ = ch;
     inserted_char_flags_ = flags;
   }
-  virtual gfx::NativeWindow GetAttachedWindow() const override {
+  gfx::NativeWindow GetAttachedWindow() const override {
     return static_cast<gfx::NativeWindow>(NULL);
   }
-  virtual TextInputType GetTextInputType() const override {
-    return input_type_;
-  }
-  virtual TextInputMode GetTextInputMode() const override {
-    return input_mode_;
-  }
-  virtual int GetTextInputFlags() const override {
-    return 0;
-  }
-  virtual bool CanComposeInline() const override {
-    return can_compose_inline_;
-  }
-  virtual gfx::Rect GetCaretBounds() const override {
-    return caret_bounds_;
-  }
-  virtual bool GetCompositionCharacterBounds(uint32 index,
-                                             gfx::Rect* rect) const override {
+  TextInputType GetTextInputType() const override { return input_type_; }
+  TextInputMode GetTextInputMode() const override { return input_mode_; }
+  int GetTextInputFlags() const override { return 0; }
+  bool CanComposeInline() const override { return can_compose_inline_; }
+  gfx::Rect GetCaretBounds() const override { return caret_bounds_; }
+  bool GetCompositionCharacterBounds(uint32 index,
+                                     gfx::Rect* rect) const override {
     return false;
   }
-  virtual bool HasCompositionText() const override {
+  bool HasCompositionText() const override {
     CompositionText empty;
     return composition_text_ != empty;
   }
-  virtual bool GetTextRange(gfx::Range* range) const override {
+  bool GetTextRange(gfx::Range* range) const override {
     *range = text_range_;
     return true;
   }
-  virtual bool GetCompositionTextRange(gfx::Range* range) const override {
+  bool GetCompositionTextRange(gfx::Range* range) const override {
     return false;
   }
-  virtual bool GetSelectionRange(gfx::Range* range) const override {
+  bool GetSelectionRange(gfx::Range* range) const override {
     *range = selection_range_;
     return true;
   }
 
-  virtual bool SetSelectionRange(const gfx::Range& range) override {
-    return false;
-  }
-  virtual bool DeleteRange(const gfx::Range& range) override { return false; }
-  virtual bool GetTextFromRange(const gfx::Range& range,
-                                base::string16* text) const override {
+  bool SetSelectionRange(const gfx::Range& range) override { return false; }
+  bool DeleteRange(const gfx::Range& range) override { return false; }
+  bool GetTextFromRange(const gfx::Range& range,
+                        base::string16* text) const override {
     *text = surrounding_text_.substr(range.GetMin(), range.length());
     return true;
   }
-  virtual void OnInputMethodChanged() override {
+  void OnInputMethodChanged() override {
     ++on_input_method_changed_call_count_;
   }
-  virtual bool ChangeTextDirectionAndLayoutAlignment(
-      base::i18n::TextDirection direction) override { return false; }
-  virtual void ExtendSelectionAndDelete(size_t before,
-                                        size_t after) override {}
-  virtual void EnsureCaretInRect(const gfx::Rect& rect) override {}
-  virtual void OnCandidateWindowShown() override {}
-  virtual void OnCandidateWindowUpdated() override {}
-  virtual void OnCandidateWindowHidden() override {}
-  virtual bool IsEditingCommandEnabled(int command_id) override {
+  bool ChangeTextDirectionAndLayoutAlignment(
+      base::i18n::TextDirection direction) override {
     return false;
   }
-  virtual void ExecuteEditingCommand(int command_id) override {}
+  void ExtendSelectionAndDelete(size_t before, size_t after) override {}
+  void EnsureCaretInRect(const gfx::Rect& rect) override {}
+  void OnCandidateWindowShown() override {}
+  void OnCandidateWindowUpdated() override {}
+  void OnCandidateWindowHidden() override {}
+  bool IsEditingCommandEnabled(int command_id) override { return false; }
+  void ExecuteEditingCommand(int command_id) override {}
 
   bool HasNativeEvent() const {
     return dispatched_key_event_.HasNativeEvent();
   }
 
   void ResetFlags() {
     dispatched_key_event_ = ui::KeyEvent(ui::ET_UNKNOWN, ui::VKEY_UNKNOWN,
                                          ui::EF_NONE);
 
     composition_text_.Clear();
@@ skipping 594 matching lines @@
 
   // Should not be called twice with same condition.
   ime_->OnCaretBoundsChanged(this);
   EXPECT_EQ(0,
             mock_ime_engine_handler_->set_surrounding_text_call_count());
 }
 
 class InputMethodChromeOSKeyEventTest : public InputMethodChromeOSTest {
  public:
   InputMethodChromeOSKeyEventTest() {}
-  virtual ~InputMethodChromeOSKeyEventTest() {}
+  ~InputMethodChromeOSKeyEventTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     InputMethodChromeOSTest::SetUp();
     ime_->Init(true);
   }
 
   DISALLOW_COPY_AND_ASSIGN(InputMethodChromeOSKeyEventTest);
 };
 
 TEST_F(InputMethodChromeOSKeyEventTest, KeyEventDelayResponseTest) {
   const int kFlags = ui::EF_SHIFT_DOWN;
   ScopedXI2Event xevent;
@@ skipping 103 matching lines @@
   ime_->ResetContext();
 
   // Do callback.
   mock_ime_engine_handler_->last_passed_callback().Run(true);
 
   EXPECT_EQ(0, ime_->process_key_event_post_ime_call_count());
 }
 // TODO(nona): Introduce ProcessKeyEventPostIME tests(crbug.com/156593).
 
 }  // namespace ui