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

ppapi/host/resource_message_filter_unittest.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 41 matching lines @@
   const IPC::Message& last_handled_msg() const { return last_handled_msg_; }
   const IPC::Message& last_reply_msg() const { return last_reply_msg_; }
   base::MessageLoop* last_reply_message_loop() const {
     return last_reply_message_loop_;
   }
 
   void AddMessageFilter(scoped_refptr<ResourceMessageFilter> filter) {
     AddFilter(filter);
   }
 
-  virtual int32_t OnResourceMessageReceived(
-      const IPC::Message& msg,
-      HostMessageContext* context) override {
+  int32_t OnResourceMessageReceived(const IPC::Message& msg,
+                                    HostMessageContext* context) override {
     last_handled_msg_ = msg;
     if (msg.type() == msg_type_) {
       context->reply_msg = IPC::Message(0, reply_msg_type_,
                                         IPC::Message::PRIORITY_NORMAL);
       return PP_OK;
     }
     return PP_ERROR_FAILED;
   }
 
-  virtual void SendReply(const ReplyMessageContext& context,
-                         const IPC::Message& msg) override {
+  void SendReply(const ReplyMessageContext& context,
+                 const IPC::Message& msg) override {
     last_reply_msg_ = msg;
     last_reply_message_loop_ = base::MessageLoop::current();
     g_handler_completion.Signal();
   }
 
  private:
   uint32 msg_type_;
   uint32 reply_msg_type_;
 
   IPC::Message last_handled_msg_;
@@ skipping 17 matching lines @@
       : ResourceMessageFilter(io_thread.message_loop_proxy()),
         message_loop_proxy_(bg_thread.message_loop_proxy()),
         msg_type_(msg_type),
         reply_msg_type_(reply_msg_type),
         last_message_loop_(NULL) {
   }
 
   const IPC::Message& last_handled_msg() const { return last_handled_msg_; }
   base::MessageLoop* last_message_loop() const { return last_message_loop_; }
 
-  virtual scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(
+  scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(
       const IPC::Message& msg) override {
     if (msg.type() == msg_type_)
       return message_loop_proxy_;
     return NULL;
   }
 
-  virtual int32_t OnResourceMessageReceived(
+  int32_t OnResourceMessageReceived(
       const IPC::Message& msg,
       HostMessageContext* context) override {
     last_handled_msg_ = msg;
     last_message_loop_ = base::MessageLoop::current();
     if (msg.type() == msg_type_) {
       context->reply_msg = IPC::Message(0, reply_msg_type_,
                                         IPC::Message::PRIORITY_NORMAL);
       return PP_OK;
     }
     return PP_ERROR_FAILED;
@@ skipping 84 matching lines @@
   main_message_loop.PostTask(
       FROM_HERE,
       base::Bind(&ResourceMessageFilterTest::TestHandleMessageImpl,
                  base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace proxy
 }  // namespace ppapi