Replace FINAL and OVERRIDE with their C++11 counterparts in chrome/test

chrome/test/nacl/nacl_browsertest_util.h

 // 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.
 
 #ifndef CHROME_TEST_NACL_NACL_BROWSERTEST_UTIL_H_
 #define CHROME_TEST_NACL_NACL_BROWSERTEST_UTIL_H_
 
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "content/public/test/javascript_test_observer.h"
 
 // A helper base class that decodes structured automation messages of the form:
 // {"type": type_name, ...}
 class StructuredMessageHandler : public content::TestMessageHandler {
  public:
-  virtual MessageResponse HandleMessage(const std::string& json) OVERRIDE;
+  virtual MessageResponse HandleMessage(const std::string& json) override;
 
   // This method provides a higher-level interface for handling JSON messages
   // from the DOM automation controler.  Instead of handling a string
   // containing a JSON-encoded object, this specialization of TestMessageHandler
   // decodes the string into a dictionary. This makes it easier to send and
   // receive structured messages.  It is assumed the dictionary will always have
   // a "type" field that indicates the nature of message.
   virtual MessageResponse HandleStructuredMessage(
       const std::string& type,
       base::DictionaryValue* msg) = 0;
@@ skipping 10 matching lines @@
 
 // A simple structured message handler for tests that load nexes.
 class LoadTestMessageHandler : public StructuredMessageHandler {
  public:
   LoadTestMessageHandler();
 
   void Log(const std::string& type, const std::string& message);
 
   virtual MessageResponse HandleStructuredMessage(
       const std::string& type,
-      base::DictionaryValue* msg) OVERRIDE;
+      base::DictionaryValue* msg) override;
 
   bool test_passed() const {
     return test_passed_;
   }
 
  private:
   bool test_passed_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadTestMessageHandler);
 };
 
 class NaClBrowserTestBase : public InProcessBrowserTest {
  public:
   NaClBrowserTestBase();
   virtual ~NaClBrowserTestBase();
 
-  virtual void SetUpCommandLine(base::CommandLine* command_line) OVERRIDE;
+  virtual void SetUpCommandLine(base::CommandLine* command_line) override;
 
-  virtual void SetUpOnMainThread() OVERRIDE;
+  virtual void SetUpOnMainThread() override;
 
   // What variant are we running - newlib, glibc, pnacl, etc?
   // This is used to compute what directory we're pulling data from, but it can
   // also be used to affect the behavior of the test.
   virtual base::FilePath::StringType Variant() = 0;
 
   // Where are the files for this class of test located on disk?
   virtual bool GetDocumentRoot(base::FilePath* document_root);
 
   virtual bool IsAPnaclTest();
@@ skipping 24 matching lines @@
                               bool full_url = false);
 
  private:
   bool StartTestServer();
 
   scoped_ptr<net::SpawnedTestServer> test_server_;
 };
 
 class NaClBrowserTestNewlib : public NaClBrowserTestBase {
  public:
-  virtual base::FilePath::StringType Variant() OVERRIDE;
+  virtual base::FilePath::StringType Variant() override;
 };
 
 class NaClBrowserTestGLibc : public NaClBrowserTestBase {
  public:
-  virtual base::FilePath::StringType Variant() OVERRIDE;
+  virtual base::FilePath::StringType Variant() override;
 };
 
 class NaClBrowserTestPnacl : public NaClBrowserTestBase {
  public:
-  virtual base::FilePath::StringType Variant() OVERRIDE;
+  virtual base::FilePath::StringType Variant() override;
 
-  virtual bool IsAPnaclTest() OVERRIDE;
+  virtual bool IsAPnaclTest() override;
 };
 
 class NaClBrowserTestPnaclNonSfi : public NaClBrowserTestBase {
  public:
-  virtual void SetUpCommandLine(base::CommandLine* command_line) OVERRIDE;
-  virtual base::FilePath::StringType Variant() OVERRIDE;
+  virtual void SetUpCommandLine(base::CommandLine* command_line) override;
+  virtual base::FilePath::StringType Variant() override;
 };
 
 class NaClBrowserTestNonSfiMode : public NaClBrowserTestBase {
  public:
-  virtual void SetUpCommandLine(base::CommandLine* command_line) OVERRIDE;
-  virtual base::FilePath::StringType Variant() OVERRIDE;
+  virtual void SetUpCommandLine(base::CommandLine* command_line) override;
+  virtual base::FilePath::StringType Variant() override;
 };
 
 // A NaCl browser test only using static files.
 class NaClBrowserTestStatic : public NaClBrowserTestBase {
  public:
-  virtual base::FilePath::StringType Variant() OVERRIDE;
-  virtual bool GetDocumentRoot(base::FilePath* document_root) OVERRIDE;
+  virtual base::FilePath::StringType Variant() override;
+  virtual bool GetDocumentRoot(base::FilePath* document_root) override;
 };
 
 // A NaCl browser test that loads from an unpacked chrome extension.
 // The directory of the unpacked extension files is determined by
 // the tester's document root.
 class NaClBrowserTestNewlibExtension : public NaClBrowserTestNewlib {
  public:
-  virtual void SetUpCommandLine(base::CommandLine* command_line) OVERRIDE;
+  virtual void SetUpCommandLine(base::CommandLine* command_line) override;
 };
 
 class NaClBrowserTestGLibcExtension : public NaClBrowserTestGLibc {
  public:
-  virtual void SetUpCommandLine(base::CommandLine* command_line) OVERRIDE;
+  virtual void SetUpCommandLine(base::CommandLine* command_line) override;
 };
 
 // PNaCl tests take a long time on windows debug builds
 // and sometimes time out.  Disable until it is made faster:
 // https://code.google.com/p/chromium/issues/detail?id=177555
 #if (defined(OS_WIN) && !defined(NDEBUG))
 #  define MAYBE_PNACL(test_name) DISABLED_##test_name
 #else
 #  define MAYBE_PNACL(test_name) test_name
 #endif
@@ skipping 25 matching lines @@
 
 #define NACL_BROWSER_TEST_F(suite, name, body) \
 IN_PROC_BROWSER_TEST_F(suite##Newlib, name) \
 body \
 IN_PROC_BROWSER_TEST_F(suite##GLibc, MAYBE_GLIBC(name)) \
 body \
 IN_PROC_BROWSER_TEST_F(suite##Pnacl, MAYBE_PNACL(name)) \
 body
 
 #endif  // CHROME_TEST_NACL_NACL_BROWSERTEST_UTIL_H_