replace OVERRIDE and FINAL with override and final in net/

BUG=417463

Review URL: https://codereview.chromium.org/623213004

Cr-Commit-Position: refs/heads/master@{#298844}

15 files changed, 158 insertions, 158 deletions

diff --git a/net/websockets/websocket_basic_handshake_stream.h b/net/websockets/websocket_basic_handshake_stream.h
index 51f0c4d..cc8f5bf 100644
--- a/net/websockets/websocket_basic_handshake_stream.h
+++ b/net/websockets/websocket_basic_handshake_stream.h
@@ -42,35 +42,35 @@ class NET_EXPORT_PRIVATE WebSocketBasicHandshakeStream
   virtual int InitializeStream(const HttpRequestInfo* request_info,
                                RequestPriority priority,
                                const BoundNetLog& net_log,
-                               const CompletionCallback& callback) OVERRIDE;
+                               const CompletionCallback& callback) override;
   virtual int SendRequest(const HttpRequestHeaders& request_headers,
                           HttpResponseInfo* response,
-                          const CompletionCallback& callback) OVERRIDE;
-  virtual int ReadResponseHeaders(const CompletionCallback& callback) OVERRIDE;
+                          const CompletionCallback& callback) override;
+  virtual int ReadResponseHeaders(const CompletionCallback& callback) override;
   virtual int ReadResponseBody(IOBuffer* buf,
                                int buf_len,
-                               const CompletionCallback& callback) OVERRIDE;
-  virtual void Close(bool not_reusable) OVERRIDE;
-  virtual bool IsResponseBodyComplete() const OVERRIDE;
-  virtual bool CanFindEndOfResponse() const OVERRIDE;
-  virtual bool IsConnectionReused() const OVERRIDE;
-  virtual void SetConnectionReused() OVERRIDE;
-  virtual bool IsConnectionReusable() const OVERRIDE;
-  virtual int64 GetTotalReceivedBytes() const OVERRIDE;
+                               const CompletionCallback& callback) override;
+  virtual void Close(bool not_reusable) override;
+  virtual bool IsResponseBodyComplete() const override;
+  virtual bool CanFindEndOfResponse() const override;
+  virtual bool IsConnectionReused() const override;
+  virtual void SetConnectionReused() override;
+  virtual bool IsConnectionReusable() const override;
+  virtual int64 GetTotalReceivedBytes() const override;
   virtual bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const
-      OVERRIDE;
-  virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+      override;
+  virtual void GetSSLInfo(SSLInfo* ssl_info) override;
   virtual void GetSSLCertRequestInfo(
-      SSLCertRequestInfo* cert_request_info) OVERRIDE;
-  virtual bool IsSpdyHttpStream() const OVERRIDE;
-  virtual void Drain(HttpNetworkSession* session) OVERRIDE;
-  virtual void SetPriority(RequestPriority priority) OVERRIDE;
+      SSLCertRequestInfo* cert_request_info) override;
+  virtual bool IsSpdyHttpStream() const override;
+  virtual void Drain(HttpNetworkSession* session) override;
+  virtual void SetPriority(RequestPriority priority) override;
 
   // This is called from the top level once correct handshake response headers
   // have been received. It creates an appropriate subclass of WebSocketStream
   // depending on what extensions were negotiated. This object is unusable after
   // Upgrade() has been called and should be disposed of as soon as possible.
-  virtual scoped_ptr<WebSocketStream> Upgrade() OVERRIDE;
+  virtual scoped_ptr<WebSocketStream> Upgrade() override;
 
   // Set the value used for the next Sec-WebSocket-Key header
   // deterministically. The key is only used once, and then discarded.
diff --git a/net/websockets/websocket_basic_stream.h b/net/websockets/websocket_basic_stream.h
index ccfebd8..ed2f195 100644
--- a/net/websockets/websocket_basic_stream.h
+++ b/net/websockets/websocket_basic_stream.h
@@ -44,16 +44,16 @@ class NET_EXPORT_PRIVATE WebSocketBasicStream : public WebSocketStream {
 
   // WebSocketStream implementation.
   virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
-                         const CompletionCallback& callback) OVERRIDE;
+                         const CompletionCallback& callback) override;
 
   virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) OVERRIDE;
+                          const CompletionCallback& callback) override;
 
-  virtual void Close() OVERRIDE;
+  virtual void Close() override;
 
-  virtual std::string GetSubProtocol() const OVERRIDE;
+  virtual std::string GetSubProtocol() const override;
 
-  virtual std::string GetExtensions() const OVERRIDE;
+  virtual std::string GetExtensions() const override;
 
   ////////////////////////////////////////////////////////////////////////////
   // Methods for testing only.
diff --git a/net/websockets/websocket_basic_stream_test.cc b/net/websockets/websocket_basic_stream_test.cc
index c67583d..a658fcf 100644
--- a/net/websockets/websocket_basic_stream_test.cc
+++ b/net/websockets/websocket_basic_stream_test.cc
@@ -237,7 +237,7 @@ class WebSocketBasicStreamSocketWriteTest
  protected:
   // All write tests use the same frame, so it is easiest to create it during
   // test creation.
-  virtual void SetUp() OVERRIDE { PrepareWriteFrame(); }
+  virtual void SetUp() override { PrepareWriteFrame(); }
 
   // Creates a WebSocketFrame with a wire format matching kWriteFrame and adds
   // it to |frames_|.
