Add OVERRIDE to chrome/browser/.

chrome/browser/net/passive_log_collector.h

 // 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.
 
 #ifndef CHROME_BROWSER_NET_PASSIVE_LOG_COLLECTOR_H_
 #define CHROME_BROWSER_NET_PASSIVE_LOG_COLLECTOR_H_
 #pragma once
 
 #include <deque>
 #include <string>
@@ skipping 75 matching lines @@
   };
 
   // This source tracker is intended for TYPE_NONE. All entries go into a
   // circular buffer, and there is no concept of live/dead requests.
   class GlobalSourceTracker : public SourceTrackerInterface {
    public:
     GlobalSourceTracker();
     virtual ~GlobalSourceTracker();
 
     // SourceTrackerInterface implementation:
-    virtual void OnAddEntry(const ChromeNetLog::Entry& entry);
-    virtual void Clear();
-    virtual void AppendAllEntries(ChromeNetLog::EntryList* out) const;
+    virtual void OnAddEntry(const ChromeNetLog::Entry& entry) OVERRIDE;
+    virtual void Clear() OVERRIDE;
+    virtual void AppendAllEntries(ChromeNetLog::EntryList* out) const OVERRIDE;
 
    private:
     typedef std::deque<ChromeNetLog::Entry> CircularEntryList;
     CircularEntryList entries_;
     DISALLOW_COPY_AND_ASSIGN(GlobalSourceTracker);
   };
 
   // This class stores and manages the passively logged information for
   // URLRequests/SocketStreams/ConnectJobs.
   class SourceTracker : public SourceTrackerInterface {
    public:
     // Creates a SourceTracker that will track at most |max_num_sources|.
     // Up to |max_graveyard_size| unreferenced sources will be kept around
     // before deleting them for good. |parent| may be NULL, and points to
     // the owning PassiveLogCollector (it is used when adding references
     // to other sources).
     SourceTracker(size_t max_num_sources,
                   size_t max_graveyard_size,
                   PassiveLogCollector* parent);
 
     virtual ~SourceTracker();
 
     // SourceTrackerInterface implementation:
-    virtual void OnAddEntry(const ChromeNetLog::Entry& entry);
-    virtual void Clear();
-    virtual void AppendAllEntries(ChromeNetLog::EntryList* out) const;
+    virtual void OnAddEntry(const ChromeNetLog::Entry& entry) OVERRIDE;
+    virtual void Clear() OVERRIDE;
+    virtual void AppendAllEntries(ChromeNetLog::EntryList* out) const OVERRIDE;
 
 #ifdef UNIT_TEST
     // Helper used to inspect the current state by unit-tests.
     // Retuns a copy of the source infos held by the tracker.
     SourceInfoList GetAllDeadOrAliveSources(bool is_alive) const {
       SourceInfoList result;
       for (SourceIDToInfoMap::const_iterator it = sources_.begin();
            it != sources_.end(); ++it) {
         if (it->second.is_alive == is_alive)
           result.push_back(it->second);
@@ skipping 60 matching lines @@
   // Specialization of SourceTracker for handling ConnectJobs.
   class ConnectJobTracker : public SourceTracker {
    public:
     static const size_t kMaxNumSources;
     static const size_t kMaxGraveyardSize;
 
     explicit ConnectJobTracker(PassiveLogCollector* parent);
 
    private:
     virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
-                              SourceInfo* out_info);
+                              SourceInfo* out_info) OVERRIDE;
     DISALLOW_COPY_AND_ASSIGN(ConnectJobTracker);
   };
 
   // Specialization of SourceTracker for handling Sockets.
   class SocketTracker : public SourceTracker {
    public:
     static const size_t kMaxNumSources;
     static const size_t kMaxGraveyardSize;
 
     SocketTracker();
 
    private:
     virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
-                              SourceInfo* out_info);
+                              SourceInfo* out_info) OVERRIDE;
 
     DISALLOW_COPY_AND_ASSIGN(SocketTracker);
   };
 
   // Specialization of SourceTracker for handling net::URLRequest/SocketStream.
   class RequestTracker : public SourceTracker {
    public:
     static const size_t kMaxNumSources;
     static const size_t kMaxGraveyardSize;
 
     explicit RequestTracker(PassiveLogCollector* parent);
 
    private:
     virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
-                              SourceInfo* out_info);
+                              SourceInfo* out_info) OVERRIDE;
 
     DISALLOW_COPY_AND_ASSIGN(RequestTracker);
   };
 
   // Specialization of SourceTracker for handling
   // SOURCE_INIT_PROXY_RESOLVER.
   class InitProxyResolverTracker : public SourceTracker {
    public:
     static const size_t kMaxNumSources;
     static const size_t kMaxGraveyardSize;
 
     InitProxyResolverTracker();
 
    private:
     virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
-                              SourceInfo* out_info);
+                              SourceInfo* out_info) OVERRIDE;
 
     DISALLOW_COPY_AND_ASSIGN(InitProxyResolverTracker);
   };
 
   // Tracks the log entries for the last seen SOURCE_SPDY_SESSION.
   class SpdySessionTracker : public SourceTracker {
    public:
     static const size_t kMaxNumSources;
     static const size_t kMaxGraveyardSize;
 
     SpdySessionTracker();
 
    private:
     virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
-                              SourceInfo* out_info);
+                              SourceInfo* out_info) OVERRIDE;
 
     DISALLOW_COPY_AND_ASSIGN(SpdySessionTracker);
   };
 
   // Tracks the log entries for the last seen SOURCE_HOST_RESOLVER_IMPL_REQUEST.
   class DNSRequestTracker : public SourceTracker {
    public:
     static const size_t kMaxNumSources;
     static const size_t kMaxGraveyardSize;
 
     DNSRequestTracker();
 
    private:
     virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
-                              SourceInfo* out_info);
+                              SourceInfo* out_info) OVERRIDE;
 
     DISALLOW_COPY_AND_ASSIGN(DNSRequestTracker);
   };
 
   // Tracks the log entries for the last seen SOURCE_HOST_RESOLVER_IMPL_JOB.
   class DNSJobTracker : public SourceTracker {
    public:
     static const size_t kMaxNumSources;
     static const size_t kMaxGraveyardSize;
 
     DNSJobTracker();
 
    private:
     virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
-                              SourceInfo* out_info);
+                              SourceInfo* out_info) OVERRIDE;
 
     DISALLOW_COPY_AND_ASSIGN(DNSJobTracker);
   };
 
   // Tracks the log entries for the last seen SOURCE_DISK_CACHE_ENTRY.
   class DiskCacheEntryTracker : public SourceTracker {
    public:
     static const size_t kMaxNumSources;
     static const size_t kMaxGraveyardSize;
 
     DiskCacheEntryTracker();
 
    private:
     virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
-                              SourceInfo* out_info);
+                              SourceInfo* out_info) OVERRIDE;
 
     DISALLOW_COPY_AND_ASSIGN(DiskCacheEntryTracker);
   };
 
   // Tracks the log entries for the last seen SOURCE_DISK_CACHE_ENTRY.
   class MemCacheEntryTracker : public SourceTracker {
    public:
     static const size_t kMaxNumSources;
     static const size_t kMaxGraveyardSize;
 
     MemCacheEntryTracker();
 
    protected:
     virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
-                              SourceInfo* out_info);
+                              SourceInfo* out_info) OVERRIDE;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(MemCacheEntryTracker);
   };
 
   class HttpStreamJobTracker : public SourceTracker {
    public:
     static const size_t kMaxNumSources;
     static const size_t kMaxGraveyardSize;
 
     explicit HttpStreamJobTracker(PassiveLogCollector* parent);
 
    private:
     virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
-                              SourceInfo* out_info);
+                              SourceInfo* out_info) OVERRIDE;
     DISALLOW_COPY_AND_ASSIGN(HttpStreamJobTracker);
   };
 
   class ExponentialBackoffThrottlingTracker : public SourceTracker {
    public:
     static const size_t kMaxNumSources;
     static const size_t kMaxGraveyardSize;
 
     explicit ExponentialBackoffThrottlingTracker(PassiveLogCollector* parent);
 
    private:
     virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
-                              SourceInfo* out_info);
+                              SourceInfo* out_info) OVERRIDE;
     DISALLOW_COPY_AND_ASSIGN(ExponentialBackoffThrottlingTracker);
   };
 
   // Tracks the log entries for the last seen SOURCE_DNS_TRANSACTION.
   class DnsTransactionTracker : public SourceTracker {
    public:
     static const size_t kMaxNumSources;
     static const size_t kMaxGraveyardSize;
 
     DnsTransactionTracker();
 
    private:
     virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
-                              SourceInfo* out_info);
+                              SourceInfo* out_info) OVERRIDE;
 
     DISALLOW_COPY_AND_ASSIGN(DnsTransactionTracker);
   };
 
   // Tracks the log entries for the last seen SOURCE_ASYNC_HOST_RESOLVER_REQUEST
   class AsyncHostResolverRequestTracker : public SourceTracker {
    public:
     static const size_t kMaxNumSources;
     static const size_t kMaxGraveyardSize;
 
     AsyncHostResolverRequestTracker();
 
    private:
     virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
-                              SourceInfo* out_info);
+                              SourceInfo* out_info) OVERRIDE;
 
     DISALLOW_COPY_AND_ASSIGN(AsyncHostResolverRequestTracker);
   };
 
 
   // Tracks the log entries for the last seen SOURCE_UDP_SOCKET.
   class UDPSocketTracker : public SourceTracker {
    public:
     static const size_t kMaxNumSources;
     static const size_t kMaxGraveyardSize;
 
     UDPSocketTracker();
 
    private:
     virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
-                              SourceInfo* out_info);
+                              SourceInfo* out_info) OVERRIDE;
 
     DISALLOW_COPY_AND_ASSIGN(UDPSocketTracker);
   };
 
   // Tracks the log entries for the last seen SOURCE_CERT_VERIFIER_JOB
   class CertVerifierJobTracker : public SourceTracker {
    public:
     static const size_t kMaxNumSources;
     static const size_t kMaxGraveyardSize;
 
     CertVerifierJobTracker();
 
    private:
     virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
-                              SourceInfo* out_info);
+                              SourceInfo* out_info) OVERRIDE;
 
     DISALLOW_COPY_AND_ASSIGN(CertVerifierJobTracker);
   };
 
   PassiveLogCollector();
   virtual ~PassiveLogCollector();
 
   // ThreadSafeObserver implementation:
   virtual void OnAddEntry(net::NetLog::EventType type,
                           const base::TimeTicks& time,
                           const net::NetLog::Source& source,
                           net::NetLog::EventPhase phase,
-                          net::NetLog::EventParameters* params);
+                          net::NetLog::EventParameters* params) OVERRIDE;
 
   // Clears all of the passively logged data.
   void Clear();
 
   // Fills |out| with the full list of events that have been passively
   // captured. The list is ordered by capture time.
   void GetAllCapturedEvents(ChromeNetLog::EntryList* out) const;
 
  private:
   // Returns the tracker to use for sources of type |source_type|, or NULL.
@@ skipping 29 matching lines @@
   SourceTrackerInterface* trackers_[net::NetLog::SOURCE_COUNT];
 
   // The count of how many events have flowed through this log. Used to set the
   // "order" field on captured events.
   uint32 num_events_seen_;
 
   DISALLOW_COPY_AND_ASSIGN(PassiveLogCollector);
 };
 
 #endif  // CHROME_BROWSER_NET_PASSIVE_LOG_COLLECTOR_H_