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

chrome/browser/extensions/api/gcd_private/gcd_private_api.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 "chrome/browser/extensions/api/gcd_private/gcd_private_api.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 132 matching lines @@
   typedef std::map<std::string /* id_string */,
                    linked_ptr<api::gcd_private::GCDDevice> > GCDDeviceMap;
 
   typedef std::map<int /* session id*/, linked_ptr<GcdPrivateSessionHolder> >
       GCDSessionMap;
 
   typedef std::map<std::string /* ssid */, std::string /* password */>
       PasswordMap;
 
   // EventRouter::Observer implementation.
-  virtual void OnListenerAdded(const EventListenerInfo& details) override;
-  virtual void OnListenerRemoved(const EventListenerInfo& details) override;
+  void OnListenerAdded(const EventListenerInfo& details) override;
+  void OnListenerRemoved(const EventListenerInfo& details) override;
 
   // local_discovery::PrivetDeviceLister implementation.
-  virtual void DeviceChanged(
+  void DeviceChanged(
       bool added,
       const std::string& name,
       const local_discovery::DeviceDescription& description) override;
-  virtual void DeviceRemoved(const std::string& name) override;
-  virtual void DeviceCacheFlushed() override;
+  void DeviceRemoved(const std::string& name) override;
+  void DeviceCacheFlushed() override;
 
   void SendMessageInternal(int session_id,
                            const std::string& api,
                            const base::DictionaryValue& input,
                            const MessageResponseCallback& callback);
 
 #if defined(ENABLE_WIFI_BOOTSTRAPPING)
   void OnWifiPassword(const SuccessCallback& callback,
                       bool success,
                       const std::string& ssid,
@@ skipping 17 matching lines @@
 #endif
   PasswordMap wifi_passwords_;
 };
 
 class GcdPrivateRequest : public local_discovery::PrivetV3Session::Request {
  public:
   GcdPrivateRequest(const std::string& api,
                     const base::DictionaryValue& input,
                     const GcdPrivateAPIImpl::MessageResponseCallback& callback,
                     GcdPrivateSessionHolder* session_holder);
-  virtual ~GcdPrivateRequest();
+  ~GcdPrivateRequest() override;
 
   // local_discovery::PrivetV3Session::Request implementation.
-  virtual std::string GetName() override;
-  virtual const base::DictionaryValue& GetInput() override;
-  virtual void OnError() override;
-  virtual void OnParsedJson(const base::DictionaryValue& value,
-                            bool has_error) override;
+  std::string GetName() override;
+  const base::DictionaryValue& GetInput() override;
+  void OnError() override;
+  void OnParsedJson(const base::DictionaryValue& value,
+                    bool has_error) override;
 
   void RunCallback(gcd_private::Status status,
                    const base::DictionaryValue& value);
 
  private:
   std::string api_;
   scoped_ptr<base::DictionaryValue> input_;
   GcdPrivateAPIImpl::MessageResponseCallback callback_;
   GcdPrivateSessionHolder* session_holder_;
 };
 
 class GcdPrivateSessionHolder
     : public local_discovery::PrivetV3Session::Delegate {
  public:
   typedef base::Callback<void(api::gcd_private::Status status,
                               const std::string& code,
                               api::gcd_private::ConfirmationType type)>
       ConfirmationCodeCallback;
 
   GcdPrivateSessionHolder(const std::string& ip_address,
                           int port,
                           net::URLRequestContextGetter* request_context);
-  virtual ~GcdPrivateSessionHolder();
+  ~GcdPrivateSessionHolder() override;
 
   void Start(const ConfirmationCodeCallback& callback);
 
   void ConfirmCode(
       const std::string& code,
       const GcdPrivateAPIImpl::SessionEstablishedCallback& callback);
 
   void SendMessage(const std::string& api,
                    const base::DictionaryValue& input,
                    GcdPrivateAPIImpl::MessageResponseCallback callback);
 
   void DeleteRequest(GcdPrivateRequest* request);
 
  private:
   // local_discovery::PrivetV3Session::Delegate implementation.
-  virtual void OnSetupConfirmationNeeded(
+  void OnSetupConfirmationNeeded(
       const std::string& confirmation_code,
       api::gcd_private::ConfirmationType confirmation_type) override;
-  virtual void OnSessionStatus(api::gcd_private::Status status) override;
+  void OnSessionStatus(api::gcd_private::Status status) override;
 
   scoped_ptr<local_discovery::PrivetHTTPClient> http_client_;
   scoped_ptr<local_discovery::PrivetV3Session> privet_session_;
   typedef ScopedVector<GcdPrivateRequest> RequestVector;
   RequestVector requests_;
 
   ConfirmationCodeCallback confirm_callback_;
   GcdPrivateAPIImpl::SessionEstablishedCallback session_established_callback_;
 };
 
@@ skipping 692 matching lines @@
 }
 
 GcdPrivateGetCommandsListFunction::~GcdPrivateGetCommandsListFunction() {
 }
 
 bool GcdPrivateGetCommandsListFunction::RunAsync() {
   return false;
 }
 
 }  // namespace extensions