Make base::Environment::Create() return unique_ptrs.

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>
 #if defined(USE_GCONF)
 #include <gconf/gconf-client.h>
 #endif  // defined(USE_GCONF)
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/inotify.h>
 #include <unistd.h>
 
 #include <map>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/debug/leak_annotations.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 59 matching lines @@
     host.resize(host.length() - 1);
   return host;
 }
 
 }  // namespace
 
 ProxyConfigServiceLinux::Delegate::~Delegate() {
 }
 
 bool ProxyConfigServiceLinux::Delegate::GetProxyFromEnvVarForScheme(
-    const char* variable, ProxyServer::Scheme scheme,
+    base::StringPiece 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;
-      }
-    }
+  if (!env_var_getter_->GetVar(variable, &env_value))
+    return false;
+
+  if (env_value.empty())
+    return false;
+
+  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;
   }
+  LOG(ERROR) << "Failed to parse environment variable " << variable;
   return false;
 }
 
 bool ProxyConfigServiceLinux::Delegate::GetProxyFromEnvVar(
-    const char* variable, ProxyServer* result_server) {
+    base::StringPiece 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;
@@ skipping 67 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),
+      : client_(nullptr),
         system_proxy_id_(0),
         system_http_proxy_id_(0),
-        notify_delegate_(NULL),
+        notify_delegate_(nullptr),
         debounce_timer_(new base::OneShotTimer()) {}
 
   ~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.
@@ skipping 20 matching lines @@
       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;
+      task_runner_ = nullptr;
       return false;
     }
-    GError* error = NULL;
+    GError* error = nullptr;
     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);
-    if (error == NULL) {
+    if (!error) {
       added_system_proxy = true;
       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;
-    }
-    return true;
+    if (!error)
+      return true;
+
+    LOG(ERROR) << "Error requesting gconf directory: " << error->message;
+    g_error_free(error);
+    if (added_system_proxy)
+      gconf_client_remove_dir(client_, "/system/proxy", nullptr);
+    g_object_unref(client_);
+    client_ = nullptr;
+    task_runner_ = nullptr;
+    return false;
   }
 
   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);
+      gconf_client_remove_dir(client_, "/system/http_proxy", nullptr);
+      gconf_client_remove_dir(client_, "/system/proxy", nullptr);
       g_object_unref(client_);
-      client_ = NULL;
-      task_runner_ = NULL;
+      client_ = nullptr;
+      task_runner_ = nullptr;
     }
     debounce_timer_.reset();
   }
 
   bool SetUpNotifications(
       ProxyConfigServiceLinux::Delegate* delegate) override {
     DCHECK(client_);
     DCHECK(task_runner_->BelongsToCurrentThread());
-    GError* error = NULL;
+    GError* error = nullptr;
     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_proxy_id_ = gconf_client_notify_add(client_, "/system/proxy",
+                                               OnGConfChangeNotification, this,
+                                               nullptr, &error);
+    if (!error) {
       system_http_proxy_id_ = gconf_client_notify_add(
-          client_, "/system/http_proxy",
-          OnGConfChangeNotification, this,
-          NULL, &error);
+          client_, "/system/http_proxy", OnGConfChangeNotification, this,
+          nullptr, &error);
     }
-    if (error != NULL) {
-      LOG(ERROR) << "Error requesting gconf notifications: " << error->message;
-      g_error_free(error);
-      ShutDown();
-      return false;
+    if (!error) {
+      // Simulate a change to avoid possibly losing updates before this point.
+      OnChangeNotification();
+      return true;
     }
-    // Simulate a change to avoid possibly losing updates before this point.
-    OnChangeNotification();
-    return true;
+
+    LOG(ERROR) << "Error requesting gconf notifications: " << error->message;
+    g_error_free(error);
+    ShutDown();
+    return false;
   }
 
   const scoped_refptr<base::SingleThreadTaskRunner>& GetNotificationTaskRunner()
       override {
     return task_runner_;
   }
 
   ProxyConfigSource GetConfigSource() override {
     return PROXY_CONFIG_SOURCE_GCONF;
   }
@@ skipping 49 matching lines @@
   }
 
   bool BypassListIsReversed() override {
     // This is a KDE-specific setting.
     return false;
   }
 
   bool MatchHostsUsingSuffixMatching() override { return false; }
 
  private:
