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

net/proxy/proxy_config_service_linux.h

 // 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.
 
 #ifndef NET_PROXY_PROXY_CONFIG_SERVICE_LINUX_H_
 #define NET_PROXY_PROXY_CONFIG_SERVICE_LINUX_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 13 matching lines @@
 namespace base {
 class SingleThreadTaskRunner;
 }  // namespace base
 
 namespace net {
 
 // Implementation of ProxyConfigService that retrieves the system proxy
 // settings from environment variables, gconf, gsettings, or kioslaverc (KDE).
 class NET_EXPORT_PRIVATE ProxyConfigServiceLinux : public ProxyConfigService {
  public:
-
-  // Forward declaration of Delegate.
   class Delegate;
 
   class SettingGetter {
    public:
     // Buffer size used in some implementations of this class when reading
     // files. Defined here so unit tests can construct worst-case inputs.
     static const size_t BUFFER_SIZE = 512;
 
     SettingGetter() {}
     virtual ~SettingGetter() {}
@@ skipping 115 matching lines @@
   // ProxyConfigServiceLinux is deleted from the IO thread.
   //
   // The substance of the ProxyConfigServiceLinux implementation is
   // wrapped in the Delegate ref counted class. On deleting the
   // ProxyConfigServiceLinux, Delegate::OnDestroy() is posted to either
   // the UI thread (gconf/gsettings) or the file thread (KDE) where change
   // notifications will be safely stopped before releasing Delegate.
 
   class Delegate : public base::RefCountedThreadSafe<Delegate> {
    public:
-    // Constructor receives env var getter implementation to use, and
-    // takes ownership of it. This is the normal constructor.
-    explicit Delegate(base::Environment* env_var_getter);
-    // Constructor receives setting and env var getter implementations
-    // to use, and takes ownership of them. Used for testing.
-    Delegate(base::Environment* env_var_getter, SettingGetter* setting_getter);
+    // Normal constructor.
+    explicit Delegate(std::unique_ptr<base::Environment> env_var_getter);
+
+    // Constructor for testing.
+    Delegate(std::unique_ptr<base::Environment> env_var_getter,
+             SettingGetter* setting_getter);
 
     // Synchronously obtains the proxy configuration. If gconf,
     // gsettings, or kioslaverc are used, also enables notifications for
     // setting changes. gconf/gsettings must only be accessed from the
     // thread running the default glib main loop, and so this method
     // must be called from the UI thread. The message loop for the IO
     // thread is specified so that notifications can post tasks to it
     // (and for assertions). The message loop for the file thread is
     // used to read any files needed to determine proxy settings.
     void SetUpAndFetchInitialConfig(
@@ skipping 22 matching lines @@
     void OnDestroy();
 
    private:
     friend class base::RefCountedThreadSafe<Delegate>;
 
     ~Delegate();
 
     // Obtains an environment variable's value. Parses a proxy server
     // specification from it and puts it in result. Returns true if the
     // requested variable is defined and the value valid.
-    bool GetProxyFromEnvVarForScheme(const char* variable,
+    bool GetProxyFromEnvVarForScheme(base::StringPiece variable,
                                      ProxyServer::Scheme scheme,
                                      ProxyServer* result_server);
     // As above but with scheme set to HTTP, for convenience.
-    bool GetProxyFromEnvVar(const char* variable, ProxyServer* result_server);
+    bool GetProxyFromEnvVar(base::StringPiece variable,
+                            ProxyServer* result_server);
     // Fills proxy config from environment variables. Returns true if
     // variables were found and the configuration is valid.
     bool GetConfigFromEnv(ProxyConfig* config);
 
     // Obtains host and port config settings and parses a proxy server
     // specification from it and puts it in result. Returns true if the
     // requested variable is defined and the value valid.
     bool GetProxyFromSettings(SettingGetter::StringSetting host_key,
                               ProxyServer* result_server);
     // Fills proxy config from settings. Returns true if settings were found
@@ skipping 36 matching lines @@
 
     base::ObserverList<Observer> observers_;
 
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
   // Thin wrapper shell around Delegate.
 
   // Usual constructor
   ProxyConfigServiceLinux();
+
   // For testing: take alternate setting and env var getter implementations.
-  explicit ProxyConfigServiceLinux(base::Environment* env_var_getter);
-  ProxyConfigServiceLinux(base::Environment* env_var_getter,
+  explicit ProxyConfigServiceLinux(
+      std::unique_ptr<base::Environment> env_var_getter);
+  ProxyConfigServiceLinux(std::unique_ptr<base::Environment> env_var_getter,
                           SettingGetter* setting_getter);
 
   ~ProxyConfigServiceLinux() override;
 
   void 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) {
     delegate_->SetUpAndFetchInitialConfig(glib_task_runner,
                                           io_task_runner,
@@ skipping 12 matching lines @@
 
  private:
   scoped_refptr<Delegate> delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyConfigServiceLinux);
 };
 
 }  // namespace net
 
 #endif  // NET_PROXY_PROXY_CONFIG_SERVICE_LINUX_H_