replace OVERRIDE and FINAL with override and final in chrome/browser/[j-q]*

chrome/browser/local_discovery/privet_http_unittest.cc

 // Copyright 2013 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/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop/message_loop.h"
 #include "chrome/browser/local_discovery/privet_http_impl.h"
 #include "net/base/host_port_pair.h"
@@ skipping 364 matching lines @@
 class MockRegisterDelegate : public PrivetRegisterOperation::Delegate {
  public:
   MockRegisterDelegate() {
   }
   ~MockRegisterDelegate() {
   }
 
   virtual void OnPrivetRegisterClaimToken(
       PrivetRegisterOperation* operation,
       const std::string& token,
-      const GURL& url) OVERRIDE {
+      const GURL& url) override {
     OnPrivetRegisterClaimTokenInternal(token, url);
   }
 
   MOCK_METHOD2(OnPrivetRegisterClaimTokenInternal, void(
       const std::string& token,
       const GURL& url));
 
   virtual void OnPrivetRegisterError(
       PrivetRegisterOperation* operation,
       const std::string& action,
       PrivetRegisterOperation::FailureReason reason,
       int printer_http_code,
-      const base::DictionaryValue* json) OVERRIDE {
+      const base::DictionaryValue* json) override {
     // TODO(noamsml): Save and test for JSON?
     OnPrivetRegisterErrorInternal(action, reason, printer_http_code);
   }
 
   MOCK_METHOD3(OnPrivetRegisterErrorInternal,
                void(const std::string& action,
                     PrivetRegisterOperation::FailureReason reason,
                     int printer_http_code));
 
   virtual void OnPrivetRegisterDone(
       PrivetRegisterOperation* operation,
-      const std::string& device_id) OVERRIDE {
+      const std::string& device_id) override {
     OnPrivetRegisterDoneInternal(device_id);
   }
 
   MOCK_METHOD1(OnPrivetRegisterDoneInternal,
                void(const std::string& device_id));
 };
 
 class MockLocalPrintDelegate : public PrivetLocalPrintOperation::Delegate {
  public:
   MockLocalPrintDelegate() {}
@@ skipping 13 matching lines @@
 
   MOCK_METHOD1(OnPrivetPrintingErrorInternal, void(int http_code));
 };
 
 class PrivetInfoTest : public PrivetHTTPTest {
  public:
   PrivetInfoTest() {}
 
   virtual ~PrivetInfoTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     info_operation_ = privet_client_->CreateInfoOperation(
         info_callback_.callback());
   }
 
  protected:
   scoped_ptr<PrivetJSONOperation> info_operation_;
   StrictMock<MockJSONCallback> info_callback_;
 };
 
 TEST_F(PrivetInfoTest, SuccessfulInfo) {
@@ skipping 26 matching lines @@
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 }
 
 class PrivetRegisterTest : public PrivetHTTPTest {
  public:
   PrivetRegisterTest() {
   }
   virtual ~PrivetRegisterTest() {
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     info_operation_ = privet_client_->CreateInfoOperation(
         info_callback_.callback());
     register_operation_ =
         privet_client_->CreateRegisterOperation("example@google.com",
                                                 &register_delegate_);
   }
 
  protected:
   bool SuccessfulResponseToURL(const GURL& url,
                                const std::string& response) {
@@ skipping 168 matching lines @@
   // deleted.
   RunFor(base::TimeDelta::FromSeconds(3));
 }
 
 class PrivetCapabilitiesTest : public PrivetHTTPTest {
  public:
   PrivetCapabilitiesTest() {}
 
   virtual ~PrivetCapabilitiesTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     capabilities_operation_ = privet_client_->CreateCapabilitiesOperation(
         capabilities_callback_.callback());
   }
 
  protected:
   scoped_ptr<PrivetJSONOperation> capabilities_operation_;
   StrictMock<MockJSONCallback> capabilities_callback_;
 };
 
 TEST_F(PrivetCapabilitiesTest, SuccessfulCapabilities) {
@@ skipping 70 matching lines @@
  public:
   FakePWGRasterConverter() {
   }
 
   virtual ~FakePWGRasterConverter() {
   }
 
   virtual void Start(base::RefCountedMemory* data,
                      const printing::PdfRenderSettings& conversion_settings,
                      const printing::PwgRasterSettings& bitmap_settings,
-                     const ResultCallback& callback) OVERRIDE {
+                     const ResultCallback& callback) override {
     bitmap_settings_ = bitmap_settings;
     std::string data_str(data->front_as<char>(), data->size());
     callback.Run(true, base::FilePath().AppendASCII(data_str + "test.pdf"));
   }
 
   const printing::PwgRasterSettings& bitmap_settings() {
     return bitmap_settings_;
   }
 
  private:
   printing::PwgRasterSettings bitmap_settings_;
 };
 
 class PrivetLocalPrintTest : public PrivetHTTPTest {
  public:
   PrivetLocalPrintTest() {}
 
   virtual ~PrivetLocalPrintTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     PrivetURLFetcher::ResetTokenMapForTests();
 
     local_print_operation_ = privet_client_->CreateLocalPrintOperation(
         &local_print_delegate_);
 
     scoped_ptr<FakePWGRasterConverter> pwg_converter(
         new FakePWGRasterConverter);
     pwg_converter_ = pwg_converter.get();
     local_print_operation_->SetPWGRasterConverterForTesting(
         pwg_converter.PassAs<PWGRasterConverter>());
@@ skipping 271 matching lines @@
 
   EXPECT_TRUE(SuccessfulResponseToURL(
       GURL("http://10.0.0.8:6006/privet/printer/createjob"),
       kSampleCreatejobResponse));
 }
 #endif  // ENABLE_FULL_PRINTING
 
 }  // namespace
 
 }  // namespace local_discovery