diff --git a/net/websockets/websocket_channel.cc b/net/websockets/websocket_channel.cc
index 8c264f1..70fa771 100644
--- a/net/websockets/websocket_channel.cc
+++ b/net/websockets/websocket_channel.cc
@@ -156,23 +156,23 @@ class WebSocketChannel::ConnectDelegate
  public:
   explicit ConnectDelegate(WebSocketChannel* creator) : creator_(creator) {}
 
-  virtual void OnSuccess(scoped_ptr<WebSocketStream> stream) OVERRIDE {
+  virtual void OnSuccess(scoped_ptr<WebSocketStream> stream) override {
     creator_->OnConnectSuccess(stream.Pass());
     // |this| may have been deleted.
   }
 
-  virtual void OnFailure(const std::string& message) OVERRIDE {
+  virtual void OnFailure(const std::string& message) override {
     creator_->OnConnectFailure(message);
     // |this| has been deleted.
   }
 
   virtual void OnStartOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeRequestInfo> request) OVERRIDE {
+      scoped_ptr<WebSocketHandshakeRequestInfo> request) override {
     creator_->OnStartOpeningHandshake(request.Pass());
   }
 
   virtual void OnFinishOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeResponseInfo> response) OVERRIDE {
+      scoped_ptr<WebSocketHandshakeResponseInfo> response) override {
     creator_->OnFinishOpeningHandshake(response.Pass());
   }
 
@@ -180,7 +180,7 @@ class WebSocketChannel::ConnectDelegate
       scoped_ptr<WebSocketEventInterface::SSLErrorCallbacks>
           ssl_error_callbacks,
       const SSLInfo& ssl_info,
-      bool fatal) OVERRIDE {
+      bool fatal) override {
     creator_->OnSSLCertificateError(
         ssl_error_callbacks.Pass(), ssl_info, fatal);
   }
diff --git a/net/websockets/websocket_channel_test.cc b/net/websockets/websocket_channel_test.cc
index 42c1ed6..6535741 100644
--- a/net/websockets/websocket_channel_test.cc
+++ b/net/websockets/websocket_channel_test.cc
@@ -163,12 +163,12 @@ class MockWebSocketEventInterface : public WebSocketEventInterface {
 
   // We can't use GMock with scoped_ptr.
   ChannelState OnStartOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeRequestInfo>) OVERRIDE {
+      scoped_ptr<WebSocketHandshakeRequestInfo>) override {
     OnStartOpeningHandshakeCalled();
     return CHANNEL_ALIVE;
   }
   ChannelState OnFinishOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeResponseInfo>) OVERRIDE {
+      scoped_ptr<WebSocketHandshakeResponseInfo>) override {
     OnFinishOpeningHandshakeCalled();
     return CHANNEL_ALIVE;
   }
