Move EnvironmentVariableGetter from base/linux_util.h to base/env_var.h. Labe...

net/proxy/proxy_config_service_linux.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/inotify.h>
 #include <unistd.h>
 
+#include <map>
+
 #include "base/file_path.h"
 #include "base/file_util.h"
+#include "base/linux_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/timer.h"
 #include "googleurl/src/url_canon.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_util.h"
 #include "net/proxy/proxy_config.h"
@@ skipping 43 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_->GetEnv(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_->GetEnv("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_->GetEnv("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_->GetEnv("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 231 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(GConfSettingGetterImplGConf);
 };
 
 // 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 GConfSettingGetterImplKDE
     : public ProxyConfigServiceLinux::GConfSettingGetter,
       public base::MessagePumpLibevent::Watcher {
  public:
-  explicit GConfSettingGetterImplKDE(
-      base::EnvironmentVariableGetter* env_var_getter)
+  explicit GConfSettingGetterImplKDE(base::EnvVarGetter* env_var_getter)
       : inotify_fd_(-1), notify_delegate_(NULL), indirect_manual_(false),
         auto_no_pac_(false), reversed_exception_(false), file_loop_(NULL) {
     // We don't save the env var getter for later use since we don't own it.
     // Instead we use it here and save the result we actually care about.
     std::string kde_home;
-    if (!env_var_getter->Getenv("KDE_HOME", &kde_home)) {
-      if (!env_var_getter->Getenv("HOME", &kde_home))
+    if (!env_var_getter->GetEnv("KDE_HOME", &kde_home)) {
+      if (!env_var_getter->GetEnv("HOME", &kde_home))
         // User has no $HOME? Give up. Later we'll report the failure.
         return;
       kde_home = FilePath(kde_home).Append(FILE_PATH_LITERAL(".kde")).value();
     }
     kde_config_dir_ = FilePath(kde_home).Append(
         FILE_PATH_LITERAL("share")).Append(FILE_PATH_LITERAL("config"));
   }
 
   virtual ~GConfSettingGetterImplKDE() {
     // inotify_fd_ should have been closed before now, from
@@ skipping 524 matching lines @@
   config->proxy_rules().bypass_rules.Clear();
   for (size_t i = 0; i < ignore_hosts_list.size(); ++i)
     config->proxy_rules().bypass_rules.AddRuleFromString(ignore_hosts_list[i]);
 
   // Note that there are no settings with semantics corresponding to
   // bypass of local names.
 
   return true;
 }
 
-ProxyConfigServiceLinux::Delegate::Delegate(
-    base::EnvironmentVariableGetter* env_var_getter)
+ProxyConfigServiceLinux::Delegate::Delegate(base::EnvVarGetter* env_var_getter)
     : env_var_getter_(env_var_getter),
       glib_default_loop_(NULL), io_loop_(NULL) {
   // Figure out which GConfSettingGetterImpl to use, if any.
   switch (base::GetDesktopEnvironment(env_var_getter)) {
     case base::DESKTOP_ENVIRONMENT_GNOME:
       gconf_getter_.reset(new GConfSettingGetterImplGConf());
       break;
     case base::DESKTOP_ENVIRONMENT_KDE3:
     case base::DESKTOP_ENVIRONMENT_KDE4:
       gconf_getter_.reset(new GConfSettingGetterImplKDE(env_var_getter));
       break;
     case base::DESKTOP_ENVIRONMENT_XFCE:
     case base::DESKTOP_ENVIRONMENT_OTHER:
       break;
   }
 }
 
-ProxyConfigServiceLinux::Delegate::Delegate(
-    base::EnvironmentVariableGetter* env_var_getter,
+ProxyConfigServiceLinux::Delegate::Delegate(base::EnvVarGetter* env_var_getter,
     GConfSettingGetter* gconf_getter)
     : env_var_getter_(env_var_getter), gconf_getter_(gconf_getter),
       glib_default_loop_(NULL), io_loop_(NULL) {
 }
 
 void ProxyConfigServiceLinux::Delegate::SetupAndFetchInitialConfig(
     MessageLoop* glib_default_loop, MessageLoop* io_loop,
     MessageLoopForIO* file_loop) {
   // We should be running on the default glib main loop thread right
   // now. gconf can only be accessed from this thread.
@@ skipping 117 matching lines @@
             &ProxyConfigServiceLinux::Delegate::OnDestroy));
   }
 }
 void ProxyConfigServiceLinux::Delegate::OnDestroy() {
   MessageLoop* shutdown_loop = gconf_getter_->GetNotificationLoop();
   DCHECK(!shutdown_loop || MessageLoop::current() == shutdown_loop);
   gconf_getter_->Shutdown();
 }
 
 ProxyConfigServiceLinux::ProxyConfigServiceLinux()
-    : delegate_(new Delegate(base::EnvironmentVariableGetter::Create())) {
+    : delegate_(new Delegate(base::EnvVarGetter::Create())) {
 }
 
 ProxyConfigServiceLinux::ProxyConfigServiceLinux(
-    base::EnvironmentVariableGetter* env_var_getter)
+    base::EnvVarGetter* env_var_getter)
     : delegate_(new Delegate(env_var_getter)) {
 }
 
 ProxyConfigServiceLinux::ProxyConfigServiceLinux(
-    base::EnvironmentVariableGetter* env_var_getter,
+    base::EnvVarGetter* env_var_getter,
     GConfSettingGetter* gconf_getter)
     : delegate_(new Delegate(env_var_getter, gconf_getter)) {
 }
 
 }  // namespace net