Standardize usage of virtual/override/final in content/browser/

content/browser/streams/stream_unittest.cc

 // Copyright (c) 2013 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 "base/message_loop/message_loop.h"
 #include "base/test/test_simple_task_runner.h"
 #include "content/browser/streams/stream.h"
 #include "content/browser/streams/stream_read_observer.h"
 #include "content/browser/streams/stream_registry.h"
 #include "content/browser/streams/stream_write_observer.h"
@@ skipping 25 matching lines @@
   scoped_ptr<StreamRegistry> registry_;
 
  private:
   int producing_seed_key_;
 };
 
 class TestStreamReader : public StreamReadObserver {
  public:
   TestStreamReader() : buffer_(new net::GrowableIOBuffer()), completed_(false) {
   }
-  virtual ~TestStreamReader() {}
+  ~TestStreamReader() override {}
 
   void Read(Stream* stream) {
     const size_t kBufferSize = 32768;
     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
 
     int bytes_read = 0;
     while (true) {
       Stream::StreamState state =
           stream->ReadRawData(buffer.get(), kBufferSize, &bytes_read);
       switch (state) {
@@ skipping 12 matching lines @@
           EXPECT_FALSE(completed_);
           return;
       }
       size_t old_capacity = buffer_->capacity();
       buffer_->SetCapacity(old_capacity + bytes_read);
       memcpy(buffer_->StartOfBuffer() + old_capacity,
              buffer->data(), bytes_read);
     }
   }
 
-  virtual void OnDataAvailable(Stream* stream) override {
-    Read(stream);
-  }
+  void OnDataAvailable(Stream* stream) override { Read(stream); }
 
   scoped_refptr<net::GrowableIOBuffer> buffer() { return buffer_; }
 
   bool completed() const {
     return completed_;
   }
 
  private:
   scoped_refptr<net::GrowableIOBuffer> buffer_;
   bool completed_;
 };
 
 class TestStreamWriter : public StreamWriteObserver {
  public:
   TestStreamWriter() {}
-  virtual ~TestStreamWriter() {}
+  ~TestStreamWriter() override {}
 
   void Write(Stream* stream,
              scoped_refptr<net::IOBuffer> buffer,
              size_t buffer_size) {
     stream->AddData(buffer, buffer_size);
   }
 
-  virtual void OnSpaceAvailable(Stream* stream) override {
-  }
+  void OnSpaceAvailable(Stream* stream) override {}
 
-  virtual void OnClose(Stream* stream) override {
-  }
+  void OnClose(Stream* stream) override {}
 };
 
 TEST_F(StreamTest, SetReadObserver) {
   TestStreamReader reader;
   TestStreamWriter writer;
 
   GURL url("blob://stream");
   scoped_refptr<Stream> stream(
       new Stream(registry_.get(), &writer, url));
   EXPECT_TRUE(stream->SetReadObserver(&reader));
@@ skipping 182 matching lines @@
 
   // Run loop to make |reader| consume the data.
   base::MessageLoop::current()->RunUntilIdle();
 
   writer.Write(stream.get(), buffer, kBufferSize);
 
   EXPECT_EQ(stream.get(), registry_->GetStream(url).get());
 }
 
 }  // namespace content