@@ -176,7 +176,7 @@ class MockWebSocketEventInterface : public WebSocketEventInterface {
       scoped_ptr<SSLErrorCallbacks> ssl_error_callbacks,
       const GURL& url,
       const SSLInfo& ssl_info,
-      bool fatal) OVERRIDE {
+      bool fatal) override {
     OnSSLCertificateErrorCalled(
         ssl_error_callbacks.get(), url, ssl_info, fatal);
     return CHANNEL_ALIVE;
@@ -195,39 +195,39 @@ class FakeWebSocketEventInterface : public WebSocketEventInterface {
   virtual ChannelState OnAddChannelResponse(
       bool fail,
       const std::string& selected_protocol,
-      const std::string& extensions) OVERRIDE {
+      const std::string& extensions) override {
     return fail ? CHANNEL_DELETED : CHANNEL_ALIVE;
   }
   virtual ChannelState OnDataFrame(bool fin,
                                    WebSocketMessageType type,
-                                   const std::vector<char>& data) OVERRIDE {
+                                   const std::vector<char>& data) override {
     return CHANNEL_ALIVE;
   }
-  virtual ChannelState OnFlowControl(int64 quota) OVERRIDE {
+  virtual ChannelState OnFlowControl(int64 quota) override {
     return CHANNEL_ALIVE;
   }
-  virtual ChannelState OnClosingHandshake() OVERRIDE { return CHANNEL_ALIVE; }
-  virtual ChannelState OnFailChannel(const std::string& message) OVERRIDE {
+  virtual ChannelState OnClosingHandshake() override { return CHANNEL_ALIVE; }
+  virtual ChannelState OnFailChannel(const std::string& message) override {
     return CHANNEL_DELETED;
   }
   virtual ChannelState OnDropChannel(bool was_clean,
                                      uint16 code,
-                                     const std::string& reason) OVERRIDE {
+                                     const std::string& reason) override {
     return CHANNEL_DELETED;
   }
   virtual ChannelState OnStartOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeRequestInfo> request) OVERRIDE {
+      scoped_ptr<WebSocketHandshakeRequestInfo> request) override {
     return CHANNEL_ALIVE;
   }
   virtual ChannelState OnFinishOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeResponseInfo> response) OVERRIDE {
+      scoped_ptr<WebSocketHandshakeResponseInfo> response) override {
     return CHANNEL_ALIVE;
   }
   virtual ChannelState OnSSLCertificateError(
       scoped_ptr<SSLErrorCallbacks> ssl_error_callbacks,
       const GURL& url,
       const SSLInfo& ssl_info,
-      bool fatal) OVERRIDE {
+      bool fatal) override {
     return CHANNEL_ALIVE;
   }
 };
@@ -246,22 +246,22 @@ class FakeWebSocketStream : public WebSocketStream {
       : protocol_(protocol), extensions_(extensions) {}
 
   virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
-                         const CompletionCallback& callback) OVERRIDE {
+                         const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
 
   virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) OVERRIDE {
+                          const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
 
-  virtual void Close() OVERRIDE {}
+  virtual void Close() override {}
 
   // Returns the string passed to the constructor.
-  virtual std::string GetSubProtocol() const OVERRIDE { return protocol_; }
+  virtual std::string GetSubProtocol() const override { return protocol_; }
 
   // Returns the string passed to the constructor.
-  virtual std::string GetExtensions() const OVERRIDE { return extensions_; }
+  virtual std::string GetExtensions() const override { return extensions_; }
 
  private:
   // The string to return from GetSubProtocol().
@@ -493,7 +493,7 @@ class ReadableFakeWebSocketStream : public FakeWebSocketStream {
   }
 
   virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
-                         const CompletionCallback& callback) OVERRIDE {
+                         const CompletionCallback& callback) override {
     CHECK(!read_frames_pending_);
     if (index_ >= responses_.size())
       return ERR_IO_PENDING;
@@ -550,7 +550,7 @@ class ReadableFakeWebSocketStream : public FakeWebSocketStream {
 class WriteableFakeWebSocketStream : public FakeWebSocketStream {
  public:
   virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) OVERRIDE {
+                          const CompletionCallback& callback) override {
     return OK;
   }
 };
@@ -559,7 +559,7 @@ class WriteableFakeWebSocketStream : public FakeWebSocketStream {
 class UnWriteableFakeWebSocketStream : public FakeWebSocketStream {
  public:
   virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) OVERRIDE {
+                          const CompletionCallback& callback) override {
     return ERR_CONNECTION_RESET;
   }
 };
@@ -575,7 +575,7 @@ class EchoeyFakeWebSocketStream : public FakeWebSocketStream {
   EchoeyFakeWebSocketStream() : read_frames_(NULL), done_(false) {}
 
   virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) OVERRIDE {
+                          const CompletionCallback& callback) override {
     // Users of WebSocketStream will not expect the ReadFrames() callback to be
     // called from within WriteFrames(), so post it to the message loop instead.
     stored_frames_.insert(stored_frames_.end(), frames->begin(), frames->end());
@@ -585,7 +585,7 @@ class EchoeyFakeWebSocketStream : public FakeWebSocketStream {
   }
 
   virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
-                         const CompletionCallback& callback) OVERRIDE {
+                         const CompletionCallback& callback) override {
     read_callback_ = callback;
     read_frames_ = frames;
     if (done_)
@@ -648,7 +648,7 @@ class ResetOnWriteFakeWebSocketStream : public FakeWebSocketStream {
   ResetOnWriteFakeWebSocketStream() : closed_(false), weak_ptr_factory_(this) {}
 
   virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) OVERRIDE {
+                          const CompletionCallback& callback) override {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ResetOnWriteFakeWebSocketStream::CallCallbackUnlessClosed,
@@ -665,12 +665,12 @@ class ResetOnWriteFakeWebSocketStream : public FakeWebSocketStream {
   }
 
   virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
-                         const CompletionCallback& callback) OVERRIDE {
+                         const CompletionCallback& callback) override {
     read_callback_ = callback;
     return ERR_IO_PENDING;
   }
 
-  virtual void Close() OVERRIDE { closed_ = true; }
+  virtual void Close() override { closed_ = true; }
 
  private:
   void CallCallbackUnlessClosed(const CompletionCallback& callback, int value) {
@@ -736,8 +736,8 @@ std::vector<char> AsVector(const std::string& s) {
 class FakeSSLErrorCallbacks
     : public WebSocketEventInterface::SSLErrorCallbacks {
  public:
-  virtual void CancelSSLRequest(int error, const SSLInfo* ssl_info) OVERRIDE {}
-  virtual void ContinueSSLRequest() OVERRIDE {}
+  virtual void CancelSSLRequest(int error, const SSLInfo* ssl_info) override {}
+  virtual void ContinueSSLRequest() override {}
 };
 
 // Base class for all test fixtures.
@@ -850,7 +850,7 @@ class WebSocketChannelDeletingTest : public WebSocketChannelTest {
                   EVENT_ON_SSL_CERTIFICATE_ERROR) {}
   // Create a ChannelDeletingFakeWebSocketEventInterface. Defined out-of-line to
   // avoid circular dependency.
-  virtual scoped_ptr<WebSocketEventInterface> CreateEventInterface() OVERRIDE;
+  virtual scoped_ptr<WebSocketEventInterface> CreateEventInterface() override;
 
   // Tests can set deleting_ to a bitmap of EventInterfaceCall members that they
   // want to cause Channel deletion. The default is for all calls to cause
@@ -870,47 +870,47 @@ class ChannelDeletingFakeWebSocketEventInterface
   virtual ChannelState OnAddChannelResponse(
       bool fail,
       const std::string& selected_protocol,
-      const std::string& extensions) OVERRIDE {
+      const std::string& extensions) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_ADD_CHANNEL_RESPONSE);
   }
 
   virtual ChannelState OnDataFrame(bool fin,
                                    WebSocketMessageType type,
-                                   const std::vector<char>& data) OVERRIDE {
+                                   const std::vector<char>& data) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_DATA_FRAME);
   }
 
-  virtual ChannelState OnFlowControl(int64 quota) OVERRIDE {
+  virtual ChannelState OnFlowControl(int64 quota) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_FLOW_CONTROL);
   }
 
