Mojo: Convert the remaining OVERRIDEs to override in mojo/.

mojo/services/html_viewer/websockethandle_impl.cc

 // Copyright 2014 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 "mojo/services/html_viewer/websockethandle_impl.h"
 
 #include <vector>
 
 #include "base/bind.h"
+#include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "mojo/services/html_viewer/blink_basic_type_converters.h"
 #include "mojo/services/public/cpp/network/web_socket_read_queue.h"
 #include "mojo/services/public/cpp/network/web_socket_write_queue.h"
 #include "mojo/services/public/interfaces/network/network_service.mojom.h"
 #include "third_party/WebKit/public/platform/WebSerializedOrigin.h"
 #include "third_party/WebKit/public/platform/WebSocketHandleClient.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
@@ skipping 48 matching lines @@
                                blink::WebSocketHandleClient* client)
       : handle_(handle), client_(client) {}
   virtual ~WebSocketClientImpl() {}
 
  private:
   // WebSocketClient methods:
   virtual void DidConnect(bool fail,
                           const String& selected_subprotocol,
                           const String& extensions,
                           ScopedDataPipeConsumerHandle receive_stream)
-      OVERRIDE {
+      override {
     blink::WebSocketHandleClient* client = client_;
     WebSocketHandleImpl* handle = handle_;
     receive_stream_ = receive_stream.Pass();
     read_queue_.reset(new WebSocketReadQueue(receive_stream_.get()));
     if (fail)
       handle->Disconnect();  // deletes |this|
     client->didConnect(handle,
                        fail,
                        selected_subprotocol.To<WebString>(),
                        extensions.To<WebString>());
     // |handle| can be deleted here.
   }
 
   virtual void DidReceiveData(bool fin,
                               WebSocket::MessageType type,
-                              uint32_t num_bytes) OVERRIDE {
+                              uint32_t num_bytes) override {
     read_queue_->Read(num_bytes,
                       base::Bind(&WebSocketClientImpl::DidReadFromReceiveStream,
                                  base::Unretained(this),
                                  fin, type, num_bytes));
   }
 
-  virtual void DidReceiveFlowControl(int64_t quota) OVERRIDE {
+  virtual void DidReceiveFlowControl(int64_t quota) override {
     client_->didReceiveFlowControl(handle_, quota);
     // |handle| can be deleted here.
   }
 
-  virtual void DidFail(const String& message) OVERRIDE {
+  virtual void DidFail(const String& message) override {
     blink::WebSocketHandleClient* client = client_;
     WebSocketHandleImpl* handle = handle_;
     handle->Disconnect();  // deletes |this|
     client->didFail(handle, message.To<WebString>());
     // |handle| can be deleted here.
   }
 
   virtual void DidClose(bool was_clean,
                         uint16_t code,
-                        const String& reason) OVERRIDE {
+                        const String& reason) override {
     blink::WebSocketHandleClient* client = client_;
     WebSocketHandleImpl* handle = handle_;
     handle->Disconnect();  // deletes |this|
     client->didClose(handle, was_clean, code, reason.To<WebString>());
     // |handle| can be deleted here.
   }
 
   void DidReadFromReceiveStream(bool fin,
                                 WebSocket::MessageType type,
                                 uint32_t num_bytes,
@@ skipping 81 matching lines @@
     const char* data) {
   web_socket_->Send(fin, ConvertTo<WebSocket::MessageType>(type), num_bytes);
 }
 
 void WebSocketHandleImpl::Disconnect() {
   did_close_ = true;
   client_.reset();
 }
 
 }  // namespace mojo