replace OVERRIDE and FINAL with override and final in chrome/browser/[a-i]*

chrome/browser/apps/app_shim/app_shim_host_mac_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 "chrome/browser/apps/app_shim/app_shim_host_mac.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_vector.h"
 #include "chrome/common/mac/app_shim_messages.h"
 #include "ipc/ipc_message.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class TestingAppShimHost : public AppShimHost {
  public:
   TestingAppShimHost() {}
   virtual ~TestingAppShimHost() {}
 
   bool ReceiveMessage(IPC::Message* message);
 
   const std::vector<IPC::Message*>& sent_messages() {
     return sent_messages_.get();
   }
 
  protected:
-  virtual bool Send(IPC::Message* message) OVERRIDE;
+  virtual bool Send(IPC::Message* message) override;
 
  private:
   ScopedVector<IPC::Message> sent_messages_;
 
   DISALLOW_COPY_AND_ASSIGN(TestingAppShimHost);
 };
 
 bool TestingAppShimHost::ReceiveMessage(IPC::Message* message) {
   bool handled = OnMessageReceived(*message);
   delete message;
@@ skipping 37 matching lines @@
     return param.a;
   }
 
   void SimulateDisconnect() {
     implicit_cast<IPC::Listener*>(host_.release())->OnChannelError();
   }
 
  protected:
   virtual void OnShimLaunch(Host* host,
                             apps::AppShimLaunchType launch_type,
-                            const std::vector<base::FilePath>& file) OVERRIDE {
+                            const std::vector<base::FilePath>& file) override {
     ++launch_count_;
     if (launch_type == apps::APP_SHIM_LAUNCH_NORMAL)
       ++launch_now_count_;
     host->OnAppLaunchComplete(launch_result_);
   }
 
-  virtual void OnShimClose(Host* host) OVERRIDE { ++close_count_; }
+  virtual void OnShimClose(Host* host) override { ++close_count_; }
 
   virtual void OnShimFocus(Host* host,
                            apps::AppShimFocusType focus_type,
-                           const std::vector<base::FilePath>& file) OVERRIDE {
+                           const std::vector<base::FilePath>& file) override {
     ++focus_count_;
   }
 
-  virtual void OnShimSetHidden(Host* host, bool hidden) OVERRIDE {}
+  virtual void OnShimSetHidden(Host* host, bool hidden) override {}
 
-  virtual void OnShimQuit(Host* host) OVERRIDE { ++quit_count_; }
+  virtual void OnShimQuit(Host* host) override { ++quit_count_; }
 
   apps::AppShimLaunchResult launch_result_;
   int launch_count_;
   int launch_now_count_;
   int close_count_;
   int focus_count_;
   int quit_count_;
 
  private:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     testing::Test::SetUp();
     host_.reset(new TestingAppShimHost());
   }
 
   scoped_ptr<TestingAppShimHost> host_;
 
   DISALLOW_COPY_AND_ASSIGN(AppShimHostTest);
 };
 
 
@@ skipping 41 matching lines @@
   apps::AppShimHandler::RemoveHandler(kTestAppId);
 }
 
 TEST_F(AppShimHostTest, TestFailLaunch) {
   apps::AppShimHandler::RegisterHandler(kTestAppId, this);
   launch_result_ = apps::APP_SHIM_LAUNCH_APP_NOT_FOUND;
   LaunchApp(apps::APP_SHIM_LAUNCH_NORMAL);
   EXPECT_EQ(apps::APP_SHIM_LAUNCH_APP_NOT_FOUND, GetLaunchResult());
   apps::AppShimHandler::RemoveHandler(kTestAppId);
 }