-  virtual ChannelState OnClosingHandshake() OVERRIDE {
+  virtual ChannelState OnClosingHandshake() override {
     return fixture_->DeleteIfDeleting(EVENT_ON_CLOSING_HANDSHAKE);
   }
 
-  virtual ChannelState OnFailChannel(const std::string& message) OVERRIDE {
+  virtual ChannelState OnFailChannel(const std::string& message) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_FAIL_CHANNEL);
   }
 
   virtual ChannelState OnDropChannel(bool was_clean,
                                      uint16 code,
-                                     const std::string& reason) OVERRIDE {
+                                     const std::string& reason) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_DROP_CHANNEL);
   }
 
   virtual ChannelState OnStartOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeRequestInfo> request) OVERRIDE {
+      scoped_ptr<WebSocketHandshakeRequestInfo> request) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_START_OPENING_HANDSHAKE);
   }
   virtual ChannelState OnFinishOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeResponseInfo> response) OVERRIDE {
+      scoped_ptr<WebSocketHandshakeResponseInfo> response) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_FINISH_OPENING_HANDSHAKE);
   }
   virtual ChannelState OnSSLCertificateError(
       scoped_ptr<SSLErrorCallbacks> ssl_error_callbacks,
       const GURL& url,
       const SSLInfo& ssl_info,
-      bool fatal) OVERRIDE {
+      bool fatal) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_SSL_CERTIFICATE_ERROR);
   }
 
