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

ppapi/shared_impl/thread_aware_callback_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 "ppapi/shared_impl/thread_aware_callback.h"
 
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 35 matching lines @@
 }
 
 typedef proxy::PluginProxyTest ThreadAwareCallbackTest;
 
 // Test that a callback created on the main thread will run on the main thread,
 // even when requested from a different thread.
 class ThreadAwareCallbackMultiThreadTest
     : public proxy::PluginProxyMultiThreadTest {
  public:
   ThreadAwareCallbackMultiThreadTest() : main_thread_callback_called_(false) {}
-  virtual ~ThreadAwareCallbackMultiThreadTest() {
+  ~ThreadAwareCallbackMultiThreadTest() override {
     CHECK(main_thread_callback_called_);
   }
 
   // proxy::PluginProxyMultiThreadTest implementation.
-  virtual void SetUpTestOnMainThread() override {
+  void SetUpTestOnMainThread() override {
     ProxyAutoLock auto_lock;
 
     main_thread_callback_.reset(
         ThreadAwareCallback<CallbackFunc>::Create(&MainThreadCallbackBody));
   }
 
-  virtual void SetUpTestOnSecondaryThread() override {
+  void SetUpTestOnSecondaryThread() override {
     {
       ProxyAutoLock auto_lock;
       main_thread_callback_->RunOnTargetThread(this);
     }
 
     PostQuitForSecondaryThread();
     PostQuitForMainThread();
   }
 
  private:
@@ skipping 14 matching lines @@
 
   scoped_ptr<ThreadAwareCallback<CallbackFunc> > main_thread_callback_;
   bool main_thread_callback_called_;
 };
 
 // Test that when a ThreadAwareCallback instance is destroyed, pending tasks to
 // run the callback will be ignored.
 class ThreadAwareCallbackAbortTest : public proxy::PluginProxyMultiThreadTest {
  public:
   ThreadAwareCallbackAbortTest() {}
-  virtual ~ThreadAwareCallbackAbortTest() {}
+  ~ThreadAwareCallbackAbortTest() override {}
 
   // proxy::PluginProxyMultiThreadTest implementation.
-  virtual void SetUpTestOnMainThread() override {
+  void SetUpTestOnMainThread() override {
     ProxyAutoLock auto_lock;
 
     main_thread_callback_.reset(
         ThreadAwareCallback<CallbackFunc>::Create(&MainThreadCallbackBody));
   }
 
-  virtual void SetUpTestOnSecondaryThread() override {
+  void SetUpTestOnSecondaryThread() override {
     {
       ProxyAutoLock auto_lock;
       main_thread_message_loop_proxy_->PostTask(
           FROM_HERE,
           base::Bind(&ThreadAwareCallbackAbortTest::DeleteCallback,
                      base::Unretained(this)));
       // |main_thread_callback_| is still valid, even if DeleteCallback() can be
       // called before this following statement. That is because |auto_lock| is
       // still held by this method, which prevents DeleteCallback() from
       // deleting the callback.
@@ skipping 66 matching lines @@
       1, &double_arg, &bool_arg, object_arg, object_arg);
 
   EXPECT_EQ(6, called_num);
 }
 
 TEST_F(ThreadAwareCallbackMultiThreadTest, RunOnTargetThread) { RunTest(); }
 
 TEST_F(ThreadAwareCallbackAbortTest, NotRunIfAborted) { RunTest(); }
 
 }  // namespace ppapi