base: rename Environment::GetEnv to Environment::GetVar.

net/proxy/proxy_config_service_linux.cc

 // Copyright (c) 2010 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>
 #include <gconf/gconf-client.h>
 #include <limits.h>
@@ skipping 65 matching lines @@
     host.resize(host.length() - 1);
   return host;
 }
 
 }  // namespace
 
 bool ProxyConfigServiceLinux::Delegate::GetProxyFromEnvVarForScheme(
     const char* variable, ProxyServer::Scheme scheme,
     ProxyServer* result_server) {
   std::string env_value;
-  if (env_var_getter_->GetEnv(variable, &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);
 }
 
 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_->GetEnv("auto_proxy", &auto_proxy)) {
+  if (env_var_getter_->GetVar("auto_proxy", &auto_proxy)) {
     if (auto_proxy.empty()) {
       // Defined and empty => autodetect
       config->set_auto_detect(true);
     } else {
       // specified autoconfig URL
       config->set_pac_url(GURL(auto_proxy));
     }
     return true;
   }
   // "all_proxy" is a shortcut to avoid defining {http,https,ftp}_proxy.
@@ skipping 19 matching lines @@
     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.
     ProxyServer::Scheme scheme = ProxyServer::SCHEME_SOCKS4;
     std::string env_version;
-    if (env_var_getter_->GetEnv("SOCKS_VERSION", &env_version)
+    if (env_var_getter_->GetVar("SOCKS_VERSION", &env_version)
         && env_version == "5")
       scheme = ProxyServer::SCHEME_SOCKS5;
     if (GetProxyFromEnvVarForScheme("SOCKS_SERVER", scheme, &proxy_server)) {
       config->proxy_rules().type = ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY;
       config->proxy_rules().single_proxy = proxy_server;
     }
   }
   // Look for the proxy bypass list.
   std::string no_proxy;
-  env_var_getter_->GetEnv("no_proxy", &no_proxy);
+  env_var_getter_->GetVar("no_proxy", &no_proxy);
   if (config->proxy_rules().empty()) {
     // Having only "no_proxy" set, presumably to "*", makes it
     // explicit that env vars do specify a configuration: having no
     // rules specified only means the user explicitly asks for direct
     // connections.
     return !no_proxy.empty();
   }
   // Note that this uses "suffix" matching. So a bypass of "google.com"
   // is understood to mean a bypass of "*google.com".
   config->proxy_rules().bypass_rules.ParseFromStringUsingSuffixMatching(
@@ skipping 246 matching lines @@
 class GConfSettingGetterImplKDE
     : public ProxyConfigServiceLinux::GConfSettingGetter,
       public base::MessagePumpLibevent::Watcher {
  public:
   explicit GConfSettingGetterImplKDE(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) {
     // Derive the location of the kde config dir from the environment.
     std::string home;
-    if (env_var_getter->GetEnv("KDEHOME", &home) && !home.empty()) {
+    if (env_var_getter->GetVar("KDEHOME", &home) && !home.empty()) {
       // $KDEHOME is set. Use it unconditionally.
       kde_config_dir_ = KDEHomeToConfigPath(FilePath(home));
     } else {
       // $KDEHOME is unset. Try to figure out what to use. This seems to be
       // the common case on most distributions.
-      if (!env_var_getter->GetEnv(base::env_vars::kHome, &home))
+      if (!env_var_getter->GetVar(base::env_vars::kHome, &home))
         // User has no $HOME? Give up. Later we'll report the failure.
         return;
       if (base::GetDesktopEnvironment(env_var_getter) ==
           base::DESKTOP_ENVIRONMENT_KDE3) {
         // KDE3 always uses .kde for its configuration.
         FilePath kde_path = FilePath(home).Append(".kde");
         kde_config_dir_ = KDEHomeToConfigPath(kde_path);
       } else {
         // Some distributions patch KDE4 to use .kde4 instead of .kde, so that
         // both can be installed side-by-side. Sadly they don't all do this, and
@@ skipping 233 matching lines @@
         LOG(WARNING) <<
             "Proxy authentication parameters ignored, see bug 16709";
       }
     }
   }
 
   void ResolveIndirect(const std::string& key) {
     string_map_type::iterator it = string_table_.find(key);
     if (it != string_table_.end()) {
       std::string value;
-      if (env_var_getter_->GetEnv(it->second.c_str(), &value))
+      if (env_var_getter_->GetVar(it->second.c_str(), &value))
         it->second = value;
       else
         string_table_.erase(it);
     }
   }
 
   void ResolveIndirectList(const std::string& key) {
     strings_map_type::iterator it = strings_table_.find(key);
     if (it != strings_table_.end()) {
       std::string value;
       if (!it->second.empty() &&
-          env_var_getter_->GetEnv(it->second[0].c_str(), &value))
+          env_var_getter_->GetVar(it->second[0].c_str(), &value))
         AddHostList(key, value);
       else
         strings_table_.erase(it);
     }
   }
 
   // The settings in kioslaverc could occur in any order, but some affect
   // others. Rather than read the whole file in and then query them in an
   // order that allows us to handle that, we read the settings in whatever
   // order they occur and do any necessary tweaking after we finish.
@@ skipping 518 matching lines @@
     : delegate_(new Delegate(env_var_getter)) {
 }
 
 ProxyConfigServiceLinux::ProxyConfigServiceLinux(
     base::Environment* env_var_getter,
     GConfSettingGetter* gconf_getter)
     : delegate_(new Delegate(env_var_getter, gconf_getter)) {
 }
 
 }  // namespace net