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

chrome/browser/extensions/api/messaging/native_message_process_host_unittest.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 "base/bind.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 63 matching lines @@
     write_flags |= base::File::FLAG_ASYNC;
 #endif
 
     return scoped_ptr<NativeProcessLauncher>(new FakeLauncher(
         read_pipe.Pass(),
         base::File(write_file, write_flags)));
   }
 
   virtual void Launch(const GURL& origin,
                       const std::string& native_host_name,
-                      LaunchedCallback callback) const OVERRIDE {
+                      LaunchedCallback callback) const override {
     callback.Run(NativeProcessLauncher::RESULT_SUCCESS,
                  base::kNullProcessHandle,
                  read_file_.Pass(), write_file_.Pass());
   }
 
  private:
   mutable base::File read_file_;
   mutable base::File write_file_;
 };
 
 class NativeMessagingTest : public ::testing::Test,
                             public NativeMessageProcessHost::Client,
                             public base::SupportsWeakPtr<NativeMessagingTest> {
  protected:
   NativeMessagingTest()
       : current_channel_(chrome::VersionInfo::CHANNEL_DEV),
         thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
         channel_closed_(false) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     if (native_message_process_host_.get()) {
       BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE,
                                 native_message_process_host_.release());
     }
     base::RunLoop().RunUntilIdle();
   }
 
   virtual void PostMessageFromNativeProcess(
       int port_id,
-      const std::string& message) OVERRIDE  {
+      const std::string& message) override  {
     last_message_ = message;
 
     // Parse the message.
     base::Value* parsed = base::JSONReader::Read(message);
     base::DictionaryValue* dict_value;
     if (parsed && parsed->GetAsDictionary(&dict_value)) {
       last_message_parsed_.reset(dict_value);
     } else {
       LOG(ERROR) << "Failed to parse " << message;
       last_message_parsed_.reset();
       delete parsed;
     }
 
     if (run_loop_)
       run_loop_->Quit();
   }
 
   virtual void CloseChannel(int port_id,
-                            const std::string& error_message) OVERRIDE {
+                            const std::string& error_message) override {
     channel_closed_ = true;
     if (run_loop_)
       run_loop_->Quit();
   }
 
  protected:
   std::string FormatMessage(const std::string& message) {
     uint32_t length = message.length();
     return std::string(reinterpret_cast<char*>(&length), 4).append(message);
   }
@@ skipping 164 matching lines @@
       ScopedTestNativeMessagingHost::kHostName, 0, false);
   ASSERT_TRUE(native_message_process_host_.get());
   run_loop_.reset(new base::RunLoop());
   run_loop_->Run();
 
   // The host should fail to start.
   ASSERT_TRUE(channel_closed_);
 }
 
 }  // namespace extensions