Clang format slam.

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 36 matching lines @@
 
 namespace net {
 
 namespace {
 
 // Given a proxy hostname from a setting, returns that hostname with
 // an appropriate proxy server scheme prefix.
 // scheme indicates the desired proxy scheme: usually http, with
 // socks 4 or 5 as special cases.
 // TODO(arindam): Remove URI string manipulation by using MapUrlSchemeToProxy.
-std::string FixupProxyHostScheme(ProxyServer::Scheme scheme,
-                                 std::string host) {
+std::string FixupProxyHostScheme(ProxyServer::Scheme scheme, std::string host) {
   if (scheme == ProxyServer::SCHEME_SOCKS5 &&
       StartsWithASCII(host, "socks4://", false)) {
     // We default to socks 5, but if the user specifically set it to
     // socks4://, then use that.
     scheme = ProxyServer::SCHEME_SOCKS4;
   }
   // Strip the scheme if any.
   std::string::size_type colon = host.find("://");
   if (colon != std::string::npos)
     host = host.substr(colon + 3);
@@ skipping 20 matching lines @@
     host.resize(host.length() - 1);
   return host;
 }
 
 }  // namespace
 
 ProxyConfigServiceLinux::Delegate::~Delegate() {
 }
 
 bool ProxyConfigServiceLinux::Delegate::GetProxyFromEnvVarForScheme(
-    const char* variable, ProxyServer::Scheme scheme,
+    const char* variable,
+    ProxyServer::Scheme scheme,
     ProxyServer* result_server) {
   std::string env_value;
   if (env_var_getter_->GetVar(variable, &env_value)) {
     if (!env_value.empty()) {
       env_value = FixupProxyHostScheme(scheme, env_value);
       ProxyServer proxy_server =
           ProxyServer::FromURI(env_value, ProxyServer::SCHEME_HTTP);
       if (proxy_server.is_valid() && !proxy_server.is_direct()) {
         *result_server = proxy_server;
         return true;
       } else {
         LOG(ERROR) << "Failed to parse environment variable " << variable;
       }
     }
   }
   return false;
 }
 
 bool ProxyConfigServiceLinux::Delegate::GetProxyFromEnvVar(
-    const char* variable, ProxyServer* result_server) {
-  return GetProxyFromEnvVarForScheme(variable, ProxyServer::SCHEME_HTTP,
-                                     result_server);
+    const char* variable,
+    ProxyServer* result_server) {
+  return GetProxyFromEnvVarForScheme(
+      variable, ProxyServer::SCHEME_HTTP, result_server);
 }
 
 bool ProxyConfigServiceLinux::Delegate::GetConfigFromEnv(ProxyConfig* config) {
   // Check for automatic configuration first, in
   // "auto_proxy". Possibly only the "environment_proxy" firefox
   // extension has ever used this, but it still sounds like a good
   // idea.
   std::string auto_proxy;
   if (env_var_getter_->GetVar("auto_proxy", &auto_proxy)) {
     if (auto_proxy.empty()) {
@@ skipping 14 matching lines @@
     bool have_http = GetProxyFromEnvVar("http_proxy", &proxy_server);
     if (have_http)
       config->proxy_rules().proxies_for_http.SetSingleProxyServer(proxy_server);
     // It would be tempting to let http_proxy apply for all protocols
     // if https_proxy and ftp_proxy are not defined. Googling turns up
     // several documents that mention only http_proxy. But then the
     // user really might not want to proxy https. And it doesn't seem
     // like other apps do this. So we will refrain.
     bool have_https = GetProxyFromEnvVar("https_proxy", &proxy_server);
     if (have_https)
-      config->proxy_rules().proxies_for_https.
-          SetSingleProxyServer(proxy_server);
+      config->proxy_rules().proxies_for_https.SetSingleProxyServer(
+          proxy_server);
     bool have_ftp = GetProxyFromEnvVar("ftp_proxy", &proxy_server);
     if (have_ftp)
       config->proxy_rules().proxies_for_ftp.SetSingleProxyServer(proxy_server);
     if (have_http || have_https || have_ftp) {
       // mustn't change type unless some rules are actually set.
       config->proxy_rules().type =
           ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME;
     }
   }
   if (config->proxy_rules().empty()) {
     // If the above were not defined, try for socks.
     // For environment variables, we default to version 5, per the gnome
     // documentation: http://library.gnome.org/devel/gnet/stable/gnet-socks.html
     ProxyServer::Scheme scheme = ProxyServer::SCHEME_SOCKS5;
     std::string env_version;
-    if (env_var_getter_->GetVar("SOCKS_VERSION", &env_version)
-        && env_version == "4")
+    if (env_var_getter_->GetVar("SOCKS_VERSION", &env_version) &&
+        env_version == "4")
       scheme = ProxyServer::SCHEME_SOCKS4;
     if (GetProxyFromEnvVarForScheme("SOCKS_SERVER", scheme, &proxy_server)) {
       config->proxy_rules().type = ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY;
       config->proxy_rules().single_proxies.SetSingleProxyServer(proxy_server);
     }
   }
   // Look for the proxy bypass list.
   std::string no_proxy;
   env_var_getter_->GetVar("no_proxy", &no_proxy);
   if (config->proxy_rules().empty()) {
@@ skipping 12 matching lines @@
 
 namespace {
 
 const int kDebounceTimeoutMilliseconds = 250;
 
 #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) {
-  }
+      : client_(NULL),
+        system_proxy_id_(0),
+        system_http_proxy_id_(0),
+        notify_delegate_(NULL) {}
 
   virtual ~SettingGetterImplGConf() {
     // 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()) {
@@ skipping 26 matching lines @@
       LOG(ERROR) << "Unable to create a gconf client";
       task_runner_ = NULL;
       return false;
     }
     GError* error = NULL;
     bool added_system_proxy = false;
     // We need to add the directories for which we'll be asking
     // for notifications, and we might as well ask to preload them.
     // These need to be removed again in ShutDown(); we are careful
     // here to only leave client_ non-NULL if both have been added.
-    gconf_client_add_dir(client_, "/system/proxy",
-                         GCONF_CLIENT_PRELOAD_ONELEVEL, &error);
+    gconf_client_add_dir(
+        client_, "/system/proxy", GCONF_CLIENT_PRELOAD_ONELEVEL, &error);
     if (error == NULL) {
       added_system_proxy = true;
-      gconf_client_add_dir(client_, "/system/http_proxy",
-                           GCONF_CLIENT_PRELOAD_ONELEVEL, &error);
+      gconf_client_add_dir(
+          client_, "/system/http_proxy", GCONF_CLIENT_PRELOAD_ONELEVEL, &error);
     }
     if (error != NULL) {
       LOG(ERROR) << "Error requesting gconf directory: " << error->message;
       g_error_free(error);
       if (added_system_proxy)
         gconf_client_remove_dir(client_, "/system/proxy", NULL);
       g_object_unref(client_);
       client_ = NULL;
       task_runner_ = NULL;
       return false;
@@ skipping 20 matching lines @@
 
   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,
-        NULL, &error);
+    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);
+      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;
@@ skipping 55 matching lines @@
         return GetStringListByPath("/system/http_proxy/ignore_hosts", result);
     }
     return false;  // Placate compiler.
   }
 
   virtual bool BypassListIsReversed() OVERRIDE {
     // This is a KDE-specific setting.
     return false;
   }
 
-  virtual bool MatchHostsUsingSuffixMatching() OVERRIDE {
-    return false;
-  }
+  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))
       return false;
     if (!value)
