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

chrome/browser/local_discovery/privetv3_setup_flow_unittest.cc

 // Copyright 2014 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 "chrome/browser/local_discovery/privetv3_setup_flow.h"
 
 #include "base/json/json_reader.h"
 #include "base/run_loop.h"
 #include "chrome/browser/local_discovery/gcd_api_flow.h"
 #include "net/http/http_response_headers.h"
@@ skipping 29 matching lines @@
     request_context_ =
         new net::TestURLRequestContextGetter(base::MessageLoopProxy::current());
   }
 
   MOCK_METHOD0(GetName, const std::string&());
   MOCK_METHOD1(
       CreateInfoOperationPtr,
       PrivetJSONOperation*(const PrivetJSONOperation::ResultCallback&));
 
   virtual void RefreshPrivetToken(
-      const PrivetURLFetcher::TokenCallback& callback) OVERRIDE {
+      const PrivetURLFetcher::TokenCallback& callback) override {
     callback.Run("x-privet-token");
   }
 
   virtual scoped_ptr<PrivetJSONOperation> CreateInfoOperation(
-      const PrivetJSONOperation::ResultCallback& callback) OVERRIDE {
+      const PrivetJSONOperation::ResultCallback& callback) override {
     return make_scoped_ptr(CreateInfoOperationPtr(callback));
   }
 
   virtual scoped_ptr<PrivetURLFetcher> CreateURLFetcher(
       const GURL& url,
       net::URLFetcher::RequestType request_type,
-      PrivetURLFetcher::Delegate* delegate) OVERRIDE {
+      PrivetURLFetcher::Delegate* delegate) override {
     return make_scoped_ptr(new PrivetURLFetcher(
         url, request_type, request_context_.get(), delegate));
   }
 
   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
 };
 
 class MockDelegate : public PrivetV3SetupFlow::Delegate {
  public:
   MockDelegate() : privet_client_ptr_(NULL) {}
 
   class MockGCDApiFlow : public GCDApiFlow {
    public:
     explicit MockGCDApiFlow(MockDelegate* delegate) : delegate_(delegate) {}
 
-    virtual void Start(scoped_ptr<Request> request) OVERRIDE {
+    virtual void Start(scoped_ptr<Request> request) override {
       ASSERT_FALSE(delegate_->gcd_request_);
       delegate_->gcd_request_ = request.Pass();
       delegate_->ReplyWithToken();
     }
 
    private:
     MockDelegate* delegate_;
   };
 
   MOCK_METHOD1(GetWiFiCredentials, void(const CredentialsCallback&));
   MOCK_METHOD1(SwitchToSetupWiFi, void(const ResultCallback&));
   virtual void CreatePrivetV3Client(
       const std::string& service_name,
-      const PrivetClientCallback& callback) OVERRIDE {
+      const PrivetClientCallback& callback) override {
     scoped_ptr<MockPrivetHTTPClient> privet_client(new MockPrivetHTTPClient());
     privet_client_ptr_ = privet_client.get();
     callback.Run(privet_client.PassAs<PrivetHTTPClient>());
   }
   MOCK_METHOD2(ConfirmSecurityCode,
                void(const std::string&, const ResultCallback&));
   MOCK_METHOD1(RestoreWifi, void(const ResultCallback&));
   MOCK_METHOD0(OnSetupDone, void());
   MOCK_METHOD0(OnSetupError, void());
 
-  virtual scoped_ptr<GCDApiFlow> CreateApiFlow() OVERRIDE {
+  virtual scoped_ptr<GCDApiFlow> CreateApiFlow() override {
     scoped_ptr<MockGCDApiFlow> mock_gcd(new MockGCDApiFlow(this));
     return mock_gcd.PassAs<GCDApiFlow>();
   }
 
   void ReplyWithToken() {
     scoped_ptr<base::Value> value(base::JSONReader::Read(gcd_server_response_));
     const base::DictionaryValue* dictionary = NULL;
     value->GetAsDictionary(&dictionary);
     gcd_request_->OnGCDAPIFlowComplete(*dictionary);
   }
 
   std::string gcd_server_response_;
   scoped_ptr<GCDApiFlow::Request> gcd_request_;
   MockPrivetHTTPClient* privet_client_ptr_;
   base::Closure quit_closure_;
 };
 
 class PrivetV3SetupFlowTest : public testing::Test {
  public:
   PrivetV3SetupFlowTest() : setup_(&delegate_) {}
 
   virtual ~PrivetV3SetupFlowTest() {}
 
   void ConfirmCode(const MockDelegate::ResultCallback& confirm_callback) {
     base::MessageLoop::current()->PostTask(FROM_HERE, quit_closure_);
     confirm_callback.Run(true);
   }
 
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     quit_closure_ = run_loop_.QuitClosure();
     EXPECT_CALL(delegate_, GetWiFiCredentials(_)).Times(0);
     EXPECT_CALL(delegate_, SwitchToSetupWiFi(_)).Times(0);
     EXPECT_CALL(delegate_, ConfirmSecurityCode(_, _)).Times(0);
     EXPECT_CALL(delegate_, RestoreWifi(_)).Times(0);
     EXPECT_CALL(delegate_, OnSetupDone()).Times(0);
     EXPECT_CALL(delegate_, OnSetupError()).Times(0);
   }
 
   void SimulateFetch(int response_code, const std::string& response) {
@@ skipping 40 matching lines @@
       WithArgs<1>(Invoke(this, &PrivetV3SetupFlowTest::ConfirmCode)));
   delegate_.gcd_server_response_ = kRegistrationTicketResponse;
   setup_.Register(kServiceName);
   run_loop_.Run();
   SimulateFetch(200, "{}");
 }
 
 }  // namespace
 
 }  // namespace local_discovery