[presubmit] Enabling readability/inheritance linter checking.

test/unittests/base/platform/condition-variable-unittest.cc

 // Copyright 2014 the V8 project 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 "src/base/platform/condition-variable.h"
 
 #include "src/base/platform/platform.h"
 #include "src/base/platform/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 17 matching lines @@
 
 
 namespace {
 
 class ThreadWithMutexAndConditionVariable final : public Thread {
  public:
   ThreadWithMutexAndConditionVariable()
       : Thread(Options("ThreadWithMutexAndConditionVariable")),
         running_(false),
         finished_(false) {}
-  virtual ~ThreadWithMutexAndConditionVariable() {}
 
-  virtual void Run() override {
+  void Run() override {
     LockGuard<Mutex> lock_guard(&mutex_);
     running_ = true;
     cv_.NotifyOne();
     while (running_) {
       cv_.Wait(&mutex_);
     }
     finished_ = true;
     cv_.NotifyAll();
   }
 
@@ skipping 58 matching lines @@
 namespace {
 
 class ThreadWithSharedMutexAndConditionVariable final : public Thread {
  public:
   ThreadWithSharedMutexAndConditionVariable()
       : Thread(Options("ThreadWithSharedMutexAndConditionVariable")),
         running_(false),
         finished_(false),
         cv_(NULL),
         mutex_(NULL) {}
-  virtual ~ThreadWithSharedMutexAndConditionVariable() {}
 
-  virtual void Run() override {
+  void Run() override {
     LockGuard<Mutex> lock_guard(mutex_);
     running_ = true;
     cv_->NotifyAll();
     while (running_) {
       cv_->Wait(mutex_);
     }
     finished_ = true;
     cv_->NotifyAll();
   }
 
@@ skipping 94 matching lines @@
         rem_(rem),
         counter_(counter),
         limit_(limit),
         thread_count_(thread_count),
         cv_(cv),
         mutex_(mutex) {
     EXPECT_LT(rem, thread_count);
     EXPECT_EQ(0, limit % thread_count);
   }
 
-  virtual void Run() override {
+  void Run() override {
     int last_count = -1;
     while (true) {
       LockGuard<Mutex> lock_guard(mutex_);
       int count = *counter_;
       while (count % thread_count_ != rem_ && count < limit_) {
         cv_->Wait(mutex_);
         count = *counter_;
       }
       if (count >= limit_) break;
       EXPECT_EQ(*counter_, count);
@@ skipping 45 matching lines @@
       delete threads[n];
     }
     delete[] threads;
 
     EXPECT_EQ(limit, counter);
   }
 }
 
 }  // namespace base
 }  // namespace v8