-  bool GetStringByPath(const char* key, std::string* result) {
+  bool GetStringByPath(base::StringPiece 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))
+    GError* error = nullptr;
+    gchar* value = gconf_client_get_string(client_, key.data(), &error);
+    if (HandleGError(error, key.data()))
       return false;
     if (!value)
       return false;
     *result = value;
     g_free(value);
     return true;
   }
-  bool GetBoolByPath(const char* key, bool* result) {
+  bool GetBoolByPath(base::StringPiece key, bool* result) {
     DCHECK(client_);
     DCHECK(task_runner_->BelongsToCurrentThread());
-    GError* error = NULL;
+    GError* error = nullptr;
     // We want to distinguish unset values from values defaulting to
     // false. For that we need to use the type-generic
     // gconf_client_get() rather than gconf_client_get_bool().
-    GConfValue* gconf_value = gconf_client_get(client_, key, &error);
-    if (HandleGError(error, key))
+    GConfValue* gconf_value = gconf_client_get(client_, key.data(), &error);
+    if (HandleGError(error, key.data()))
       return false;
     if (!gconf_value) {
       // Unset.
       return false;
     }
     if (gconf_value->type != GCONF_VALUE_BOOL) {
       gconf_value_free(gconf_value);
       return false;
     }
     gboolean bool_value = gconf_value_get_bool(gconf_value);
     *result = static_cast<bool>(bool_value);
     gconf_value_free(gconf_value);
     return true;
   }
-  bool GetIntByPath(const char* key, int* result) {
+  bool GetIntByPath(base::StringPiece key, int* result) {
     DCHECK(client_);
     DCHECK(task_runner_->BelongsToCurrentThread());
-    GError* error = NULL;
-    int value = gconf_client_get_int(client_, key, &error);
-    if (HandleGError(error, key))
+    GError* error = nullptr;
+    int value = gconf_client_get_int(client_, key.data(), &error);
+    if (HandleGError(error, key.data()))
       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) {
+  bool GetStringListByPath(base::StringPiece 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);
-    if (HandleGError(error, key))
+    GError* error = nullptr;
+    GSList* list =
+        gconf_client_get_list(client_, key.data(), GCONF_VALUE_STRING, &error);
+    if (HandleGError(error, key.data()))
       return false;
     if (!list)
       return false;
     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;
-      g_error_free(error);
-      return true;
-    }
-    return false;
+  bool HandleGError(GError* error, base::StringPiece key) {
+    if (!error)
+      return false;
+
+    LOG(ERROR) << "Error getting gconf value for " << key << ": "
+               << error->message;
+    g_error_free(error);
+    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();
   }
 
@@ skipping 36 matching lines @@
 #endif  // defined(USE_GCONF)
 
 #if defined(USE_GIO)
 const char kProxyGConfSchema[] = "org.gnome.system.proxy";
 
 // 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),
+      : client_(nullptr),
+        http_client_(nullptr),
+        https_client_(nullptr),
+        ftp_client_(nullptr),
+        socks_client_(nullptr),
+        notify_delegate_(nullptr),
         debounce_timer_(new base::OneShotTimer()) {}
 
   ~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
         // the case at least for ui_tests running under Valgrind in
         // bug 16076.
         VLOG(1) << "~SettingGetterImplGSettings: releasing gsettings client";
         ShutDown();
       } else {
         LOG(WARNING) << "~SettingGetterImplGSettings: leaking gsettings client";
-        client_ = NULL;
+        client_ = nullptr;
       }
     }
     DCHECK(!client_);
   }
 
-  bool SchemaExists(const char* schema_name) {
+  bool SchemaExists(base::StringPiece schema_name) {
     const gchar* const* schemas = libgio_loader_.g_settings_list_schemas();
     while (*schemas) {
-      if (strcmp(schema_name, static_cast<const char*>(*schemas)) == 0)
+      if (!strcmp(schema_name.data(), static_cast<const char*>(*schemas)))
         return true;
       schemas++;
     }
     return false;
   }
 
   // LoadAndCheckVersion() must be called *before* Init()!
   bool LoadAndCheckVersion(base::Environment* env);
 
   bool Init(const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,
@@ skipping 22 matching lines @@
   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;
+      client_ = nullptr;
+      task_runner_ = nullptr;
     }
     debounce_timer_.reset();
   }
 
   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
