Update {virtual,override,final} to follow C++11 style.

The Google style guide states that only one of {virtual,override,final}
should be used for each declaration, since override implies virtual and
final implies both virtual and override.

This patch was automatically generated with an OS=android build using a
variation of https://codereview.chromium.org/598073004.

BUG=417463
R=caitkp@chromium.org

Review URL: https://codereview.chromium.org/893303003

Cr-Commit-Position: refs/heads/master@{#314677}

components/crash/browser/crash_dump_manager_android.h

@@ -39,7 +39,7 @@ class CrashDumpManager : public content::BrowserChildProcessObserver,
   // Should be created on the UI thread.
   explicit CrashDumpManager(const base::FilePath& crash_dump_dir);
 
-  virtual ~CrashDumpManager();
+  ~CrashDumpManager() override;
 
   // Returns a file that should be used to generate a minidump for the process
   // |child_process_id|.
@@ -52,15 +52,15 @@ class CrashDumpManager : public content::BrowserChildProcessObserver,
                               base::ProcessHandle pid);
 
   // content::BrowserChildProcessObserver implementation:
-  virtual void BrowserChildProcessHostDisconnected(
+  void BrowserChildProcessHostDisconnected(
       const content::ChildProcessData& data) override;
-  virtual void BrowserChildProcessCrashed(
+  void BrowserChildProcessCrashed(
       const content::ChildProcessData& data) override;
 
   // NotificationObserver implementation:
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) override;
+  void Observe(int type,
+               const content::NotificationSource& source,
+               const content::NotificationDetails& details) override;
 
   // Called on child process exit (including crash).
   void OnChildExit(int child_process_id, base::ProcessHandle pid);

components/cronet/android/cronet_url_request_context_adapter.cc

@@ -30,7 +30,7 @@ namespace {
 class BasicNetworkDelegate : public net::NetworkDelegateImpl {
  public:
   BasicNetworkDelegate() {}
-  virtual ~BasicNetworkDelegate() {}
+  ~BasicNetworkDelegate() override {}
 
  private:
   // net::NetworkDelegate implementation.

components/cronet/android/url_request_adapter.h

@@ -49,7 +49,7 @@ class URLRequestAdapter : public net::URLRequest::Delegate {
                     URLRequestAdapterDelegate* delegate,
                     GURL url,
                     net::RequestPriority priority);
-  virtual ~URLRequestAdapter();
+  ~URLRequestAdapter() override;
 
   // Sets the request method GET, POST etc
   void SetMethod(const std::string& method);

components/cronet/android/url_request_context_adapter.cc

@@ -39,7 +39,7 @@ net::NetworkChangeNotifier* g_network_change_notifier = nullptr;
 class BasicNetworkDelegate : public net::NetworkDelegateImpl {
  public:
   BasicNetworkDelegate() {}
-  virtual ~BasicNetworkDelegate() {}
+  ~BasicNetworkDelegate() override {}
 
  private:
   // net::NetworkDelegate implementation.

components/cronet/android/url_request_context_adapter.h

@@ -37,7 +37,7 @@ class NetLogObserver : public net::NetLog::ThreadSafeObserver {
  public:
   NetLogObserver() {}
 
-  virtual ~NetLogObserver() {}
+  ~NetLogObserver() override {}
 
   void OnAddEntry(const net::NetLog::Entry& entry) override;
 

components/cronet/android/wrapped_channel_upload_element_reader.h

@@ -26,16 +26,16 @@ class WrappedChannelElementReader : public net::UploadElementReader {
   WrappedChannelElementReader(
       scoped_refptr<URLRequestAdapter::URLRequestAdapterDelegate> delegate,
       uint64 length);
-  virtual ~WrappedChannelElementReader();
+  ~WrappedChannelElementReader() override;
 
   // UploadElementReader overrides:
-  virtual int Init(const net::CompletionCallback& callback) override;
-  virtual uint64 GetContentLength() const override;
-  virtual uint64 BytesRemaining() const override;
-  virtual bool IsInMemory() const override;
-  virtual int Read(net::IOBuffer* buf,
-                   int buf_length,
-                   const net::CompletionCallback& callback) override;
+  int Init(const net::CompletionCallback& callback) override;
+  uint64 GetContentLength() const override;
+  uint64 BytesRemaining() const override;
+  bool IsInMemory() const override;
+  int Read(net::IOBuffer* buf,
+           int buf_length,
+           const net::CompletionCallback& callback) override;
 
  private:
   const uint64 length_;

components/devtools_bridge/android/session_dependency_factory_android.cc

@@ -39,15 +39,15 @@ class PeerConnectionDelegateImpl
     connected_ = false;
   }
 
-  virtual void OnIceConnectionChange(bool connected) override {
+  void OnIceConnectionChange(bool connected) override {
     JNIEnv* env = AttachCurrentThread();
     Java_SessionDependencyFactoryNative_notifyIceConnectionChange(
         env, java_object_.obj(), connected);
   }
 
-  virtual void OnIceCandidate(
-      const std::string& sdp_mid, int sdp_mline_index, const std::string& sdp)
-      override {
+  void OnIceCandidate(const std::string& sdp_mid,
+                      int sdp_mline_index,
+                      const std::string& sdp) override {
     JNIEnv* env = AttachCurrentThread();
     Java_SessionDependencyFactoryNative_notifyIceCandidate(
         env, java_object_.obj(),
@@ -62,29 +62,27 @@ class PeerConnectionDelegateImpl
         ConvertUTF8ToJavaString(env, description).obj());
   }
 
-  virtual void OnLocalOfferCreatedAndSetSet(const std::string& description)
-      override {
+  void OnLocalOfferCreatedAndSetSet(const std::string& description) override {
     JNIEnv* env = AttachCurrentThread();
     Java_SessionDependencyFactoryNative_notifyLocalOfferCreatedAndSetSet(
         env, java_object_.obj(),
         ConvertUTF8ToJavaString(env, description).obj());
   }
 
-  virtual void OnLocalAnswerCreatedAndSetSet(const std::string& description)
-      override {
+  void OnLocalAnswerCreatedAndSetSet(const std::string& description) override {
     JNIEnv* env = AttachCurrentThread();
     Java_SessionDependencyFactoryNative_notifyLocalAnswerCreatedAndSetSet(
         env, java_object_.obj(),
         ConvertUTF8ToJavaString(env, description).obj());
   }
 
-  virtual void OnRemoteDescriptionSet() override {
+  void OnRemoteDescriptionSet() override {
     JNIEnv* env = AttachCurrentThread();
     Java_SessionDependencyFactoryNative_notifyRemoteDescriptionSet(
         env, java_object_.obj());
   }
 
-  virtual void OnFailure(const std::string& description) override {
+  void OnFailure(const std::string& description) override {
     JNIEnv* env = AttachCurrentThread();
     Java_SessionDependencyFactoryNative_notifyConnectionFailure(
         env, java_object_.obj(),
@@ -102,19 +100,19 @@ class DataChannelObserverImpl : public AbstractDataChannel::Observer {
     java_object_.Reset(env, java_object);
   }
 
-  virtual void OnOpen() override {
+  void OnOpen() override {
     JNIEnv* env = AttachCurrentThread();
     Java_SessionDependencyFactoryNative_notifyChannelOpen(
         env, java_object_.obj());
   }
 
-  virtual void OnClose() override {
+  void OnClose() override {
     JNIEnv* env = AttachCurrentThread();
     Java_SessionDependencyFactoryNative_notifyChannelClose(
         env, java_object_.obj());
   }
 
-  virtual void OnMessage(const void* data, size_t length) override {
+  void OnMessage(const void* data, size_t length) override {
     JNIEnv* env = AttachCurrentThread();
 
     ScopedJavaLocalRef<jobject> byte_buffer(

components/devtools_bridge/android/session_dependency_factory_android.h

@@ -14,17 +14,16 @@ namespace android {
 class SessionDependencyFactoryAndroid : public SessionDependencyFactory {
  public:
   SessionDependencyFactoryAndroid();
-  virtual ~SessionDependencyFactoryAndroid();
+  ~SessionDependencyFactoryAndroid() override;
 
   static bool RegisterNatives(JNIEnv* env);
 
-  virtual scoped_ptr<AbstractPeerConnection> CreatePeerConnection(
+  scoped_ptr<AbstractPeerConnection> CreatePeerConnection(
       scoped_ptr<RTCConfiguration> config,
       scoped_ptr<AbstractPeerConnection::Delegate> delegate) override;
 
-  virtual scoped_refptr<base::TaskRunner> signaling_thread_task_runner()
-      override;
-  virtual scoped_refptr<base::TaskRunner> io_thread_task_runner() override;
+  scoped_refptr<base::TaskRunner> signaling_thread_task_runner() override;
+  scoped_refptr<base::TaskRunner> io_thread_task_runner() override;
 
  private:
   const scoped_ptr<SessionDependencyFactory> impl_;

components/devtools_bridge/session_dependency_factory.cc

@@ -25,11 +25,9 @@ class RTCConfiguration::Impl
     : public RTCConfiguration,
       public webrtc::PeerConnectionInterface::RTCConfiguration {
  public:
-
-  virtual void AddIceServer(
-      const std::string& uri,
-      const std::string& username,
-      const std::string& credential) override {
+  void AddIceServer(const std::string& uri,
+                    const std::string& username,
+                    const std::string& credential) override {
     webrtc::PeerConnectionInterface::IceServer server;
     server.uri = uri;
     server.username = username;
@@ -55,15 +53,11 @@ void CheckedRelease(rtc::scoped_refptr<T>* ptr) {
 class MediaConstraints
     : public webrtc::MediaConstraintsInterface {
  public:
-  virtual ~MediaConstraints() {}
+  ~MediaConstraints() override {}
 
-  virtual const Constraints& GetMandatory() const override {
-    return mandatory_;
-  }
+  const Constraints& GetMandatory() const override { return mandatory_; }
 
-  virtual const Constraints& GetOptional() const override {
-    return optional_;
-  }
+  const Constraints& GetOptional() const override { return optional_; }
 
   void AddMandatory(const std::string& key, const std::string& value) {
     mandatory_.push_back(Constraint(key, value));
@@ -133,7 +127,7 @@ class DataChannelObserverImpl : public webrtc::DataChannelObserver {
     open_ = data_channel_->state() == webrtc::DataChannelInterface::kOpen;
   }
 
-  virtual void OnStateChange() override {
+  void OnStateChange() override {
     bool open = data_channel_->state() == webrtc::DataChannelInterface::kOpen;
 
     if (open == open_) return;
@@ -146,7 +140,7 @@ class DataChannelObserverImpl : public webrtc::DataChannelObserver {
     }
   }
 
-  virtual void OnMessage(const webrtc::DataBuffer& buffer) override {
+  void OnMessage(const webrtc::DataBuffer& buffer) override {
     observer_->OnMessage(buffer.data.data(), buffer.size());
   }
 
@@ -173,7 +167,7 @@ class DataChannelProxyImpl : public AbstractDataChannel::Proxy {
     data_channel_ = NULL;
   }
 
-  virtual void SendBinaryMessage(const void* data, size_t length) override {
+  void SendBinaryMessage(const void* data, size_t length) override {
     auto buffer = make_scoped_ptr(new webrtc::DataBuffer(rtc::Buffer(), true));
     buffer->data.SetData(data, length);
 
@@ -184,7 +178,7 @@ class DataChannelProxyImpl : public AbstractDataChannel::Proxy {
             base::Passed(&buffer)));
   }
 
-  virtual void Close() override {
+  void Close() override {
     signaling_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DataChannelProxyImpl::CloseOnSignalingThread,
                               this));
@@ -221,30 +215,30 @@ class DataChannelImpl : public AbstractDataChannel {
         impl_(impl) {
   }
 
-  ~DataChannelImpl() {
+  ~DataChannelImpl() override {
     if (proxy_.get()) {
       signaling_thread_->Invoke<void>(rtc::Bind(
           &DataChannelProxyImpl::StopOnSignalingThread, proxy_.get()));
     }
   }
 
-  virtual void RegisterObserver(scoped_ptr<Observer> observer) override {
+  void RegisterObserver(scoped_ptr<Observer> observer) override {
     observer_.reset(new DataChannelObserverImpl(impl_.get(), observer.Pass()));
     signaling_thread_->Invoke<void>(rtc::Bind(
         &DataChannelImpl::RegisterObserverOnSignalingThread, this));
   }
 
-  virtual void UnregisterObserver() override {
+  void UnregisterObserver() override {
     DCHECK(observer_.get() != NULL);
     impl_->UnregisterObserver();
     observer_.reset();
   }
 
-  virtual void SendBinaryMessage(void* data, size_t length) override {
+  void SendBinaryMessage(void* data, size_t length) override {
     SendMessage(data, length, true);
   }
 
-  virtual void SendTextMessage(void* data, size_t length) override {
+  void SendTextMessage(void* data, size_t length) override {
     SendMessage(data, length, false);
   }
 
@@ -285,20 +279,18 @@ class PeerConnectionObserverImpl
         connected_(false) {
   }
 
-  virtual void OnAddStream(webrtc::MediaStreamInterface* stream) override {}
+  void OnAddStream(webrtc::MediaStreamInterface* stream) override {}
 
-  virtual void OnRemoveStream(webrtc::MediaStreamInterface* stream) override {}
+  void OnRemoveStream(webrtc::MediaStreamInterface* stream) override {}
 
-  virtual void OnDataChannel(webrtc::DataChannelInterface* data_channel)
-      override {}
+  void OnDataChannel(webrtc::DataChannelInterface* data_channel) override {}
 
-  virtual void OnRenegotiationNeeded() override {}
+  void OnRenegotiationNeeded() override {}
 
-  virtual void OnSignalingChange(
-       webrtc::PeerConnectionInterface::SignalingState new_state) override {
-  }
+  void OnSignalingChange(
+      webrtc::PeerConnectionInterface::SignalingState new_state) override {}
 
-  virtual void OnIceConnectionChange(
+  void OnIceConnectionChange(
       webrtc::PeerConnectionInterface::IceConnectionState new_state) override {
     bool connected =
         new_state == webrtc::PeerConnectionInterface::kIceConnectionConnected ||
@@ -310,8 +302,7 @@ class PeerConnectionObserverImpl
     }
   }
 
-  virtual void OnIceCandidate(const webrtc::IceCandidateInterface* candidate)
-      override {
+  void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override {
     std::string sdp;
     candidate->ToString(&sdp);
 
@@ -341,9 +332,7 @@ class PeerConnectionHolder : public rtc::RefCountInterface {
         disposed_(false) {
   }
 
-  virtual ~PeerConnectionHolder() {
-    DCHECK(disposed_);
-  }
+  ~PeerConnectionHolder() override { DCHECK(disposed_); }
 
   void Dispose() {
     DCHECK(!IsDisposed());
@@ -381,7 +370,7 @@ class CreateAndSetHandler
       : holder_(holder) {
   }
 
-  virtual void OnSuccess(webrtc::SessionDescriptionInterface* desc) override {
+  void OnSuccess(webrtc::SessionDescriptionInterface* desc) override {
     if (holder_->IsDisposed()) return;
 
     type_ = desc->type();
@@ -392,7 +381,7 @@ class CreateAndSetHandler
     }
   }
 
-  virtual void OnSuccess() override {
+  void OnSuccess() override {
     if (holder_->IsDisposed()) return;
 
     if (type_ == webrtc::SessionDescriptionInterface::kOffer) {
@@ -404,7 +393,7 @@ class CreateAndSetHandler
     }
   }
 
-  virtual void OnFailure(const std::string& error) override {
+  void OnFailure(const std::string& error) override {
     if (holder_->IsDisposed()) return;
 
     holder_->delegate()->OnFailure(error);
@@ -424,13 +413,13 @@ class SetRemoteDescriptionHandler
       : holder_(holder) {
   }
 
-  virtual void OnSuccess() override {
+  void OnSuccess() override {
     if (holder_->IsDisposed()) return;
 
     holder_->delegate()->OnRemoteDescriptionSet();
   }
 
-  virtual void OnFailure(const std::string& error) override {
+  void OnFailure(const std::string& error) override {
     if (holder_->IsDisposed()) return;
 
     holder_->delegate()->OnFailure(error);
@@ -457,25 +446,25 @@ class PeerConnectionImpl : public AbstractPeerConnection {
         delegate_(delegate.Pass()) {
   }
 
-  virtual ~PeerConnectionImpl() {
+  ~PeerConnectionImpl() override {
     signaling_thread_->Invoke<void>(rtc::Bind(
         &PeerConnectionImpl::DisposeOnSignalingThread, this));
   }
 
-  virtual void CreateAndSetLocalOffer() override {
+  void CreateAndSetLocalOffer() override {
     connection_->CreateOffer(MakeCreateAndSetHandler(), NULL);
   }
 
-  virtual void CreateAndSetLocalAnswer() override {
+  void CreateAndSetLocalAnswer() override {
     connection_->CreateAnswer(MakeCreateAndSetHandler(), NULL);
   }
 
-  virtual void SetRemoteOffer(const std::string& description) override {
+  void SetRemoteOffer(const std::string& description) override {
     SetRemoteDescription(
         webrtc::SessionDescriptionInterface::kOffer, description);
   }
 
-  virtual void SetRemoteAnswer(const std::string& description) override {
+  void SetRemoteAnswer(const std::string& description) override {
     SetRemoteDescription(
         webrtc::SessionDescriptionInterface::kAnswer, description);
   }
@@ -495,10 +484,9 @@ class PeerConnectionImpl : public AbstractPeerConnection {
         value.release());
   }
 
-  virtual void AddIceCandidate(
-      const std::string& sdp_mid,
-      int sdp_mline_index,
-      const std::string& sdp) override {
+  void AddIceCandidate(const std::string& sdp_mid,
+                       int sdp_mline_index,
+                       const std::string& sdp) override {
     webrtc::SdpParseError error;
     auto candidate = webrtc::CreateIceCandidate(
         sdp_mid, sdp_mline_index, sdp, &error);
@@ -511,8 +499,7 @@ class PeerConnectionImpl : public AbstractPeerConnection {
     delete candidate;
   }
 
-  virtual scoped_ptr<AbstractDataChannel> CreateDataChannel(
-      int channelId) override {
+  scoped_ptr<AbstractDataChannel> CreateDataChannel(int channelId) override {
     webrtc::DataChannelInit init;
     init.ordered = true;
     init.negotiated = true;
@@ -562,7 +549,7 @@ class SessionDependencyFactoryImpl : public SessionDependencyFactory {
         &worker_thread_, &signaling_thread_, NULL, NULL, NULL);
   }
 
-  virtual ~SessionDependencyFactoryImpl() {
+  ~SessionDependencyFactoryImpl() override {
     if (signaling_thread_task_runner_.get())
       signaling_thread_task_runner_->Stop();
 
@@ -570,7 +557,7 @@ class SessionDependencyFactoryImpl : public SessionDependencyFactory {
         &SessionDependencyFactoryImpl::DisposeOnSignalingThread, this));
   }
 
-  virtual scoped_ptr<AbstractPeerConnection> CreatePeerConnection(
+  scoped_ptr<AbstractPeerConnection> CreatePeerConnection(
       scoped_ptr<RTCConfiguration> config,
       scoped_ptr<AbstractPeerConnection::Delegate> delegate) override {
     auto observer = make_scoped_ptr(

components/devtools_bridge/socket_tunnel_server.cc

@@ -56,7 +56,7 @@ class SocketTunnelServer::Connection : public SocketTunnelConnection {
     ReadNextChunk();
   }
 
-  virtual void OnReadError(int error) override {
+  void OnReadError(int error) override {
     socket()->Disconnect();
     SendControlPacket(SERVER_CLOSE);
     delegate_->RemoveConnection(index_);

components/dom_distiller/core/distilled_page_prefs_android.h

@@ -40,9 +40,9 @@ class DistilledPagePrefsObserverAndroid : public DistilledPagePrefs::Observer {
   virtual ~DistilledPagePrefsObserverAndroid();
 
   // DistilledPagePrefs::Observer implementation.
-  virtual void OnChangeFontFamily(
+  void OnChangeFontFamily(
       DistilledPagePrefs::FontFamily new_font_family) override;
-  virtual void OnChangeTheme(DistilledPagePrefs::Theme new_theme) override;
+  void OnChangeTheme(DistilledPagePrefs::Theme new_theme) override;
 
   virtual void DestroyObserverAndroid(JNIEnv* env, jobject obj);
 

components/gcm_driver/gcm_driver_android.h

@@ -18,7 +18,7 @@ namespace gcm {
 class GCMDriverAndroid : public GCMDriver {
  public:
   GCMDriverAndroid();
-  virtual ~GCMDriverAndroid();
+  ~GCMDriverAndroid() override;
 
   // Methods called from Java via JNI:
   void OnRegisterFinished(JNIEnv* env,
@@ -44,40 +44,36 @@ class GCMDriverAndroid : public GCMDriver {
   static bool RegisterBindings(JNIEnv* env);
 
   // GCMDriver implementation:
-  virtual void OnSignedIn() override;
-  virtual void OnSignedOut() override;
-  virtual void Enable() override;
-  virtual void AddConnectionObserver(GCMConnectionObserver* observer) override;
-  virtual void RemoveConnectionObserver(
-      GCMConnectionObserver* observer) override;
-  virtual void Disable() override;
-  virtual GCMClient* GetGCMClientForTesting() const override;
-  virtual bool IsStarted() const override;
-  virtual bool IsConnected() const override;
-  virtual void GetGCMStatistics(const GetGCMStatisticsCallback& callback,
-                                bool clear_logs) override;
-  virtual void SetGCMRecording(const GetGCMStatisticsCallback& callback,
-                               bool recording) override;
-  virtual void SetAccountTokens(
+  void OnSignedIn() override;
+  void OnSignedOut() override;
+  void Enable() override;
+  void AddConnectionObserver(GCMConnectionObserver* observer) override;
+  void RemoveConnectionObserver(GCMConnectionObserver* observer) override;
+  void Disable() override;
+  GCMClient* GetGCMClientForTesting() const override;
+  bool IsStarted() const override;
+  bool IsConnected() const override;
+  void GetGCMStatistics(const GetGCMStatisticsCallback& callback,
+                        bool clear_logs) override;
+  void SetGCMRecording(const GetGCMStatisticsCallback& callback,
+                       bool recording) override;
+  void SetAccountTokens(
       const std::vector<GCMClient::AccountTokenInfo>& account_tokens) override;
-  virtual void UpdateAccountMapping(
-      const AccountMapping& account_mapping) override;
-  virtual void RemoveAccountMapping(const std::string& account_id) override;
-  virtual base::Time GetLastTokenFetchTime() override;
-  virtual void SetLastTokenFetchTime(const base::Time& time) override;
-  virtual void WakeFromSuspendForHeartbeat(bool wake) override;
+  void UpdateAccountMapping(const AccountMapping& account_mapping) override;
+  void RemoveAccountMapping(const std::string& account_id) override;
+  base::Time GetLastTokenFetchTime() override;
+  void SetLastTokenFetchTime(const base::Time& time) override;
+  void WakeFromSuspendForHeartbeat(bool wake) override;
 
  protected:
   // GCMDriver implementation:
-  virtual GCMClient::Result EnsureStarted(
-      GCMClient::StartMode start_mode) override;
-  virtual void RegisterImpl(
-      const std::string& app_id,
-      const std::vector<std::string>& sender_ids) override;
-  virtual void UnregisterImpl(const std::string& app_id) override;
-  virtual void SendImpl(const std::string& app_id,
-                        const std::string& receiver_id,
-                        const GCMClient::OutgoingMessage& message) override;
+  GCMClient::Result EnsureStarted(GCMClient::StartMode start_mode) override;
+  void RegisterImpl(const std::string& app_id,
+                    const std::vector<std::string>& sender_ids) override;
+  void UnregisterImpl(const std::string& app_id) override;
+  void SendImpl(const std::string& app_id,
+                const std::string& receiver_id,
+                const GCMClient::OutgoingMessage& message) override;
 
  private:
   base::android::ScopedJavaGlobalRef<jobject> java_ref_;

components/history/core/browser/android/android_urls_sql_handler.h

@@ -15,14 +15,14 @@ class AndroidURLsDatabase;
 class AndroidURLsSQLHandler : public SQLHandler {
  public:
   explicit AndroidURLsSQLHandler(AndroidURLsDatabase* android_urls_db);
-  virtual ~AndroidURLsSQLHandler();
+  ~AndroidURLsSQLHandler() override;
 
-  virtual bool Update(const HistoryAndBookmarkRow& row,
-                      const TableIDRows& ids_set) override;
+  bool Update(const HistoryAndBookmarkRow& row,
+              const TableIDRows& ids_set) override;
 
-  virtual bool Insert(HistoryAndBookmarkRow* row) override;
+  bool Insert(HistoryAndBookmarkRow* row) override;
 
-  virtual bool Delete(const TableIDRows& ids_set) override;
+  bool Delete(const TableIDRows& ids_set) override;
 
  private:
   AndroidURLsDatabase* android_urls_db_;

components/history/core/browser/android/favicon_sql_handler.h

@@ -15,13 +15,13 @@ class ThumbnailDatabase;
 class FaviconSQLHandler : public SQLHandler {
  public:
   explicit FaviconSQLHandler(ThumbnailDatabase* thumbnail_db);
-  virtual ~FaviconSQLHandler();
+  ~FaviconSQLHandler() override;
 
   // SQLHandler overrides:
-  virtual bool Update(const HistoryAndBookmarkRow& row,
-                      const TableIDRows& ids_set) override;
-  virtual bool Delete(const TableIDRows& ids_set) override;
-  virtual bool Insert(HistoryAndBookmarkRow* row) override;
+  bool Update(const HistoryAndBookmarkRow& row,
+              const TableIDRows& ids_set) override;
+  bool Delete(const TableIDRows& ids_set) override;
+  bool Insert(HistoryAndBookmarkRow* row) override;
 
  private:
   // Deletes the given favicons if they are not used by any pages. Returns

components/history/core/browser/android/urls_sql_handler.h

@@ -15,13 +15,13 @@ class URLDatabase;
 class UrlsSQLHandler : public SQLHandler {
  public:
   explicit UrlsSQLHandler(URLDatabase* url_db);
-  virtual ~UrlsSQLHandler();
+  ~UrlsSQLHandler() override;
 
   // Overriden from SQLHandler.
-  virtual bool Insert(HistoryAndBookmarkRow* row) override;
-  virtual bool Update(const HistoryAndBookmarkRow& row,
-                      const TableIDRows& ids_set) override;
-  virtual bool Delete(const TableIDRows& ids_set) override;
+  bool Insert(HistoryAndBookmarkRow* row) override;
+  bool Update(const HistoryAndBookmarkRow& row,
+              const TableIDRows& ids_set) override;
+  bool Delete(const TableIDRows& ids_set) override;
 
  private:
   URLDatabase* url_db_;

components/history/core/browser/android/visit_sql_handler.h

@@ -20,13 +20,13 @@ class VisitDatabase;
 class VisitSQLHandler : public SQLHandler {
  public:
   VisitSQLHandler(URLDatabase* url_db, VisitDatabase* visit_db);
-  virtual ~VisitSQLHandler();
+  ~VisitSQLHandler() override;
 
   // Overriden from SQLHandler.
-  virtual bool Update(const HistoryAndBookmarkRow& row,
-                      const TableIDRows& ids_set) override;
-  virtual bool Insert(HistoryAndBookmarkRow* row) override;
-  virtual bool Delete(const TableIDRows& ids_set) override;
+  bool Update(const HistoryAndBookmarkRow& row,
+              const TableIDRows& ids_set) override;
+  bool Insert(HistoryAndBookmarkRow* row) override;
+  bool Delete(const TableIDRows& ids_set) override;
 
  private:
   // Add a row in visit table with the given |url_id| and |visit_time|.

components/invalidation/invalidation_service_android.h

@@ -30,27 +30,25 @@ class InvalidationServiceAndroid
       public InvalidationService {
  public:
   InvalidationServiceAndroid(jobject context);
-  virtual ~InvalidationServiceAndroid();
+  ~InvalidationServiceAndroid() override;
 
   // InvalidationService implementation.
   //
   // Note that this implementation does not properly support Ack-tracking,
   // fetching the invalidator state, or querying the client's ID.  Support for
   // exposing the client ID should be available soon; see crbug.com/172391.
-  virtual void RegisterInvalidationHandler(
+  void RegisterInvalidationHandler(
       syncer::InvalidationHandler* handler) override;
-  virtual void UpdateRegisteredInvalidationIds(
-      syncer::InvalidationHandler* handler,
-      const syncer::ObjectIdSet& ids) override;
-  virtual void UnregisterInvalidationHandler(
+  void UpdateRegisteredInvalidationIds(syncer::InvalidationHandler* handler,
+                                       const syncer::ObjectIdSet& ids) override;
+  void UnregisterInvalidationHandler(
       syncer::InvalidationHandler* handler) override;
-  virtual syncer::InvalidatorState GetInvalidatorState() const override;
-  virtual std::string GetInvalidatorClientId() const override;
-  virtual InvalidationLogger* GetInvalidationLogger() override;
-  virtual void RequestDetailedStatus(
-      base::Callback<void(const base::DictionaryValue&)> caller) const
-      override;
-  virtual IdentityProvider* GetIdentityProvider() override;
+  syncer::InvalidatorState GetInvalidatorState() const override;
+  std::string GetInvalidatorClientId() const override;
+  InvalidationLogger* GetInvalidationLogger() override;
+  void RequestDetailedStatus(
+      base::Callback<void(const base::DictionaryValue&)> caller) const override;
+  IdentityProvider* GetIdentityProvider() override;
 
   void RequestSync(JNIEnv* env,
                    jobject obj,

components/invalidation/invalidation_service_android_unittest.cc

@@ -17,7 +17,7 @@ class InvalidationServiceAndroidTest : public testing::Test {
  public:
   InvalidationServiceAndroidTest() :
       invalidation_service_(base::android::GetApplicationContext()) {}
-  virtual ~InvalidationServiceAndroidTest() {}
+  ~InvalidationServiceAndroidTest() override {}
 
   InvalidationService& invalidation_service() {
     return invalidation_service_;

components/navigation_interception/intercept_navigation_delegate.h

@@ -38,7 +38,7 @@ class NavigationParams;
 class InterceptNavigationDelegate : public base::SupportsUserData::Data {
  public:
   InterceptNavigationDelegate(JNIEnv* env, jobject jdelegate);
-  virtual ~InterceptNavigationDelegate();
+  ~InterceptNavigationDelegate() override;
 
   // Associates the InterceptNavigationDelegate with a WebContents using the
   // SupportsUserData mechanism.

components/policy/core/common/policy_provider_android.h

@@ -18,7 +18,7 @@ class Schema;
 class POLICY_EXPORT PolicyProviderAndroid : public ConfigurationPolicyProvider {
  public:
   PolicyProviderAndroid();
-  virtual ~PolicyProviderAndroid();
+  ~PolicyProviderAndroid() override;
 
   // Call this method to tell the policy system whether it should wait for
   // policies to be loaded by this provider. If this method is called,
@@ -33,9 +33,9 @@ class POLICY_EXPORT PolicyProviderAndroid : public ConfigurationPolicyProvider {
   void SetPolicies(scoped_ptr<PolicyBundle> policy);
 
   // ConfigurationPolicyProvider:
-  virtual void Shutdown() override;
-  virtual bool IsInitializationComplete(PolicyDomain domain) const override;
-  virtual void RefreshPolicies() override;
+  void Shutdown() override;
+  bool IsInitializationComplete(PolicyDomain domain) const override;
+  void RefreshPolicies() override;
 
  private:
   PolicyProviderAndroidDelegate* delegate_;

components/policy/core/common/policy_provider_android_unittest.cc

@@ -60,10 +60,10 @@ class PolicyProviderAndroidTestFixture {
 class PolicyProviderAndroidTest : public ::testing::Test {
  protected:
   PolicyProviderAndroidTest();
-  virtual ~PolicyProviderAndroidTest();
+  ~PolicyProviderAndroidTest() override;
 
-  virtual void SetUp() override;
-  virtual void TearDown() override;
+  void SetUp() override;
+  void TearDown() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PolicyProviderAndroidTest);

components/web_contents_delegate_android/color_chooser_android.h

@@ -28,13 +28,13 @@ class ColorChooserAndroid : public content::ColorChooser {
   ColorChooserAndroid(content::WebContents* tab,
                       SkColor initial_color,
                       const std::vector<content::ColorSuggestion>& suggestions);
-  virtual ~ColorChooserAndroid();
+  ~ColorChooserAndroid() override;
 
   void OnColorChosen(JNIEnv* env, jobject obj, jint color);
 
   // ColorChooser interface
-  virtual void End() override;
-  virtual void SetSelectedColor(SkColor color) override;
+  void End() override;
+  void SetSelectedColor(SkColor color) override;
 
  private:
   base::android::ScopedJavaGlobalRef<jobject> j_color_chooser_;

components/web_contents_delegate_android/web_contents_delegate_android.h

@@ -43,7 +43,7 @@ enum WebContentsDelegateLogLevel {
 class WebContentsDelegateAndroid : public content::WebContentsDelegate {
  public:
   WebContentsDelegateAndroid(JNIEnv* env, jobject obj);
-  virtual ~WebContentsDelegateAndroid();
+  ~WebContentsDelegateAndroid() override;
 
   // Binds this WebContentsDelegateAndroid to the passed WebContents instance,
   // such that when that WebContents is destroyed, this
@@ -51,33 +51,31 @@ class WebContentsDelegateAndroid : public content::WebContentsDelegate {
   void SetOwnerWebContents(content::WebContents* contents);
 
   // Overridden from WebContentsDelegate:
-  virtual content::WebContents* OpenURLFromTab(
+  content::WebContents* OpenURLFromTab(
       content::WebContents* source,
       const content::OpenURLParams& params) override;
-  virtual content::ColorChooser* OpenColorChooser(
+  content::ColorChooser* OpenColorChooser(
       content::WebContents* source,
       SkColor color,
       const std::vector<content::ColorSuggestion>& suggestions) override;
-  virtual void NavigationStateChanged(
-      content::WebContents* source,
-      content::InvalidateTypes changed_flags) override;
-  virtual void VisibleSSLStateChanged(
-      const content::WebContents* source) override;
-  virtual void ActivateContents(content::WebContents* contents) override;
-  virtual void DeactivateContents(content::WebContents* contents) override;
-  virtual void LoadingStateChanged(content::WebContents* source,
-                                   bool to_different_document) override;
-  virtual void LoadProgressChanged(content::WebContents* source,
-                                   double load_progress) override;
-  virtual void RendererUnresponsive(content::WebContents* source) override;
-  virtual void RendererResponsive(content::WebContents* source) override;
-  virtual void DidNavigateToPendingEntry(content::WebContents* source) override;
-  virtual void WebContentsCreated(content::WebContents* source_contents,
-                                  int opener_render_frame_id,
-                                  const base::string16& frame_name,
-                                  const GURL& target_url,
-                                  content::WebContents* new_contents) override;
-  virtual bool ShouldCreateWebContents(
+  void NavigationStateChanged(content::WebContents* source,
+                              content::InvalidateTypes changed_flags) override;
+  void VisibleSSLStateChanged(const content::WebContents* source) override;
+  void ActivateContents(content::WebContents* contents) override;
+  void DeactivateContents(content::WebContents* contents) override;
+  void LoadingStateChanged(content::WebContents* source,
+                           bool to_different_document) override;
+  void LoadProgressChanged(content::WebContents* source,
+                           double load_progress) override;
+  void RendererUnresponsive(content::WebContents* source) override;
+  void RendererResponsive(content::WebContents* source) override;
+  void DidNavigateToPendingEntry(content::WebContents* source) override;
+  void WebContentsCreated(content::WebContents* source_contents,
+                          int opener_render_frame_id,
+                          const base::string16& frame_name,
+                          const GURL& target_url,
+                          content::WebContents* new_contents) override;
+  bool ShouldCreateWebContents(
       content::WebContents* web_contents,
       int route_id,
       int main_frame_route_id,
@@ -86,38 +84,33 @@ class WebContentsDelegateAndroid : public content::WebContentsDelegate {
       const GURL& target_url,
       const std::string& partition_id,
       content::SessionStorageNamespace* session_storage_namespace) override;
-  virtual bool OnGoToEntryOffset(int offset) override;
-  virtual void CloseContents(content::WebContents* source) override;
-  virtual void MoveContents(content::WebContents* source,
-                            const gfx::Rect& pos) override;
-  virtual bool AddMessageToConsole(content::WebContents* source,
-                                   int32 level,
-                                   const base::string16& message,
-                                   int32 line_no,
-                                   const base::string16& source_id) override;
-  virtual void UpdateTargetURL(content::WebContents* source,
-                               const GURL& url) override;
-  virtual void HandleKeyboardEvent(
+  bool OnGoToEntryOffset(int offset) override;
+  void CloseContents(content::WebContents* source) override;
+  void MoveContents(content::WebContents* source,
+                    const gfx::Rect& pos) override;
+  bool AddMessageToConsole(content::WebContents* source,
+                           int32 level,
+                           const base::string16& message,
+                           int32 line_no,
+                           const base::string16& source_id) override;
+  void UpdateTargetURL(content::WebContents* source, const GURL& url) override;
+  void HandleKeyboardEvent(
       content::WebContents* source,
       const content::NativeWebKeyboardEvent& event) override;
-  virtual bool TakeFocus(content::WebContents* source, bool reverse) override;
-  virtual void ShowRepostFormWarningDialog(
-      content::WebContents* source) override;
-  virtual void EnterFullscreenModeForTab(content::WebContents* web_contents,
-                                         const GURL& origin) override;
-  virtual void ExitFullscreenModeForTab(
-      content::WebContents* web_contents) override;
-  virtual bool IsFullscreenForTabOrPending(
+  bool TakeFocus(content::WebContents* source, bool reverse) override;
+  void ShowRepostFormWarningDialog(content::WebContents* source) override;
+  void EnterFullscreenModeForTab(content::WebContents* web_contents,
+                                 const GURL& origin) override;
+  void ExitFullscreenModeForTab(content::WebContents* web_contents) override;
+  bool IsFullscreenForTabOrPending(
       const content::WebContents* web_contents) const override;
-  virtual void ShowValidationMessage(content::WebContents* web_contents,
-                                     const gfx::Rect& anchor_in_root_view,
-                                     const base::string16& main_text,
-                                     const base::string16& sub_text) override;
-  virtual void HideValidationMessage(
-      content::WebContents* web_contents) override;
-  virtual void MoveValidationMessage(
-      content::WebContents* web_contents,
-      const gfx::Rect& anchor_in_root_view) override;
+  void ShowValidationMessage(content::WebContents* web_contents,
+                             const gfx::Rect& anchor_in_root_view,
+                             const base::string16& main_text,
+                             const base::string16& sub_text) override;
+  void HideValidationMessage(content::WebContents* web_contents) override;
+  void MoveValidationMessage(content::WebContents* web_contents,
+                             const gfx::Rect& anchor_in_root_view) override;
 
  protected:
   base::android::ScopedJavaLocalRef<jobject> GetJavaDelegate(JNIEnv* env) const;