@@ -949,7 +949,7 @@ class WebSocketChannelEventInterfaceTest : public WebSocketChannelTest {
   // object before calling CreateChannelAndConnect() or
   // CreateChannelAndConnectSuccessfully(). This will only work once per test
   // case, but once should be enough.
-  virtual scoped_ptr<WebSocketEventInterface> CreateEventInterface() OVERRIDE {
+  virtual scoped_ptr<WebSocketEventInterface> CreateEventInterface() override {
     return scoped_ptr<WebSocketEventInterface>(event_interface_.release());
   }
 
@@ -963,7 +963,7 @@ class WebSocketChannelStreamTest : public WebSocketChannelTest {
   WebSocketChannelStreamTest()
       : mock_stream_(new StrictMock<MockWebSocketStream>) {}
 
-  virtual void CreateChannelAndConnectSuccessfully() OVERRIDE {
+  virtual void CreateChannelAndConnectSuccessfully() override {
     set_stream(mock_stream_.Pass());
     WebSocketChannelTest::CreateChannelAndConnectSuccessfully();
   }
@@ -3317,7 +3317,7 @@ class WebSocketChannelStreamTimeoutTest : public WebSocketChannelStreamTest {
  protected:
   WebSocketChannelStreamTimeoutTest() {}
 
-  virtual void CreateChannelAndConnectSuccessfully() OVERRIDE {
+  virtual void CreateChannelAndConnectSuccessfully() override {
     set_stream(mock_stream_.Pass());
     CreateChannelAndConnect();
     channel_->SendFlowControl(kPlentyOfQuota);
diff --git a/net/websockets/websocket_deflate_predictor_impl.h b/net/websockets/websocket_deflate_predictor_impl.h
index 88a919c..d6b52c4 100644
--- a/net/websockets/websocket_deflate_predictor_impl.h
+++ b/net/websockets/websocket_deflate_predictor_impl.h
@@ -21,9 +21,9 @@ class NET_EXPORT_PRIVATE WebSocketDeflatePredictorImpl
   virtual ~WebSocketDeflatePredictorImpl() {}
 
   virtual Result Predict(const ScopedVector<WebSocketFrame>& frames,
-                         size_t frame_index) OVERRIDE;
-  virtual void RecordInputDataFrame(const WebSocketFrame* frame) OVERRIDE;
-  virtual void RecordWrittenDataFrame(const WebSocketFrame* frame) OVERRIDE;
+                         size_t frame_index) override;
+  virtual void RecordInputDataFrame(const WebSocketFrame* frame) override;
+  virtual void RecordWrittenDataFrame(const WebSocketFrame* frame) override;
 };
 
 }  // namespace net
diff --git a/net/websockets/websocket_deflate_stream.h b/net/websockets/websocket_deflate_stream.h
index 39ac2df..8f939ec1 100644
--- a/net/websockets/websocket_deflate_stream.h
+++ b/net/websockets/websocket_deflate_stream.h
@@ -47,12 +47,12 @@ class NET_EXPORT_PRIVATE WebSocketDeflateStream : public WebSocketStream {
 
   // WebSocketStream functions.
   virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
-                         const CompletionCallback& callback) OVERRIDE;
+                         const CompletionCallback& callback) override;
   virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) OVERRIDE;
-  virtual void Close() OVERRIDE;
-  virtual std::string GetSubProtocol() const OVERRIDE;
-  virtual std::string GetExtensions() const OVERRIDE;
+                          const CompletionCallback& callback) override;
+  virtual void Close() override;
+  virtual std::string GetSubProtocol() const override;
+  virtual std::string GetExtensions() const override;
 
  private:
   enum ReadingState {
diff --git a/net/websockets/websocket_deflate_stream_test.cc b/net/websockets/websocket_deflate_stream_test.cc
index 590f616..4f1c418 100644
--- a/net/websockets/websocket_deflate_stream_test.cc
+++ b/net/websockets/websocket_deflate_stream_test.cc
@@ -125,10 +125,10 @@ class WebSocketDeflatePredictorMock : public WebSocketDeflatePredictor {
 
   // WebSocketDeflatePredictor functions.
   virtual Result Predict(const ScopedVector<WebSocketFrame>& frames,
-                         size_t frame_index) OVERRIDE {
+                         size_t frame_index) override {
     return result_;
   }
-  virtual void RecordInputDataFrame(const WebSocketFrame* frame) OVERRIDE {
+  virtual void RecordInputDataFrame(const WebSocketFrame* frame) override {
     if (!WebSocketFrameHeader::IsKnownDataOpCode(frame->header.opcode)) {
       ADD_FAILURE() << "Control frames should not be recorded.";
       return;
@@ -147,7 +147,7 @@ class WebSocketDeflatePredictorMock : public WebSocketDeflatePredictor {
     }
     frames_to_be_input_.pop_front();
   }
-  virtual void RecordWrittenDataFrame(const WebSocketFrame* frame) OVERRIDE {
+  virtual void RecordWrittenDataFrame(const WebSocketFrame* frame) override {
     if (!WebSocketFrameHeader::IsKnownDataOpCode(frame->header.opcode)) {
       ADD_FAILURE() << "Control frames should not be recorded.";
       return;
diff --git a/net/websockets/websocket_handshake_stream_create_helper.h b/net/websockets/websocket_handshake_stream_create_helper.h
index fd9ab74..aad2644 100644
--- a/net/websockets/websocket_handshake_stream_create_helper.h
+++ b/net/websockets/websocket_handshake_stream_create_helper.h
@@ -38,12 +38,12 @@ class NET_EXPORT_PRIVATE WebSocketHandshakeStreamCreateHelper
   // Create a WebSocketBasicHandshakeStream.
   virtual WebSocketHandshakeStreamBase* CreateBasicStream(
       scoped_ptr<ClientSocketHandle> connection,
-      bool using_proxy) OVERRIDE;
+      bool using_proxy) override;
 
   // Unimplemented as of November 2013.
   virtual WebSocketHandshakeStreamBase* CreateSpdyStream(
       const base::WeakPtr<SpdySession>& session,
-      bool use_relative_url) OVERRIDE;
+      bool use_relative_url) override;
 
   // Call Upgrade() on the WebSocketHandshakeStream and return the result. This
   // must only be called if the handshake succeeded.
diff --git a/net/websockets/websocket_handshake_stream_create_helper_test.cc b/net/websockets/websocket_handshake_stream_create_helper_test.cc
index 88b868f..a776acd 100644
--- a/net/websockets/websocket_handshake_stream_create_helper_test.cc
+++ b/net/websockets/websocket_handshake_stream_create_helper_test.cc
@@ -61,17 +61,17 @@ class TestConnectDelegate : public WebSocketStream::ConnectDelegate {
  public:
   virtual ~TestConnectDelegate() {}
 
-  virtual void OnSuccess(scoped_ptr<WebSocketStream> stream) OVERRIDE {}
-  virtual void OnFailure(const std::string& failure_message) OVERRIDE {}
+  virtual void OnSuccess(scoped_ptr<WebSocketStream> stream) override {}
+  virtual void OnFailure(const std::string& failure_message) override {}
   virtual void OnStartOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeRequestInfo> request) OVERRIDE {}
+      scoped_ptr<WebSocketHandshakeRequestInfo> request) override {}
   virtual void OnFinishOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeResponseInfo> response) OVERRIDE {}
+      scoped_ptr<WebSocketHandshakeResponseInfo> response) override {}
   virtual void OnSSLCertificateError(
       scoped_ptr<WebSocketEventInterface::SSLErrorCallbacks>
           ssl_error_callbacks,
       const SSLInfo& ssl_info,
-      bool fatal) OVERRIDE {}
+      bool fatal) override {}
 };
 
 class WebSocketHandshakeStreamCreateHelperTest : public ::testing::Test {
diff --git a/net/websockets/websocket_job.h b/net/websockets/websocket_job.h
index 2e90a24..924fdd0 100644
--- a/net/websockets/websocket_job.h
+++ b/net/websockets/websocket_job.h
@@ -50,37 +50,37 @@ class NET_EXPORT WebSocketJob
   static void EnsureInit();
 
   State state() const { return state_; }
-  virtual void Connect() OVERRIDE;
-  virtual bool SendData(const char* data, int len) OVERRIDE;
-  virtual void Close() OVERRIDE;
-  virtual void RestartWithAuth(const AuthCredentials& credentials) OVERRIDE;
-  virtual void DetachDelegate() OVERRIDE;
+  virtual void Connect() override;
+  virtual bool SendData(const char* data, int len) override;
+  virtual void Close() override;
+  virtual void RestartWithAuth(const AuthCredentials& credentials) override;
+  virtual void DetachDelegate() override;
 
   // SocketStream::Delegate methods.
   virtual int OnStartOpenConnection(
-      SocketStream* socket, const CompletionCallback& callback) OVERRIDE;
+      SocketStream* socket, const CompletionCallback& callback) override;
   virtual void OnConnected(SocketStream* socket,
-                           int max_pending_send_allowed) OVERRIDE;
-  virtual void OnSentData(SocketStream* socket, int amount_sent) OVERRIDE;
+                           int max_pending_send_allowed) override;
+  virtual void OnSentData(SocketStream* socket, int amount_sent) override;
   virtual void OnReceivedData(SocketStream* socket,
                               const char* data,
-                              int len) OVERRIDE;
-  virtual void OnClose(SocketStream* socket) OVERRIDE;
+                              int len) override;
+  virtual void OnClose(SocketStream* socket) override;
   virtual void OnAuthRequired(
-      SocketStream* socket, AuthChallengeInfo* auth_info) OVERRIDE;
+      SocketStream* socket, AuthChallengeInfo* auth_info) override;
   virtual void OnSSLCertificateError(SocketStream* socket,
                                      const SSLInfo& ssl_info,
-                                     bool fatal) OVERRIDE;
-  virtual void OnError(const SocketStream* socket, int error) OVERRIDE;
+                                     bool fatal) override;
+  virtual void OnError(const SocketStream* socket, int error) override;
 
   // SpdyWebSocketStream::Delegate methods.
