Fix IPC fuzzer build for strict {virtual,override,final} checks.

BUG=417463,445748 Review URL: https://codereview.chromium.org/831963002 Cr-Commit-Position: refs/heads/master@{#309820}
280723148 · Jan 1, 2015 · 6bda0a3 · 6bda0a3
1 parent 63ac1c7
commit 6bda0a3
Show file tree

Hide file tree

Showing 3 changed files with 48 additions and 48 deletions.
diff --git a/tools/ipc_fuzzer/mutate/generate.cc b/tools/ipc_fuzzer/mutate/generate.cc
@@ -104,65 +104,65 @@ class GeneratorImpl : public Generator {
   GeneratorImpl() {}
   virtual ~GeneratorImpl() {}
 
-  virtual void GenerateBool(bool* value) override {
+  void GenerateBool(bool* value) override {
     *value = RandInRange(2);
   }
 
-  virtual void GenerateInt(int* value) override {
+  void GenerateInt(int* value) override {
     GenerateIntegralType<int>(value);
   }
 
-  virtual void GenerateLong(long* value) override {
+  void GenerateLong(long* value) override {
     GenerateIntegralType<long>(value);
   }
 
-  virtual void GenerateSize(size_t* value) override {
+  void GenerateSize(size_t* value) override {
     GenerateIntegralType<size_t>(value);
   }
 
-  virtual void GenerateUChar(unsigned char* value) override {
+  void GenerateUChar(unsigned char* value) override {
     GenerateIntegralType<unsigned char>(value);
   }
 
-  virtual void GenerateUInt16(uint16* value) override {
+  void GenerateUInt16(uint16* value) override {
     GenerateIntegralType<uint16>(value);
   }
 
-  virtual void GenerateUInt32(uint32* value) override {
+  void GenerateUInt32(uint32* value) override {
     GenerateIntegralType<uint32>(value);
   }
 
-  virtual void GenerateInt64(int64* value) override {
+  void GenerateInt64(int64* value) override {
     GenerateIntegralType<int64>(value);
   }
 
-  virtual void GenerateUInt64(uint64* value) override {
+  void GenerateUInt64(uint64* value) override {
     GenerateIntegralType<uint64>(value);
   }
 
-  virtual void GenerateFloat(float* value) override {
+  void GenerateFloat(float* value) override {
     GenerateFloatingType<float>(value);
   }
 
-  virtual void GenerateDouble(double* value) override {
+  void GenerateDouble(double* value) override {
     GenerateFloatingType<double>(value);
   }
 
-  virtual void GenerateString(std::string* value) override {
+  void GenerateString(std::string* value) override {
     GenerateStringType<std::string>(value);
   }
 
-  virtual void GenerateString16(base::string16* value) override {
+  void GenerateString16(base::string16* value) override {
     GenerateStringType<base::string16>(value);
   }
 
-  virtual void GenerateData(char* data, int length) override {
+  void GenerateData(char* data, int length) override {
     for (int i = 0; i < length; ++i) {
       GenerateIntegralType<char>(&data[i]);
     }
   }
 
-  virtual void GenerateBytes(void* data, int data_len) override {
+  void GenerateBytes(void* data, int data_len) override {
     GenerateData(static_cast<char*>(data), data_len);
   }
 };

diff --git a/tools/ipc_fuzzer/mutate/mutate.cc b/tools/ipc_fuzzer/mutate/mutate.cc
@@ -94,72 +94,72 @@ class DefaultFuzzer : public Fuzzer {
 
   virtual ~DefaultFuzzer() {}
 
-  virtual void FuzzBool(bool* value) override {
+  void FuzzBool(bool* value) override {
     if (RandEvent(frequency_))
       (*value) = !(*value);
   }
 
-  virtual void FuzzInt(int* value) override {
+  void FuzzInt(int* value) override {
     FuzzIntegralType<int>(value, frequency_);
   }
 
-  virtual void FuzzLong(long* value) override {
+  void FuzzLong(long* value) override {
     FuzzIntegralType<long>(value, frequency_);
   }
 
-  virtual void FuzzSize(size_t* value) override {
+  void FuzzSize(size_t* value) override {
     FuzzIntegralType<size_t>(value, frequency_);
   }
 
-  virtual void FuzzUChar(unsigned char* value) override {
+  void FuzzUChar(unsigned char* value) override {
     FuzzIntegralType<unsigned char>(value, frequency_);
   }
 
-  virtual void FuzzUInt16(uint16* value) override {
+  void FuzzUInt16(uint16* value) override {
     FuzzIntegralType<uint16>(value, frequency_);
   }
 
-  virtual void FuzzUInt32(uint32* value) override {
+  void FuzzUInt32(uint32* value) override {
     FuzzIntegralType<uint32>(value, frequency_);
   }
 
-  virtual void FuzzInt64(int64* value) override {
+  void FuzzInt64(int64* value) override {
     FuzzIntegralType<int64>(value, frequency_);
   }
 
-  virtual void FuzzUInt64(uint64* value) override {
+  void FuzzUInt64(uint64* value) override {
     FuzzIntegralType<uint64>(value, frequency_);
   }
 
-  virtual void FuzzFloat(float* value) override {
+  void FuzzFloat(float* value) override {
     if (RandEvent(frequency_))
       *value = RandDouble();
   }
 
-  virtual void FuzzDouble(double* value) override {
+  void FuzzDouble(double* value) override {
     if (RandEvent(frequency_))
       *value = RandDouble();
   }
 
-  virtual void FuzzString(std::string* value) override {
+  void FuzzString(std::string* value) override {
     FuzzStringType<std::string>(value, frequency_, "BORKED", std::string());
   }
 
-  virtual void FuzzString16(base::string16* value) override {
+  void FuzzString16(base::string16* value) override {
     FuzzStringType<base::string16>(value, frequency_,
                                    base::WideToUTF16(L"BORKED"),
                                    base::WideToUTF16(L""));
   }
 
-  virtual void FuzzData(char* data, int length) override {
+  void FuzzData(char* data, int length) override {
     if (RandEvent(frequency_)) {
       for (int i = 0; i < length; ++i) {
         FuzzIntegralType<char>(&data[i], frequency_);
       }
     }
   }
 
-  virtual void FuzzBytes(void* data, int data_len) override {
+  void FuzzBytes(void* data, int data_len) override {
     FuzzData(static_cast<char*>(data), data_len);
   }
 
@@ -175,21 +175,21 @@ class NoOpFuzzer : public Fuzzer {
   NoOpFuzzer() {}
   virtual ~NoOpFuzzer() {}
 
-  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 FuzzString16(base::string16* value) override {}
-  virtual void FuzzData(char* data, int length) override {}
-  virtual void FuzzBytes(void* data, int data_len) override {}
+  void FuzzBool(bool* value) override {}
+  void FuzzInt(int* value) override {}
+  void FuzzLong(long* value) override {}
+  void FuzzSize(size_t* value) override {}
+  void FuzzUChar(unsigned char* value) override {}
+  void FuzzUInt16(uint16* value) override {}
+  void FuzzUInt32(uint32* value) override {}
+  void FuzzInt64(int64* value) override {}
+  void FuzzUInt64(uint64* value) override {}
+  void FuzzFloat(float* value) override {}
+  void FuzzDouble(double* value) override {}
+  void FuzzString(std::string* value) override {}
+  void FuzzString16(base::string16* value) override {}
+  void FuzzData(char* data, int length) override {}
+  void FuzzBytes(void* data, int data_len) override {}
 };
 
 class FuzzerFactory {

diff --git a/tools/ipc_fuzzer/replay/replay_process.h b/tools/ipc_fuzzer/replay/replay_process.h
@@ -20,7 +20,7 @@ namespace ipc_fuzzer {
 class ReplayProcess : public IPC::Listener {
  public:
   ReplayProcess();
-  virtual ~ReplayProcess();
+  ~ReplayProcess() override;
 
   // Set up command line, logging, IO thread. Returns true on success, false
   // otherwise.
@@ -37,8 +37,8 @@ class ReplayProcess : public IPC::Listener {
   void Run();
 
   // IPC::Listener implementation.
-  virtual bool OnMessageReceived(const IPC::Message& message) override;
-  virtual void OnChannelError() override;
+  bool OnMessageReceived(const IPC::Message& message) override;
+  void OnChannelError() override;
 
  private:
   void SendNextMessage();