Standardize usage of virtual/override/final in components/

components/variations/entropy_provider_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 "components/variations/entropy_provider.h"
 
 #include <cmath>
 #include <limits>
 #include <numeric>
 
@@ skipping 62 matching lines @@
 
 // An TrialEntropyGenerator that uses the SHA1EntropyProvider with the high
 // entropy source (random GUID with 128 bits of entropy + 13 additional bits of
 // entropy corresponding to a low entropy source).
 class SHA1EntropyGenerator : public TrialEntropyGenerator {
  public:
   explicit SHA1EntropyGenerator(const std::string& trial_name)
       : trial_name_(trial_name) {
   }
 
-  virtual ~SHA1EntropyGenerator() {
-  }
+  ~SHA1EntropyGenerator() override {}
 
-  virtual double GenerateEntropyValue() const override {
+  double GenerateEntropyValue() const override {
     // Use a random GUID + 13 additional bits of entropy to match how the
     // SHA1EntropyProvider is used in metrics_service.cc.
     const int low_entropy_source =
         static_cast<uint16>(base::RandInt(0, kMaxLowEntropySize - 1));
     const std::string high_entropy_source =
         base::GenerateGUID() + base::IntToString(low_entropy_source);
     return GenerateSHA1Entropy(high_entropy_source, trial_name_);
   }
 
  private:
   std::string trial_name_;
 
   DISALLOW_COPY_AND_ASSIGN(SHA1EntropyGenerator);
 };
 
 // An TrialEntropyGenerator that uses the permuted entropy provider algorithm,
 // using 13-bit low entropy source values.
 class PermutedEntropyGenerator : public TrialEntropyGenerator {
  public:
   explicit PermutedEntropyGenerator(const std::string& trial_name)
       : mapping_(kMaxLowEntropySize) {
     // Note: Given a trial name, the computed mapping will be the same.
     // As a performance optimization, pre-compute the mapping once per trial
     // name and index into it for each entropy value.
     const uint32 randomization_seed = HashName(trial_name);
     internal::PermuteMappingUsingRandomizationSeed(randomization_seed,
                                                    &mapping_);
   }
 
-  virtual ~PermutedEntropyGenerator() {
-  }
+  ~PermutedEntropyGenerator() override {}
 
-  virtual double GenerateEntropyValue() const override {
+  double GenerateEntropyValue() const override {
     const int low_entropy_source =
         static_cast<uint16>(base::RandInt(0, kMaxLowEntropySize - 1));
     return mapping_[low_entropy_source] /
            static_cast<double>(kMaxLowEntropySize);
   }
 
  private:
   std::vector<uint16> mapping_;
 
   DISALLOW_COPY_AND_ASSIGN(PermutedEntropyGenerator);
@@ skipping 230 matching lines @@
       ++count;
     }
 
     ASSERT_LT(count, kMaxAttempts) << "Expected average was " <<
         kExpectedAverage << ", average ended at " << cumulative_average <<
         ", for trial " << kTestTrialNames[i];
   }
 }
 
 }  // namespace metrics