@@ skipping 34 matching lines @@
       return false;
     // We don't bother to distinguish an unset value because callers
     // don't care. 0 is returned if unset.
     *result = value;
     return true;
   }
   bool GetStringListByPath(const char* key, std::vector<std::string>* result) {
     DCHECK(client_);
     DCHECK(task_runner_->BelongsToCurrentThread());
     GError* error = NULL;
-    GSList* list = gconf_client_get_list(client_, key,
-                                         GCONF_VALUE_STRING, &error);
+    GSList* list =
+        gconf_client_get_list(client_, key, GCONF_VALUE_STRING, &error);
     if (HandleGError(error, key))
       return false;
     if (!list)
       return false;
-    for (GSList *it = list; it; it = it->next) {
+    for (GSList* it = list; it; it = it->next) {
       result->push_back(static_cast<char*>(it->data));
       g_free(it->data);
     }
     g_slist_free(list);
     return true;
   }
 
   // Logs and frees a glib error. Returns false if there was no error
   // (error is NULL).
   bool HandleGError(GError* error, const char* key) {
     if (error != NULL) {
-      LOG(ERROR) << "Error getting gconf value for " << key
-                 << ": " << error->message;
+      LOG(ERROR) << "Error getting gconf value for " << key << ": "
+                 << error->message;
       g_error_free(error);
       return true;
     }
     return false;
   }
 
   // This is the callback from the debounce timer.
   void OnDebouncedNotification() {
     DCHECK(task_runner_->BelongsToCurrentThread());
     CHECK(notify_delegate_);
     // Forward to a method on the proxy config service delegate object.
     notify_delegate_->OnCheckProxyConfigSettings();
   }
 
   void OnChangeNotification() {
     // We don't use Reset() because the timer may not yet be running.
     // (In that case Stop() is a no-op.)
     debounce_timer_.Stop();
-    debounce_timer_.Start(FROM_HERE,
+    debounce_timer_.Start(
+        FROM_HERE,
         base::TimeDelta::FromMilliseconds(kDebounceTimeoutMilliseconds),
-        this, &SettingGetterImplGConf::OnDebouncedNotification);
+        this,
+        &SettingGetterImplGConf::OnDebouncedNotification);
   }
 
   // gconf notification callback, dispatched on the default glib main loop.
-  static void OnGConfChangeNotification(GConfClient* client, guint cnxn_id,
-                                        GConfEntry* entry, gpointer user_data) {
+  static void OnGConfChangeNotification(GConfClient* client,
+                                        guint cnxn_id,
+                                        GConfEntry* entry,
+                                        gpointer user_data) {
     VLOG(1) << "gconf change notification for key "
             << gconf_entry_get_key(entry);
     // We don't track which key has changed, just that something did change.
     SettingGetterImplGConf* setting_getter =
         reinterpret_cast<SettingGetterImplGConf*>(user_data);
     setting_getter->OnChangeNotification();
   }
 
   GConfClient* client_;
   // These ids are the values returned from gconf_client_notify_add(), which we
@@ skipping 11 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(SettingGetterImplGConf);
 };
 #endif  // defined(USE_GCONF)
 
 #if defined(USE_GIO)
 // This setting getter uses gsettings, as used in most GNOME 3 desktops.
 class SettingGetterImplGSettings
     : public ProxyConfigServiceLinux::SettingGetter {
  public:
-  SettingGetterImplGSettings() :
-    client_(NULL),
-    http_client_(NULL),
-    https_client_(NULL),
-    ftp_client_(NULL),
-    socks_client_(NULL),
-    notify_delegate_(NULL) {
-  }
+  SettingGetterImplGSettings()
+      : client_(NULL),
+        http_client_(NULL),
+        https_client_(NULL),
+        ftp_client_(NULL),
+        socks_client_(NULL),
+        notify_delegate_(NULL) {}
 
   virtual ~SettingGetterImplGSettings() {
     // 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.
@@ skipping 62 matching lines @@
   }
 
   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);
-    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);
+    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 base::SingleThreadTaskRunner* GetNotificationTaskRunner() OVERRIDE {
     return task_runner_.get();
   }
 
   virtual ProxyConfigSource GetConfigSource() OVERRIDE {
@@ skipping 58 matching lines @@
         return GetStringListByPath(client_, "ignore-hosts", result);
     }
     return false;  // Placate compiler.
   }
 
   virtual bool BypassListIsReversed() OVERRIDE {
     // This is a KDE-specific setting.
     return false;
   }
 
