net: Fix clang warnings about missing virtual and OVERRIDE annotations.

net/proxy/proxy_config_service_linux.cc

 // Copyright (c) 2012 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 "net/proxy/proxy_config_service_linux.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #if defined(USE_GCONF)
 #include <gconf/gconf-client.h>
@@ skipping 252 matching lines @@
       if (added_system_proxy)
         gconf_client_remove_dir(client_, "/system/proxy", NULL);
       g_object_unref(client_);
       client_ = NULL;
       task_runner_ = NULL;
       return false;
     }
     return true;
   }
 
-  void ShutDown() {
+  virtual void ShutDown() OVERRIDE {
     if (client_) {
       DCHECK(task_runner_->BelongsToCurrentThread());
       // We must explicitly disable gconf notifications here, because the gconf
       // client will be shared between all setting getters, and they do not all
       // have the same lifetimes. (For instance, incognito sessions get their
       // own, which is destroyed when the session ends.)
       gconf_client_notify_remove(client_, system_http_proxy_id_);
       gconf_client_notify_remove(client_, system_proxy_id_);
       gconf_client_remove_dir(client_, "/system/http_proxy", NULL);
       gconf_client_remove_dir(client_, "/system/proxy", NULL);
       g_object_unref(client_);
       client_ = NULL;
       task_runner_ = NULL;
     }
   }
 
-  bool SetUpNotifications(ProxyConfigServiceLinux::Delegate* delegate) {
+  virtual bool SetUpNotifications(
+      ProxyConfigServiceLinux::Delegate* delegate) OVERRIDE {
     DCHECK(client_);
     DCHECK(task_runner_->BelongsToCurrentThread());
     GError* error = NULL;
     notify_delegate_ = delegate;
     // We have to keep track of the IDs returned by gconf_client_notify_add() so
     // that we can remove them in ShutDown(). (Otherwise, notifications will be
     // delivered to this object after it is deleted, which is bad, m'kay?)
     system_proxy_id_ = gconf_client_notify_add(
         client_, "/system/proxy",
         OnGConfChangeNotification, this,
@@ skipping 288 matching lines @@
     task_runner_ = glib_thread_task_runner;
     // We assume these all work if the above call worked.
     http_client_ = g_settings_get_child(client_, "http");
     https_client_ = g_settings_get_child(client_, "https");
     ftp_client_ = g_settings_get_child(client_, "ftp");
     socks_client_ = g_settings_get_child(client_, "socks");
     DCHECK(http_client_ && https_client_ && ftp_client_ && socks_client_);
     return true;
   }
 
-  void ShutDown() {
+  virtual void ShutDown() OVERRIDE {
     if (client_) {
       DCHECK(task_runner_->BelongsToCurrentThread());
       // This also disables gsettings notifications.
       g_object_unref(socks_client_);
       g_object_unref(ftp_client_);
       g_object_unref(https_client_);
       g_object_unref(http_client_);
       g_object_unref(client_);
       // We only need to null client_ because it's the only one that we check.
       client_ = NULL;
       task_runner_ = NULL;
     }
   }
 
-  bool SetUpNotifications(ProxyConfigServiceLinux::Delegate* delegate) {
+  virtual bool SetUpNotifications(
+      ProxyConfigServiceLinux::Delegate* delegate) OVERRIDE {
     DCHECK(client_);
     DCHECK(task_runner_->BelongsToCurrentThread());
     notify_delegate_ = delegate;
     // We could watch for the change-event signal instead of changed, but
     // since we have to watch more than one object, we'd still have to
     // debounce change notifications. This is conceptually simpler.
     g_signal_connect(G_OBJECT(client_), "changed",
                      G_CALLBACK(OnGSettingsChangeNotification), this);
     g_signal_connect(G_OBJECT(http_client_), "changed",
                      G_CALLBACK(OnGSettingsChangeNotification), this);
@@ skipping 370 matching lines @@
       inotify_fd_ = -1;
       return false;
     }
     file_loop_ = file_loop;
     // The initial read is done on the current thread, not |file_loop_|,
     // since we will need to have it for SetUpAndFetchInitialConfig().
     UpdateCachedSettings();
     return true;
   }
 
-  void ShutDown() {
+  virtual void ShutDown() OVERRIDE {
     if (inotify_fd_ >= 0) {
       ResetCachedSettings();
       inotify_watcher_.StopWatchingFileDescriptor();
       close(inotify_fd_);
       inotify_fd_ = -1;
     }
   }
 
-  bool SetUpNotifications(ProxyConfigServiceLinux::Delegate* delegate) {
+  virtual bool SetUpNotifications(
+      ProxyConfigServiceLinux::Delegate* delegate) OVERRIDE {
     DCHECK(inotify_fd_ >= 0);
     DCHECK(MessageLoop::current() == file_loop_);
     // We can't just watch the kioslaverc file directly, since KDE will write
     // a new copy of it and then rename it whenever settings are changed and
     // inotify watches inodes (so we'll be watching the old deleted file after
     // the first change, and it will never change again). So, we watch the
     // directory instead. We then act only on changes to the kioslaverc entry.
     if (inotify_add_watch(inotify_fd_, kde_config_dir_.value().c_str(),
                           IN_MODIFY | IN_MOVED_TO) < 0)
       return false;
     notify_delegate_ = delegate;
     if (!file_loop_->WatchFileDescriptor(inotify_fd_, true,
             MessageLoopForIO::WATCH_READ, &inotify_watcher_, this))
       return false;
     // Simulate a change to avoid possibly losing updates before this point.
     OnChangeNotification();
     return true;
   }
 
   virtual base::SingleThreadTaskRunner* GetNotificationTaskRunner() OVERRIDE {
     return file_loop_ ? file_loop_->message_loop_proxy() : NULL;
   }
 
   // Implement base::MessagePumpLibevent::Watcher.
-  void OnFileCanReadWithoutBlocking(int fd) {
+  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE {
     DCHECK_EQ(fd, inotify_fd_);
     DCHECK(MessageLoop::current() == file_loop_);
     OnChangeNotification();
   }
-  void OnFileCanWriteWithoutBlocking(int fd) {
+  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE {
     NOTREACHED();
   }
 
   virtual ProxyConfigSource GetConfigSource() OVERRIDE {
     return PROXY_CONFIG_SOURCE_KDE;
   }
 
   virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
     string_map_type::iterator it = string_table_.find(key);
     if (it == string_table_.end())
@@ skipping 758 matching lines @@
 void ProxyConfigServiceLinux::RemoveObserver(Observer* observer) {
   delegate_->RemoveObserver(observer);
 }
 
 ProxyConfigService::ConfigAvailability
     ProxyConfigServiceLinux::GetLatestProxyConfig(ProxyConfig* config) {
   return delegate_->GetLatestProxyConfig(config);
 }
 
 }  // namespace net