@@ skipping 84 matching lines @@
   }
 
   bool BypassListIsReversed() override {
     // This is a KDE-specific setting.
     return false;
   }
 
   bool MatchHostsUsingSuffixMatching() override { return false; }
 
  private:
-  bool GetStringByPath(GSettings* client, const char* key,
+  bool GetStringByPath(GSettings* client,
+                       base::StringPiece key,
                        std::string* result) {
     DCHECK(task_runner_->BelongsToCurrentThread());
-    gchar* value = libgio_loader_.g_settings_get_string(client, key);
+    gchar* value = libgio_loader_.g_settings_get_string(client, key.data());
     if (!value)
       return false;
     *result = value;
     g_free(value);
     return true;
   }
-  bool GetBoolByPath(GSettings* client, const char* key, bool* result) {
+  bool GetBoolByPath(GSettings* client, base::StringPiece key, bool* result) {
     DCHECK(task_runner_->BelongsToCurrentThread());
     *result = static_cast<bool>(
-        libgio_loader_.g_settings_get_boolean(client, key));
+        libgio_loader_.g_settings_get_boolean(client, key.data()));
     return true;
   }
-  bool GetIntByPath(GSettings* client, const char* key, int* result) {
+  bool GetIntByPath(GSettings* client, base::StringPiece key, int* result) {
     DCHECK(task_runner_->BelongsToCurrentThread());
-    *result = libgio_loader_.g_settings_get_int(client, key);
+    *result = libgio_loader_.g_settings_get_int(client, key.data());
     return true;
   }
-  bool GetStringListByPath(GSettings* client, const char* key,
+  bool GetStringListByPath(GSettings* client,
+                           base::StringPiece key,
                            std::vector<std::string>* result) {
     DCHECK(task_runner_->BelongsToCurrentThread());
-    gchar** list = libgio_loader_.g_settings_get_strv(client, key);
+    gchar** list = libgio_loader_.g_settings_get_strv(client, key.data());
     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;
   }
 
@@ skipping 71 matching lines @@
     }
 
     // g_type_init will be deprecated in 2.36. 2.35 is the development
     // version for 2.36, hence do not call g_type_init starting 2.35.
     // http://developer.gnome.org/gobject/unstable/gobject-Type-Information.html#g-type-init
     if (libgio_loader_.glib_check_version(2, 35, 0)) {
       libgio_loader_.g_type_init();
     }
   }
 
-  GSettings* client = NULL;
+  GSettings* client = nullptr;
   if (SchemaExists(kProxyGConfSchema)) {
-    ANNOTATE_SCOPED_MEMORY_LEAK; // http://crbug.com/380782
+    ANNOTATE_SCOPED_MEMORY_LEAK;  // http://crbug.com/380782
     client = libgio_loader_.g_settings_new(kProxyGConfSchema);
   }
   if (!client) {
     VLOG(1) << "Cannot create gsettings client. Will fall back to gconf.";
     return false;
   }
   g_object_unref(client);
 
   // Yes, we're on the UI thread. Yes, we're accessing the file system.
   // Sadly, we don't have much choice. We need the proxy settings and we
@@ skipping 13 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),
+        notify_delegate_(nullptr),
         debounce_timer_(new base::OneShotTimer()),
         indirect_manual_(false),
         auto_no_pac_(false),
         reversed_bypass_list_(false),
         env_var_getter_(env_var_getter),
-        file_task_runner_(NULL) {
+        file_task_runner_(nullptr) {
     // 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 49 matching lines @@
   ~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);
+    DCHECK_LT(inotify_fd_, 0);
   }
 
   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);