-  virtual bool MatchHostsUsingSuffixMatching() OVERRIDE {
-    return false;
-  }
+  virtual bool MatchHostsUsingSuffixMatching() OVERRIDE { return false; }
 
  private:
-  bool GetStringByPath(GSettings* client, const char* key,
+  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);
     return true;
   }
   bool GetBoolByPath(GSettings* client, const char* key, bool* result) {
     DCHECK(task_runner_->BelongsToCurrentThread());
-    *result = static_cast<bool>(
-        libgio_loader_.g_settings_get_boolean(client, key));
+    *result =
+        static_cast<bool>(libgio_loader_.g_settings_get_boolean(client, key));
     return true;
   }
   bool GetIntByPath(GSettings* client, const char* key, int* result) {
     DCHECK(task_runner_->BelongsToCurrentThread());
     *result = libgio_loader_.g_settings_get_int(client, key);
     return true;
   }
-  bool GetStringListByPath(GSettings* client, const char* key,
+  bool GetStringListByPath(GSettings* client,
+                           const char* key,
                            std::vector<std::string>* result) {
     DCHECK(task_runner_->BelongsToCurrentThread());
     gchar** list = libgio_loader_.g_settings_get_strv(client, key);
     if (!list)
       return false;
     for (size_t i = 0; list[i]; ++i) {
       result->push_back(static_cast<char*>(list[i]));
       g_free(list[i]);
     }
     g_free(list);
     return true;
   }
 
   // This is the callback from the debounce timer.
   void OnDebouncedNotification() {
     DCHECK(task_runner_->BelongsToCurrentThread());
     CHECK(notify_delegate_);
     // Forward to a method on the proxy config service delegate object.
     notify_delegate_->OnCheckProxyConfigSettings();
   }
 
   void OnChangeNotification() {
     // We don't use Reset() because the timer may not yet be running.
     // (In that case Stop() is a no-op.)
     debounce_timer_.Stop();
-    debounce_timer_.Start(FROM_HERE,
+    debounce_timer_.Start(
+        FROM_HERE,
         base::TimeDelta::FromMilliseconds(kDebounceTimeoutMilliseconds),
-        this, &SettingGetterImplGSettings::OnDebouncedNotification);
+        this,
+        &SettingGetterImplGSettings::OnDebouncedNotification);
   }
 
   // gsettings notification callback, dispatched on the default glib main loop.
-  static void OnGSettingsChangeNotification(GSettings* client, gchar* key,
+  static void OnGSettingsChangeNotification(GSettings* client,
+                                            gchar* key,
                                             gpointer user_data) {
     VLOG(1) << "gsettings change notification for key " << key;
     // We don't track which key has changed, just that something did change.
     SettingGetterImplGSettings* setting_getter =
         reinterpret_cast<SettingGetterImplGSettings*>(user_data);
     setting_getter->OnChangeNotification();
   }
 
   GSettings* client_;
   GSettings* http_client_;
   GSettings* https_client_;
   GSettings* ftp_client_;
   GSettings* socks_client_;
   ProxyConfigServiceLinux::Delegate* notify_delegate_;
   base::OneShotTimer<SettingGetterImplGSettings> debounce_timer_;
 
   // Task runner for the thread that we make gsettings calls on. It should
   // be the UI thread and all our methods should be called on this
   // thread. Only for assertions.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   LibGioLoader libgio_loader_;
 
   DISALLOW_COPY_AND_ASSIGN(SettingGetterImplGSettings);
 };
 
-bool SettingGetterImplGSettings::LoadAndCheckVersion(
-    base::Environment* env) {
+bool SettingGetterImplGSettings::LoadAndCheckVersion(base::Environment* env) {
   // LoadAndCheckVersion() must be called *before* Init()!
   DCHECK(!client_);
 
   // The APIs to query gsettings were introduced after the minimum glib
   // version we target, so we can't link directly against them. We load them
   // dynamically at runtime, and if they don't exist, return false here. (We
   // support linking directly via gyp flags though.) Additionally, even when
   // they are present, we do two additional checks to make sure we should use
   // them and not gconf. First, we attempt to load the schema for proxy
   // settings. Second, we check for the program that was used in older
@@ skipping 47 matching lines @@
 }
 #endif  // defined(USE_GIO)
 
 // This is the KDE version that reads kioslaverc and simulates gconf.
 // Doing this allows the main Delegate code, as well as the unit tests
 // for it, to stay the same - and the settings map fairly well besides.
 class SettingGetterImplKDE : public ProxyConfigServiceLinux::SettingGetter,
                              public base::MessagePumpLibevent::Watcher {
  public:
   explicit SettingGetterImplKDE(base::Environment* env_var_getter)
-      : inotify_fd_(-1), notify_delegate_(NULL), indirect_manual_(false),
-        auto_no_pac_(false), reversed_bypass_list_(false),
-        env_var_getter_(env_var_getter), file_loop_(NULL) {
+      : inotify_fd_(-1),
+        notify_delegate_(NULL),
+        indirect_manual_(false),
+        auto_no_pac_(false),
+        reversed_bypass_list_(false),
+        env_var_getter_(env_var_getter),
+        file_loop_(NULL) {
     // This has to be called on the UI thread (http://crbug.com/69057).
     base::ThreadRestrictions::ScopedAllowIO allow_io;
 
     // Derive the location of the kde config dir from the environment.
     std::string home;
     if (env_var_getter->GetVar("KDEHOME", &home) && !home.empty()) {
       // $KDEHOME is set. Use it unconditionally.
       kde_config_dir_ = KDEHomeToConfigPath(base::FilePath(home));
     } else {
       // $KDEHOME is unset. Try to figure out what to use. This seems to be
@@ skipping 90 matching lines @@
 
   virtual bool SetUpNotifications(
       ProxyConfigServiceLinux::Delegate* delegate) OVERRIDE {
     DCHECK(inotify_fd_ >= 0);
     DCHECK(base::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(),
+    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,
                                          base::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().get() : NULL;
   }
 
   // Implement base::MessagePumpLibevent::Watcher.
   virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE {
     DCHECK_EQ(fd, inotify_fd_);
     DCHECK(base::MessageLoop::current() == file_loop_);
     OnChangeNotification();
   }
-  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE {
-    NOTREACHED();
-  }
+  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())
       return false;
     *result = it->second;
     return true;
   }
   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 {
     // 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 {
     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_;
-  }
+  virtual bool BypassListIsReversed() OVERRIDE { return reversed_bypass_list_; }
 
-  virtual bool MatchHostsUsingSuffixMatching() OVERRIDE {
-    return true;
-  }
+  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 79 matching lines @@
       reversed_bypass_list_ = (value == "true" || int_value);
     } else if (key == "NoProxyFor") {
       AddHostList(PROXY_IGNORE_HOSTS, value);
     } else if (key == "AuthMode") {
       // Check for authentication, just so we can warn.
       int mode;
       base::StringToInt(value, &mode);
       if (mode) {
         // ProxyConfig does not support authentication parameters, but
         // Chrome will prompt for the password later. So we ignore this.
-        LOG(WARNING) <<
-            "Proxy authentication parameters ignored, see bug 16709";
+        LOG(WARNING)
+            << "Proxy authentication parameters ignored, see bug 16709";
       }
     }
   }
 
   void ResolveIndirect(StringSetting key) {
     string_map_type::iterator it = string_table_.find(key);
     if (it != string_table_.end()) {
       std::string value;
       if (env_var_getter_->GetVar(it->second.c_str(), &value))
         it->second = value;
@@ skipping 115 matching lines @@
     UpdateCachedSettings();
     CHECK(notify_delegate_);
     // Forward to a method on the proxy config service delegate object.
     notify_delegate_->OnCheckProxyConfigSettings();
   }
 
   // Called by OnFileCanReadWithoutBlocking() on the file thread. Reads
   // from the inotify file descriptor and starts up a debounce timer if
   // an event for kioslaverc is seen.
   void OnChangeNotification() {
-    DCHECK_GE(inotify_fd_,  0);
+    DCHECK_GE(inotify_fd_, 0);
     DCHECK(base::MessageLoop::current() == file_loop_);
     char event_buf[(sizeof(inotify_event) + NAME_MAX + 1) * 4];
     bool kioslaverc_touched = false;
     ssize_t r;
     while ((r = read(inotify_fd_, event_buf, sizeof(event_buf))) > 0) {
       // inotify returns variable-length structures, which is why we have
       // this strange-looking loop instead of iterating through an array.
       char* event_ptr = event_buf;
       while (event_ptr < event_buf + r) {
         inotify_event* event = reinterpret_cast<inotify_event*>(event_ptr);
@@ skipping 23 matching lines @@
         LOG(ERROR) << "inotify failure; no longer watching kioslaverc!";
         inotify_watcher_.StopWatchingFileDescriptor();
         close(inotify_fd_);
         inotify_fd_ = -1;
       }
     }
     if (kioslaverc_touched) {
       // We don't use Reset() because the timer may not yet be running.
       // (In that case Stop() is a no-op.)
       debounce_timer_.Stop();
-      debounce_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(
-          kDebounceTimeoutMilliseconds), this,
+      debounce_timer_.Start(
+          FROM_HERE,
+          base::TimeDelta::FromMilliseconds(kDebounceTimeoutMilliseconds),
+          this,
           &SettingGetterImplKDE::OnDebouncedNotification);
     }
   }
 
   typedef std::map<StringSetting, std::string> string_map_type;
-  typedef std::map<StringListSetting,
-                   std::vector<std::string> > strings_map_type;
+  typedef std::map<StringListSetting, std::vector<std::string> >
+      strings_map_type;
 
   int inotify_fd_;
   base::MessagePumpLibevent::FileDescriptorWatcher inotify_watcher_;
   ProxyConfigServiceLinux::Delegate* notify_delegate_;
   base::OneShotTimer<SettingGetterImplKDE> debounce_timer_;
   base::FilePath kde_config_dir_;
   bool indirect_manual_;
   bool auto_no_pac_;
   bool reversed_bypass_list_;
   // We don't own |env_var_getter_|.  It's safe to hold a pointer to it, since
@@ skipping 29 matching lines @@
       SettingGetter::HostSettingToPortSetting(host_key);
   setting_getter_->GetInt(port_key, &port);
   if (port != 0) {
     // If a port is set and non-zero:
     host += ":" + base::IntToString(port);
   }
 
   // gconf settings do not appear to distinguish between SOCKS version. We
   // default to version 5. For more information on this policy decision, see:
   // http://code.google.com/p/chromium/issues/detail?id=55912#c2
-  ProxyServer::Scheme scheme = (host_key == SettingGetter::PROXY_SOCKS_HOST) ?
-      ProxyServer::SCHEME_SOCKS5 : ProxyServer::SCHEME_HTTP;
+  ProxyServer::Scheme scheme = (host_key == SettingGetter::PROXY_SOCKS_HOST)
+                                   ? ProxyServer::SCHEME_SOCKS5
+                                   : ProxyServer::SCHEME_HTTP;
   host = FixupProxyHostScheme(scheme, host);
-  ProxyServer proxy_server = ProxyServer::FromURI(host,
-                                                  ProxyServer::SCHEME_HTTP);
+  ProxyServer proxy_server =
+      ProxyServer::FromURI(host, ProxyServer::SCHEME_HTTP);
   if (proxy_server.is_valid()) {
     *result_server = proxy_server;
     return true;
   }
   return false;
 }
 
 bool ProxyConfigServiceLinux::Delegate::GetConfigFromSettings(
     ProxyConfig* config) {
   std::string mode;
@@ skipping 27 matching lines @@
     config->set_auto_detect(true);
     return true;
   }
 
   if (mode != "manual") {
     // Mode is unrecognized.
     return false;
   }
   bool use_http_proxy;
   if (setting_getter_->GetBool(SettingGetter::PROXY_USE_HTTP_PROXY,
-                               &use_http_proxy)
-      && !use_http_proxy) {
+                               &use_http_proxy) &&
+      !use_http_proxy) {
     // Another master switch for some reason. If set to false, then no
     // proxy. But we don't panic if the key doesn't exist.
     return true;
   }
 
   bool same_proxy = false;
   // Indicates to use the http proxy for all protocols. This one may
   // not exist (presumably on older versions); we assume false in that
   // case.
-  setting_getter_->GetBool(SettingGetter::PROXY_USE_SAME_PROXY,
-                           &same_proxy);
+  setting_getter_->GetBool(SettingGetter::PROXY_USE_SAME_PROXY, &same_proxy);
 
   ProxyServer proxy_for_http;
   ProxyServer proxy_for_https;
   ProxyServer proxy_for_ftp;
   ProxyServer socks_proxy;  // (socks)
 
   // This counts how many of the above ProxyServers were defined and valid.
   size_t num_proxies_specified = 0;
 
   // Extract the per-scheme proxies. If we failed to parse it, or no proxy was
@@ skipping 15 matching lines @@
     }
   } else if (num_proxies_specified > 0) {
     if (socks_proxy.is_valid() && num_proxies_specified == 1) {
       // If the only proxy specified was for SOCKS, use it for all schemes.
       config->proxy_rules().type = ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY;
       config->proxy_rules().single_proxies.SetSingleProxyServer(socks_proxy);
     } else {
       // Otherwise use the indicated proxies per-scheme.
       config->proxy_rules().type =
           ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME;
-      config->proxy_rules().proxies_for_http.
-          SetSingleProxyServer(proxy_for_http);
-      config->proxy_rules().proxies_for_https.
-          SetSingleProxyServer(proxy_for_https);
+      config->proxy_rules().proxies_for_http.SetSingleProxyServer(
+          proxy_for_http);
+      config->proxy_rules().proxies_for_https.SetSingleProxyServer(
+          proxy_for_https);
       config->proxy_rules().proxies_for_ftp.SetSingleProxyServer(proxy_for_ftp);
       config->proxy_rules().fallback_proxies.SetSingleProxyServer(socks_proxy);
     }
   }
 
   if (config->proxy_rules().empty()) {
     // Manual mode but we couldn't parse any rules.
     return false;
   }
 
   // Check for authentication, just so we can warn.
   bool use_auth = false;
