Standardize usage of virtual/override/final in content/browser/

content/browser/devtools/devtools_system_info_handler.cc

 // Copyright 2013 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 "content/browser/devtools/devtools_system_info_handler.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/values.h"
 #include "content/browser/devtools/devtools_protocol_constants.h"
@@ skipping 16 matching lines @@
 const char kModelVersion[] = "modelVersion";
 const char kVendorId[] = "vendorId";
 const char kVendorString[] = "vendorString";
 
 class AuxGPUInfoEnumerator : public gpu::GPUInfo::Enumerator {
  public:
   AuxGPUInfoEnumerator(base::DictionaryValue* dictionary)
       : dictionary_(dictionary),
         in_aux_attributes_(false) { }
 
-  virtual void AddInt64(const char* name, int64 value) override {
+  void AddInt64(const char* name, int64 value) override {
     if (in_aux_attributes_)
       dictionary_->SetDouble(name, value);
   }
 
-  virtual void AddInt(const char* name, int value) override {
+  void AddInt(const char* name, int value) override {
     if (in_aux_attributes_)
       dictionary_->SetInteger(name, value);
   }
 
-  virtual void AddString(const char* name, const std::string& value) override {
+  void AddString(const char* name, const std::string& value) override {
     if (in_aux_attributes_)
       dictionary_->SetString(name, value);
   }
 
-  virtual void AddBool(const char* name, bool value) override {
+  void AddBool(const char* name, bool value) override {
     if (in_aux_attributes_)
       dictionary_->SetBoolean(name, value);
   }
 
-  virtual void AddTimeDeltaInSecondsF(const char* name,
-                                      const base::TimeDelta& value) override {
+  void AddTimeDeltaInSecondsF(const char* name,
+                              const base::TimeDelta& value) override {
     if (in_aux_attributes_)
       dictionary_->SetDouble(name, value.InSecondsF());
   }
 
-  virtual void BeginGPUDevice() override {
-  }
+  void BeginGPUDevice() override {}
 
-  virtual void EndGPUDevice() override {
-  }
+  void EndGPUDevice() override {}
 
-  virtual void BeginVideoEncodeAcceleratorSupportedProfile() override {}
+  void BeginVideoEncodeAcceleratorSupportedProfile() override {}
 
-  virtual void EndVideoEncodeAcceleratorSupportedProfile() override {}
+  void EndVideoEncodeAcceleratorSupportedProfile() override {}
 
-  virtual void BeginAuxAttributes() override {
-    in_aux_attributes_ = true;
-  }
+  void BeginAuxAttributes() override { in_aux_attributes_ = true; }
 
-  virtual void EndAuxAttributes() override {
-    in_aux_attributes_ = false;
-  }
+  void EndAuxAttributes() override { in_aux_attributes_ = false; }
 
  private:
   base::DictionaryValue* dictionary_;
   bool in_aux_attributes_;
 };
 
 base::DictionaryValue* GPUDeviceToDictionary(
     const gpu::GPUInfo::GPUDevice& device) {
   base::DictionaryValue* result = new base::DictionaryValue;
   result->SetInteger(kVendorId, device.vendor_id);
@@ skipping 37 matching lines @@
   gpu_dict->Set(kDriverBugWorkarounds, GetDriverBugWorkarounds());
 
   base::DictionaryValue* system_dict = new base::DictionaryValue;
   system_dict->SetString(kModelName, gpu_info.machine_model_name);
   system_dict->SetString(kModelVersion, gpu_info.machine_model_version);
   system_dict->Set(kGPU, gpu_dict);
   return command->SuccessResponse(system_dict);
 }
 
 }  // namespace content