Update from chromium https://crrev.com/301725/

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 188 matching lines @@
 
 #if defined(USE_GCONF)
 // This setting getter uses gconf, as used in GNOME 2 and some GNOME 3 desktops.
 class SettingGetterImplGConf : public ProxyConfigServiceLinux::SettingGetter {
  public:
   SettingGetterImplGConf()
       : client_(NULL), system_proxy_id_(0), system_http_proxy_id_(0),
         notify_delegate_(NULL) {
   }
 
-  virtual ~SettingGetterImplGConf() {
+  ~SettingGetterImplGConf() override {
     // client_ should have been released before now, from
     // Delegate::OnDestroy(), while running on the UI thread. However
     // on exiting the process, it may happen that Delegate::OnDestroy()
     // task is left pending on the glib loop after the loop was quit,
     // and pending tasks may then be deleted without being run.
     if (client_) {
       // gconf client was not cleaned up.
       if (task_runner_->BelongsToCurrentThread()) {
         // We are on the UI thread so we can clean it safely. This is
         // the case at least for ui_tests running under Valgrind in
         // bug 16076.
         VLOG(1) << "~SettingGetterImplGConf: releasing gconf client";
         ShutDown();
       } else {
         // This is very bad! We are deleting the setting getter but we're not on
         // the UI thread. This is not supposed to happen: the setting getter is
         // owned by the proxy config service's delegate, which is supposed to be
         // destroyed on the UI thread only. We will get change notifications to
         // 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)
+  bool Init(const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,
+            const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
       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;
@@ skipping 18 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 {
+  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(
+  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,
         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 {
+  const scoped_refptr<base::SingleThreadTaskRunner>& GetNotificationTaskRunner()
+      override {
     return task_runner_;
   }
 
-  virtual ProxyConfigSource GetConfigSource() override {
+  ProxyConfigSource GetConfigSource() override {
     return PROXY_CONFIG_SOURCE_GCONF;
   }
 
-  virtual bool GetString(StringSetting key, std::string* result) override {
+  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 {
+  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 {
+  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 {
+  bool GetStringList(StringListSetting key,
+                     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 {
+  bool BypassListIsReversed() override {
     // This is a KDE-specific setting.
     return false;
   }
 
-  virtual bool MatchHostsUsingSuffixMatching() override {
-    return false;
-  }
+  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))
       return false;
     if (!value)
@@ skipping 122 matching lines @@
  public:
   SettingGetterImplGSettings() :
     client_(NULL),
     http_client_(NULL),
     https_client_(NULL),
     ftp_client_(NULL),
     socks_client_(NULL),
     notify_delegate_(NULL) {
   }
 
-  virtual ~SettingGetterImplGSettings() {
+  ~SettingGetterImplGSettings() override {
     // client_ should have been released before now, from
     // Delegate::OnDestroy(), while running on the UI thread. However
     // on exiting the process, it may happen that
     // Delegate::OnDestroy() task is left pending on the glib loop
     // after the loop was quit, and pending tasks may then be deleted
     // without being run.
     if (client_) {
       // gconf client was not cleaned up.
       if (task_runner_->BelongsToCurrentThread()) {
         // We are on the UI thread so we can clean it safely. This is
@@ skipping 15 matching lines @@
       if (strcmp(schema_name, static_cast<const char*>(*schemas)) == 0)
         return true;
       schemas++;
     }
     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)
+  bool Init(const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,
+            const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
       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 {
+  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(
+  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);
     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 {
+  const scoped_refptr<base::SingleThreadTaskRunner>& GetNotificationTaskRunner()
+      override {
     return task_runner_;
   }
 
-  virtual ProxyConfigSource GetConfigSource() override {
+  ProxyConfigSource GetConfigSource() override {
     return PROXY_CONFIG_SOURCE_GSETTINGS;
   }
 
-  virtual bool GetString(StringSetting key, std::string* result) override {
+  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 {
+  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 {
+  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 {
+  bool GetStringList(StringListSetting key,
+                     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 {
+  bool BypassListIsReversed() override {
     // This is a KDE-specific setting.
     return false;
   }
 
-  virtual bool MatchHostsUsingSuffixMatching() override {
-    return false;
-  }
+  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;
     *result = value;
     g_free(value);
@@ skipping 192 matching lines @@
         }
         if (use_kde4) {
           kde_config_dir_ = KDEHomeToConfigPath(kde4_path);
         } else {
           kde_config_dir_ = KDEHomeToConfigPath(kde3_path);
         }
       }
     }
   }
 
-  virtual ~SettingGetterImplKDE() {
+  ~SettingGetterImplKDE() override {
     // inotify_fd_ should have been closed before now, from
     // Delegate::OnDestroy(), while running on the file thread. However
     // on exiting the process, it may happen that Delegate::OnDestroy()
     // task is left pending on the file loop after the loop was quit,
     // and pending tasks may then be deleted without being run.
     // 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)
+  bool Init(const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,
+            const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
       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 {
+  void ShutDown() override {
     if (inotify_fd_ >= 0) {
       ResetCachedSettings();
       inotify_watcher_.StopWatchingFileDescriptor();
       close(inotify_fd_);
       inotify_fd_ = -1;
     }
   }
 
-  virtual bool SetUpNotifications(
+  bool SetUpNotifications(
       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 {
+  const scoped_refptr<base::SingleThreadTaskRunner>& GetNotificationTaskRunner()
+      override {
     return file_task_runner_;
   }
 
   // Implement base::MessagePumpLibevent::Watcher.
-  virtual void OnFileCanReadWithoutBlocking(int fd) override {
+  void OnFileCanReadWithoutBlocking(int fd) override {
     DCHECK_EQ(fd, inotify_fd_);
     DCHECK(file_task_runner_->BelongsToCurrentThread());
     OnChangeNotification();
   }
-  virtual void OnFileCanWriteWithoutBlocking(int fd) override {
-    NOTREACHED();
-  }
+  void OnFileCanWriteWithoutBlocking(int fd) override { NOTREACHED(); }
 
-  virtual ProxyConfigSource GetConfigSource() override {
+  ProxyConfigSource GetConfigSource() override {
     return PROXY_CONFIG_SOURCE_KDE;
   }
 
-  virtual bool GetString(StringSetting key, std::string* result) override {
+  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 {
+  bool GetBool(BoolSetting key, bool* result) override {
     // We don't ever have any booleans.
     return false;
   }
-  virtual bool GetInt(IntSetting key, int* result) override {
+  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 {
+  bool GetStringList(StringListSetting key,
+                     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 {
-    return reversed_bypass_list_;
-  }
+  bool BypassListIsReversed() override { return reversed_bypass_list_; }
 
-  virtual bool MatchHostsUsingSuffixMatching() override {
-    return true;
-  }
+  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 721 matching lines @@
 void ProxyConfigServiceLinux::RemoveObserver(Observer* observer) {
   delegate_->RemoveObserver(observer);
 }
 
 ProxyConfigService::ConfigAvailability
     ProxyConfigServiceLinux::GetLatestProxyConfig(ProxyConfig* config) {
   return delegate_->GetLatestProxyConfig(config);
 }
 
 }  // namespace net