Move ProxyConfigService construction onto the IO thread.

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>
 #include <fcntl.h>
 #if defined(USE_GCONF)
 #include <gconf/gconf-client.h>
@@ skipping 189 matching lines @@
 // This setting getter uses gconf, as used in GNOME 2 and some GNOME 3 desktops.
 class SettingGetterImplGConf : public ProxyConfigServiceLinux::SettingGetter {
  public:
   SettingGetterImplGConf()
       : client_(NULL), system_proxy_id_(0), system_http_proxy_id_(0),
         notify_delegate_(NULL) {
   }
 
   virtual ~SettingGetterImplGConf() {
     // 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.
+    // Delegate::OnDestroy(), while running on the UI thread.
     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) << "~SettingGetterImplGConf: releasing gconf client";
         ShutDown();
       } else {
         // This is very bad! We are deleting the setting getter but we're not on
@@ skipping 54 matching lines @@
       // 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);
       g_object_unref(client_);
       client_ = NULL;
       task_runner_ = NULL;
     }
+    debounce_timer_.reset();
   }
 
   virtual bool SetUpNotifications(
       ProxyConfigServiceLinux::Delegate* delegate) OVERRIDE {
     DCHECK(client_);
     DCHECK(task_runner_->BelongsToCurrentThread());
     GError* error = NULL;
     notify_delegate_ = delegate;
+    debounce_timer_.reset(new base::OneShotTimer<SettingGetterImplGConf>());
     // 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_http_proxy_id_ = gconf_client_notify_add(
           client_, "/system/http_proxy",
@@ skipping 161 matching lines @@
   void OnDebouncedNotification() {
     DCHECK(task_runner_->BelongsToCurrentThread());
     CHECK(notify_delegate_);
     // Forward to a method on the proxy config service delegate object.
     notify_delegate_->OnCheckProxyConfigSettings();
   }
 
   void OnChangeNotification() {
     // We don't use Reset() because the timer may not yet be running.
     // (In that case Stop() is a no-op.)
-    debounce_timer_.Stop();
-    debounce_timer_.Start(FROM_HERE,
+    debounce_timer_->Stop();
+    debounce_timer_->Start(FROM_HERE,
         base::TimeDelta::FromMilliseconds(kDebounceTimeoutMilliseconds),
         this, &SettingGetterImplGConf::OnDebouncedNotification);
   }
 
   // gconf notification callback, dispatched on the default glib main loop.
   static void OnGConfChangeNotification(GConfClient* client, guint cnxn_id,
                                         GConfEntry* entry, gpointer user_data) {
     VLOG(1) << "gconf change notification for key "
             << gconf_entry_get_key(entry);
     // We don't track which key has changed, just that something did change.
     SettingGetterImplGConf* setting_getter =
         reinterpret_cast<SettingGetterImplGConf*>(user_data);
     setting_getter->OnChangeNotification();
   }
 
   GConfClient* client_;
   // These ids are the values returned from gconf_client_notify_add(), which we
   // will need in order to later call gconf_client_notify_remove().
   guint system_proxy_id_;
   guint system_http_proxy_id_;
 
   ProxyConfigServiceLinux::Delegate* notify_delegate_;
-  base::OneShotTimer<SettingGetterImplGConf> debounce_timer_;
+  scoped_ptr<base::OneShotTimer<SettingGetterImplGConf> > debounce_timer_;
 
   // Task runner for the thread that we make gconf calls on. It should
   // be the UI thread and all our methods should be called on this
   // thread. Only for assertions.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(SettingGetterImplGConf);
 };
 #endif  // defined(USE_GCONF)
 
@@ skipping 16 matching lines @@
     client_(NULL),
     http_client_(NULL),
     https_client_(NULL),
     ftp_client_(NULL),
     socks_client_(NULL),
     notify_delegate_(NULL) {
   }
 
   virtual ~SettingGetterImplGSettings() {
     // 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.
+    // Delegate::OnDestroy(), while running on the UI thread.
     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";
@@ skipping 50 matching lines @@
       // 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;
     }
+    debounce_timer_.reset();
   }
 
   virtual bool SetUpNotifications(
       ProxyConfigServiceLinux::Delegate* delegate) OVERRIDE {
     DCHECK(client_);
     DCHECK(task_runner_->BelongsToCurrentThread());
     notify_delegate_ = delegate;
+    debounce_timer_.reset(
+        new base::OneShotTimer<SettingGetterImplGSettings>());
     // We could watch for the change-event signal instead of changed, but
     // since we have to watch more than one object, we'd still have to
     // debounce change notifications. This is conceptually simpler.
     g_signal_connect(G_OBJECT(client_), "changed",
                      G_CALLBACK(OnGSettingsChangeNotification), this);
     g_signal_connect(G_OBJECT(http_client_), "changed",
                      G_CALLBACK(OnGSettingsChangeNotification), this);
     g_signal_connect(G_OBJECT(https_client_), "changed",
                      G_CALLBACK(OnGSettingsChangeNotification), this);
     g_signal_connect(G_OBJECT(ftp_client_), "changed",
@@ skipping 152 matching lines @@
   void OnDebouncedNotification() {
     DCHECK(task_runner_->BelongsToCurrentThread());
     CHECK(notify_delegate_);
     // Forward to a method on the proxy config service delegate object.
     notify_delegate_->OnCheckProxyConfigSettings();
   }
 
   void OnChangeNotification() {
     // We don't use Reset() because the timer may not yet be running.
     // (In that case Stop() is a no-op.)
-    debounce_timer_.Stop();
-    debounce_timer_.Start(FROM_HERE,
+    debounce_timer_->Stop();
+    debounce_timer_->Start(FROM_HERE,
         base::TimeDelta::FromMilliseconds(kDebounceTimeoutMilliseconds),
         this, &SettingGetterImplGSettings::OnDebouncedNotification);
   }
 
   // gsettings notification callback, dispatched on the default glib main loop.
   static void OnGSettingsChangeNotification(GSettings* client, gchar* key,
                                             gpointer user_data) {
     VLOG(1) << "gsettings change notification for key " << key;
     // We don't track which key has changed, just that something did change.
     SettingGetterImplGSettings* setting_getter =
         reinterpret_cast<SettingGetterImplGSettings*>(user_data);
     setting_getter->OnChangeNotification();
   }
 
   GSettings* client_;
   GSettings* http_client_;
   GSettings* https_client_;
   GSettings* ftp_client_;
   GSettings* socks_client_;
   ProxyConfigServiceLinux::Delegate* notify_delegate_;
-  base::OneShotTimer<SettingGetterImplGSettings> debounce_timer_;
+  scoped_ptr<base::OneShotTimer<SettingGetterImplGSettings> > debounce_timer_;
 
   // Task runner for the thread that we make gsettings calls on. It should
   // be the UI thread and all our methods should be called on this
   // thread. Only for assertions.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(SettingGetterImplGSettings);
 };
 
 bool SettingGetterImplGSettings::LoadAndCheckVersion(
@@ skipping 137 matching lines @@
           kde_config_dir_ = KDEHomeToConfigPath(kde4_path);
         } else {
           kde_config_dir_ = KDEHomeToConfigPath(kde3_path);
         }
       }
     }
   }
 
   virtual ~SettingGetterImplKDE() {
     // 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.)
+    // Delegate::OnDestroy(), while running on the file thread.
     if (inotify_fd_ >= 0)
       ShutDown();
     DCHECK(inotify_fd_ < 0);
   }
 
   virtual bool Init(base::SingleThreadTaskRunner* glib_thread_task_runner,
                     MessageLoopForIO* file_loop) OVERRIDE {
     // This has to be called on the UI thread (http://crbug.com/69057).
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     DCHECK(inotify_fd_ < 0);
@@ skipping 16 matching lines @@
     return true;
   }
 
   virtual void ShutDown() OVERRIDE {
     if (inotify_fd_ >= 0) {
       ResetCachedSettings();
       inotify_watcher_.StopWatchingFileDescriptor();
       close(inotify_fd_);
       inotify_fd_ = -1;
     }
+    debounce_timer_.reset();
   }
 
   virtual bool SetUpNotifications(
       ProxyConfigServiceLinux::Delegate* delegate) OVERRIDE {
     DCHECK(inotify_fd_ >= 0);
     DCHECK(MessageLoop::current() == file_loop_);
+    debounce_timer_.reset(new base::OneShotTimer<SettingGetterImplKDE>());
     // 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;
     notify_delegate_ = delegate;
     if (!file_loop_->WatchFileDescriptor(inotify_fd_, true,
@@ skipping 325 matching lines @@
         // would be forever ready to read. Close it and stop watching instead.
         LOG(ERROR) << "inotify failure; no longer watching kioslaverc!";
         inotify_watcher_.StopWatchingFileDescriptor();
         close(inotify_fd_);
         inotify_fd_ = -1;
       }
     }
     if (kioslaverc_touched) {
       // We don't use Reset() because the timer may not yet be running.
       // (In that case Stop() is a no-op.)
-      debounce_timer_.Stop();
-      debounce_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(
+      debounce_timer_->Stop();
+      debounce_timer_->Start(FROM_HERE, base::TimeDelta::FromMilliseconds(
           kDebounceTimeoutMilliseconds), this,
           &SettingGetterImplKDE::OnDebouncedNotification);
     }
   }
 
   typedef std::map<StringSetting, std::string> string_map_type;
   typedef std::map<StringListSetting,
                    std::vector<std::string> > strings_map_type;
 
   int inotify_fd_;
   base::MessagePumpLibevent::FileDescriptorWatcher inotify_watcher_;
   ProxyConfigServiceLinux::Delegate* notify_delegate_;
-  base::OneShotTimer<SettingGetterImplKDE> debounce_timer_;
+  scoped_ptr<base::OneShotTimer<SettingGetterImplKDE> > 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::Environment* env_var_getter_;
 
   // We cache these settings whenever we re-read the kioslaverc file.
@@ skipping 207 matching lines @@
       setting_getter_.reset(new SettingGetterImplKDE(env_var_getter));
       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) {
+    : env_var_getter_(env_var_getter), setting_getter_(setting_getter),
+      finished_initialization_(false) {
 }
 
 void ProxyConfigServiceLinux::Delegate::SetUpAndFetchInitialConfig(
     base::SingleThreadTaskRunner* glib_thread_task_runner,
     base::SingleThreadTaskRunner* io_thread_task_runner,
     MessageLoopForIO* file_loop) {
+  DCHECK(io_thread_task_runner->BelongsToCurrentThread());
+
+  glib_thread_task_runner_ = glib_thread_task_runner;
+  io_thread_task_runner_ = io_thread_task_runner;
+
+  glib_thread_task_runner->PostTask(FROM_HERE, base::Bind(
+      &Delegate::SetUpAndFetchInitialConfigOnUIThread,
+      this,
+      file_loop));
+}
+
+void ProxyConfigServiceLinux::Delegate::SetUpAndFetchInitialConfigOnUIThread(
+    MessageLoopForIO* file_loop) {
   // We should be running on the default glib main loop thread right
   // now. gconf can only be accessed from this thread.
-  DCHECK(glib_thread_task_runner->BelongsToCurrentThread());
-  glib_thread_task_runner_ = glib_thread_task_runner;
-  io_thread_task_runner_ = io_thread_task_runner;
+  DCHECK(glib_thread_task_runner_->BelongsToCurrentThread());
 
   // If we are passed a NULL |io_thread_task_runner| or |file_loop|,
   // then we don't set up proxy setting change notifications. This
   // should not be the usual case but is intended to simplify test
   // setups.
   if (!io_thread_task_runner_ || !file_loop)
     VLOG(1) << "Monitoring of proxy setting changes is disabled";
 
   // Fetch and cache the current proxy config. The config is left in
   // cached_config_, where GetLatestProxyConfig() running on the IO thread
   // will expect to find it. This is safe to do because we return
   // 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() &&
-      setting_getter_->Init(glib_thread_task_runner, file_loop) &&
-      GetConfigFromSettings(&cached_config_)) {
-    cached_config_.set_id(1);  // Mark it as valid.
-    cached_config_.set_source(setting_getter_->GetConfigSource());
+      setting_getter_->Init(glib_thread_task_runner_, file_loop) &&
+      GetConfigFromSettings(&reference_config_)) {
+    reference_config_.set_id(1);  // Mark it as valid.
+    reference_config_.set_source(setting_getter_->GetConfigSource());
     VLOG(1) << "Obtained proxy settings from "
-            << ProxyConfigSourceToString(cached_config_.source());
+            << ProxyConfigSourceToString(reference_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
     // whereever we can find one.
     got_config = true;
 
-    // Keep a copy of the config for use from this thread for
-    // comparison with updated settings when we get notifications.
-    reference_config_ = cached_config_;
-    reference_config_.set_id(1);  // Mark it as valid.
-
     // We only set up notifications if we have IO and file loops available.
     // We do this after getting the initial configuration so that we don't have
     // to worry about cancelling it if the initial fetch above fails. Note that
     // setting up notifications has the side effect of simulating a change, so
     // that we won't lose any updates that may have happened after the initial
     // fetch and before setting up notifications. We'll detect the common case
     // of no changes in OnCheckProxyConfigSettings() (or sooner) and ignore it.
-    if (io_thread_task_runner && file_loop) {
+    if (io_thread_task_runner_ && file_loop) {
       scoped_refptr<base::SingleThreadTaskRunner> required_loop =
           setting_getter_->GetNotificationTaskRunner();
       if (!required_loop || required_loop->BelongsToCurrentThread()) {
         // In this case we are already on an acceptable thread.
         SetUpNotifications();
       } else {
         // Post a task to set up notifications. We don't wait for success.
         required_loop->PostTask(FROM_HERE, base::Bind(
             &ProxyConfigServiceLinux::Delegate::SetUpNotifications, this));
       }
     }
   }
 
   if (!got_config) {
     // We fall back on environment variables.
     //
     // Consulting environment variables doesn't need to be done from the
     // default glib main loop, but it's a tiny enough amount of work.
-    if (GetConfigFromEnv(&cached_config_)) {
-      cached_config_.set_source(PROXY_CONFIG_SOURCE_ENV);
-      cached_config_.set_id(1);  // Mark it as valid.
+    if (GetConfigFromEnv(&reference_config_)) {
+      reference_config_.set_source(PROXY_CONFIG_SOURCE_ENV);
+      reference_config_.set_id(1);  // Mark it as valid.
       VLOG(1) << "Obtained proxy settings from environment variables";
     }
   }
+
+  // Post a task to the IO thread with the new configuration, so it can
+  // update |cached_config_|.
+  io_thread_task_runner_->PostTask(FROM_HERE, base::Bind(
+      &ProxyConfigServiceLinux::Delegate::SetNewProxyConfig,
+      this, reference_config_));
 }
 
 // Depending on the SettingGetter in use, this method will be called
 // on either the UI thread (GConf) or the file thread (KDE).
 void ProxyConfigServiceLinux::Delegate::SetUpNotifications() {
   scoped_refptr<base::SingleThreadTaskRunner> required_loop =
       setting_getter_->GetNotificationTaskRunner();
   DCHECK(!required_loop || required_loop->BelongsToCurrentThread());
   if (!setting_getter_->SetUpNotifications(this))
     LOG(ERROR) << "Unable to set up proxy configuration change notifications";
 }
 
 void ProxyConfigServiceLinux::Delegate::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void ProxyConfigServiceLinux::Delegate::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 ProxyConfigService::ConfigAvailability
     ProxyConfigServiceLinux::Delegate::GetLatestProxyConfig(
         ProxyConfig* config) {
   // This is called from the IO thread.
   DCHECK(!io_thread_task_runner_ ||
          io_thread_task_runner_->BelongsToCurrentThread());
 
+  if (!finished_initialization_)
+    return CONFIG_PENDING;
+
   // Simply return the last proxy configuration that glib_default_loop
   // notified us of.
   if (cached_config_.is_valid()) {
     *config = cached_config_;
   } else {
     *config = ProxyConfig::CreateDirect();
     config->set_source(PROXY_CONFIG_SOURCE_SYSTEM_FAILED);
   }
 
-  // We return CONFIG_VALID to indicate that *config was filled in. It is always
-  // going to be available since we initialized eagerly on the UI thread.
-  // TODO(eroman): do lazy initialization instead, so we no longer need
-  //               to construct ProxyConfigServiceLinux on the UI thread.
-  //               In which case, we may return false here.
+  // We return CONFIG_VALID to indicate that *config was filled in.
   return CONFIG_VALID;
 }
 
 // Depending on the SettingGetter in use, this method will be called
 // on either the UI thread (GConf) or the file thread (KDE).
 void ProxyConfigServiceLinux::Delegate::OnCheckProxyConfigSettings() {
   scoped_refptr<base::SingleThreadTaskRunner> required_loop =
       setting_getter_->GetNotificationTaskRunner();
   DCHECK(!required_loop || required_loop->BelongsToCurrentThread());
   ProxyConfig new_config;
@@ skipping 14 matching lines @@
   } else {
     VLOG(1) << "Detected no-op change to proxy settings. Doing nothing.";
   }
 }
 
 void ProxyConfigServiceLinux::Delegate::SetNewProxyConfig(
     const ProxyConfig& new_config) {
   DCHECK(io_thread_task_runner_->BelongsToCurrentThread());
   VLOG(1) << "Proxy configuration changed";
   cached_config_ = new_config;
+  finished_initialization_ = true;
   FOR_EACH_OBSERVER(
       Observer, observers_,
       OnProxyConfigChanged(new_config, ProxyConfigService::CONFIG_VALID));
 }
 
 void ProxyConfigServiceLinux::Delegate::PostDestroyTask() {
   if (!setting_getter_.get())
     return;
   scoped_refptr<base::SingleThreadTaskRunner> shutdown_loop =
       setting_getter_->GetNotificationTaskRunner();
   if (!shutdown_loop || shutdown_loop->BelongsToCurrentThread()) {
     // Already on the right thread, call directly.
     // This is the case for the unittests.
+    // The browser's UI thread will not execute any more tasks at this point
+    // so its necessary to call directly.
     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 || shutdown_loop->BelongsToCurrentThread());
   setting_getter_->ShutDown();
 }
 
-ProxyConfigServiceLinux::ProxyConfigServiceLinux()
+ProxyConfigServiceLinux::ProxyConfigServiceLinux(
+    base::SingleThreadTaskRunner* glib_thread_task_runner,
+    base::SingleThreadTaskRunner* io_thread_task_runner,
+    MessageLoopForIO* file_loop)
     : delegate_(new Delegate(base::Environment::Create())) {
+  SetupAndFetchInitialConfig(glib_thread_task_runner,
+                             io_thread_task_runner,
+                             file_loop);
 }
 
 ProxyConfigServiceLinux::~ProxyConfigServiceLinux() {
+}
+
+void ProxyConfigServiceLinux::StartTearDown() {
+  // This must be done prior to destruction.  Destruction occurs as the threads
+  // are dying which is too late to post tasks.  Previously this code relied on
+  // ~Delegate() being called when the unexecuted Delegate::OnDestroy() task
+  // was purged from the UI thread's MessageLoop as we shutdown. This didn't
+  // work very well as things like BelongsToCurrentThread() don't operate
+  // properly at this late a stage.
   delegate_->PostDestroyTask();
 }
 
 ProxyConfigServiceLinux::ProxyConfigServiceLinux(
     base::Environment* env_var_getter)
     : delegate_(new Delegate(env_var_getter)) {
 }
 
 ProxyConfigServiceLinux::ProxyConfigServiceLinux(
     base::Environment* env_var_getter, SettingGetter* setting_getter)
     : delegate_(new Delegate(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