net: Fix more clang warnings about missing virtual and OVERRIDE annotations.

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 32 matching lines @@
 class WebSocketHixie76 : public net::WebSocket {
  public:
   static net::WebSocket* Create(HttpConnection* connection,
                                 const HttpServerRequestInfo& request,
                                 size_t* pos) {
     if (connection->recv_data().length() < *pos + kWebSocketHandshakeBodyLen)
       return NULL;
     return new WebSocketHixie76(connection, request, pos);
   }
 
-  virtual void Accept(const HttpServerRequestInfo& request) {
+  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);
 
     base::MD5Digest digest;
     base::MD5Sum(data, 16, &digest);
 
     std::string origin = request.GetHeaderValue("Origin");
     std::string host = request.GetHeaderValue("Host");
     std::string location = "ws://" + host + request.path;
     connection_->Send(base::StringPrintf(
         "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
         "Upgrade: WebSocket\r\n"
         "Connection: Upgrade\r\n"
         "Sec-WebSocket-Origin: %s\r\n"
         "Sec-WebSocket-Location: %s\r\n"
         "\r\n",
         origin.c_str(),
         location.c_str()));
     connection_->Send(reinterpret_cast<char*>(digest.a), 16);
   }
 
-  virtual ParseResult Read(std::string* message) {
+  virtual ParseResult Read(std::string* message) OVERRIDE {
     DCHECK(message);
     const std::string& data = connection_->recv_data();
     if (data[0])
       return FRAME_ERROR;
 
     size_t pos = data.find('\377', 1);
     if (pos == std::string::npos)
       return FRAME_INCOMPLETE;
 
     std::string buffer(data.begin() + 1, data.begin() + pos);
     message->swap(buffer);
     connection_->Shift(pos + 1);
 
     return FRAME_OK;
   }
 
-  virtual void Send(const std::string& message) {
+  virtual void Send(const std::string& message) OVERRIDE {
     char message_start = 0;
     char message_end = -1;
     connection_->Send(&message_start, 1);
     connection_->Send(message);
     connection_->Send(&message_end, 1);
   }
 
  private:
   static const int kWebSocketHandshakeBodyLen;
 
@@ skipping 64 matching lines @@
 
     std::string key = request.GetHeaderValue("Sec-WebSocket-Key");
     if (key.empty()) {
       connection->Send500("Invalid request format. "
               "Sec-WebSocket-Key is empty or isn't specified.");
       return NULL;
     }
     return new WebSocketHybi17(connection, request, pos);
   }
 
-  virtual void Accept(const HttpServerRequestInfo& request) {
+  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);
 
     std::string response = 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());
     connection_->Send(response);
   }
 
-  virtual ParseResult Read(std::string* message) {
+  virtual ParseResult Read(std::string* message) OVERRIDE {
     size_t data_length = connection_->recv_data().length();
     if (data_length < 2)
       return FRAME_INCOMPLETE;
 
     const char* p = connection_->recv_data().c_str();
     const char* buffer_end = p + data_length;
 
     unsigned char first_byte = *p++;
     unsigned char second_byte = *p++;
 
@@ skipping 63 matching lines @@
       message->swap(buffer);
     }
 
     size_t pos = p + kMaskingKeyWidthInBytes + payload_length_ -
         connection_->recv_data().c_str();
     connection_->Shift(pos);
 
     return closed_ ? FRAME_CLOSE : FRAME_OK;
   }
 
-  virtual void Send(const std::string& message) {
+  virtual void Send(const std::string& message) OVERRIDE {
     if (closed_)
       return;
 
     std::vector<char> frame;
     OpCode op_code = kOpCodeText;
     size_t data_length = message.length();
 
     frame.push_back(kFinalBit | op_code);
     if (data_length <= kMaxSingleBytePayloadLength)
       frame.push_back(data_length);
@@ skipping 62 matching lines @@
   if (socket)
     return socket;
 
   return WebSocketHixie76::Create(connection, request, pos);
 }
 
 WebSocket::WebSocket(HttpConnection* connection) : connection_(connection) {
 }
 
 }  // namespace net