-  setting_getter_->GetBool(SettingGetter::PROXY_USE_AUTHENTICATION,
-                           &use_auth);
+  setting_getter_->GetBool(SettingGetter::PROXY_USE_AUTHENTICATION, &use_auth);
   if (use_auth) {
     // ProxyConfig does not support authentication parameters, but
     // Chrome will prompt for the password later. So we ignore
     // /system/http_proxy/*auth* settings.
     LOG(WARNING) << "Proxy authentication parameters ignored, see bug 16709";
   }
 
   // Now the bypass list.
   std::vector<std::string> ignore_hosts_list;
   config->proxy_rules().bypass_rules.Clear();
   if (setting_getter_->GetStringList(SettingGetter::PROXY_IGNORE_HOSTS,
                                      &ignore_hosts_list)) {
     std::vector<std::string>::const_iterator it(ignore_hosts_list.begin());
     for (; it != ignore_hosts_list.end(); ++it) {
       if (setting_getter_->MatchHostsUsingSuffixMatching()) {
-        config->proxy_rules().bypass_rules.
-            AddRuleFromStringUsingSuffixMatching(*it);
+        config->proxy_rules().bypass_rules.AddRuleFromStringUsingSuffixMatching(
+            *it);
       } else {
         config->proxy_rules().bypass_rules.AddRuleFromString(*it);
       }
     }
   }
   // Note that there are no settings with semantics corresponding to
   // bypass of local names in GNOME. In KDE, "<local>" is supported
   // as a hostname rule.
 
   // KDE allows one to reverse the bypass rules.
   config->proxy_rules().reverse_bypass =
       setting_getter_->BypassListIsReversed();
 
   return true;
 }
 
 ProxyConfigServiceLinux::Delegate::Delegate(base::Environment* env_var_getter)
     : env_var_getter_(env_var_getter) {
   // Figure out which SettingGetterImpl to use, if any.
   switch (base::nix::GetDesktopEnvironment(env_var_getter)) {
     case base::nix::DESKTOP_ENVIRONMENT_GNOME:
     case base::nix::DESKTOP_ENVIRONMENT_UNITY:
 #if defined(USE_GIO)
-      {
-        scoped_ptr<SettingGetterImplGSettings> gs_getter(
-            new SettingGetterImplGSettings());
-        // We have to load symbols and check the GNOME version in use to decide
-        // if we should use the gsettings getter. See LoadAndCheckVersion().
-        if (gs_getter->LoadAndCheckVersion(env_var_getter))
-          setting_getter_.reset(gs_getter.release());
-      }
+    {
+      scoped_ptr<SettingGetterImplGSettings> gs_getter(
+          new SettingGetterImplGSettings());
+      // We have to load symbols and check the GNOME version in use to decide
+      // if we should use the gsettings getter. See LoadAndCheckVersion().
+      if (gs_getter->LoadAndCheckVersion(env_var_getter))
+        setting_getter_.reset(gs_getter.release());
+    }
 #endif
 #if defined(USE_GCONF)
       // Fall back on gconf if gsettings is unavailable or incorrect.
       if (!setting_getter_.get())
         setting_getter_.reset(new SettingGetterImplGConf());
 #endif
       break;
     case base::nix::DESKTOP_ENVIRONMENT_KDE3:
     case base::nix::DESKTOP_ENVIRONMENT_KDE4:
       setting_getter_.reset(new SettingGetterImplKDE(env_var_getter));
       break;
     case base::nix::DESKTOP_ENVIRONMENT_XFCE:
     case base::nix::DESKTOP_ENVIRONMENT_OTHER:
       break;
   }
 }
 