+    DCHECK_LT(inotify_fd_, 0);
     inotify_fd_ = inotify_init();
     if (inotify_fd_ < 0) {
       PLOG(ERROR) << "inotify_init failed";
       return false;
     }
     if (!base::SetNonBlocking(inotify_fd_)) {
       PLOG(ERROR) << "base::SetNonBlocking failed";
       close(inotify_fd_);
       inotify_fd_ = -1;
       return false;
@@ skipping 11 matching lines @@
       ResetCachedSettings();
       inotify_watcher_.StopWatchingFileDescriptor();
       close(inotify_fd_);
       inotify_fd_ = -1;
     }
     debounce_timer_.reset();
   }
 
   bool SetUpNotifications(
       ProxyConfigServiceLinux::Delegate* delegate) override {
-    DCHECK(inotify_fd_ >= 0);
+    DCHECK_GE(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;
     }
@@ skipping 534 matching lines @@
   // 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) {
+ProxyConfigServiceLinux::Delegate::Delegate(
+    std::unique_ptr<base::Environment> env_var_getter)
+    : env_var_getter_(std::move(env_var_getter)) {
   // Figure out which SettingGetterImpl to use, if any.
-  switch (base::nix::GetDesktopEnvironment(env_var_getter)) {
+  switch (base::nix::GetDesktopEnvironment(env_var_getter_.get())) {
     case base::nix::DESKTOP_ENVIRONMENT_GNOME:
     case base::nix::DESKTOP_ENVIRONMENT_UNITY:
 #if defined(USE_GIO)
       {
       std::unique_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))
+      if (gs_getter->LoadAndCheckVersion(env_var_getter_.get()))
         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())
+      if (!setting_getter_)
         setting_getter_.reset(new SettingGetterImplGConf());
 #endif
       break;
     case base::nix::DESKTOP_ENVIRONMENT_KDE3:
     case base::nix::DESKTOP_ENVIRONMENT_KDE4:
     case base::nix::DESKTOP_ENVIRONMENT_KDE5:
-      setting_getter_.reset(new SettingGetterImplKDE(env_var_getter));
+      setting_getter_.reset(new SettingGetterImplKDE(env_var_getter_.get()));
       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)
-    : env_var_getter_(env_var_getter), setting_getter_(setting_getter) {
-}
+    std::unique_ptr<base::Environment> env_var_getter,
+    SettingGetter* setting_getter)
+    : env_var_getter_(std::move(env_var_getter)),
+      setting_getter_(setting_getter) {}
 
 void ProxyConfigServiceLinux::Delegate::SetUpAndFetchInitialConfig(
     const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner) {
   // We should be running on the default glib main loop thread right
   // now. gconf can only be accessed from this thread.
   DCHECK(glib_task_runner->BelongsToCurrentThread());
   glib_task_runner_ = glib_task_runner;
   io_task_runner_ = io_task_runner;
@@ skipping 10 matching lines @@
   // before this ProxyConfigServiceLinux is passed on to
   // the ProxyService.
 
   // Note: It would be nice to prioritize environment variables
   // and only fall back to gconf if env vars were unset. But
   // gnome-terminal "helpfully" sets http_proxy and no_proxy, and it
   // does so even if the proxy mode is set to auto, which would
   // mislead us.
 
   bool got_config = false;
-  if (setting_getter_.get() &&
+  if (setting_getter_ &&
       setting_getter_->Init(glib_task_runner, file_task_runner) &&
       GetConfigFromSettings(&cached_config_)) {
     cached_config_.set_id(1);  // Mark it as valid.
     cached_config_.set_source(setting_getter_->GetConfigSource());
     VLOG(1) << "Obtained proxy settings from "
             << ProxyConfigSourceToString(cached_config_.source());
 
     // If gconf proxy mode is "none", meaning direct, then we take
     // that to be a valid config and will not check environment
     // variables. The alternative would have been to look for a proxy
@@ skipping 111 matching lines @@
     const ProxyConfig& new_config) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   VLOG(1) << "Proxy configuration changed";
   cached_config_ = new_config;
   FOR_EACH_OBSERVER(
       Observer, observers_,
       OnProxyConfigChanged(new_config, ProxyConfigService::CONFIG_VALID));
 }
 
 void ProxyConfigServiceLinux::Delegate::PostDestroyTask() {
-  if (!setting_getter_.get())
+  if (!setting_getter_)
     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));
   }
 }
 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)) {
-}
+    std::unique_ptr<base::Environment> env_var_getter)
+    : delegate_(new Delegate(std::move(env_var_getter))) {}
 
 ProxyConfigServiceLinux::ProxyConfigServiceLinux(
-    base::Environment* env_var_getter, SettingGetter* setting_getter)
-    : delegate_(new Delegate(env_var_getter, setting_getter)) {
-}
+    std::unique_ptr<base::Environment> env_var_getter,
+    SettingGetter* setting_getter)
+    : delegate_(new Delegate(std::move(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) {
   return delegate_->GetLatestProxyConfig(config);
 }
 
 }  // namespace net