base: Rename EnvVarGetter to Environment.

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>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/inotify.h>
 #include <unistd.h>
 
 #include <map>
 
-#include "base/env_var.h"
+#include "base/environment.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/timer.h"
 #include "base/xdg_util.h"
@@ skipping 386 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::EnvVarGetter* env_var_getter)
+  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()) {
       // $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
@@ skipping 436 matching lines @@
   base::MessagePumpLibevent::FileDescriptorWatcher inotify_watcher_;
   ProxyConfigServiceLinux::Delegate* notify_delegate_;
   base::OneShotTimer<GConfSettingGetterImplKDE> debounce_timer_;
   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
   // both it and us are owned by ProxyConfigServiceLinux::Delegate, and have the
   // same lifetime.
-  base::EnvVarGetter* env_var_getter_;
+  base::Environment* env_var_getter_;
 
   // We cache these settings whenever we re-read the kioslaverc file.
   string_map_type string_table_;
   strings_map_type strings_table_;
 
   // Message loop of the file thread, for reading kioslaverc. If NULL,
   // just read it directly (for testing). We also handle inotify events
   // on this thread.
   MessageLoopForIO* file_loop_;
 
@@ skipping 151 matching lines @@
   // 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 = gconf_getter_->BypassListIsReversed();
 
   return true;
 }
 
-ProxyConfigServiceLinux::Delegate::Delegate(base::EnvVarGetter* env_var_getter)
+ProxyConfigServiceLinux::Delegate::Delegate(base::Environment* 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::EnvVarGetter* env_var_getter,
+ProxyConfigServiceLinux::Delegate::Delegate(base::Environment* 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 134 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::EnvVarGetter::Create())) {
+    : delegate_(new Delegate(base::Environment::Create())) {
 }
 
 ProxyConfigServiceLinux::ProxyConfigServiceLinux(
-    base::EnvVarGetter* env_var_getter)
+    base::Environment* env_var_getter)
     : delegate_(new Delegate(env_var_getter)) {
 }
 
 ProxyConfigServiceLinux::ProxyConfigServiceLinux(
-    base::EnvVarGetter* env_var_getter,
+    base::Environment* env_var_getter,
     GConfSettingGetter* gconf_getter)
     : delegate_(new Delegate(env_var_getter, gconf_getter)) {
 }
 
 }  // namespace net