Standardize usage of virtual/override/final in chrome/browser/extensions/

chrome/browser/extensions/api/networking_private/networking_private_apitest.cc

 // Copyright 2014 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 <map>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "chrome/browser/extensions/api/networking_private/networking_private_delegate.h"
@@ skipping 20 matching lines @@
 const char kSuccess[] = "Success";
 const char kGuid[] = "SOME_GUID";
 
 class TestDelegate : public KeyedService,
                      public NetworkingPrivateDelegate {
  public:
   TestDelegate() : fail_(false) {
   }
 
   // Asynchronous methods
-  virtual void GetProperties(const std::string& guid,
-                             const DictionaryCallback& success_callback,
-                             const FailureCallback& failure_callback) override {
+  void GetProperties(const std::string& guid,
+                     const DictionaryCallback& success_callback,
+                     const FailureCallback& failure_callback) override {
     DictionaryResult(guid, success_callback, failure_callback);
   }
 
-  virtual void GetManagedProperties(
-      const std::string& guid,
-      const DictionaryCallback& success_callback,
-      const FailureCallback& failure_callback) override {
+  void GetManagedProperties(const std::string& guid,
+                            const DictionaryCallback& success_callback,
+                            const FailureCallback& failure_callback) override {
     DictionaryResult(guid, success_callback, failure_callback);
   }
 
-  virtual void GetState(const std::string& guid,
-                        const DictionaryCallback& success_callback,
-                        const FailureCallback& failure_callback) override {
+  void GetState(const std::string& guid,
+                const DictionaryCallback& success_callback,
+                const FailureCallback& failure_callback) override {
     DictionaryResult(guid, success_callback, failure_callback);
   }
 
-
-  virtual void SetProperties(const std::string& guid,
-                             scoped_ptr<base::DictionaryValue> properties,
-                             const VoidCallback& success_callback,
-                             const FailureCallback& failure_callback) override {
+  void SetProperties(const std::string& guid,
+                     scoped_ptr<base::DictionaryValue> properties,
+                     const VoidCallback& success_callback,
+                     const FailureCallback& failure_callback) override {
     VoidResult(success_callback, failure_callback);
   }
 
-  virtual void CreateNetwork(bool shared,
-                             scoped_ptr<base::DictionaryValue> properties,
-                             const StringCallback& success_callback,
-                             const FailureCallback& failure_callback) override {
+  void CreateNetwork(bool shared,
+                     scoped_ptr<base::DictionaryValue> properties,
+                     const StringCallback& success_callback,
+                     const FailureCallback& failure_callback) override {
     StringResult(success_callback, failure_callback);
   }
 
-  virtual void GetNetworks(const std::string& network_type,
-                           bool configured_only,
-                           bool visible_only,
-                           int limit,
-                           const NetworkListCallback& success_callback,
-                           const FailureCallback& failure_callback) override {
+  void GetNetworks(const std::string& network_type,
+                   bool configured_only,
+                   bool visible_only,
+                   int limit,
+                   const NetworkListCallback& success_callback,
+                   const FailureCallback& failure_callback) override {
     if (fail_) {
       failure_callback.Run(kFailure);
     } else {
       scoped_ptr<base::ListValue> result(new base::ListValue);
       scoped_ptr<base::DictionaryValue> network(new base::DictionaryValue);
       network->SetString(::onc::network_config::kType,
                          ::onc::network_config::kEthernet);
       network->SetString(::onc::network_config::kGUID, kGuid);
       result->Append(network.release());
       success_callback.Run(result.Pass());
     }
   }
 
-  virtual void StartConnect(const std::string& guid,
-                            const VoidCallback& success_callback,
-                            const FailureCallback& failure_callback) override {
+  void StartConnect(const std::string& guid,
+                    const VoidCallback& success_callback,
+                    const FailureCallback& failure_callback) override {
     VoidResult(success_callback, failure_callback);
   }
 
-  virtual void StartDisconnect(
-      const std::string& guid,
-      const VoidCallback& success_callback,
-      const FailureCallback& failure_callback) override {
+  void StartDisconnect(const std::string& guid,
+                       const VoidCallback& success_callback,
+                       const FailureCallback& failure_callback) override {
     VoidResult(success_callback, failure_callback);
   }
 
-  virtual void VerifyDestination(
-      const VerificationProperties& verification_properties,
-      const BoolCallback& success_callback,
-      const FailureCallback& failure_callback) override {
+  void VerifyDestination(const VerificationProperties& verification_properties,
+                         const BoolCallback& success_callback,
+                         const FailureCallback& failure_callback) override {
     BoolResult(success_callback, failure_callback);
   }
 
-  virtual void VerifyAndEncryptCredentials(
+  void VerifyAndEncryptCredentials(
       const std::string& guid,
       const VerificationProperties& verification_properties,
       const StringCallback& success_callback,
       const FailureCallback& failure_callback) override {
     StringResult(success_callback, failure_callback);
   }
 
-  virtual void VerifyAndEncryptData(
+  void VerifyAndEncryptData(
       const VerificationProperties& verification_properties,
       const std::string& data,
       const StringCallback& success_callback,
       const FailureCallback& failure_callback) override {
     StringResult(success_callback, failure_callback);
   }
 
-  virtual void SetWifiTDLSEnabledState(
+  void SetWifiTDLSEnabledState(
       const std::string& ip_or_mac_address,
       bool enabled,
       const StringCallback& success_callback,
       const FailureCallback& failure_callback) override {
     StringResult(success_callback, failure_callback);
   }
 
-  virtual void GetWifiTDLSStatus(
-      const std::string& ip_or_mac_address,
-      const StringCallback& success_callback,
-      const FailureCallback& failure_callback) override {
+  void GetWifiTDLSStatus(const std::string& ip_or_mac_address,
+                         const StringCallback& success_callback,
+                         const FailureCallback& failure_callback) override {
     StringResult(success_callback, failure_callback);
   }
 
-  virtual void GetCaptivePortalStatus(
+  void GetCaptivePortalStatus(
       const std::string& guid,
       const StringCallback& success_callback,
       const FailureCallback& failure_callback) override {
     StringResult(success_callback, failure_callback);
   }
 
   // Synchronous methods
-  virtual scoped_ptr<base::ListValue> GetEnabledNetworkTypes() override {
+  scoped_ptr<base::ListValue> GetEnabledNetworkTypes() override {
     scoped_ptr<base::ListValue> result;
     if (!fail_) {
       result.reset(new base::ListValue);
       result->AppendString(::onc::network_config::kEthernet);
     }
     return result.Pass();
   }
 
-  virtual bool EnableNetworkType(const std::string& type) override{
+  bool EnableNetworkType(const std::string& type) override {
     enabled_[type] = true;
     return !fail_;
   }
 
-  virtual bool DisableNetworkType(const std::string& type) override {
+  bool DisableNetworkType(const std::string& type) override {
     disabled_[type] = true;
     return !fail_;
   }
 
-  virtual bool RequestScan() override {
+  bool RequestScan() override {
     scan_requested_.push_back(true);
     return !fail_;
   }
 
   void set_fail(bool fail) { fail_ = fail; }
   bool GetEnabled(const std::string& type) { return enabled_[type]; }
   bool GetDisabled(const std::string& type) { return disabled_[type]; }
   size_t GetScanRequested() { return scan_requested_.size(); }
 
  private:
@@ skipping 50 matching lines @@
     if (!s_test_delegate_)
       s_test_delegate_ = new TestDelegate;
   }
 
   static KeyedService* GetNetworkingPrivateDelegate(
       content::BrowserContext* profile) {
     CHECK(s_test_delegate_);
     return s_test_delegate_;
   }
 
-  virtual void SetUpCommandLine(CommandLine* command_line) override {
+  void SetUpCommandLine(CommandLine* command_line) override {
     ExtensionApiTest::SetUpCommandLine(command_line);
     // Whitelist the extension ID of the test extension.
     command_line->AppendSwitchASCII(
         extensions::switches::kWhitelistedExtensionID,
         "epcifkihnkjgphfkloaaleeakhpmgdmn");
   }
 
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     ExtensionApiTest::SetUpOnMainThread();
 #if defined(OS_CHROMEOS)
     NetworkingPrivateChromeOSFactory::GetInstance()->SetTestingFactory(
         profile(),
         &NetworkingPrivateApiTest::GetNetworkingPrivateDelegate);
 #else
     NetworkingPrivateServiceClientFactory::GetInstance()->SetTestingFactory(
         profile(),
         &NetworkingPrivateApiTest::GetNetworkingPrivateDelegate);
 #endif
@@ skipping 199 matching lines @@
   EXPECT_FALSE(RunNetworkingSubtest("getWifiTDLSStatus")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, GetCaptivePortalStatus) {
   EXPECT_FALSE(RunNetworkingSubtest("getCaptivePortalStatus")) << message_;
 }
 
 #endif // defined(OS_WIN)
 
 }  // namespace extensions