replace OVERRIDE and FINAL with override and final in chromeos/

chromeos/process_proxy/process_proxy_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 <gtest/gtest.h>
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 23 matching lines @@
   virtual void StartRegistryTest(ProcessProxyRegistry* registry) = 0;
 
  protected:
   pid_t pid_;
 };
 
 class RegistryTestRunner : public TestRunner {
  public:
   virtual ~RegistryTestRunner() {}
 
-  virtual void SetupExpectations(pid_t pid) OVERRIDE {
+  virtual void SetupExpectations(pid_t pid) override {
     pid_ = pid;
     left_to_check_index_[0] = 0;
     left_to_check_index_[1] = 0;
     // We consider that a line processing has started if a value in
     // left_to_check__[index] is set to 0, thus -2.
     lines_left_ = 2 * kTestLineNum - 2;
     expected_line_ = kTestLineExpected;
   }
 
   // Method to test validity of received input. We will receive two streams of
   // the same data. (input will be echoed twice by the testing process). Each
   // stream will contain the same string repeated |kTestLineNum| times. So we
   // have to match 2 * |kTestLineNum| lines. The problem is the received lines
   // from different streams may be interleaved (e.g. we may receive
   // abc|abcdef|defgh|gh). To deal with that, we allow to test received text
   // against two lines. The lines MUST NOT have two same characters for this
   // algorithm to work.
   virtual void OnSomeRead(pid_t pid, const std::string& type,
-                          const std::string& output) OVERRIDE {
+                          const std::string& output) override {
     EXPECT_EQ(type, kStdoutType);
     EXPECT_EQ(pid_, pid);
 
     bool valid = true;
     for (size_t i = 0; i < output.length(); i++) {
       // The character output[i] should be next in at least one of the lines we
       // are testing.
       valid = (ProcessReceivedCharacter(output[i], 0) ||
                ProcessReceivedCharacter(output[i], 1));
       EXPECT_TRUE(valid) << "Received: " << output;
     }
 
     if (!valid || TestSucceeded()) {
       base::MessageLoop::current()->PostTask(FROM_HERE,
                                              base::MessageLoop::QuitClosure());
     }
   }
 
-  virtual void StartRegistryTest(ProcessProxyRegistry* registry) OVERRIDE {
+  virtual void StartRegistryTest(ProcessProxyRegistry* registry) override {
     for (int i = 0; i < kTestLineNum; i++) {
       EXPECT_TRUE(registry->SendInput(pid_, kTestLineToSend));
     }
   }
 
  private:
   bool ProcessReceivedCharacter(char received, size_t stream) {
     if (stream >= arraysize(left_to_check_index_))
       return false;
     bool success = left_to_check_index_[stream] < expected_line_.length() &&
@@ skipping 18 matching lines @@
 
   size_t left_to_check_index_[2];
   size_t lines_left_;
   std::string expected_line_;
 };
 
 class RegistryNotifiedOnProcessExitTestRunner : public TestRunner {
  public:
   virtual ~RegistryNotifiedOnProcessExitTestRunner() {}
 
-  virtual void SetupExpectations(pid_t pid) OVERRIDE {
+  virtual void SetupExpectations(pid_t pid) override {
     output_received_ = false;
     pid_ = pid;
   }
 
   virtual void OnSomeRead(pid_t pid, const std::string& type,
-                          const std::string& output) OVERRIDE {
+                          const std::string& output) override {
     EXPECT_EQ(pid_, pid);
     if (!output_received_) {
       output_received_ = true;
       EXPECT_EQ(type, "stdout");
       EXPECT_EQ(output, "p");
       base::KillProcess(pid_, 0 , true);
       return;
     }
     EXPECT_EQ("exit", type);
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::MessageLoop::QuitClosure());
   }
 
-  virtual void StartRegistryTest(ProcessProxyRegistry* registry) OVERRIDE {
+  virtual void StartRegistryTest(ProcessProxyRegistry* registry) override {
     EXPECT_TRUE(registry->SendInput(pid_, "p"));
   }
 
  private:
   bool output_received_;
 };
 
 class SigIntTestRunner : public TestRunner {
  public:
   virtual ~SigIntTestRunner() {}
 
-  virtual void SetupExpectations(pid_t pid) OVERRIDE {
+  virtual void SetupExpectations(pid_t pid) override {
     pid_ = pid;
   }
 
   virtual void OnSomeRead(pid_t pid, const std::string& type,
-                          const std::string& output) OVERRIDE {
+                          const std::string& output) override {
     EXPECT_EQ(pid_, pid);
     // We may receive ^C on stdout, but we don't care about that, as long as we
     // eventually received exit event.
     if (type == "exit") {
       base::MessageLoop::current()->PostTask(FROM_HERE,
                                              base::MessageLoop::QuitClosure());
     }
   }
 
-  virtual void StartRegistryTest(ProcessProxyRegistry* registry) OVERRIDE {
+  virtual void StartRegistryTest(ProcessProxyRegistry* registry) override {
     // Send SingInt and verify the process exited.
     EXPECT_TRUE(registry->SendInput(pid_, "\003"));
   }
 };
 
 }  // namespace
 
 class ProcessProxyTest : public testing::Test {
  public:
   ProcessProxyTest() {}
@@ skipping 66 matching lines @@
 }
 
 // Test verifies that \003 message send to process is processed as SigInt.
 // Timing out on the waterfall: http://crbug.com/115064
 TEST_F(ProcessProxyTest, DISABLED_SigInt) {
   test_runner_.reset(new SigIntTestRunner());
   RunTest();
 }
 
 }  // namespace chromeos