Add virtual and OVERRIDE to base/ implementation files

base/shared_memory_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/basictypes.h"
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 #include "base/memory/scoped_ptr.h"
 #include "base/shared_memory.h"
@@ skipping 17 matching lines @@
 namespace base {
 
 namespace {
 
 // Each thread will open the shared memory.  Each thread will take a different 4
 // byte int pointer, and keep changing it, with some small pauses in between.
 // Verify that each thread's value in the shared memory is always correct.
 class MultipleThreadMain : public PlatformThread::Delegate {
  public:
   explicit MultipleThreadMain(int16 id) : id_(id) {}
-  ~MultipleThreadMain() {}
+  virtual ~MultipleThreadMain() {}
 
   static void CleanUp() {
     SharedMemory memory;
     memory.Delete(s_test_name_);
   }
 
   // PlatformThread::Delegate interface.
-  void ThreadMain() {
+  virtual void ThreadMain() OVERRIDE {
 #if defined(OS_MACOSX)
     mac::ScopedNSAutoreleasePool pool;
 #endif
     const uint32 kDataSize = 1024;
     SharedMemory memory;
     bool rv = memory.CreateNamed(s_test_name_, true, kDataSize);
     EXPECT_TRUE(rv);
     rv = memory.Map(kDataSize);
     EXPECT_TRUE(rv);
     int *ptr = static_cast<int*>(memory.memory()) + id_;
@@ skipping 25 matching lines @@
 // This test requires the ability to pass file descriptors between processes.
 // We haven't done that yet in Chrome for POSIX.
 #if defined(OS_WIN)
 // Each thread will open the shared memory.  Each thread will take the memory,
 // and keep changing it while trying to lock it, with some small pauses in
 // between. Verify that each thread's value in the shared memory is always
 // correct.
 class MultipleLockThread : public PlatformThread::Delegate {
  public:
   explicit MultipleLockThread(int id) : id_(id) {}
-  ~MultipleLockThread() {}
+  virtual ~MultipleLockThread() {}
 
   // PlatformThread::Delegate interface.
-  void ThreadMain() {
+  virtual void ThreadMain() OVERRIDE {
     const uint32 kDataSize = sizeof(int);
     SharedMemoryHandle handle = NULL;
     {
       SharedMemory memory1;
       EXPECT_TRUE(memory1.CreateNamed("SharedMemoryMultipleLockThreadTest",
                                  true, kDataSize));
       EXPECT_TRUE(memory1.ShareToProcess(GetCurrentProcess(), &handle));
       // TODO(paulg): Implement this once we have a posix version of
       // SharedMemory::ShareToProcess.
       EXPECT_TRUE(true);
@@ skipping 321 matching lines @@
   }
 
   SharedMemoryProcessTest::CleanUp();
 }
 
 MULTIPROCESS_TEST_MAIN(SharedMemoryTestMain) {
   return SharedMemoryProcessTest::TaskTestMain();
 }
 
 }  // namespace base