replace OVERRIDE and FINAL with override and final in net/

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 217 matching lines @@
         // a deleted object if we continue here, so fail now.
         LOG(FATAL) << "~SettingGetterImplGConf: deleting on wrong thread!";
       }
     }
     DCHECK(!client_);
   }
 
   virtual bool Init(
       const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,
       const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
-      OVERRIDE {
+      override {
     DCHECK(glib_task_runner->BelongsToCurrentThread());
     DCHECK(!client_);
     DCHECK(!task_runner_.get());
     task_runner_ = glib_task_runner;
     client_ = gconf_client_get_default();
     if (!client_) {
       // It's not clear whether/when this can return NULL.
       LOG(ERROR) << "Unable to create a gconf client";
       task_runner_ = NULL;
       return false;
@@ skipping 17 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;
   }
 
-  virtual void ShutDown() OVERRIDE {
+  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;
     }
   }
 
   virtual bool SetUpNotifications(
-      ProxyConfigServiceLinux::Delegate* delegate) OVERRIDE {
+      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,
         NULL, &error);
     if (error == NULL) {
       system_http_proxy_id_ = gconf_client_notify_add(
           client_, "/system/http_proxy",
           OnGConfChangeNotification, this,
           NULL, &error);
     }
     if (error != NULL) {
       LOG(ERROR) << "Error requesting gconf notifications: " << error->message;
       g_error_free(error);
       ShutDown();
       return false;
     }
     // Simulate a change to avoid possibly losing updates before this point.
     OnChangeNotification();
     return true;
   }
 
   virtual const scoped_refptr<base::SingleThreadTaskRunner>&
-  GetNotificationTaskRunner() OVERRIDE {
+  GetNotificationTaskRunner() override {
     return task_runner_;
   }
 
-  virtual ProxyConfigSource GetConfigSource() OVERRIDE {
+  virtual ProxyConfigSource GetConfigSource() override {
     return PROXY_CONFIG_SOURCE_GCONF;
   }
 
-  virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
+  virtual bool GetString(StringSetting key, std::string* result) override {
     switch (key) {
       case PROXY_MODE:
         return GetStringByPath("/system/proxy/mode", result);
       case PROXY_AUTOCONF_URL:
         return GetStringByPath("/system/proxy/autoconfig_url", result);
       case PROXY_HTTP_HOST:
         return GetStringByPath("/system/http_proxy/host", result);
       case PROXY_HTTPS_HOST:
         return GetStringByPath("/system/proxy/secure_host", result);
       case PROXY_FTP_HOST:
         return GetStringByPath("/system/proxy/ftp_host", result);
       case PROXY_SOCKS_HOST:
         return GetStringByPath("/system/proxy/socks_host", result);
     }
     return false;  // Placate compiler.
   }
-  virtual bool GetBool(BoolSetting key, bool* result) OVERRIDE {
+  virtual bool GetBool(BoolSetting key, bool* result) override {
     switch (key) {
       case PROXY_USE_HTTP_PROXY:
         return GetBoolByPath("/system/http_proxy/use_http_proxy", result);
       case PROXY_USE_SAME_PROXY:
         return GetBoolByPath("/system/http_proxy/use_same_proxy", result);
       case PROXY_USE_AUTHENTICATION:
         return GetBoolByPath("/system/http_proxy/use_authentication", result);
     }
     return false;  // Placate compiler.
   }
-  virtual bool GetInt(IntSetting key, int* result) OVERRIDE {
+  virtual bool GetInt(IntSetting key, int* result) override {
     switch (key) {
       case PROXY_HTTP_PORT:
         return GetIntByPath("/system/http_proxy/port", result);
       case PROXY_HTTPS_PORT:
         return GetIntByPath("/system/proxy/secure_port", result);
       case PROXY_FTP_PORT:
         return GetIntByPath("/system/proxy/ftp_port", result);
       case PROXY_SOCKS_PORT:
         return GetIntByPath("/system/proxy/socks_port", result);
     }
     return false;  // Placate compiler.
   }
   virtual bool GetStringList(StringListSetting key,
-                             std::vector<std::string>* result) OVERRIDE {
+                             std::vector<std::string>* result) override {
     switch (key) {
       case PROXY_IGNORE_HOSTS:
         return GetStringListByPath("/system/http_proxy/ignore_hosts", result);
     }
     return false;  // Placate compiler.
   }
 
-  virtual bool BypassListIsReversed() OVERRIDE {
+  virtual bool BypassListIsReversed() override {
     // This is a KDE-specific setting.
     return false;
   }
 
-  virtual bool MatchHostsUsingSuffixMatching() OVERRIDE {
+  virtual bool MatchHostsUsingSuffixMatching() override {
     return false;
   }
 
  private:
   bool GetStringByPath(const char* key, std::string* result) {
     DCHECK(client_);
     DCHECK(task_runner_->BelongsToCurrentThread());
     GError* error = NULL;
     gchar* value = gconf_client_get_string(client_, key, &error);
     if (HandleGError(error, key))
@@ skipping 163 matching lines @@
     }
     return false;
   }
 
   // LoadAndCheckVersion() must be called *before* Init()!
   bool LoadAndCheckVersion(base::Environment* env);
 
   virtual bool Init(
       const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,
       const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
-      OVERRIDE {
+      override {
     DCHECK(glib_task_runner->BelongsToCurrentThread());
     DCHECK(!client_);
     DCHECK(!task_runner_.get());
 
     if (!SchemaExists(kProxyGConfSchema) ||
         !(client_ = libgio_loader_.g_settings_new(kProxyGConfSchema))) {
       // It's not clear whether/when this can return NULL.
       LOG(ERROR) << "Unable to create a gsettings client";
       return false;
     }
     task_runner_ = glib_task_runner;
     // We assume these all work if the above call worked.
     http_client_ = libgio_loader_.g_settings_get_child(client_, "http");
     https_client_ = libgio_loader_.g_settings_get_child(client_, "https");
     ftp_client_ = libgio_loader_.g_settings_get_child(client_, "ftp");
     socks_client_ = libgio_loader_.g_settings_get_child(client_, "socks");
     DCHECK(http_client_ && https_client_ && ftp_client_ && socks_client_);
     return true;
   }
 
-  virtual void ShutDown() OVERRIDE {
+  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;
     }
   }
 
   virtual bool SetUpNotifications(
-      ProxyConfigServiceLinux::Delegate* delegate) OVERRIDE {
+      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);
     g_signal_connect(G_OBJECT(https_client_), "changed",
                      G_CALLBACK(OnGSettingsChangeNotification), this);
     g_signal_connect(G_OBJECT(ftp_client_), "changed",
                      G_CALLBACK(OnGSettingsChangeNotification), this);
     g_signal_connect(G_OBJECT(socks_client_), "changed",
                      G_CALLBACK(OnGSettingsChangeNotification), this);
     // Simulate a change to avoid possibly losing updates before this point.
     OnChangeNotification();
     return true;
   }
 
   virtual const scoped_refptr<base::SingleThreadTaskRunner>&
-  GetNotificationTaskRunner() OVERRIDE {
+  GetNotificationTaskRunner() override {
     return task_runner_;
   }
 
-  virtual ProxyConfigSource GetConfigSource() OVERRIDE {
+  virtual ProxyConfigSource GetConfigSource() override {
     return PROXY_CONFIG_SOURCE_GSETTINGS;
   }
 
-  virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
+  virtual bool GetString(StringSetting key, std::string* result) override {
     DCHECK(client_);
     switch (key) {
       case PROXY_MODE:
         return GetStringByPath(client_, "mode", result);
       case PROXY_AUTOCONF_URL:
         return GetStringByPath(client_, "autoconfig-url", result);
       case PROXY_HTTP_HOST:
         return GetStringByPath(http_client_, "host", result);
       case PROXY_HTTPS_HOST:
         return GetStringByPath(https_client_, "host", result);
       case PROXY_FTP_HOST:
         return GetStringByPath(ftp_client_, "host", result);
       case PROXY_SOCKS_HOST:
         return GetStringByPath(socks_client_, "host", result);
     }
     return false;  // Placate compiler.
   }
-  virtual bool GetBool(BoolSetting key, bool* result) OVERRIDE {
+  virtual bool GetBool(BoolSetting key, bool* result) override {
     DCHECK(client_);
     switch (key) {
       case PROXY_USE_HTTP_PROXY:
         // Although there is an "enabled" boolean in http_client_, it is not set
         // to true by the proxy config utility. We ignore it and return false.
         return false;
       case PROXY_USE_SAME_PROXY:
         // Similarly, although there is a "use-same-proxy" boolean in client_,
         // it is never set to false by the proxy config utility. We ignore it.
         return false;
       case PROXY_USE_AUTHENTICATION:
         // There is also no way to set this in the proxy config utility, but it
         // doesn't hurt us to get the actual setting (unlike the two above).
         return GetBoolByPath(http_client_, "use-authentication", result);
     }
     return false;  // Placate compiler.
   }
-  virtual bool GetInt(IntSetting key, int* result) OVERRIDE {
+  virtual bool GetInt(IntSetting key, int* result) override {
     DCHECK(client_);
     switch (key) {
       case PROXY_HTTP_PORT:
         return GetIntByPath(http_client_, "port", result);
       case PROXY_HTTPS_PORT:
         return GetIntByPath(https_client_, "port", result);
       case PROXY_FTP_PORT:
         return GetIntByPath(ftp_client_, "port", result);
       case PROXY_SOCKS_PORT:
         return GetIntByPath(socks_client_, "port", result);
     }
     return false;  // Placate compiler.
   }
   virtual bool GetStringList(StringListSetting key,
-                             std::vector<std::string>* result) OVERRIDE {
+                             std::vector<std::string>* result) override {
     DCHECK(client_);
     switch (key) {
       case PROXY_IGNORE_HOSTS:
         return GetStringListByPath(client_, "ignore-hosts", result);
     }
     return false;  // Placate compiler.
   }
 
-  virtual bool BypassListIsReversed() OVERRIDE {
+  virtual bool BypassListIsReversed() override {
     // This is a KDE-specific setting.
     return false;
   }
 
-  virtual bool MatchHostsUsingSuffixMatching() OVERRIDE {
+  virtual bool MatchHostsUsingSuffixMatching() override {
     return false;
   }
 
  private:
   bool GetStringByPath(GSettings* client, const char* key,
                        std::string* result) {
     DCHECK(task_runner_->BelongsToCurrentThread());
     gchar* value = libgio_loader_.g_settings_get_string(client, key);
     if (!value)
       return false;
@@ skipping 210 matching lines @@
     // Here in the KDE version, we can safely close the file descriptor
     // anyway. (Not that it really matters; the process is exiting.)
     if (inotify_fd_ >= 0)
       ShutDown();
     DCHECK(inotify_fd_ < 0);
   }
 
   virtual bool Init(
       const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,
       const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
-      OVERRIDE {
+      override {
     // This has to be called on the UI thread (http://crbug.com/69057).
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     DCHECK(inotify_fd_ < 0);
     inotify_fd_ = inotify_init();
     if (inotify_fd_ < 0) {
       PLOG(ERROR) << "inotify_init failed";
       return false;
     }
     int flags = fcntl(inotify_fd_, F_GETFL);
     if (fcntl(inotify_fd_, F_SETFL, flags | O_NONBLOCK) < 0) {
       PLOG(ERROR) << "fcntl failed";
       close(inotify_fd_);
       inotify_fd_ = -1;
       return false;
     }
     file_task_runner_ = file_task_runner;
     // The initial read is done on the current thread, not
     // |file_task_runner_|, since we will need to have it for
     // SetUpAndFetchInitialConfig().
     UpdateCachedSettings();
     return true;
   }
 
-  virtual void ShutDown() OVERRIDE {
+  virtual void ShutDown() override {
     if (inotify_fd_ >= 0) {
       ResetCachedSettings();
       inotify_watcher_.StopWatchingFileDescriptor();
       close(inotify_fd_);
       inotify_fd_ = -1;
     }
   }
 
   virtual bool SetUpNotifications(
-      ProxyConfigServiceLinux::Delegate* delegate) OVERRIDE {
+      ProxyConfigServiceLinux::Delegate* delegate) override {
     DCHECK(inotify_fd_ >= 0);
     DCHECK(file_task_runner_->BelongsToCurrentThread());
     // 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 (!base::MessageLoopForIO::current()->WatchFileDescriptor(
             inotify_fd_, true, base::MessageLoopForIO::WATCH_READ,
             &inotify_watcher_, this)) {
       return false;
     }
     // Simulate a change to avoid possibly losing updates before this point.
     OnChangeNotification();
     return true;
   }
 
   virtual const scoped_refptr<base::SingleThreadTaskRunner>&
-  GetNotificationTaskRunner() OVERRIDE {
+  GetNotificationTaskRunner() override {
     return file_task_runner_;
   }
 
   // Implement base::MessagePumpLibevent::Watcher.
-  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE {
+  virtual void OnFileCanReadWithoutBlocking(int fd) override {
     DCHECK_EQ(fd, inotify_fd_);
     DCHECK(file_task_runner_->BelongsToCurrentThread());
     OnChangeNotification();
   }
-  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE {
+  virtual void OnFileCanWriteWithoutBlocking(int fd) override {
     NOTREACHED();
   }
 
-  virtual ProxyConfigSource GetConfigSource() OVERRIDE {
+  virtual ProxyConfigSource GetConfigSource() override {
     return PROXY_CONFIG_SOURCE_KDE;
   }
 
-  virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
+  virtual bool GetString(StringSetting key, std::string* result) override {
     string_map_type::iterator it = string_table_.find(key);
     if (it == string_table_.end())
       return false;
     *result = it->second;
     return true;
   }
-  virtual bool GetBool(BoolSetting key, bool* result) OVERRIDE {
+  virtual bool GetBool(BoolSetting key, bool* result) override {
     // We don't ever have any booleans.
     return false;
   }
-  virtual bool GetInt(IntSetting key, int* result) OVERRIDE {
+  virtual bool GetInt(IntSetting key, int* result) override {
     // We don't ever have any integers. (See AddProxy() below about ports.)
     return false;
   }
   virtual bool GetStringList(StringListSetting key,
-                             std::vector<std::string>* result) OVERRIDE {
+                             std::vector<std::string>* result) override {
     strings_map_type::iterator it = strings_table_.find(key);
     if (it == strings_table_.end())
       return false;
     *result = it->second;
     return true;
   }
 
-  virtual bool BypassListIsReversed() OVERRIDE {
+  virtual bool BypassListIsReversed() override {
     return reversed_bypass_list_;
   }
 
-  virtual bool MatchHostsUsingSuffixMatching() OVERRIDE {
+  virtual bool MatchHostsUsingSuffixMatching() override {
     return true;
   }
 
  private:
   void ResetCachedSettings() {
     string_table_.clear();
     strings_table_.clear();
     indirect_manual_ = false;
     auto_no_pac_ = false;
     reversed_bypass_list_ = false;
@@ skipping 723 matching lines @@
 void ProxyConfigServiceLinux::RemoveObserver(Observer* observer) {
   delegate_->RemoveObserver(observer);
 }
 
 ProxyConfigService::ConfigAvailability
     ProxyConfigServiceLinux::GetLatestProxyConfig(ProxyConfig* config) {
   return delegate_->GetLatestProxyConfig(config);
 }
 
 }  // namespace net