replace OVERRIDE and FINAL with override and final in chrome/browser/extensions/

chrome/browser/extensions/api/input_ime/input_ime_api.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/extensions/api/input_ime/input_ime_api.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/input_method/input_method_engine.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
@@ skipping 86 matching lines @@
 }  // namespace
 
 namespace chromeos {
 class ImeObserver : public InputMethodEngineInterface::Observer {
  public:
   explicit ImeObserver(const std::string& extension_id)
       : extension_id_(extension_id) {}
 
   virtual ~ImeObserver() {}
 
-  virtual void OnActivate(const std::string& component_id) OVERRIDE {
+  virtual void OnActivate(const std::string& component_id) override {
     if (extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(input_ime::OnActivate::Create(
         component_id,
         input_ime::OnActivate::ParseScreen(GetCurrentScreenType())));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnActivate::kEventName, args.Pass());
   }
 
-  virtual void OnDeactivated(const std::string& component_id) OVERRIDE {
+  virtual void OnDeactivated(const std::string& component_id) override {
     if (extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnDeactivated::Create(component_id));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnDeactivated::kEventName, args.Pass());
   }
 
   virtual void OnFocus(
-      const InputMethodEngineInterface::InputContext& context) OVERRIDE {
+      const InputMethodEngineInterface::InputContext& context) override {
     if (extension_id_.empty())
       return;
 
     input_ime::InputContext context_value;
     context_value.context_id = context.id;
     context_value.type = input_ime::InputContext::ParseType(context.type);
 
     scoped_ptr<base::ListValue> args(input_ime::OnFocus::Create(context_value));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnFocus::kEventName, args.Pass());
   }
 
-  virtual void OnBlur(int context_id) OVERRIDE {
+  virtual void OnBlur(int context_id) override {
     if (extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(input_ime::OnBlur::Create(context_id));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnBlur::kEventName, args.Pass());
   }
 
   virtual void OnInputContextUpdate(
-      const InputMethodEngineInterface::InputContext& context) OVERRIDE {
+      const InputMethodEngineInterface::InputContext& context) override {
     if (extension_id_.empty())
       return;
 
     input_ime::InputContext context_value;
     context_value.context_id = context.id;
     context_value.type = input_ime::InputContext::ParseType(context.type);
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnInputContextUpdate::Create(context_value));
 
     DispatchEventToExtension(extension_id_,
                              input_ime::OnInputContextUpdate::kEventName,
                              args.Pass());
   }
 
   virtual void OnKeyEvent(
       const std::string& component_id,
       const InputMethodEngineInterface::KeyboardEvent& event,
-      chromeos::input_method::KeyEventHandle* key_data) OVERRIDE {
+      chromeos::input_method::KeyEventHandle* key_data) override {
     if (extension_id_.empty())
       return;
 
     // If there is no listener for the event, no need to dispatch the event to
     // extension. Instead, releases the key event for default system behavior.
     if (!ShouldForwardKeyEvent()) {
       // Continue processing the key event so that the physical keyboard can
       // still work.
       CallbackKeyEventHandle(key_data, false);
       return;
@@ skipping 20 matching lines @@
     scoped_ptr<base::ListValue> args(
         input_ime::OnKeyEvent::Create(component_id, key_data_value));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnKeyEvent::kEventName, args.Pass());
   }
 
   virtual void OnCandidateClicked(
       const std::string& component_id,
       int candidate_id,
-      InputMethodEngineInterface::MouseButtonEvent button) OVERRIDE {
+      InputMethodEngineInterface::MouseButtonEvent button) override {
     if (extension_id_.empty())
       return;
 
     input_ime::OnCandidateClicked::Button button_enum =
         input_ime::OnCandidateClicked::BUTTON_NONE;
     switch (button) {
       case InputMethodEngineInterface::MOUSE_BUTTON_MIDDLE:
         button_enum = input_ime::OnCandidateClicked::BUTTON_MIDDLE;
         break;
 
       case InputMethodEngineInterface::MOUSE_BUTTON_RIGHT:
         button_enum = input_ime::OnCandidateClicked::BUTTON_RIGHT;
         break;
 
       case InputMethodEngineInterface::MOUSE_BUTTON_LEFT:
       // Default to left.
       default:
         button_enum = input_ime::OnCandidateClicked::BUTTON_LEFT;
         break;
     }
 
     scoped_ptr<base::ListValue> args(input_ime::OnCandidateClicked::Create(
         component_id, candidate_id, button_enum));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnCandidateClicked::kEventName, args.Pass());
   }
 
   virtual void OnMenuItemActivated(const std::string& component_id,
-                                   const std::string& menu_id) OVERRIDE {
+                                   const std::string& menu_id) override {
     if (extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnMenuItemActivated::Create(component_id, menu_id));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnMenuItemActivated::kEventName, args.Pass());
   }
 
   virtual void OnSurroundingTextChanged(const std::string& component_id,
                                         const std::string& text,
                                         int cursor_pos,
-                                        int anchor_pos) OVERRIDE {
+                                        int anchor_pos) override {
     if (extension_id_.empty())
       return;
 
     input_ime::OnSurroundingTextChanged::SurroundingInfo info;
     info.text = text;
     info.focus = cursor_pos;
     info.anchor = anchor_pos;
     scoped_ptr<base::ListValue> args(
         input_ime::OnSurroundingTextChanged::Create(component_id, info));
 
     DispatchEventToExtension(extension_id_,
                              input_ime::OnSurroundingTextChanged::kEventName,
                              args.Pass());
   }
 
-  virtual void OnReset(const std::string& component_id) OVERRIDE {
+  virtual void OnReset(const std::string& component_id) override {
     if (extension_id_.empty())
       return;
 
     scoped_ptr<base::ListValue> args(input_ime::OnReset::Create(component_id));
 
     DispatchEventToExtension(
         extension_id_, input_ime::OnReset::kEventName, args.Pass());
   }
 
  private:
@@ skipping 564 matching lines @@
   // Notifies the IME extension for IME ready with onActivate/onFocus events.
   if (engine)
     engine->Enable(engine->GetActiveComponentId());
 }
 
 InputImeEventRouter* InputImeAPI::input_ime_event_router() {
   return InputImeEventRouter::GetInstance();
 }
 
 }  // namespace extensions