replace OVERRIDE and FINAL with override and final in ui/

ui/base/ime/remote_input_method_win.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 "base/observer_list.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/metro.h"
 #include "base/win/scoped_handle.h"
@@ skipping 110 matching lines @@
 
   virtual ~RemoteInputMethodWin() {
     FOR_EACH_OBSERVER(InputMethodObserver,
                       observer_list_,
                       OnInputMethodDestroyed(this));
     UnregisterInstance(this);
   }
 
  private:
   // Overridden from InputMethod:
-  virtual void SetDelegate(internal::InputMethodDelegate* delegate) OVERRIDE {
+  virtual void SetDelegate(internal::InputMethodDelegate* delegate) override {
     delegate_ = delegate;
   }
 
-  virtual void Init(bool focused) OVERRIDE {
+  virtual void Init(bool focused) override {
   }
 
-  virtual void OnFocus() OVERRIDE {
+  virtual void OnFocus() override {
   }
 
-  virtual void OnBlur() OVERRIDE {
+  virtual void OnBlur() override {
   }
 
   virtual bool OnUntranslatedIMEMessage(const base::NativeEvent& event,
-                                        NativeEventResult* result) OVERRIDE {
+                                        NativeEventResult* result) override {
     return false;
   }
 
-  virtual void SetFocusedTextInputClient(TextInputClient* client) OVERRIDE {
+  virtual void SetFocusedTextInputClient(TextInputClient* client) override {
     std::vector<int32> prev_input_scopes;
     std::swap(input_scopes_, prev_input_scopes);
     std::vector<gfx::Rect> prev_bounds;
     std::swap(composition_character_bounds_, prev_bounds);
     if (client) {
       input_scopes_ = GetInputScopesAsInt(client->GetTextInputType(),
                                           client->GetTextInputMode());
       composition_character_bounds_ = GetCompositionCharacterBounds(client);
     }
 
     const bool text_input_client_changed = text_input_client_ != client;
     text_input_client_ = client;
     if (text_input_client_changed) {
       FOR_EACH_OBSERVER(InputMethodObserver,
                         observer_list_,
                         OnTextInputStateChanged(client));
     }
 
     if (!remote_delegate_ || (prev_input_scopes == input_scopes_ &&
                               prev_bounds == composition_character_bounds_))
       return;
     remote_delegate_->OnTextInputClientUpdated(input_scopes_,
                                                composition_character_bounds_);
   }
 
-  virtual void DetachTextInputClient(TextInputClient* client) OVERRIDE {
+  virtual void DetachTextInputClient(TextInputClient* client) override {
     if (text_input_client_ != client)
       return;
     SetFocusedTextInputClient(NULL);
   }
 
-  virtual TextInputClient* GetTextInputClient() const OVERRIDE {
+  virtual TextInputClient* GetTextInputClient() const override {
     return text_input_client_;
   }
 
-  virtual bool DispatchKeyEvent(const ui::KeyEvent& event) OVERRIDE {
+  virtual bool DispatchKeyEvent(const ui::KeyEvent& event) override {
     if (event.HasNativeEvent()) {
       const base::NativeEvent& native_key_event = event.native_event();
       if (native_key_event.message != WM_CHAR)
         return false;
       if (!text_input_client_)
         return false;
       text_input_client_->InsertChar(
           static_cast<base::char16>(native_key_event.wParam),
           ui::GetModifiersFromKeyState());
       return true;
     }
 
     if (event.is_char()) {
       if (text_input_client_) {
         text_input_client_->InsertChar(event.key_code(),
                                        ui::GetModifiersFromKeyState());
       }
       return true;
     }
     if (!delegate_)
       return false;
     return delegate_->DispatchKeyEventPostIME(event);
   }
 
-  virtual void OnTextInputTypeChanged(const TextInputClient* client) OVERRIDE {
+  virtual void OnTextInputTypeChanged(const TextInputClient* client) override {
     if (!text_input_client_ || text_input_client_ != client)
       return;
     std::vector<int32> prev_input_scopes;
     std::swap(input_scopes_, prev_input_scopes);
     input_scopes_ = GetInputScopesAsInt(client->GetTextInputType(),
                                         client->GetTextInputMode());
     if (input_scopes_ != prev_input_scopes && remote_delegate_) {
       remote_delegate_->OnTextInputClientUpdated(
           input_scopes_, composition_character_bounds_);
     }
   }
 
-  virtual void OnCaretBoundsChanged(const TextInputClient* client) OVERRIDE {
+  virtual void OnCaretBoundsChanged(const TextInputClient* client) override {
     if (!text_input_client_ || text_input_client_ != client)
       return;
     std::vector<gfx::Rect> prev_rects;
     std::swap(composition_character_bounds_, prev_rects);
     composition_character_bounds_ = GetCompositionCharacterBounds(client);
     if (composition_character_bounds_ != prev_rects && remote_delegate_) {
       remote_delegate_->OnTextInputClientUpdated(
           input_scopes_, composition_character_bounds_);
     }
   }
 
-  virtual void CancelComposition(const TextInputClient* client) OVERRIDE {
+  virtual void CancelComposition(const TextInputClient* client) override {
     if (CanSendRemoteNotification(client))
       remote_delegate_->CancelComposition();
   }
 
-  virtual void OnInputLocaleChanged() OVERRIDE {
+  virtual void OnInputLocaleChanged() override {
   }
 
-  virtual std::string GetInputLocale() OVERRIDE {
+  virtual std::string GetInputLocale() override {
     const LCID locale_id = MAKELCID(langid_, SORT_DEFAULT);
     std::string language =
         GetLocaleString(locale_id, LOCALE_SISO639LANGNAME);
     if (SUBLANGID(langid_) == SUBLANG_NEUTRAL || language.empty())
       return language;
     const std::string& region =
         GetLocaleString(locale_id, LOCALE_SISO3166CTRYNAME);
     if (region.empty())
       return language;
     return language.append(1, '-').append(region);
   }
 
-  virtual bool IsActive() OVERRIDE {
+  virtual bool IsActive() override {
     return true;  // always turned on
   }
 
-  virtual TextInputType GetTextInputType() const OVERRIDE {
+  virtual TextInputType GetTextInputType() const override {
     return text_input_client_ ? text_input_client_->GetTextInputType()
                               : TEXT_INPUT_TYPE_NONE;
   }
 
-  virtual TextInputMode GetTextInputMode() const OVERRIDE {
+  virtual TextInputMode GetTextInputMode() const override {
     return text_input_client_ ? text_input_client_->GetTextInputMode()
                               : TEXT_INPUT_MODE_DEFAULT;
   }
 
-  virtual bool CanComposeInline() const OVERRIDE {
+  virtual bool CanComposeInline() const override {
     return text_input_client_ ? text_input_client_->CanComposeInline() : true;
   }
 
-  virtual bool IsCandidatePopupOpen() const OVERRIDE {
+  virtual bool IsCandidatePopupOpen() const override {
     return is_candidate_popup_open_;
   }
 
-  virtual void ShowImeIfNeeded() OVERRIDE {
+  virtual void ShowImeIfNeeded() override {
   }
 
-  virtual void AddObserver(InputMethodObserver* observer) OVERRIDE {
+  virtual void AddObserver(InputMethodObserver* observer) override {
     observer_list_.AddObserver(observer);
   }
 
-  virtual void RemoveObserver(InputMethodObserver* observer) OVERRIDE {
+  virtual void RemoveObserver(InputMethodObserver* observer) override {
     observer_list_.RemoveObserver(observer);
   }
 
   // Overridden from RemoteInputMethodPrivateWin:
   virtual void SetRemoteDelegate(
-      internal::RemoteInputMethodDelegateWin* delegate) OVERRIDE{
+      internal::RemoteInputMethodDelegateWin* delegate) override{
     remote_delegate_ = delegate;
 
     // Sync initial state.
     if (remote_delegate_) {
       remote_delegate_->OnTextInputClientUpdated(
           input_scopes_, composition_character_bounds_);
     }
   }
 
-  virtual void OnCandidatePopupChanged(bool visible) OVERRIDE {
+  virtual void OnCandidatePopupChanged(bool visible) override {
     is_candidate_popup_open_ = visible;
     if (!text_input_client_)
       return;
     // TODO(kochi): Support 'update' case, in addition to show/hide.
     // http://crbug.com/238585
     if (visible)
       text_input_client_->OnCandidateWindowShown();
     else
       text_input_client_->OnCandidateWindowHidden();
   }
 
-  virtual void OnInputSourceChanged(LANGID langid, bool /*is_ime*/) OVERRIDE {
+  virtual void OnInputSourceChanged(LANGID langid, bool /*is_ime*/) override {
     // Note: Currently |is_ime| is not utilized yet.
     const bool changed = (langid_ != langid);
     langid_ = langid;
     if (changed && GetTextInputClient())
       GetTextInputClient()->OnInputMethodChanged();
   }
 
   virtual void OnCompositionChanged(
-      const CompositionText& composition_text) OVERRIDE {
+      const CompositionText& composition_text) override {
     if (!text_input_client_)
       return;
     text_input_client_->SetCompositionText(composition_text);
   }
 
-  virtual void OnTextCommitted(const base::string16& text) OVERRIDE {
+  virtual void OnTextCommitted(const base::string16& text) override {
     if (!text_input_client_)
       return;
     if (text_input_client_->GetTextInputType() == TEXT_INPUT_TYPE_NONE) {
       // According to the comment in text_input_client.h,
       // TextInputClient::InsertText should never be called when the
       // text input type is TEXT_INPUT_TYPE_NONE.
       for (size_t i = 0; i < text.size(); ++i)
         text_input_client_->InsertChar(text[i], 0);
       return;
     }
@@ skipping 42 matching lines @@
   return scoped_ptr<InputMethod>(new RemoteInputMethodWin(delegate));
 }
 
 // static
 RemoteInputMethodPrivateWin* RemoteInputMethodPrivateWin::Get(
     InputMethod* input_method) {
   return GetPrivate(input_method);
 }
 
 }  // namespace ui