replace OVERRIDE and FINAL with override and final in extensions/

extensions/browser/api/cast_channel/cast_socket_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 "extensions/browser/api/cast_channel/cast_socket.h"
 
 #include <vector>
 
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 79 matching lines @@
       TCPClientSocket(net::AddressList(), NULL, net::NetLog::Source()),
       connect_data_(connect_data),
       do_nothing_(false) { }
 
   explicit MockTCPSocket(bool do_nothing) :
       TCPClientSocket(net::AddressList(), NULL, net::NetLog::Source()) {
     CHECK(do_nothing);
     do_nothing_ = do_nothing;
   }
 
-  virtual int Connect(const net::CompletionCallback& callback) OVERRIDE {
+  virtual int Connect(const net::CompletionCallback& callback) override {
     if (do_nothing_) {
       // Stall the I/O event loop.
       return net::ERR_IO_PENDING;
     }
 
     if (connect_data_.mode == net::ASYNC) {
       CHECK_NE(connect_data_.result, net::ERR_IO_PENDING);
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(callback, connect_data_.result));
       return net::ERR_IO_PENDING;
     } else {
       return connect_data_.result;
     }
   }
 
-  virtual bool SetKeepAlive(bool enable, int delay) OVERRIDE {
+  virtual bool SetKeepAlive(bool enable, int delay) override {
     // Always return true in tests
     return true;
   }
 
-  virtual bool SetNoDelay(bool no_delay) OVERRIDE {
+  virtual bool SetNoDelay(bool no_delay) override {
     // Always return true in tests
     return true;
   }
 
   MOCK_METHOD3(Read,
                int(net::IOBuffer*, int, const net::CompletionCallback&));
   MOCK_METHOD3(Write,
                int(net::IOBuffer*, int, const net::CompletionCallback&));
 
-  virtual void Disconnect() OVERRIDE {
+  virtual void Disconnect() override {
     // Do nothing in tests
   }
 
  private:
   net::MockConnect connect_data_;
   bool do_nothing_;
 };
 
 class CompleteHandler {
  public:
@@ skipping 134 matching lines @@
     verify_challenge_result_ = value;
   }
 
   void TriggerTimeout() {
     mock_timer_->Fire();
   }
 
   void DisallowVerifyChallengeResult() { verify_challenge_disallow_ = true; }
 
  private:
-  virtual scoped_ptr<net::TCPClientSocket> CreateTcpSocket() OVERRIDE {
+  virtual scoped_ptr<net::TCPClientSocket> CreateTcpSocket() override {
     if (tcp_unresponsive_) {
       return scoped_ptr<net::TCPClientSocket>(new MockTCPSocket(true));
     } else {
       net::MockConnect* connect_data = tcp_connect_data_[connect_index_].get();
       connect_data->peer_addr = ip_;
       return scoped_ptr<net::TCPClientSocket>(new MockTCPSocket(*connect_data));
     }
   }
 
   virtual scoped_ptr<net::SSLClientSocket> CreateSslSocket(
-      scoped_ptr<net::StreamSocket> socket) OVERRIDE {
+      scoped_ptr<net::StreamSocket> socket) override {
     net::MockConnect* connect_data = ssl_connect_data_[connect_index_].get();
     connect_data->peer_addr = ip_;
     ++connect_index_;
 
     ssl_data_.reset(new net::StaticSocketDataProvider(
         reads_.data(), reads_.size(), writes_.data(), writes_.size()));
     ssl_data_->set_connect_data(*connect_data);
     // NOTE: net::MockTCPClientSocket inherits from net::SSLClientSocket !!
     return scoped_ptr<net::SSLClientSocket>(
         new net::MockTCPClientSocket(
             net::AddressList(), &capturing_net_log_, ssl_data_.get()));
   }
 
-  virtual bool ExtractPeerCert(std::string* cert) OVERRIDE {
+  virtual bool ExtractPeerCert(std::string* cert) override {
     if (extract_cert_result_)
       cert->assign("dummy_test_cert");
     return extract_cert_result_;
   }
 
-  virtual bool VerifyChallengeReply() OVERRIDE {
+  virtual bool VerifyChallengeReply() override {
     EXPECT_FALSE(verify_challenge_disallow_);
     return verify_challenge_result_;
   }
 
-  virtual base::Timer* GetTimer() OVERRIDE {
+  virtual base::Timer* GetTimer() override {
     return mock_timer_.get();
   }
 
   net::CapturingNetLog capturing_net_log_;
   net::IPEndPoint ip_;
   // Simulated connect data
   scoped_ptr<net::MockConnect> tcp_connect_data_[2];
   scoped_ptr<net::MockConnect> ssl_connect_data_[2];
   // Simulated read / write data
   std::vector<net::MockWrite> writes_;
@@ skipping 12 matching lines @@
 };
 
 class CastSocketTest : public testing::Test {
  public:
   CastSocketTest()
       : logger_(new Logger(
             scoped_ptr<base::TickClock>(new base::SimpleTestTickClock),
             base::TimeTicks())) {}
   virtual ~CastSocketTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // Create a few test messages
     for (size_t i = 0; i < arraysize(test_messages_); i++) {
       CreateStringMessage("urn:cast", "1", "2", kTestData[i],
                           &test_messages_[i]);
       ASSERT_TRUE(MessageInfoToCastMessage(
           test_messages_[i], &test_protos_[i]));
       ASSERT_TRUE(
           MessageFramer::Serialize(test_protos_[i], &test_proto_strs_[i]));
     }
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     if (socket_.get()) {
       EXPECT_CALL(handler_, OnCloseComplete(net::OK));
       socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete,
                                 base::Unretained(&handler_)));
     }
   }
 
   // The caller can specify non-standard namespaces by setting "auth_namespace"
   // (useful for negative test cases.)
   void SetupAuthMessage(
@@ skipping 824 matching lines @@
                       A<const LastErrors&>()));
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_INVALID_MESSAGE,
             socket_->error_state());
 }
 }  // namespace cast_channel
 }  // namespace core_api
 }  // namespace extensions