-ProxyConfigServiceLinux::Delegate::Delegate(
-    base::Environment* env_var_getter, SettingGetter* setting_getter)
+ProxyConfigServiceLinux::Delegate::Delegate(base::Environment* env_var_getter,
+                                            SettingGetter* setting_getter)
     : env_var_getter_(env_var_getter), setting_getter_(setting_getter) {
 }
 
 void ProxyConfigServiceLinux::Delegate::SetUpAndFetchInitialConfig(
     base::SingleThreadTaskRunner* glib_thread_task_runner,
     base::SingleThreadTaskRunner* io_thread_task_runner,
     base::MessageLoopForIO* file_loop) {
   // We should be running on the default glib main loop thread right
   // now. gconf can only be accessed from this thread.
   DCHECK(glib_thread_task_runner->BelongsToCurrentThread());
@@ skipping 47 matching lines @@
     // fetch and before setting up notifications. We'll detect the common case
     // of no changes in OnCheckProxyConfigSettings() (or sooner) and ignore it.
     if (io_thread_task_runner && file_loop) {
       scoped_refptr<base::SingleThreadTaskRunner> required_loop =
           setting_getter_->GetNotificationTaskRunner();
       if (!required_loop.get() || required_loop->BelongsToCurrentThread()) {
         // In this case we are already on an acceptable thread.
         SetUpNotifications();
       } else {
         // Post a task to set up notifications. We don't wait for success.
-        required_loop->PostTask(FROM_HERE, base::Bind(
-            &ProxyConfigServiceLinux::Delegate::SetUpNotifications, this));
+        required_loop->PostTask(
+            FROM_HERE,
+            base::Bind(&ProxyConfigServiceLinux::Delegate::SetUpNotifications,
+                       this));
       }
     }
   }
 
   if (!got_config) {
     // We fall back on environment variables.
     //
     // Consulting environment variables doesn't need to be done from the
     // default glib main loop, but it's a tiny enough amount of work.
     if (GetConfigFromEnv(&cached_config_)) {
@@ skipping 16 matching lines @@
 
 void ProxyConfigServiceLinux::Delegate::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void ProxyConfigServiceLinux::Delegate::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 ProxyConfigService::ConfigAvailability
-    ProxyConfigServiceLinux::Delegate::GetLatestProxyConfig(
-        ProxyConfig* config) {
+ProxyConfigServiceLinux::Delegate::GetLatestProxyConfig(ProxyConfig* config) {
   // This is called from the IO thread.
   DCHECK(!io_thread_task_runner_.get() ||
          io_thread_task_runner_->BelongsToCurrentThread());
 
   // Simply return the last proxy configuration that glib_default_loop
   // notified us of.
   if (cached_config_.is_valid()) {
     *config = cached_config_;
   } else {
     *config = ProxyConfig::CreateDirect();
@@ skipping 17 matching lines @@
   ProxyConfig new_config;
   bool valid = GetConfigFromSettings(&new_config);
   if (valid)
     new_config.set_id(1);  // mark it as valid
 
   // See if it is different from what we had before.
   if (new_config.is_valid() != reference_config_.is_valid() ||
       !new_config.Equals(reference_config_)) {
     // Post a task to the IO thread with the new configuration, so it can
     // update |cached_config_|.
-    io_thread_task_runner_->PostTask(FROM_HERE, base::Bind(
-        &ProxyConfigServiceLinux::Delegate::SetNewProxyConfig,
-        this, new_config));
+    io_thread_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&ProxyConfigServiceLinux::Delegate::SetNewProxyConfig,
+                   this,
+                   new_config));
     // Update the thread-private copy in |reference_config_| as well.
     reference_config_ = new_config;
   } else {
     VLOG(1) << "Detected no-op change to proxy settings. Doing nothing.";
   }
 }
 
 void ProxyConfigServiceLinux::Delegate::SetNewProxyConfig(
     const ProxyConfig& new_config) {
   DCHECK(io_thread_task_runner_->BelongsToCurrentThread());
   VLOG(1) << "Proxy configuration changed";
   cached_config_ = new_config;
   FOR_EACH_OBSERVER(
-      Observer, observers_,
+      Observer,
+      observers_,
       OnProxyConfigChanged(new_config, ProxyConfigService::CONFIG_VALID));
 }
 
 void ProxyConfigServiceLinux::Delegate::PostDestroyTask() {
   if (!setting_getter_.get())
     return;
   scoped_refptr<base::SingleThreadTaskRunner> shutdown_loop =
       setting_getter_->GetNotificationTaskRunner();
   if (!shutdown_loop.get() || shutdown_loop->BelongsToCurrentThread()) {
     // Already on the right thread, call directly.
     // This is the case for the unittests.
     OnDestroy();
   } else {
     // Post to shutdown thread. Note that on browser shutdown, we may quit
     // this MessageLoop and exit the program before ever running this.
-    shutdown_loop->PostTask(FROM_HERE, base::Bind(
-        &ProxyConfigServiceLinux::Delegate::OnDestroy, this));
+    shutdown_loop->PostTask(
+        FROM_HERE,
+        base::Bind(&ProxyConfigServiceLinux::Delegate::OnDestroy, this));
   }
 }
 void ProxyConfigServiceLinux::Delegate::OnDestroy() {
   scoped_refptr<base::SingleThreadTaskRunner> shutdown_loop =
       setting_getter_->GetNotificationTaskRunner();
   DCHECK(!shutdown_loop.get() || shutdown_loop->BelongsToCurrentThread());
   setting_getter_->ShutDown();
 }
 
 ProxyConfigServiceLinux::ProxyConfigServiceLinux()
     : delegate_(new Delegate(base::Environment::Create())) {
 }
 
 ProxyConfigServiceLinux::~ProxyConfigServiceLinux() {
   delegate_->PostDestroyTask();
 }
 
 ProxyConfigServiceLinux::ProxyConfigServiceLinux(
     base::Environment* env_var_getter)
     : delegate_(new Delegate(env_var_getter)) {
 }
 
 ProxyConfigServiceLinux::ProxyConfigServiceLinux(
-    base::Environment* env_var_getter, SettingGetter* setting_getter)
+    base::Environment* env_var_getter,
+    SettingGetter* setting_getter)
     : delegate_(new Delegate(env_var_getter, setting_getter)) {
 }
 
 void ProxyConfigServiceLinux::AddObserver(Observer* observer) {
   delegate_->AddObserver(observer);
 }
 
 void ProxyConfigServiceLinux::RemoveObserver(Observer* observer) {
   delegate_->RemoveObserver(observer);
 }
 
 ProxyConfigService::ConfigAvailability
-    ProxyConfigServiceLinux::GetLatestProxyConfig(ProxyConfig* config) {
+ProxyConfigServiceLinux::GetLatestProxyConfig(ProxyConfig* config) {
   return delegate_->GetLatestProxyConfig(config);
 }
 
 }  // namespace net