Replacing the OVERRIDE with override and FINAL with final in jingle

jingle/glue/chrome_async_socket_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 "jingle/glue/chrome_async_socket.h"
 
 #include <deque>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 25 matching lines @@
  public:
   AsyncSocketDataProvider() : has_pending_read_(false) {}
 
   virtual ~AsyncSocketDataProvider() {
     EXPECT_TRUE(writes_.empty());
     EXPECT_TRUE(reads_.empty());
   }
 
   // If there's no read, sets the "has pending read" flag.  Otherwise,
   // pops the next read.
-  virtual net::MockRead GetNextRead() OVERRIDE {
+  virtual net::MockRead GetNextRead() override {
     if (reads_.empty()) {
       DCHECK(!has_pending_read_);
       has_pending_read_ = true;
       const net::MockRead pending_read(net::SYNCHRONOUS, net::ERR_IO_PENDING);
       return pending_read;
     }
     net::MockRead mock_read = reads_.front();
     reads_.pop_front();
     return mock_read;
   }
 
   // Simply pops the next write and, if applicable, compares it to
   // |data|.
-  virtual net::MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual net::MockWriteResult OnWrite(const std::string& data) override {
     DCHECK(!writes_.empty());
     net::MockWrite mock_write = writes_.front();
     writes_.pop_front();
     if (mock_write.result != net::OK) {
       return net::MockWriteResult(mock_write.mode, mock_write.result);
     }
     std::string expected_data(mock_write.data, mock_write.data_len);
     EXPECT_EQ(expected_data, data);
     if (expected_data != data) {
       return net::MockWriteResult(net::SYNCHRONOUS, net::ERR_UNEXPECTED);
     }
     return net::MockWriteResult(mock_write.mode, data.size());
   }
 
   // We ignore resets so we can pre-load the socket data provider with
   // read/write events.
-  virtual void Reset() OVERRIDE {}
+  virtual void Reset() override {}
 
   // If there is a pending read, completes it with the given read.
   // Otherwise, queues up the given read.
   void AddRead(const net::MockRead& mock_read) {
     DCHECK_NE(mock_read.result, net::ERR_IO_PENDING);
     if (has_pending_read_) {
       socket()->OnReadComplete(mock_read);
       has_pending_read_ = false;
       return;
     }
@@ skipping 20 matching lines @@
       net::ClientSocketFactory* mock_client_socket_factory,
       const net::AddressList& address_list)
           : mock_client_socket_factory_(mock_client_socket_factory),
             address_list_(address_list),
             cert_verifier_(new net::MockCertVerifier),
             transport_security_state_(new net::TransportSecurityState) {
   }
 
   // ResolvingClientSocketFactory implementation.
   virtual scoped_ptr<net::StreamSocket> CreateTransportClientSocket(
-      const net::HostPortPair& host_and_port) OVERRIDE {
+      const net::HostPortPair& host_and_port) override {
     return mock_client_socket_factory_->CreateTransportClientSocket(
         address_list_, NULL, net::NetLog::Source());
   }
 
   virtual scoped_ptr<net::SSLClientSocket> CreateSSLClientSocket(
       scoped_ptr<net::ClientSocketHandle> transport_socket,
-      const net::HostPortPair& host_and_port) OVERRIDE {
+      const net::HostPortPair& host_and_port) override {
     net::SSLClientSocketContext context;
     context.cert_verifier = cert_verifier_.get();
     context.transport_security_state = transport_security_state_.get();
     return mock_client_socket_factory_->CreateSSLClientSocket(
         transport_socket.Pass(), host_and_port, ssl_config_, context);
   }
 
  private:
   scoped_ptr<net::ClientSocketFactory> mock_client_socket_factory_;
   net::AddressList address_list_;
@@ skipping 947 matching lines @@
   message_loop_->RunUntilIdle();
 
   ExpectNoSignal();
 
   DoSSLCloseOpenedNoError();
 }
 
 }  // namespace
 
 }  // namespace jingle_glue