Revert of Enable -Winconsistent-missing-override flag.

webrtc/base/sslstreamadapter_unittest.cc

 /*
  *  Copyright 2011 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 544 matching lines @@
   }
 
   void CreateStreams() override {
     client_stream_ =
         new SSLDummyStreamTLS(this, "c2s", &client_buffer_, &server_buffer_);
     server_stream_ =
         new SSLDummyStreamTLS(this, "s2c", &server_buffer_, &client_buffer_);
   }
 
   // Test data transfer for TLS
-  void TestTransfer(int size) override {
+  virtual void TestTransfer(int size) {
     LOG(LS_INFO) << "Starting transfer test with " << size << " bytes";
     // Create some dummy data to send.
     size_t received;
 
     send_stream_.ReserveSize(size);
     for (int i = 0; i < size; ++i) {
       char ch = static_cast<char>(i);
       send_stream_.Write(&ch, 1, NULL, NULL);
     }
     send_stream_.Rewind();
 
     // Prepare the receive stream.
     recv_stream_.ReserveSize(size);
 
     // Start sending
     WriteData();
 
     // Wait for the client to close
     EXPECT_TRUE_WAIT(server_ssl_->GetState() == rtc::SS_CLOSED, 10000);
 
     // Now check the data
     recv_stream_.GetSize(&received);
 
     EXPECT_EQ(static_cast<size_t>(size), received);
     EXPECT_EQ(0, memcmp(send_stream_.GetBuffer(),
                         recv_stream_.GetBuffer(), size));
   }
 
-  void WriteData() override {
+  void WriteData() {
     size_t position, tosend, size;
     rtc::StreamResult rv;
     size_t sent;
     char block[kBlockSize];
 
     send_stream_.GetSize(&size);
     if (!size)
       return;
 
     for (;;) {
@@ skipping 15 matching lines @@
         }
       } else {
         // Now close
         LOG(LS_INFO) << "Wrote " << position << " bytes. Closing";
         client_ssl_->Close();
         break;
       }
     }
   };
 
-  void ReadData(rtc::StreamInterface *stream) override {
+  virtual void ReadData(rtc::StreamInterface *stream) {
     char buffer[1600];
     size_t bread;
     int err2;
     rtc::StreamResult r;
 
     for (;;) {
       r = stream->Read(buffer, sizeof(buffer), &bread, &err2);
 
       if (r == rtc::SR_ERROR || r == rtc::SR_EOS) {
         // Unfortunately, errors are the way that the stream adapter
@@ skipping 43 matching lines @@
       packet_size_(1000), count_(0), sent_(0) {
   }
 
   void CreateStreams() override {
     client_stream_ =
         new SSLDummyStreamDTLS(this, "c2s", &client_buffer_, &server_buffer_);
     server_stream_ =
         new SSLDummyStreamDTLS(this, "s2c", &server_buffer_, &client_buffer_);
   }
 
-  void WriteData() override {
+  virtual void WriteData() {
     unsigned char *packet = new unsigned char[1600];
 
     while (sent_ < count_) {
       unsigned int rand_state = sent_;
       packet[0] = sent_;
       for (size_t i = 1; i < packet_size_; i++) {
         // This is a simple LC PRNG.  Keep in synch with identical code below.
         rand_state = (rand_state * 251 + 19937) >> 7;
         packet[i] = rand_state & 0xff;
       }
 
       size_t sent;
       rtc::StreamResult rv = client_ssl_->Write(packet, packet_size_, &sent, 0);
       if (rv == rtc::SR_SUCCESS) {
         LOG(LS_VERBOSE) << "Sent: " << sent_;
         sent_++;
       } else if (rv == rtc::SR_BLOCK) {
         LOG(LS_VERBOSE) << "Blocked...";
         break;
       } else {
         ADD_FAILURE();
         break;
       }
     }
 
     delete [] packet;
   }
 
-  void ReadData(rtc::StreamInterface *stream) override {
+  virtual void ReadData(rtc::StreamInterface *stream) {
     unsigned char buffer[2000];
     size_t bread;
     int err2;
     rtc::StreamResult r;
 
     for (;;) {
       r = stream->Read(buffer, 2000, &bread, &err2);
 
       if (r == rtc::SR_ERROR) {
         // Unfortunately, errors are the way that the stream adapter
@@ skipping 15 matching lines @@
       unsigned int rand_state = packet_num;
       for (size_t i = 1; i < packet_size_; i++) {
         // This is a simple LC PRNG.  Keep in synch with identical code above.
         rand_state = (rand_state * 251 + 19937) >> 7;
         ASSERT_EQ(rand_state & 0xff, buffer[i]);
       }
       received_.insert(packet_num);
     }
   }
 
-  void TestTransfer(int count) override {
+  virtual void TestTransfer(int count) {
     count_ = count;
 
     WriteData();
 
     EXPECT_TRUE_WAIT(sent_ == count_, 10000);
     LOG(LS_INFO) << "sent_ == " << sent_;
 
     if (damage_) {
       WAIT(false, 2000);
       EXPECT_EQ(0U, received_.size());
@@ skipping 388 matching lines @@
                    rtc::KeyParams::ECDSA(rtc::EC_NIST_P256))));
 INSTANTIATE_TEST_CASE_P(
     SSLStreamAdapterTestsDTLS,
     SSLStreamAdapterTestDTLS,
     Combine(Values(rtc::KeyParams::RSA(1024, 65537),
                    rtc::KeyParams::RSA(1152, 65537),
                    rtc::KeyParams::ECDSA(rtc::EC_NIST_P256)),
             Values(rtc::KeyParams::RSA(1024, 65537),
                    rtc::KeyParams::RSA(1152, 65537),
                    rtc::KeyParams::ECDSA(rtc::EC_NIST_P256))));