replace 'virtual ... OVERRIDE' with '... override'

base/metrics/histogram.h

 // 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.
 
 // Histogram is an object that aggregates statistics, and can summarize them in
 // various forms, including ASCII graphical, HTML, and numerically (as a
 // vector of numbers corresponding to each of the aggregating buckets).
 
 // It supports calls to accumulate either time intervals (which are processed
 // as integral number of milliseconds), or arbitrary integral units.
@@ skipping 341 matching lines @@
   // certain amount of slop before flagging this as an inconsistency. Even with
   // an inconsistency, we'll snapshot it again (for UMA in about a half hour),
   // so we'll eventually get the data, if it was not the result of a corruption.
   static const int kCommonRaceBasedCountMismatch;
 
   // Check to see if bucket ranges, counts and tallies in the snapshot are
   // consistent with the bucket ranges and checksums in our histogram.  This can
   // produce a false-alarm if a race occurred in the reading of the data during
   // a SnapShot process, but should otherwise be false at all times (unless we
   // have memory over-writes, or DRAM failures).
-  virtual int FindCorruption(const HistogramSamples& samples) const OVERRIDE;
+  int FindCorruption(const HistogramSamples& samples) const override;
 
   //----------------------------------------------------------------------------
   // Accessors for factory construction, serialization and testing.
   //----------------------------------------------------------------------------
   Sample declared_min() const { return declared_min_; }
   Sample declared_max() const { return declared_max_; }
   virtual Sample ranges(size_t i) const;
   virtual size_t bucket_count() const;
   const BucketRanges* bucket_ranges() const { return bucket_ranges_; }
 
   // This function validates histogram construction arguments. It returns false
   // if some of the arguments are totally bad.
   // Note. Currently it allow some bad input, e.g. 0 as minimum, but silently
   // converts it to good input: 1.
   // TODO(kaiwang): Be more restrict and return false for any bad input, and
   // make this a readonly validating function.
   static bool InspectConstructionArguments(const std::string& name,
                                            Sample* minimum,
                                            Sample* maximum,
                                            size_t* bucket_count);
 
   // HistogramBase implementation:
-  virtual HistogramType GetHistogramType() const OVERRIDE;
-  virtual bool HasConstructionArguments(
-      Sample expected_minimum,
-      Sample expected_maximum,
-      size_t expected_bucket_count) const OVERRIDE;
-  virtual void Add(Sample value) OVERRIDE;
-  virtual scoped_ptr<HistogramSamples> SnapshotSamples() const OVERRIDE;
-  virtual void AddSamples(const HistogramSamples& samples) OVERRIDE;
-  virtual bool AddSamplesFromPickle(PickleIterator* iter) OVERRIDE;
-  virtual void WriteHTMLGraph(std::string* output) const OVERRIDE;
-  virtual void WriteAscii(std::string* output) const OVERRIDE;
+  HistogramType GetHistogramType() const override;
+  bool HasConstructionArguments(Sample expected_minimum,
+                                Sample expected_maximum,
+                                size_t expected_bucket_count) const override;
+  void Add(Sample value) override;
+  scoped_ptr<HistogramSamples> SnapshotSamples() const override;
+  void AddSamples(const HistogramSamples& samples) override;
+  bool AddSamplesFromPickle(PickleIterator* iter) override;
+  void WriteHTMLGraph(std::string* output) const override;
+  void WriteAscii(std::string* output) const override;
 
  protected:
   // |ranges| should contain the underflow and overflow buckets. See top
   // comments for example.
   Histogram(const std::string& name,
             Sample minimum,
             Sample maximum,
             const BucketRanges* ranges);
 
   virtual ~Histogram();
 
   // HistogramBase implementation:
-  virtual bool SerializeInfoImpl(Pickle* pickle) const OVERRIDE;
+  bool SerializeInfoImpl(Pickle* pickle) const override;
 
   // Method to override to skip the display of the i'th bucket if it's empty.
   virtual bool PrintEmptyBucket(size_t index) const;
 
   // Get normalized size, relative to the ranges(i).
   virtual double GetBucketSize(Count current, size_t i) const;
 
   // Return a string description of what goes in a given bucket.
   // Most commonly this is the numeric value, but in derived classes it may
   // be a name (or string description) given to the bucket.
@@ skipping 32 matching lines @@
                         Count sample_count,
                         std::string* output) const;
 
   // Write information about previous, current, and next buckets.
   // Information such as cumulative percentage, etc.
   void WriteAsciiBucketContext(const int64 past, const Count current,
                                const int64 remaining, const size_t i,
                                std::string* output) const;
 
   // WriteJSON calls these.
-  virtual void GetParameters(DictionaryValue* params) const OVERRIDE;
+  void GetParameters(DictionaryValue* params) const override;
 
-  virtual void GetCountAndBucketData(Count* count,
-                                     int64* sum,
-                                     ListValue* buckets) const OVERRIDE;
+  void GetCountAndBucketData(Count* count,
+                             int64* sum,
+                             ListValue* buckets) const override;
 
   // Does not own this object. Should get from StatisticsRecorder.
   const BucketRanges* bucket_ranges_;
 
   Sample declared_min_;  // Less than this goes into the first bucket.
   Sample declared_max_;  // Over this goes into the last bucket.
 
   // Finally, provide the state that changes with the addition of each new
   // sample.
   scoped_ptr<SampleVector> samples_;
