replace OVERRIDE and FINAL with override and final in components/

components/nacl/loader/nacl_listener.cc

 // Copyright 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 "components/nacl/loader/nacl_listener.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 145 matching lines @@
 }
 
 }  // namespace
 
 class BrowserValidationDBProxy : public NaClValidationDB {
  public:
   explicit BrowserValidationDBProxy(NaClListener* listener)
       : listener_(listener) {
   }
 
-  virtual bool QueryKnownToValidate(const std::string& signature) OVERRIDE {
+  virtual bool QueryKnownToValidate(const std::string& signature) override {
     // Initialize to false so that if the Send fails to write to the return
     // value we're safe.  For example if the message is (for some reason)
     // dispatched as an async message the return parameter will not be written.
     bool result = false;
     if (!listener_->Send(new NaClProcessMsg_QueryKnownToValidate(signature,
                                                                  &result))) {
       LOG(ERROR) << "Failed to query NaCl validation cache.";
       result = false;
     }
     return result;
   }
 
-  virtual void SetKnownToValidate(const std::string& signature) OVERRIDE {
+  virtual void SetKnownToValidate(const std::string& signature) override {
     // Caching is optional: NaCl will still work correctly if the IPC fails.
     if (!listener_->Send(new NaClProcessMsg_SetKnownToValidate(signature))) {
       LOG(ERROR) << "Failed to update NaCl validation cache.";
     }
   }
 
   // This is the "old" code path for resolving file tokens. It's only
   // used for resolving the main nexe.
   // TODO(teravest): Remove this.
   virtual bool ResolveFileToken(struct NaClFileToken* file_token,
-                                int32* fd, std::string* path) OVERRIDE {
+                                int32* fd, std::string* path) override {
     *fd = -1;
     *path = "";
     if (!NaClFileTokenIsValid(file_token)) {
       return false;
     }
     IPC::PlatformFileForTransit ipc_fd = IPC::InvalidPlatformFileForTransit();
     base::FilePath ipc_path;
     if (!listener_->Send(new NaClProcessMsg_ResolveFileToken(file_token->lo,
                                                              file_token->hi,
                                                              &ipc_fd,
@@ skipping 54 matching lines @@
     return filter_->Send(msg);
   }
 }
 
 // The NaClProcessMsg_ResolveFileTokenAsyncReply message must be
 // processed in a MessageFilter so it can be handled on the IO thread.
 // The main thread used by NaClListener is busy in
 // NaClChromeMainAppStart(), so it can't be used for servicing messages.
 class FileTokenMessageFilter : public IPC::MessageFilter {
  public:
-  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE {
+  virtual bool OnMessageReceived(const IPC::Message& msg) override {
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(FileTokenMessageFilter, msg)
       IPC_MESSAGE_HANDLER(NaClProcessMsg_ResolveFileTokenAsyncReply,
                           OnResolveFileTokenAsyncReply)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     return handled;
   }
 
   void OnResolveFileTokenAsyncReply(
@@ skipping 215 matching lines @@
 }
 
 void NaClListener::OnFileTokenResolved(
     uint64_t token_lo,
     uint64_t token_hi,
     IPC::PlatformFileForTransit ipc_fd,
     base::FilePath file_path) {
   resolved_cb_.Run(ipc_fd, file_path);
   resolved_cb_.Reset();
 }