Add virtual and OVERRIDE to base/ implementation files

base/synchronization/waitable_event_watcher_posix.cc

 // Copyright (c) 2011 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/synchronization/waitable_event_watcher.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop.h"
 #include "base/synchronization/lock.h"
@@ skipping 25 matching lines @@
     AutoLock locked(lock_);
     flag_ = true;
   }
 
   bool value() const {
     AutoLock locked(lock_);
     return flag_;
   }
 
  private:
+  friend class RefCountedThreadSafe<Flag>;

[Nico, 2012/04/05 19:16:02]

likely unnecessary?

+  ~Flag() {}

[Nico, 2012/04/05 19:16:02]

unnecessary, or at least unrelated?

[Ryan Sleevi, 2012/04/05 19:22:38]

Unnecessary no, unrelated yes.

This bled in from http://codereview.chromium.org/9997007/ on my git branch. Will
shift it over to that CL.

+
   mutable Lock lock_;
   bool flag_;
 };
 
 // -----------------------------------------------------------------------------
 // This is an asynchronous waiter which posts a task to a MessageLoop when
 // fired. An AsyncWaiter may only be in a single wait-list.
 // -----------------------------------------------------------------------------
 class AsyncWaiter : public WaitableEvent::Waiter {
  public:
   AsyncWaiter(MessageLoop* message_loop,
               const base::Closure& callback,
               Flag* flag)
       : message_loop_(message_loop),
         callback_(callback),
         flag_(flag) { }
 
-  bool Fire(WaitableEvent* event) {
+  virtual bool Fire(WaitableEvent* event) OVERRIDE {
     // Post the callback if we haven't been cancelled.
     if (!flag_->value()) {
       message_loop_->PostTask(FROM_HERE, callback_);
     }
 
     // We are removed from the wait-list by the WaitableEvent itself. It only
     // remains to delete ourselves.
     delete this;
 
     // We can always return true because an AsyncWaiter is never in two
     // different wait-lists at the same time.
     return true;
   }
 
   // See StopWatching for discussion
-  bool Compare(void* tag) {
+  virtual bool Compare(void* tag) OVERRIDE {
     return tag == flag_.get();
   }
 
  private:
   MessageLoop *const message_loop_;
   base::Closure callback_;
   scoped_refptr<Flag> flag_;
 };
 
 // -----------------------------------------------------------------------------
@@ skipping 166 matching lines @@
 // -----------------------------------------------------------------------------
 // This is called when the MessageLoop which the callback will be run it is
 // deleted. We need to cancel the callback as if we had been deleted, but we
 // will still be deleted at some point in the future.
 // -----------------------------------------------------------------------------
 void WaitableEventWatcher::WillDestroyCurrentMessageLoop() {
   StopWatching();
 }
 
 }  // namespace base