Use exactly one of final, override, and virtual

minidump/minidump_writable_test.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 42 matching lines @@
 
   void Verify() {
     verified_ = true;
     EXPECT_EQ(kStateWritten, state());
     for (BaseTestMinidumpWritable* child : children_) {
       child->Verify();
     }
   }
 
  protected:
-  virtual bool Freeze() override {
+  bool Freeze() override {
     EXPECT_EQ(kStateMutable, state());
     bool rv = MinidumpWritable::Freeze();
     EXPECT_TRUE(rv);
     EXPECT_EQ(kStateFrozen, state());
     return rv;
   }
 
-  virtual size_t Alignment() override {
+  size_t Alignment() override {
     EXPECT_GE(state(), kStateFrozen);
     return has_alignment_ ? alignment_ : MinidumpWritable::Alignment();
   }
 
-  virtual std::vector<MinidumpWritable*> Children() override {
+  std::vector<MinidumpWritable*> Children() override {
     EXPECT_GE(state(), kStateFrozen);
     if (!children_.empty()) {
       std::vector<MinidumpWritable*> children;
       for (BaseTestMinidumpWritable* child : children_) {
         children.push_back(child);
       }
       return children;
     }
     return MinidumpWritable::Children();
   }
 
-  virtual Phase WritePhase() override {
+  Phase WritePhase() override {
     return has_phase_ ? phase_ : MinidumpWritable::Phase();
   }
 
-  virtual bool WillWriteAtOffsetImpl(off_t offset) override {
+  bool WillWriteAtOffsetImpl(off_t offset) override {
     EXPECT_EQ(state(), kStateFrozen);
     expected_offset_ = offset;
     bool rv = MinidumpWritable::WillWriteAtOffsetImpl(offset);
     EXPECT_TRUE(rv);
     return rv;
   }
 
-  virtual bool WriteObject(FileWriterInterface* file_writer) override {
+  bool WriteObject(FileWriterInterface* file_writer) override {
     EXPECT_EQ(state(), kStateWritable);
     EXPECT_EQ(expected_offset_, file_writer->Seek(0, SEEK_CUR));
 
     // Subclasses must override this.
     return false;
   }
 
  private:
   std::vector<BaseTestMinidumpWritable*> children_;
   off_t expected_offset_;
   size_t alignment_;
   Phase phase_;
   bool has_alignment_;
   bool has_phase_;
   bool verified_;
 
   DISALLOW_COPY_AND_ASSIGN(BaseTestMinidumpWritable);
 };
 
 class TestStringMinidumpWritable final : public BaseTestMinidumpWritable {
  public:
   TestStringMinidumpWritable() : BaseTestMinidumpWritable(), data_() {}
 
   ~TestStringMinidumpWritable() {}
 
   void SetData(const std::string& string) { data_ = string; }
 
  protected:
-  virtual size_t SizeOfObject() override {
+  size_t SizeOfObject() override {
     EXPECT_GE(state(), kStateFrozen);
     return data_.size();
   }
 
-  virtual bool WriteObject(FileWriterInterface* file_writer) override {
+  bool WriteObject(FileWriterInterface* file_writer) override {
     BaseTestMinidumpWritable::WriteObject(file_writer);
     bool rv = file_writer->Write(&data_[0], data_.size());
     EXPECT_TRUE(rv);
     return rv;
   }
 
  private:
   std::string data_;
 
   DISALLOW_COPY_AND_ASSIGN(TestStringMinidumpWritable);
@@ skipping 339 matching lines @@
 
 class TestRVAMinidumpWritable final : public BaseTestMinidumpWritable {
  public:
   TestRVAMinidumpWritable() : BaseTestMinidumpWritable(), rva_() {}
 
   ~TestRVAMinidumpWritable() {}
 
   void SetRVA(MinidumpWritable* other) { other->RegisterRVA(&rva_); }
 
  protected:
-  virtual size_t SizeOfObject() override {
+  size_t SizeOfObject() override {
     EXPECT_GE(state(), kStateFrozen);
     return sizeof(rva_);
   }
 
-  virtual bool WriteObject(FileWriterInterface* file_writer) override {
+  bool WriteObject(FileWriterInterface* file_writer) override {
     BaseTestMinidumpWritable::WriteObject(file_writer);
     EXPECT_TRUE(file_writer->Write(&rva_, sizeof(rva_)));
     return true;
   }
 
  private:
   RVA rva_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRVAMinidumpWritable);
 };
@@ skipping 111 matching lines @@
 
   ~TestLocationDescriptorMinidumpWritable() {}
 
   void SetLocationDescriptor(MinidumpWritable* other) {
     other->RegisterLocationDescriptor(&location_descriptor_);
   }
 
   void SetString(const std::string& string) { string_ = string; }
 
  protected:
-  virtual size_t SizeOfObject() override {
+  size_t SizeOfObject() override {
     EXPECT_GE(state(), kStateFrozen);
     // NUL-terminate.
     return sizeof(location_descriptor_) + string_.size() + 1;
   }
 
-  virtual bool WriteObject(FileWriterInterface* file_writer) override {
+  bool WriteObject(FileWriterInterface* file_writer) override {
     BaseTestMinidumpWritable::WriteObject(file_writer);
     WritableIoVec iov;
     iov.iov_base = &location_descriptor_;
     iov.iov_len = sizeof(location_descriptor_);
     std::vector<WritableIoVec> iovecs(1, iov);
     // NUL-terminate.
     iov.iov_base = &string_[0];
     iov.iov_len = string_.size() + 1;
     iovecs.push_back(iov);
     EXPECT_TRUE(file_writer->WriteIoVec(&iovecs));
@@ skipping 180 matching lines @@
     EXPECT_EQ(10u, ldd->location_descriptor.DataSize);
     EXPECT_EQ(12u, ldd->location_descriptor.Rva);
     EXPECT_STREQ("o", ldd->string);
     parent.Verify();
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad