Linux/ChromeOS Chromium style checker cleanup, chrome/ edition part 1.

chrome/tools/ipclist/ipcfuzz.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 <algorithm>
 #include <ostream>
 #include <set>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 107 matching lines @@
 
     if ((env_var = getenv("CHROME_IPC_FUZZING_FREQUENCY"))) {
       unsigned int new_frequency = atoi(env_var);
       if (new_frequency)
         frequency_ = new_frequency;
     }
   }
 
   virtual ~DefaultFuzzer() {}
 
-  virtual bool FuzzThisMessage(const IPC::Message *msg) {
+  virtual bool FuzzThisMessage(const IPC::Message *msg) OVERRIDE {
     return (message_set_.empty() ||
             std::find(message_set_.begin(),
                       message_set_.end(),
                       msg->type()) != message_set_.end());
   }
 
-  virtual void FuzzBool(bool* value) {
+  virtual void FuzzBool(bool* value) OVERRIDE {
     if (rand() % frequency_ == 0)
       (*value) = !(*value);
   }
 
-  virtual void FuzzInt(int* value) {
+  virtual void FuzzInt(int* value) OVERRIDE {
     FuzzIntegralType<int>(value, frequency_);
   }
 
-  virtual void FuzzLong(long* value) {
+  virtual void FuzzLong(long* value) OVERRIDE {
     FuzzIntegralType<long>(value, frequency_);
   }
 
-  virtual void FuzzSize(size_t* value) {
+  virtual void FuzzSize(size_t* value) OVERRIDE {
     FuzzIntegralType<size_t>(value, frequency_);
   }
 
-  virtual void FuzzUChar(unsigned char* value) {
+  virtual void FuzzUChar(unsigned char* value) OVERRIDE {
     FuzzIntegralType<unsigned char>(value, frequency_);
   }
 
-  virtual void FuzzUInt16(uint16* value) {
+  virtual void FuzzUInt16(uint16* value) OVERRIDE {
     FuzzIntegralType<uint16>(value, frequency_);
   }
 
-  virtual void FuzzUInt32(uint32* value) {
+  virtual void FuzzUInt32(uint32* value) OVERRIDE {
     FuzzIntegralType<uint32>(value, frequency_);
   }
 
-  virtual void FuzzInt64(int64* value) {
+  virtual void FuzzInt64(int64* value) OVERRIDE {
     FuzzIntegralType<int64>(value, frequency_);
   }
 
-  virtual void FuzzUInt64(uint64* value) {
+  virtual void FuzzUInt64(uint64* value) OVERRIDE {
     FuzzIntegralType<uint64>(value, frequency_);
   }
 
-  virtual void FuzzFloat(float* value) {
+  virtual void FuzzFloat(float* value) OVERRIDE {
     if (rand() % frequency_ == 0)
       (*value) *= rand() / 1000000.0;
   }
 
-  virtual void FuzzDouble(double* value) {
+  virtual void FuzzDouble(double* value) OVERRIDE {
     if (rand() % frequency_ == 0)
       (*value) *= rand() / 1000000.0;
   }
 
-  virtual void FuzzString(std::string* value) {
+  virtual void FuzzString(std::string* value) OVERRIDE {
     FuzzStringType<std::string>(value, frequency_, "BORKED", "");
   }
 
-  virtual void FuzzWString(std::wstring* value) {
+  virtual void FuzzWString(std::wstring* value) OVERRIDE {
     FuzzStringType<std::wstring>(value, frequency_, L"BORKED", L"");
   }
 
-  virtual void FuzzString16(string16* value) {
+  virtual void FuzzString16(string16* value) OVERRIDE {
     FuzzStringType<string16>(value, frequency_,
                              WideToUTF16(L"BORKED"),
                              WideToUTF16(L""));
   }
 
-  virtual void FuzzData(char* data, int length) {
+  virtual void FuzzData(char* data, int length) OVERRIDE {
     if (rand() % frequency_ == 0) {
       for (int i = 0; i < length; ++i) {
         FuzzIntegralType<char>(&data[i], frequency_);
       }
     }
   }
 
-  virtual void FuzzBytes(void* data, int data_len) {
+  virtual void FuzzBytes(void* data, int data_len) OVERRIDE {
     FuzzData(static_cast<char*>(data), data_len);
   }
 
  private:
   std::set<int> message_set_;
   unsigned int frequency_;
 };
 
 
 // No-op fuzzer.  Rewrites each message unchanged to check if the message
 // re-assembly is legit.
 class NoOpFuzzer : public IPC::Fuzzer {
  public:
   NoOpFuzzer() {}
   virtual ~NoOpFuzzer() {}
 
-  virtual bool FuzzThisMessage(const IPC::Message *msg) {
+  virtual bool FuzzThisMessage(const IPC::Message *msg) OVERRIDE {
     return true;
   }
 
-  virtual void FuzzBool(bool* value) {}
-  virtual void FuzzInt(int* value) {}
-  virtual void FuzzLong(long* value) {}
-  virtual void FuzzSize(size_t* value) {}
-  virtual void FuzzUChar(unsigned char* value) {}
-  virtual void FuzzUInt16(uint16* value) {}
-  virtual void FuzzUInt32(uint32* value) {}
-  virtual void FuzzInt64(int64* value) {}
-  virtual void FuzzUInt64(uint64* value) {}
-  virtual void FuzzFloat(float* value) {}
-  virtual void FuzzDouble(double* value) {}
-  virtual void FuzzString(std::string* value) {}
-  virtual void FuzzWString(std::wstring* value) {}
-  virtual void FuzzString16(string16* value) {}
-  virtual void FuzzData(char* data, int length) {}
-  virtual void FuzzBytes(void* data, int data_len) {}
+  virtual void FuzzBool(bool* value) OVERRIDE {}
+  virtual void FuzzInt(int* value) OVERRIDE {}
+  virtual void FuzzLong(long* value) OVERRIDE {}
+  virtual void FuzzSize(size_t* value) OVERRIDE {}
+  virtual void FuzzUChar(unsigned char* value) OVERRIDE {}
+  virtual void FuzzUInt16(uint16* value) OVERRIDE {}
+  virtual void FuzzUInt32(uint32* value) OVERRIDE {}
+  virtual void FuzzInt64(int64* value) OVERRIDE {}
+  virtual void FuzzUInt64(uint64* value) OVERRIDE {}
+  virtual void FuzzFloat(float* value) OVERRIDE {}
+  virtual void FuzzDouble(double* value) OVERRIDE {}
+  virtual void FuzzString(std::string* value) OVERRIDE {}
+  virtual void FuzzWString(std::wstring* value) OVERRIDE {}
+  virtual void FuzzString16(string16* value) OVERRIDE {}
+  virtual void FuzzData(char* data, int length) OVERRIDE {}
+  virtual void FuzzBytes(void* data, int data_len) OVERRIDE {}
 };
 
 class FuzzerFactory {
  public:
   static IPC::Fuzzer *NewFuzzer(const std::string& name) {
     if (name == "no-op")
       return new NoOpFuzzer();
     else
       return new DefaultFuzzer();
   }
@@ skipping 403 matching lines @@
 }
 
 class ipcfuzz : public IPC::ChannelProxy::OutgoingMessageFilter {
  public:
   ipcfuzz() {
     const char* env_var = getenv("CHROME_IPC_FUZZING_KIND");
     fuzzer_ = FuzzerFactory::NewFuzzer(env_var ? env_var : "");
     PopulateFuzzFunctionMap(&fuzz_function_map_);
   }
 
-  IPC::Message* Rewrite(IPC::Message* message) {
+  virtual IPC::Message* Rewrite(IPC::Message* message) OVERRIDE {
     if (fuzzer_ && fuzzer_->FuzzThisMessage(message)) {
       FuzzFunctionMap::iterator it = fuzz_function_map_.find(message->type());
       if (it != fuzz_function_map_.end()) {
         IPC::Message* fuzzed_message = (*it->second)(message, fuzzer_);
         if (fuzzed_message)  {
           delete message;
           message = fuzzed_message;
         }
       }
     }
     return message;
   }
 
  private:
   IPC::Fuzzer* fuzzer_;
   FuzzFunctionMap fuzz_function_map_;
 };
 
 ipcfuzz g_ipcfuzz;
 
 // Entry point avoiding mangled names.
 extern "C" {
   __attribute__((visibility("default")))
   IPC::ChannelProxy::OutgoingMessageFilter* GetFilter(void);
 }
 
 IPC::ChannelProxy::OutgoingMessageFilter* GetFilter(void) {
   return &g_ipcfuzz;
 }