Standardize usage of virtual/override/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 60 matching lines @@
     int write_flags = base::File::FLAG_CREATE | base::File::FLAG_WRITE;
 #if !defined(OS_POSIX)
     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 {
+  void Launch(const GURL& origin,
+              const std::string& native_host_name,
+              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_;
 };
 
@@ skipping 11 matching lines @@
   }
 
   virtual void TearDown() override {
     if (native_message_host_.get()) {
       BrowserThread::DeleteSoon(
           BrowserThread::IO, FROM_HERE, native_message_host_.release());
     }
     base::RunLoop().RunUntilIdle();
   }
 
-  virtual void PostMessageFromNativeHost(const std::string& message) override {
+  void PostMessageFromNativeHost(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(const std::string& error_message) override {
+  void CloseChannel(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 184 matching lines @@
   native_message_host_->Start(this);
   ASSERT_TRUE(native_message_host_.get());
   run_loop_.reset(new base::RunLoop());
   run_loop_->Run();
 
   // The host should fail to start.
   ASSERT_TRUE(channel_closed_);
 }
 
 }  // namespace extensions