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

chrome/browser/extensions/api/braille_display_private/braille_display_private_apitest.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.
 
 #ifndef USE_BRLAPI
 #error This test requires brlapi.
 #endif
 
 #include <deque>
 
@@ skipping 51 matching lines @@
   // display size doubles and the controller gets notified of a brltty
   // restart.
   bool reappear_on_disconnect;
 };
 
 class MockBrlapiConnection : public BrlapiConnection {
  public:
   explicit MockBrlapiConnection(MockBrlapiConnectionData* data)
       : data_(data) {}
   virtual ConnectResult Connect(const OnDataReadyCallback& on_data_ready)
-      OVERRIDE {
+      override {
     data_->connected = true;
     on_data_ready_ = on_data_ready;
     if (!data_->pending_keys.empty()) {
       BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                               base::Bind(&MockBrlapiConnection::NotifyDataReady,
                                         base::Unretained(this)));
     }
     return CONNECT_SUCCESS;
   }
 
-  virtual void Disconnect() OVERRIDE {
+  virtual void Disconnect() override {
     data_->connected = false;
     if (data_->reappear_on_disconnect) {
       data_->display_size *= 2;
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&BrailleControllerImpl::PokeSocketDirForTesting,
                      base::Unretained(BrailleControllerImpl::GetInstance())));
     }
   }
 
-  virtual bool Connected() OVERRIDE {
+  virtual bool Connected() override {
     return data_->connected;
   }
 
-  virtual brlapi_error_t* BrlapiError() OVERRIDE {
+  virtual brlapi_error_t* BrlapiError() override {
     return &data_->error;
   }
 
-  virtual std::string BrlapiStrError() OVERRIDE {
+  virtual std::string BrlapiStrError() override {
     return data_->error.brlerrno != BRLAPI_ERROR_SUCCESS ? "Error" : "Success";
   }
 
-  virtual bool GetDisplaySize(size_t* size) OVERRIDE {
+  virtual bool GetDisplaySize(size_t* size) override {
     *size = data_->display_size;
     return true;
   }
 
-  virtual bool WriteDots(const unsigned char* cells) OVERRIDE {
+  virtual bool WriteDots(const unsigned char* cells) override {
     std::string written(reinterpret_cast<const char*>(cells),
                         data_->display_size);
     data_->written_content.push_back(written);
     return true;
   }
 
-  virtual int ReadKey(brlapi_keyCode_t* key_code) OVERRIDE {
+  virtual int ReadKey(brlapi_keyCode_t* key_code) override {
     if (!data_->pending_keys.empty()) {
       brlapi_keyCode_t queued_key_code = data_->pending_keys.front();
       data_->pending_keys.pop_front();
       if (queued_key_code == kErrorKeyCode) {
         data_->error.brlerrno = BRLAPI_ERROR_EOF;
         return -1;  // Signal error.
       }
       *key_code = queued_key_code;
       return 1;
     } else {
@@ skipping 11 matching lines @@
                                         base::Unretained(this)));
     }
   }
 
   MockBrlapiConnectionData* data_;
   OnDataReadyCallback on_data_ready_;
 };
 
 class BrailleDisplayPrivateApiTest : public ExtensionApiTest {
  public:
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+  virtual void SetUpInProcessBrowserTestFixture() override {
     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
     connection_data_.connected = false;
     connection_data_.display_size = 0;
     connection_data_.error.brlerrno = BRLAPI_ERROR_SUCCESS;
     connection_data_.reappear_on_disconnect = false;
     BrailleControllerImpl::GetInstance()->SetCreateBrlapiConnectionForTesting(
         base::Bind(
             &BrailleDisplayPrivateApiTest::CreateBrlapiConnection,
             base::Unretained(this)));
     DisableAccessibilityManagerBraille();
@@ skipping 100 matching lines @@
 IN_PROC_BROWSER_TEST_F(BrailleDisplayPrivateApiTest, DisplayStateChanges) {
   connection_data_.display_size = 11;
   connection_data_.pending_keys.push_back(kErrorKeyCode);
   connection_data_.reappear_on_disconnect = true;
   ASSERT_TRUE(RunComponentExtensionTest(
       "braille_display_private/display_state_changes"));
 }
 
 class BrailleDisplayPrivateAPIUserTest : public BrailleDisplayPrivateApiTest {
  public:
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     command_line->AppendSwitch(chromeos::switches::kLoginManager);
     command_line->AppendSwitchASCII(chromeos::switches::kLoginProfile,
                                     TestingProfile::kTestUserProfileDir);
   }
 
   class MockEventDelegate : public BrailleDisplayPrivateAPI::EventDelegate {
    public:
     MockEventDelegate() : event_count_(0) {}
 
     int GetEventCount() { return event_count_; }
 
-    virtual void BroadcastEvent(scoped_ptr<Event> event) OVERRIDE {
+    virtual void BroadcastEvent(scoped_ptr<Event> event) override {
       ++event_count_;
     }
-    virtual bool HasListener() OVERRIDE { return true; }
+    virtual bool HasListener() override { return true; }
 
    private:
     int event_count_;
   };
 
   MockEventDelegate* SetMockEventDelegate(BrailleDisplayPrivateAPI* api) {
     MockEventDelegate* delegate = new MockEventDelegate();
     api->SetEventDelegateForTest(
         scoped_ptr<BrailleDisplayPrivateAPI::EventDelegate>(delegate).Pass());
     return delegate;
@@ skipping 14 matching lines @@
     ScreenLocker::Hide();
     content::WindowedNotificationObserver lock_state_observer(
         chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED,
         content::NotificationService::AllSources());
     if (tester->IsLocked())
       lock_state_observer.Wait();
     ASSERT_FALSE(tester->IsLocked());
   }
 
  protected:
-  virtual void DisableAccessibilityManagerBraille() OVERRIDE {
+  virtual void DisableAccessibilityManagerBraille() override {
     // Let the accessibility manager behave as usual for these tests.
   }
 };
 
 IN_PROC_BROWSER_TEST_F(BrailleDisplayPrivateAPIUserTest,
                        KeyEventOnLockScreen) {
   scoped_ptr<ScreenLockerTester> tester(ScreenLocker::GetTester());
   // Log in.
   user_manager::UserManager::Get()->UserLoggedIn(
       kTestUserName, kTestUserName, true);
@@ skipping 32 matching lines @@
   DismissLockScreen(tester.get());
   signin_api.OnBrailleKeyEvent(key_event);
   user_api.OnBrailleKeyEvent(key_event);
   EXPECT_EQ(1, signin_delegate->GetEventCount());
   EXPECT_EQ(2, user_delegate->GetEventCount());
 }
 
 }  // namespace braille_display_private
 }  // namespace api
 }  // namespace extensions