-  virtual void OnCreatedSpdyStream(int status) OVERRIDE;
-  virtual void OnSentSpdyHeaders() OVERRIDE;
+  virtual void OnCreatedSpdyStream(int status) override;
+  virtual void OnSentSpdyHeaders() override;
   virtual void OnSpdyResponseHeadersUpdated(
-      const SpdyHeaderBlock& response_headers) OVERRIDE;
-  virtual void OnSentSpdyData(size_t bytes_sent) OVERRIDE;
-  virtual void OnReceivedSpdyData(scoped_ptr<SpdyBuffer> buffer) OVERRIDE;
-  virtual void OnCloseSpdyStream() OVERRIDE;
+      const SpdyHeaderBlock& response_headers) override;
+  virtual void OnSentSpdyData(size_t bytes_sent) override;
+  virtual void OnReceivedSpdyData(scoped_ptr<SpdyBuffer> buffer) override;
+  virtual void OnCloseSpdyStream() override;
 
  private:
   friend class WebSocketThrottle;
diff --git a/net/websockets/websocket_job_test.cc b/net/websockets/websocket_job_test.cc
index 59d529a..9cf3144 100644
--- a/net/websockets/websocket_job_test.cc
+++ b/net/websockets/websocket_job_test.cc
@@ -45,18 +45,18 @@ class MockSocketStream : public SocketStream {
                    URLRequestContext* context, CookieStore* cookie_store)
       : SocketStream(url, delegate, context, cookie_store) {}
 
