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 267 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;
     // 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
@@ skipping 167 matching lines @@
 
   // 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();
   }
 
   void OnChangeNotification() {
+    if (!debounce_timer_.get())
+      debounce_timer_.reset(new base::OneShotTimer<SettingGetterImplGConf>());
     // 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 91 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;
     // 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.
@@ skipping 157 matching lines @@
 
   // 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();
   }
 
   void OnChangeNotification() {
+    if (!debounce_timer_.get())
+      debounce_timer_.reset(
+          new base::OneShotTimer<SettingGetterImplGSettings>());
     // 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 179 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_);
     // 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
@@ skipping 331 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(
+      if (!debounce_timer_.get())
+        debounce_timer_.reset(new base::OneShotTimer<SettingGetterImplKDE>());
+      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.
     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() {
   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