Warn on missing OVERRIDE/virtual everywhere, not just in header files.

net/tools/quic/quic_in_memory_cache.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 "net/tools/quic/quic_in_memory_cache.h"
 
 #include "base/file_util.h"
 #include "base/stl_util.h"
 
 using base::FilePath;
 using base::StringPiece;
 using file_util::FileEnumerator;
 using std::string;
 
 // Specifies the directory used during QuicInMemoryCache
 // construction to seed the cache. Cache directory can be
 // generated using `wget -p --save-headers <url>
 string FLAGS_quic_in_memory_cache_dir;
 
 namespace net {
 namespace tools {
 
 namespace {
 
 // BalsaVisitor implementation (glue) which caches response bodies.
 class CachingBalsaVisitor : public BalsaVisitorInterface {
  public:
   CachingBalsaVisitor() : done_framing_(false) {}
-  virtual void ProcessBodyData(const char* input, size_t size) {
+  virtual void ProcessBodyData(const char* input, size_t size) OVERRIDE {
     AppendToBody(input, size);
   }
   virtual void ProcessTrailers(const BalsaHeaders& trailer) {
     LOG(DFATAL) << "Trailers not supported.";
   }
-  virtual void MessageDone() {
+  virtual void MessageDone() OVERRIDE {
     done_framing_ = true;
   }
-  virtual void HandleHeaderError(BalsaFrame* framer) { UnhandledError(); }
-  virtual void HandleHeaderWarning(BalsaFrame* framer) { UnhandledError(); }
+  virtual void HandleHeaderError(BalsaFrame* framer) OVERRIDE {
+    UnhandledError();
+  }
+  virtual void HandleHeaderWarning(BalsaFrame* framer) OVERRIDE {
+    UnhandledError();
+  }
   virtual void HandleTrailerError(BalsaFrame* framer) { UnhandledError(); }
   virtual void HandleTrailerWarning(BalsaFrame* framer) { UnhandledError(); }
-  virtual void HandleChunkingError(BalsaFrame* framer) { UnhandledError(); }
-  virtual void HandleBodyError(BalsaFrame* framer) { UnhandledError(); }
+  virtual void HandleChunkingError(BalsaFrame* framer) OVERRIDE {
+    UnhandledError();
+  }
+  virtual void HandleBodyError(BalsaFrame* framer) OVERRIDE {
+    UnhandledError();
+  }
   void UnhandledError() {
     LOG(DFATAL) << "Unhandled error framing HTTP.";
   }
-  virtual void ProcessBodyInput(const char*, size_t) {}
-  virtual void ProcessHeaderInput(const char*, size_t) {}
-  virtual void ProcessTrailerInput(const char*, size_t) {}
-  virtual void ProcessHeaders(const net::BalsaHeaders&) {}
+  virtual void ProcessBodyInput(const char*, size_t) OVERRIDE {}
+  virtual void ProcessHeaderInput(const char*, size_t) OVERRIDE {}
+  virtual void ProcessTrailerInput(const char*, size_t) OVERRIDE {}
+  virtual void ProcessHeaders(const net::BalsaHeaders&) OVERRIDE {}
   virtual void ProcessRequestFirstLine(
       const char*, size_t, const char*, size_t,
-      const char*, size_t, const char*, size_t) {}
+      const char*, size_t, const char*, size_t) OVERRIDE {}
   virtual void ProcessResponseFirstLine(
       const char*, size_t, const char*,
-      size_t, const char*, size_t, const char*, size_t) {}
-  virtual void ProcessChunkLength(size_t) {}
-  virtual void ProcessChunkExtensions(const char*, size_t) {}
-  virtual void HeaderDone() {}
+      size_t, const char*, size_t, const char*, size_t) OVERRIDE {}
+  virtual void ProcessChunkLength(size_t) OVERRIDE {}
+  virtual void ProcessChunkExtensions(const char*, size_t) OVERRIDE {}
+  virtual void HeaderDone() OVERRIDE {}
 
   void AppendToBody(const char* input, size_t size) {
     body_.append(input, size);
   }
   bool done_framing() const { return done_framing_; }
   const string& body() const { return body_; }
 
  private:
   bool done_framing_;
   string body_;
@@ skipping 116 matching lines @@
   STLDeleteValues(&responses_);
 }
 
 string QuicInMemoryCache::GetKey(const BalsaHeaders& request_headers) const {
   return request_headers.GetHeader("host").as_string() +
       request_headers.request_uri().as_string();
 }
 
 }  // namespace tools
 }  // namespace net