EDK: Sprinkle some more |final| secret sauce.

mojo/edk/util/waitable_event.h

 // Copyright 2015 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.
 
 // Provides classes with functionality analogous to (but much more limited than)
 // Chromium's |base::WaitableEvent|, which in turn provides functionality
 // analogous to Windows's Event. (Unlike these two, we have separate types for
 // the manual- and auto-reset versions.)
 
 #ifndef MOJO_EDK_UTIL_WAITABLE_EVENT_H_
 #define MOJO_EDK_UTIL_WAITABLE_EVENT_H_
 
 #include "mojo/edk/util/cond_var.h"
 #include "mojo/edk/util/mutex.h"
 #include "mojo/edk/util/thread_annotations.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 namespace util {
 
 // AutoResetWaitableEvent ------------------------------------------------------
 
 // An event that can be signaled and waited on. This version automatically
 // returns to the unsignaled state after unblocking one waiter. (This is similar
 // to Windows's auto-reset Event, which is also imitated by Chromium's
 // auto-reset |base::WaitableEvent|. However, there are some limitations -- see
 // |Signal()|.) This class is thread-safe.
-class AutoResetWaitableEvent {
+class AutoResetWaitableEvent final {
  public:
   AutoResetWaitableEvent() {}
   ~AutoResetWaitableEvent() {}
 
   // Put the event in the signaled state. Exactly one |Wait()| will be unblocked
   // and the event will be returned to the unsignaled state.
   //
   // Notes (these are arguably bugs, but not worth working around):
   // * That |Wait()| may be one that occurs on the calling thread, *after* the
   //   call to |Signal()|.
@@ skipping 31 matching lines @@
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(AutoResetWaitableEvent);
 };
 
 // ManualResetWaitableEvent ----------------------------------------------------
 
 // An event that can be signaled and waited on. This version remains signaled
 // until explicitly reset. (This is similar to Windows's manual-reset Event,
 // which is also imitated by Chromium's manual-reset |base::WaitableEvent|.)
 // This class is thread-safe.
-class ManualResetWaitableEvent {
+class ManualResetWaitableEvent final {
  public:
   ManualResetWaitableEvent() {}
   ~ManualResetWaitableEvent() {}
 
   // Put the event into the unsignaled state.
   void Reset();
 
   // Put the event in the signaled state. If this is a manual-reset event, it
   // wakes all waiting threads (blocked on |Wait()| or |WaitWithTimeout()|).
   // Otherwise, it wakes a single waiting thread (and returns to the unsignaled
@@ skipping 27 matching lines @@
   // was awoken if |signal_id_| is different from when it started waiting.
   unsigned signal_id_ MOJO_GUARDED_BY(mutex_) = 0u;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ManualResetWaitableEvent);
 };
 
 }  // namespace util
 }  // namespace mojo
 
 #endif  // MOJO_EDK_UTIL_WAITABLE_EVENT_H_