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

chrome/browser/first_run/first_run.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/first_run/first_run.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 71 matching lines @@
 // This class acts as an observer for the ImporterProgressObserver::ImportEnded
 // callback. When the import process is started, certain errors may cause
 // ImportEnded() to be called synchronously, but the typical case is that
 // ImportEnded() is called asynchronously. Thus we have to handle both cases.
 class ImportEndedObserver : public importer::ImporterProgressObserver {
  public:
   ImportEndedObserver() : ended_(false) {}
   virtual ~ImportEndedObserver() {}
 
   // importer::ImporterProgressObserver:
-  virtual void ImportStarted() OVERRIDE {}
-  virtual void ImportItemStarted(importer::ImportItem item) OVERRIDE {}
-  virtual void ImportItemEnded(importer::ImportItem item) OVERRIDE {}
-  virtual void ImportEnded() OVERRIDE {
+  virtual void ImportStarted() override {}
+  virtual void ImportItemStarted(importer::ImportItem item) override {}
+  virtual void ImportItemEnded(importer::ImportItem item) override {}
+  virtual void ImportEnded() override {
     ended_ = true;
     if (!callback_for_import_end_.is_null())
       callback_for_import_end_.Run();
   }
 
   void set_callback_for_import_end(const base::Closure& callback) {
     callback_for_import_end_ = callback;
   }
 
   bool ended() const {
@@ skipping 23 matching lines @@
       registrar_.Add(this,
                      extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
                      content::NotificationService::AllSources());
     }
     registrar_.Add(this, chrome::NOTIFICATION_BROWSER_CLOSED,
                    content::NotificationService::AllSources());
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE {
+                       const content::NotificationDetails& details) override {
     // After processing the notification we always delete ourselves.
     if (type == extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED) {
       Profile* profile = content::Source<Profile>(source).ptr();
       ExtensionService* service =
           extensions::ExtensionSystem::Get(profile)->extension_service();
       DoExtensionWork(service);
     }
     delete this;
   }
 
@@ skipping 159 matching lines @@
   // instantiates a FirstRunBubbleLauncher, which manages its own lifetime.
   static void ShowFirstRunBubbleSoon();
 
  private:
   FirstRunBubbleLauncher();
   virtual ~FirstRunBubbleLauncher();
 
   // content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE;
+                       const content::NotificationDetails& details) override;
 
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(FirstRunBubbleLauncher);
 };
 
 // static
 void FirstRunBubbleLauncher::ShowFirstRunBubbleSoon() {
   SetShowFirstRunBubblePref(first_run::FIRST_RUN_BUBBLE_SHOW);
   // This FirstRunBubbleLauncher instance will manage its own lifetime.
@@ skipping 474 matching lines @@
   SetShouldDoPersonalDataManagerFirstRun();
 
   internal::DoPostImportPlatformSpecificTasks(profile);
 }
 
 uint16 auto_import_state() {
   return g_auto_import_state;
 }
 
 }  // namespace first_run