-  virtual void Connect() OVERRIDE {}
-  virtual bool SendData(const char* data, int len) OVERRIDE {
+  virtual void Connect() override {}
+  virtual bool SendData(const char* data, int len) override {
     sent_data_ += std::string(data, len);
     return true;
   }
 
-  virtual void Close() OVERRIDE {}
+  virtual void Close() override {}
   virtual void RestartWithAuth(
-      const AuthCredentials& credentials) OVERRIDE {
+      const AuthCredentials& credentials) override {
   }
 
-  virtual void DetachDelegate() OVERRIDE {
+  virtual void DetachDelegate() override {
     delegate_ = NULL;
   }
 
@@ -98,40 +98,40 @@ class MockSocketStreamDelegate : public SocketStream::Delegate {
 
   virtual int OnStartOpenConnection(
       SocketStream* socket,
-      const CompletionCallback& callback) OVERRIDE {
+      const CompletionCallback& callback) override {
     if (!on_start_open_connection_.is_null())
       on_start_open_connection_.Run();
     return OK;
   }
   virtual void OnConnected(SocketStream* socket,
-                           int max_pending_send_allowed) OVERRIDE {
+                           int max_pending_send_allowed) override {
     if (!on_connected_.is_null())
       on_connected_.Run();
   }
   virtual void OnSentData(SocketStream* socket,
-                          int amount_sent) OVERRIDE {
+                          int amount_sent) override {
     amount_sent_ += amount_sent;
     if (!on_sent_data_.is_null())
       on_sent_data_.Run();
   }
   virtual void OnReceivedData(SocketStream* socket,
-                              const char* data, int len) OVERRIDE {
+                              const char* data, int len) override {
     received_data_ += std::string(data, len);
     if (!on_received_data_.is_null())
       on_received_data_.Run();
   }
-  virtual void OnClose(SocketStream* socket) OVERRIDE {
+  virtual void OnClose(SocketStream* socket) override {
     if (!on_close_.is_null())
       on_close_.Run();
   }
   virtual bool CanGetCookies(SocketStream* socket,
-                             const GURL& url) OVERRIDE {
+                             const GURL& url) override {
     return allow_all_cookies_;
   }
   virtual bool CanSetCookie(SocketStream* request,
                             const GURL& url,
                             const std::string& cookie_line,
-                            CookieOptions* options) OVERRIDE {
+                            CookieOptions* options) override {
     return allow_all_cookies_;
   }
 
@@ -190,7 +190,7 @@ class MockCookieStore : public CookieStore {
       const GURL& url,
       const std::string& cookie_line,
       const CookieOptions& options,
-      const SetCookiesCallback& callback) OVERRIDE {
+      const SetCookiesCallback& callback) override {
     bool result = SetCookieWithOptions(url, cookie_line, options);
     if (!callback.is_null())
       callback.Run(result);
@@ -199,27 +199,27 @@ class MockCookieStore : public CookieStore {
   virtual void GetCookiesWithOptionsAsync(
       const GURL& url,
       const CookieOptions& options,
-      const GetCookiesCallback& callback) OVERRIDE {
+      const GetCookiesCallback& callback) override {
     if (!callback.is_null())
       callback.Run(GetCookiesWithOptions(url, options));
   }
 
   virtual void GetAllCookiesForURLAsync(
       const GURL& url,
-      const GetCookieListCallback& callback) OVERRIDE {
+      const GetCookieListCallback& callback) override {
     ADD_FAILURE();
   }
 
   virtual void DeleteCookieAsync(const GURL& url,
                                  const std::string& cookie_name,
-                                 const base::Closure& callback) OVERRIDE {
+                                 const base::Closure& callback) override {
     ADD_FAILURE();
   }
 
   virtual void DeleteAllCreatedBetweenAsync(
       const base::Time& delete_begin,
       const base::Time& delete_end,
-      const DeleteCallback& callback) OVERRIDE {
+      const DeleteCallback& callback) override {
     ADD_FAILURE();
   }
 
@@ -227,15 +227,15 @@ class MockCookieStore : public CookieStore {
       const base::Time delete_begin,
       const base::Time delete_end,
       const GURL& url,
-      const DeleteCallback& callback) OVERRIDE {
+      const DeleteCallback& callback) override {
     ADD_FAILURE();
   }
 
-  virtual void DeleteSessionCookiesAsync(const DeleteCallback&) OVERRIDE {
+  virtual void DeleteSessionCookiesAsync(const DeleteCallback&) override {
     ADD_FAILURE();
   }
 
-  virtual CookieMonster* GetCookieMonster() OVERRIDE { return NULL; }
+  virtual CookieMonster* GetCookieMonster() override { return NULL; }
 
   const std::vector<Entry>& entries() const { return entries_; }
 
@@ -248,7 +248,7 @@ class MockCookieStore : public CookieStore {
 
 class MockSSLConfigService : public SSLConfigService {
  public:
-  virtual void GetSSLConfig(SSLConfig* config) OVERRIDE {}
+  virtual void GetSSLConfig(SSLConfig* config) override {}
 
  protected:
   virtual ~MockSSLConfigService() {}
@@ -298,17 +298,17 @@ class MockHttpTransactionFactory : public HttpTransactionFactory {
 
   virtual int CreateTransaction(
       RequestPriority priority,
-      scoped_ptr<HttpTransaction>* trans) OVERRIDE {
+      scoped_ptr<HttpTransaction>* trans) override {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
 
-  virtual HttpCache* GetCache() OVERRIDE {
+  virtual HttpCache* GetCache() override {
     NOTREACHED();
     return NULL;
   }
 
-  virtual HttpNetworkSession* GetSession() OVERRIDE {
+  virtual HttpNetworkSession* GetSession() override {
     return http_session_.get();
   }
 
@@ -350,34 +350,34 @@ class DeletingSocketStreamDelegate : public SocketStream::Delegate {
   // OnStartOpenConnection() is not implemented by SocketStreamDispatcherHost
 
   virtual void OnConnected(SocketStream* socket,
-                           int max_pending_send_allowed) OVERRIDE {
+                           int max_pending_send_allowed) override {
     DeleteJobMaybe();
   }
 
-  virtual void OnSentData(SocketStream* socket, int amount_sent) OVERRIDE {
+  virtual void OnSentData(SocketStream* socket, int amount_sent) override {
     DeleteJobMaybe();
   }
 
   virtual void OnReceivedData(SocketStream* socket,
                               const char* data,
-                              int len) OVERRIDE {
+                              int len) override {
     DeleteJobMaybe();
   }
 
-  virtual void OnClose(SocketStream* socket) OVERRIDE { DeleteJobMaybe(); }
+  virtual void OnClose(SocketStream* socket) override { DeleteJobMaybe(); }
 
   virtual void OnAuthRequired(SocketStream* socket,
-                              AuthChallengeInfo* auth_info) OVERRIDE {
+                              AuthChallengeInfo* auth_info) override {
     DeleteJobMaybe();
   }
 
   virtual void OnSSLCertificateError(SocketStream* socket,
                                      const SSLInfo& ssl_info,
-                                     bool fatal) OVERRIDE {
+                                     bool fatal) override {
     DeleteJobMaybe();
   }
 
-  virtual void OnError(const SocketStream* socket, int error) OVERRIDE {
+  virtual void OnError(const SocketStream* socket, int error) override {
     DeleteJobMaybe();
   }
 
@@ -398,12 +398,12 @@ class WebSocketJobTest : public PlatformTest,
       : spdy_util_(GetParam()),
         enable_websocket_over_spdy_(false) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     stream_type_ = STREAM_INVALID;
     cookie_store_ = new MockCookieStore;
     context_.reset(new MockURLRequestContext(cookie_store_.get()));
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     cookie_store_ = NULL;
     context_.reset();
     websocket_ = NULL;
diff --git a/net/websockets/websocket_stream.cc b/net/websockets/websocket_stream.cc
index be2bc16..90cb7ca 100644
--- a/net/websockets/websocket_stream.cc
+++ b/net/websockets/websocket_stream.cc
@@ -56,7 +56,7 @@ class Delegate : public URLRequest::Delegate {
   // Implementation of URLRequest::Delegate methods.
   virtual void OnReceivedRedirect(URLRequest* request,
                                   const RedirectInfo& redirect_info,
-                                  bool* defer_redirect) OVERRIDE {
+                                  bool* defer_redirect) override {
     // HTTP status codes returned by HttpStreamParser are filtered by
     // WebSocketBasicHandshakeStream, and only 101, 401 and 407 are permitted
     // back up the stack to HttpNetworkTransaction. In particular, redirect
@@ -65,20 +65,20 @@ class Delegate : public URLRequest::Delegate {
     NOTREACHED();
   }
 
-  virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
+  virtual void OnResponseStarted(URLRequest* request) override;
 
   virtual void OnAuthRequired(URLRequest* request,
-                              AuthChallengeInfo* auth_info) OVERRIDE;
+                              AuthChallengeInfo* auth_info) override;
 
   virtual void OnCertificateRequested(URLRequest* request,
                                       SSLCertRequestInfo* cert_request_info)
-      OVERRIDE;
+      override;
 
   virtual void OnSSLCertificateError(URLRequest* request,
                                      const SSLInfo& ssl_info,
-                                     bool fatal) OVERRIDE;
+                                     bool fatal) override;
 
-  virtual void OnReadCompleted(URLRequest* request, int bytes_read) OVERRIDE;
+  virtual void OnReadCompleted(URLRequest* request, int bytes_read) override;
 
  private:
   StreamRequestImpl* owner_;
@@ -206,7 +206,7 @@ class SSLErrorCallbacks : public WebSocketEventInterface::SSLErrorCallbacks {
   explicit SSLErrorCallbacks(URLRequest* url_request)
       : url_request_(url_request) {}
 
-  virtual void CancelSSLRequest(int error, const SSLInfo* ssl_info) OVERRIDE {
+  virtual void CancelSSLRequest(int error, const SSLInfo* ssl_info) override {
     if (ssl_info) {
       url_request_->CancelWithSSLError(error, *ssl_info);
     } else {
@@ -214,7 +214,7 @@ class SSLErrorCallbacks : public WebSocketEventInterface::SSLErrorCallbacks {
     }
   }
 
-  virtual void ContinueSSLRequest() OVERRIDE {
+  virtual void ContinueSSLRequest() override {
     url_request_->ContinueDespiteLastError();
   }
 
diff --git a/net/websockets/websocket_stream_test.cc b/net/websockets/websocket_stream_test.cc
index c90777f..0b7ae4e 100644
--- a/net/websockets/websocket_stream_test.cc
+++ b/net/websockets/websocket_stream_test.cc
@@ -99,7 +99,7 @@ class DeterministicKeyWebSocketHandshakeStreamCreateHelper
       : WebSocketHandshakeStreamCreateHelper(connect_delegate,
                                              requested_subprotocols) {}
 
-  virtual void OnStreamCreated(WebSocketBasicHandshakeStream* stream) OVERRIDE {
+  virtual void OnStreamCreated(WebSocketBasicHandshakeStream* stream) override {
     stream->SetWebSocketKeyForTesting("dGhlIHNhbXBsZSBub25jZQ==");
   }
 };
@@ -201,23 +201,23 @@ class WebSocketStreamCreateTest : public ::testing::Test {
     explicit TestConnectDelegate(WebSocketStreamCreateTest* owner)
         : owner_(owner) {}
 
-    virtual void OnSuccess(scoped_ptr<WebSocketStream> stream) OVERRIDE {
+    virtual void OnSuccess(scoped_ptr<WebSocketStream> stream) override {
       stream.swap(owner_->stream_);
     }
 
-    virtual void OnFailure(const std::string& message) OVERRIDE {
+    virtual void OnFailure(const std::string& message) override {
       owner_->has_failed_ = true;
       owner_->failure_message_ = message;
     }
 
     virtual void OnStartOpeningHandshake(
-        scoped_ptr<WebSocketHandshakeRequestInfo> request) OVERRIDE {
+        scoped_ptr<WebSocketHandshakeRequestInfo> request) override {
       // Can be called multiple times (in the case of HTTP auth). Last call
       // wins.
       owner_->request_info_ = request.Pass();
     }
     virtual void OnFinishOpeningHandshake(
-        scoped_ptr<WebSocketHandshakeResponseInfo> response) OVERRIDE {
+        scoped_ptr<WebSocketHandshakeResponseInfo> response) override {
       if (owner_->response_info_)
         ADD_FAILURE();
       owner_->response_info_ = response.Pass();
@@ -226,7 +226,7 @@ class WebSocketStreamCreateTest : public ::testing::Test {
         scoped_ptr<WebSocketEventInterface::SSLErrorCallbacks>
             ssl_error_callbacks,
         const SSLInfo& ssl_info,
-        bool fatal) OVERRIDE {
+        bool fatal) override {
       owner_->ssl_error_callbacks_ = ssl_error_callbacks.Pass();
       owner_->ssl_info_ = ssl_info;
       owner_->ssl_fatal_ = fatal;
@@ -408,7 +408,7 @@ class WebSocketStreamCreateUMATest : public ::testing::Test {
   };
 
   class StreamCreation : public WebSocketStreamCreateTest {
-    virtual void TestBody() OVERRIDE {}
+    virtual void TestBody() override {}
   };
 
   scoped_ptr<base::HistogramSamples> GetSamples(const std::string& name) {
diff --git a/net/websockets/websocket_throttle_test.cc b/net/websockets/websocket_throttle_test.cc
index 4d93001..a743e93 100644
--- a/net/websockets/websocket_throttle_test.cc
+++ b/net/websockets/websocket_throttle_test.cc
@@ -25,12 +25,12 @@ class DummySocketStreamDelegate : public SocketStream::Delegate {
   DummySocketStreamDelegate() {}
   virtual ~DummySocketStreamDelegate() {}
   virtual void OnConnected(
-      SocketStream* socket, int max_pending_send_allowed) OVERRIDE {}
+      SocketStream* socket, int max_pending_send_allowed) override {}
   virtual void OnSentData(SocketStream* socket,
-                          int amount_sent) OVERRIDE {}
+                          int amount_sent) override {}
   virtual void OnReceivedData(SocketStream* socket,
-                              const char* data, int len) OVERRIDE {}
-  virtual void OnClose(SocketStream* socket) OVERRIDE {}
+                              const char* data, int len) override {}
+  virtual void OnClose(SocketStream* socket) override {}
 };
 
 class WebSocketThrottleTestContext : public TestURLRequestContext {