Replace FINAL and OVERRIDE with their C++11 counterparts in content

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"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 class StreamTest : public testing::Test {
  public:
   StreamTest() : producing_seed_key_(0) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     registry_.reset(new StreamRegistry());
   }
 
   // Create a new IO buffer of the given |buffer_size| and fill it with random
   // data.
   scoped_refptr<net::IOBuffer> NewIOBuffer(size_t buffer_size) {
     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(buffer_size));
     char *bufferp = buffer->data();
     for (size_t i = 0; i < buffer_size; i++)
       bufferp[i] = (i + producing_seed_key_) % (1 << sizeof(char));
@@ skipping 39 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 {
+  virtual 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() {}
 
   void Write(Stream* stream,
              scoped_refptr<net::IOBuffer> buffer,
              size_t buffer_size) {
     stream->AddData(buffer, buffer_size);
   }
 
-  virtual void OnSpaceAvailable(Stream* stream) OVERRIDE {
+  virtual void OnSpaceAvailable(Stream* stream) override {
   }
 
-  virtual void OnClose(Stream* stream) OVERRIDE {
+  virtual 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));
@@ skipping 183 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