@@ skipping 38 matching lines @@
       Sample maximum,
       size_t bucket_count,
       int32 flags,
       const DescriptionPair descriptions[]);
 
   static void InitializeBucketRanges(Sample minimum,
                                      Sample maximum,
                                      BucketRanges* ranges);
 
   // Overridden from Histogram:
-  virtual HistogramType GetHistogramType() const OVERRIDE;
+  HistogramType GetHistogramType() const override;
 
  protected:
   LinearHistogram(const std::string& name,
                   Sample minimum,
                   Sample maximum,
                   const BucketRanges* ranges);
 
-  virtual double GetBucketSize(Count current, size_t i) const OVERRIDE;
+  double GetBucketSize(Count current, size_t i) const override;
 
   // If we have a description for a bucket, then return that.  Otherwise
   // let parent class provide a (numeric) description.
-  virtual const std::string GetAsciiBucketRange(size_t i) const OVERRIDE;
+  const std::string GetAsciiBucketRange(size_t i) const override;
 
   // Skip printing of name for numeric range if we have a name (and if this is
   // an empty bucket).
-  virtual bool PrintEmptyBucket(size_t index) const OVERRIDE;
+  bool PrintEmptyBucket(size_t index) const override;
 
  private:
   friend BASE_EXPORT_PRIVATE HistogramBase* DeserializeHistogramInfo(
       PickleIterator* iter);
   static HistogramBase* DeserializeInfoImpl(PickleIterator* iter);
 
   // For some ranges, we store a printable description of a bucket range.
   // If there is no description, then GetAsciiBucketRange() uses parent class
   // to provide a description.
   typedef std::map<Sample, std::string> BucketDescriptionMap;
   BucketDescriptionMap bucket_description_;
 
   DISALLOW_COPY_AND_ASSIGN(LinearHistogram);
 };
 
 //------------------------------------------------------------------------------
 
 // BooleanHistogram is a histogram for booleans.
 class BASE_EXPORT BooleanHistogram : public LinearHistogram {
  public:
   static HistogramBase* FactoryGet(const std::string& name, int32 flags);
 
-  virtual HistogramType GetHistogramType() const OVERRIDE;
+  HistogramType GetHistogramType() const override;
 
  private:
   BooleanHistogram(const std::string& name, const BucketRanges* ranges);
 
   friend BASE_EXPORT_PRIVATE HistogramBase* DeserializeHistogramInfo(
       PickleIterator* iter);
   static HistogramBase* DeserializeInfoImpl(PickleIterator* iter);
 
   DISALLOW_COPY_AND_ASSIGN(BooleanHistogram);
 };
 
 //------------------------------------------------------------------------------
 
 // CustomHistogram is a histogram for a set of custom integers.
 class BASE_EXPORT CustomHistogram : public Histogram {
  public:
   // |custom_ranges| contains a vector of limits on ranges. Each limit should be
   // > 0 and < kSampleType_MAX. (Currently 0 is still accepted for backward
   // compatibility). The limits can be unordered or contain duplication, but
   // client should not depend on this.
   static HistogramBase* FactoryGet(const std::string& name,
                                    const std::vector<Sample>& custom_ranges,
                                    int32 flags);
 
   // Overridden from Histogram:
-  virtual HistogramType GetHistogramType() const OVERRIDE;
+  HistogramType GetHistogramType() const override;
 
   // Helper method for transforming an array of valid enumeration values
   // to the std::vector<int> expected by UMA_HISTOGRAM_CUSTOM_ENUMERATION.
   // This function ensures that a guard bucket exists right after any
   // valid sample value (unless the next higher sample is also a valid value),
   // so that invalid samples never fall into the same bucket as valid samples.
   // TODO(kaiwang): Change name to ArrayToCustomEnumRanges.
   static std::vector<Sample> ArrayToCustomRanges(const Sample* values,
                                                  size_t num_values);
  protected:
   CustomHistogram(const std::string& name,
                   const BucketRanges* ranges);
 
   // HistogramBase implementation:
-  virtual bool SerializeInfoImpl(Pickle* pickle) const OVERRIDE;
+  bool SerializeInfoImpl(Pickle* pickle) const override;
 
-  virtual double GetBucketSize(Count current, size_t i) const OVERRIDE;
+  double GetBucketSize(Count current, size_t i) const override;
 
  private:
   friend BASE_EXPORT_PRIVATE HistogramBase* DeserializeHistogramInfo(
       PickleIterator* iter);
   static HistogramBase* DeserializeInfoImpl(PickleIterator* iter);
 
   static bool ValidateCustomRanges(const std::vector<Sample>& custom_ranges);
   static BucketRanges* CreateBucketRangesFromCustomRanges(
       const std::vector<Sample>& custom_ranges);
 
   DISALLOW_COPY_AND_ASSIGN(CustomHistogram);
 };
 
 }  // namespace base
 
 #endif  // BASE_METRICS_HISTOGRAM_H_