replace OVERRIDE and FINAL with override and final in net/

net/server/web_socket.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 "net/server/web_socket.h"
 
 #include <limits>
 
 #include "base/base64.h"
 #include "base/rand_util.h"
@@ skipping 36 matching lines @@
   static net::WebSocket* Create(HttpServer* server,
                                 HttpConnection* connection,
                                 const HttpServerRequestInfo& request,
                                 size_t* pos) {
     if (connection->read_buf()->GetSize() <
         static_cast<int>(*pos + kWebSocketHandshakeBodyLen))
       return NULL;
     return new WebSocketHixie76(server, connection, request, pos);
   }
 
-  virtual void Accept(const HttpServerRequestInfo& request) OVERRIDE {
+  virtual void Accept(const HttpServerRequestInfo& request) override {
     std::string key1 = request.GetHeaderValue("sec-websocket-key1");
     std::string key2 = request.GetHeaderValue("sec-websocket-key2");
 
     uint32 fp1 = WebSocketKeyFingerprint(key1);
     uint32 fp2 = WebSocketKeyFingerprint(key2);
 
     char data[16];
     memcpy(data, &fp1, 4);
     memcpy(data + 4, &fp2, 4);
     memcpy(data + 8, &key3_[0], 8);
@@ skipping 11 matching lines @@
                            "Connection: Upgrade\r\n"
                            "Sec-WebSocket-Origin: %s\r\n"
                            "Sec-WebSocket-Location: %s\r\n"
                            "\r\n",
                            origin.c_str(),
                            location.c_str()));
     server_->SendRaw(connection_->id(),
                      std::string(reinterpret_cast<char*>(digest.a), 16));
   }
 
-  virtual ParseResult Read(std::string* message) OVERRIDE {
+  virtual ParseResult Read(std::string* message) override {
     DCHECK(message);
     HttpConnection::ReadIOBuffer* read_buf = connection_->read_buf();
     if (read_buf->StartOfBuffer()[0])
       return FRAME_ERROR;
 
     base::StringPiece data(read_buf->StartOfBuffer(), read_buf->GetSize());
     size_t pos = data.find('\377', 1);
     if (pos == base::StringPiece::npos)
       return FRAME_INCOMPLETE;
 
     message->assign(data.data() + 1, pos - 1);
     read_buf->DidConsume(pos + 1);
 
     return FRAME_OK;
   }
 
-  virtual void Send(const std::string& message) OVERRIDE {
+  virtual void Send(const std::string& message) override {
     char message_start = 0;
     char message_end = -1;
     server_->SendRaw(connection_->id(), std::string(1, message_start));
     server_->SendRaw(connection_->id(), message);
     server_->SendRaw(connection_->id(), std::string(1, message_end));
   }
 
  private:
   static const int kWebSocketHandshakeBodyLen;
 
@@ skipping 75 matching lines @@
       server->SendResponse(
           connection->id(),
           HttpServerResponseInfo::CreateFor500(
               "Invalid request format. Sec-WebSocket-Key is empty or isn't "
               "specified."));
       return NULL;
     }
     return new WebSocketHybi17(server, connection, request, pos);
   }
 
-  virtual void Accept(const HttpServerRequestInfo& request) OVERRIDE {
+  virtual void Accept(const HttpServerRequestInfo& request) override {
     static const char* const kWebSocketGuid =
         "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
     std::string key = request.GetHeaderValue("sec-websocket-key");
     std::string data = base::StringPrintf("%s%s", key.c_str(), kWebSocketGuid);
     std::string encoded_hash;
     base::Base64Encode(base::SHA1HashString(data), &encoded_hash);
 
     server_->SendRaw(
         connection_->id(),
         base::StringPrintf("HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
                            "Upgrade: WebSocket\r\n"
                            "Connection: Upgrade\r\n"
                            "Sec-WebSocket-Accept: %s\r\n"
                            "\r\n",
                            encoded_hash.c_str()));
   }
 
-  virtual ParseResult Read(std::string* message) OVERRIDE {
+  virtual ParseResult Read(std::string* message) override {
     HttpConnection::ReadIOBuffer* read_buf = connection_->read_buf();
     base::StringPiece frame(read_buf->StartOfBuffer(), read_buf->GetSize());
     int bytes_consumed = 0;
     ParseResult result =
         WebSocket::DecodeFrameHybi17(frame, true, &bytes_consumed, message);
     if (result == FRAME_OK)
       read_buf->DidConsume(bytes_consumed);
     if (result == FRAME_CLOSE)
       closed_ = true;
     return result;
   }
 
-  virtual void Send(const std::string& message) OVERRIDE {
+  virtual void Send(const std::string& message) override {
     if (closed_)
       return;
     server_->SendRaw(connection_->id(),
                      WebSocket::EncodeFrameHybi17(message, 0));
   }
 
  private:
   WebSocketHybi17(HttpServer* server,
                   HttpConnection* connection,
                   const HttpServerRequestInfo& request,
@@ skipping 170 matching lines @@
   }
   return std::string(&frame[0], frame.size());
 }
 
 WebSocket::WebSocket(HttpServer* server, HttpConnection* connection)
     : server_(server),
       connection_(connection) {
 }
 
 }  // namespace net