Update {virtual,override} to follow C++11 style in chrome.

The Google style guide states that only one of {virtual,override,final} should be used for each declaration, since override implies virtual and final implies both virtual and override.

This patch was manually generated using a regex and a text editor.

BUG=417463

Review URL: https://codereview.chromium.org/1100223002

Cr-Commit-Position: refs/heads/master@{#326870}

2 files changed, 44 insertions, 47 deletions

diff --git a/chrome/test/logging/win/log_file_printer.cc b/chrome/test/logging/win/log_file_printer.cc
index fc2fb48..943712a 100644
--- a/chrome/test/logging/win/log_file_printer.cc
+++ b/chrome/test/logging/win/log_file_printer.cc
@@ -87,34 +87,34 @@ const char* GetTraceTypeString(char event_type) {
 class EventPrinter : public logging_win::LogFileDelegate {
  public:
   explicit EventPrinter(std::ostream* out);
-  virtual ~EventPrinter();
-
-  virtual void OnUnknownEvent(const EVENT_TRACE* event) override;
-
-  virtual void OnUnparsableEvent(const EVENT_TRACE* event) override;
-
-  virtual void OnFileHeader(const EVENT_TRACE* event,
-                            const TRACE_LOGFILE_HEADER* header) override;
-
-  virtual void OnLogMessage(const EVENT_TRACE* event,
-                            logging::LogSeverity severity,
-                            const base::StringPiece& message) override;
-
-  virtual void OnLogMessageFull(const EVENT_TRACE* event,
-                                logging::LogSeverity severity,
-                                DWORD stack_depth,
-                                const intptr_t* backtrace,
-                                int line,
-                                const base::StringPiece& file,
-                                const base::StringPiece& message) override;
-
-  virtual void OnTraceEvent(const EVENT_TRACE* event,
-                            const base::StringPiece& name,
-                            char type,
-                            intptr_t id,
-                            const base::StringPiece& extra,
-                            DWORD stack_depth,
-                            const intptr_t* backtrace) override;
+  ~EventPrinter() override;
+
+  void OnUnknownEvent(const EVENT_TRACE* event) override;
+
+  void OnUnparsableEvent(const EVENT_TRACE* event) override;
+
+  void OnFileHeader(const EVENT_TRACE* event,
+                    const TRACE_LOGFILE_HEADER* header) override;
+
+  void OnLogMessage(const EVENT_TRACE* event,
+                    logging::LogSeverity severity,
+                    const base::StringPiece& message) override;
+
+  void OnLogMessageFull(const EVENT_TRACE* event,
+                        logging::LogSeverity severity,
+                        DWORD stack_depth,
+                        const intptr_t* backtrace,
+                        int line,
+                        const base::StringPiece& file,
+                        const base::StringPiece& message) override;
+
+  void OnTraceEvent(const EVENT_TRACE* event,
+                    const base::StringPiece& name,
+                    char type,
+                    intptr_t id,
+                    const base::StringPiece& extra,
+                    DWORD stack_depth,
+                    const intptr_t* backtrace) override;
 
  private:
   void PrintTimeStamp(LARGE_INTEGER time_stamp);
diff --git a/chrome/test/logging/win/test_log_collector.cc b/chrome/test/logging/win/test_log_collector.cc
index ec582a5..a218d60 100644
--- a/chrome/test/logging/win/test_log_collector.cc
+++ b/chrome/test/logging/win/test_log_collector.cc
@@ -50,43 +50,40 @@ class TestLogCollector {
     // Ownership of |default_result_printer| is taken by the new instance.
     EventListener(TestLogCollector* test_log_collector,
                   testing::TestEventListener* default_result_printer);
-    virtual ~EventListener();
+    ~EventListener() override;
 
     // Sets up the log collector.
-    virtual void OnTestProgramStart(
-        const testing::UnitTest& unit_test) override {
+    void OnTestProgramStart(const testing::UnitTest& unit_test) override {
       test_log_collector_->SetUp();
       default_result_printer_->OnTestProgramStart(unit_test);
     }
 
-    virtual void OnTestIterationStart(const testing::UnitTest& unit_test,
-                                      int iteration) override {
+    void OnTestIterationStart(const testing::UnitTest& unit_test,
+                              int iteration) override {
       default_result_printer_->OnTestIterationStart(unit_test, iteration);
     }
 
-    virtual void OnEnvironmentsSetUpStart(
-        const testing::UnitTest& unit_test) override {
+    void OnEnvironmentsSetUpStart(const testing::UnitTest& unit_test) override {
       default_result_printer_->OnEnvironmentsSetUpStart(unit_test);
     }
 
-    virtual void OnEnvironmentsSetUpEnd(
-        const testing::UnitTest& unit_test) override {
+    void OnEnvironmentsSetUpEnd(const testing::UnitTest& unit_test) override {
       default_result_printer_->OnEnvironmentsSetUpEnd(unit_test);
     }
 
-    virtual void OnTestCaseStart(const testing::TestCase& test_case) override {
+    void OnTestCaseStart(const testing::TestCase& test_case) override {
       default_result_printer_->OnTestCaseStart(test_case);
     }
 
     // Calls back to the collector to start collecting logs for this test.
-    virtual void OnTestStart(const testing::TestInfo& test_info) override {
+    void OnTestStart(const testing::TestInfo& test_info) override {
       default_result_printer_->OnTestStart(test_info);
       test_log_collector_->StartSessionForTest(test_info);
     }
 
     // Calls back to the collector with the partial result.  If the collector
     // does not handle it, it is given to the default result printer.
-    virtual void OnTestPartResult(
+    void OnTestPartResult(
         const testing::TestPartResult& test_part_result) override {
       if (!test_log_collector_->LogTestPartResult(test_part_result))
         default_result_printer_->OnTestPartResult(test_part_result);
@@ -94,32 +91,32 @@ class TestLogCollector {
 
     // Calls back to the collector to handle the collected log for the test that
     // has just ended.
-    virtual void OnTestEnd(const testing::TestInfo& test_info) override {
+    void OnTestEnd(const testing::TestInfo& test_info) override {
       test_log_collector_->ProcessSessionForTest(test_info);
       default_result_printer_->OnTestEnd(test_info);
     }
 
-    virtual void OnTestCaseEnd(const testing::TestCase& test_case) override {
+    void OnTestCaseEnd(const testing::TestCase& test_case) override {
       default_result_printer_->OnTestCaseEnd(test_case);
     }
 
-    virtual void OnEnvironmentsTearDownStart(
+    void OnEnvironmentsTearDownStart(
         const testing::UnitTest& unit_test) override {
       default_result_printer_->OnEnvironmentsTearDownStart(unit_test);
     }
 
-    virtual void OnEnvironmentsTearDownEnd(
+    void OnEnvironmentsTearDownEnd(
         const testing::UnitTest& unit_test) override {
       default_result_printer_->OnEnvironmentsTearDownEnd(unit_test);
     }
 
-    virtual void OnTestIterationEnd(const testing::UnitTest& unit_test,
-                                    int iteration) override {
+    void OnTestIterationEnd(const testing::UnitTest& unit_test,
+                            int iteration) override {
       default_result_printer_->OnTestIterationEnd(unit_test, iteration);
     }
 
     // Tears down the log collector.
-    virtual void OnTestProgramEnd(const testing::UnitTest& unit_test) override {
+    void OnTestProgramEnd(const testing::UnitTest& unit_test) override {
       default_result_printer_->OnTestProgramEnd(unit_test);
       test_log_collector_->TearDown();
     }