Replace OVERRIDE and FINAL with override and final in content/public/[a-s]*

content/public/browser/browser_message_filter.cc

 // Copyright (c) 2012 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 "content/public/browser/browser_message_filter.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 12 matching lines @@
 namespace content {
 
 class BrowserMessageFilter::Internal : public IPC::MessageFilter {
  public:
   explicit Internal(BrowserMessageFilter* filter) : filter_(filter) {}
 
  private:
   virtual ~Internal() {}
 
   // IPC::MessageFilter implementation:
-  virtual void OnFilterAdded(IPC::Sender* sender) OVERRIDE {
+  virtual void OnFilterAdded(IPC::Sender* sender) override {
     filter_->sender_ = sender;
     filter_->OnFilterAdded(sender);
   }
 
-  virtual void OnFilterRemoved() OVERRIDE {
+  virtual void OnFilterRemoved() override {
     filter_->OnFilterRemoved();
   }
 
-  virtual void OnChannelClosing() OVERRIDE {
+  virtual void OnChannelClosing() override {
     filter_->sender_ = NULL;
     filter_->OnChannelClosing();
   }
 
-  virtual void OnChannelConnected(int32 peer_pid) OVERRIDE {
+  virtual void OnChannelConnected(int32 peer_pid) override {
     filter_->peer_pid_ = peer_pid;
     filter_->OnChannelConnected(peer_pid);
   }
 
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
+  virtual bool OnMessageReceived(const IPC::Message& message) override {
     BrowserThread::ID thread = BrowserThread::IO;
     filter_->OverrideThreadForMessage(message, &thread);
 
     if (thread == BrowserThread::IO) {
       scoped_refptr<base::TaskRunner> runner =
           filter_->OverrideTaskRunnerForMessage(message);
       if (runner.get()) {
         runner->PostTask(
             FROM_HERE,
             base::Bind(
                 base::IgnoreResult(&Internal::DispatchMessage), this, message));
         return true;
       }
       return DispatchMessage(message);
     }
 
     if (thread == BrowserThread::UI &&
         !BrowserMessageFilter::CheckCanDispatchOnUI(message, filter_.get())) {
       return true;
     }
 
     BrowserThread::PostTask(
         thread, FROM_HERE,
         base::Bind(
             base::IgnoreResult(&Internal::DispatchMessage), this, message));
     return true;
   }
 
   virtual bool GetSupportedMessageClasses(
-      std::vector<uint32>* supported_message_classes) const OVERRIDE {
+      std::vector<uint32>* supported_message_classes) const override {
     supported_message_classes->assign(
         filter_->message_classes_to_filter().begin(),
         filter_->message_classes_to_filter().end());
     return true;
   }
 
   // Dispatches a message to the derived class.
   bool DispatchMessage(const IPC::Message& message) {
     bool rv = filter_->OnMessageReceived(message);
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO) || rv) <<
@@ skipping 125 matching lines @@
 
 IPC::MessageFilter* BrowserMessageFilter::GetFilter() {
   // We create this on demand so that if a filter is used in a unit test but
   // never attached to a channel, we don't leak Internal and this;
   DCHECK(!internal_) << "Should only be called once.";
   internal_ = new Internal(this);
   return internal_;
 }
 
 }  // namespace content