Update {virtual,override} to follow C++11 style in ppapi.

ppapi/host/resource_message_filter.h

 // 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.
 
 #ifndef PPAPI_HOST_RESOURCE_MESSAGE_FILTER_H_
 #define PPAPI_HOST_RESOURCE_MESSAGE_FILTER_H_
 
 #include "base/memory/ref_counted.h"
 #include "ppapi/c/pp_stdint.h"
 #include "ppapi/host/host_message_context.h"
@@ skipping 30 matching lines @@
 // similar to a BrowserMessageFilter but for resource messages. Note that the
 // liftetime of a ResourceHost is managed by a PpapiHost and may be destroyed
 // before or while your message is being processed on another thread.
 // If this is the case, the message handler will always be called but a reply
 // may not be sent back to the host.
 //
 // To handle a resource message on another thread you should implement a
 // subclass as follows:
 // class MyMessageFilter : public ResourceMessageFilter {
 //  protected:
-//   virtual scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(
+//   scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(
 //       const IPC::Message& message) override {
 //     if (message.type() == MyMessage::ID)
 //       return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI);
 //     return NULL;
 //   }
 //
-//   virtual int32_t OnResourceMessageReceived(
-//       const IPC::Message& msg,
-//       HostMessageContext* context) override {
+//   int32_t OnResourceMessageReceived(const IPC::Message& msg,
+//                                     HostMessageContext* context) override {
 //     IPC_BEGIN_MESSAGE_MAP(MyMessageFilter, msg)
 //       PPAPI_DISPATCH_HOST_RESOURCE_CALL(MyMessage, OnMyMessage)
 //     IPC_END_MESSAGE_MAP()
 //     return PP_ERROR_FAILED;
 //   }
 //
 //  private:
 //   int32_t OnMyMessage(ppapi::host::HostMessageContext* context, ...) {
 //     // Will be run on the UI thread.
 //   }
@@ skipping 18 matching lines @@
   ResourceMessageFilter(
       scoped_refptr<base::MessageLoopProxy> reply_thread_message_loop_proxy);
 
   // Called when a filter is added to a ResourceHost.
   void OnFilterAdded(ResourceHost* resource_host);
   // Called when a filter is removed from a ResourceHost.
   void OnFilterDestroyed();
 
   // This will dispatch the message handler on the target thread. It returns
   // true if the message was handled by this filter and false otherwise.
-  virtual bool HandleMessage(const IPC::Message& msg,
-                             HostMessageContext* context) override;
+  bool HandleMessage(const IPC::Message& msg,
+                     HostMessageContext* context) override;
 
   // This can be called from any thread.
-  virtual void SendReply(const ReplyMessageContext& context,
-      const IPC::Message& msg) override;
+  void SendReply(const ReplyMessageContext& context,
+                 const IPC::Message& msg) override;
 
  protected:
-  virtual ~ResourceMessageFilter();
+  ~ResourceMessageFilter() override;
 
   // Please see the comments of |resource_host_| for on which thread it can be
   // used and when it is NULL.
   ResourceHost* resource_host() const { return resource_host_; }
 
   // If you want the message to be handled on another thread, return a non-null
   // task runner which will target tasks accordingly.
   virtual scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(
       const IPC::Message& message);
 
@@ skipping 22 matching lines @@
   // is destroyed, |OnFilterDestroyed| is called and this will be set to NULL.
   ResourceHost* resource_host_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceMessageFilter);
 };
 
 }  // namespace host
 }  // namespace ppapi
 
 #endif  // PPAPI_HOST_RESOURCE_MESSAGE_FILTER_H_