Remove the dependence on BrowserThread::FILE for

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_descriptor_watcher_posix.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/nix/xdg_util.h"
+#include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
+#include "base/task_scheduler/post_task.h"
+#include "base/task_scheduler/task_traits.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/timer/timer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_util.h"
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_server.h"
 #include "url/url_canon.h"
 
 #if defined(USE_GIO)
 #include "library_loaders/libgio.h"  // nogncheck
@@ skipping 169 matching lines @@
         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.
-      if (task_runner_->BelongsToCurrentThread()) {
+      if (task_runner_->RunsTasksInCurrentSequence()) {
         // 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
         // the UI thread. This is not supposed to happen: the setting getter is
         // owned by the proxy config service's delegate, which is supposed to be
         // destroyed on the UI thread only. We will get change notifications to
         // a deleted object if we continue here, so fail now.
         LOG(FATAL) << "~SettingGetterImplGConf: deleting on wrong thread!";
       }
     }
     DCHECK(!client_);
   }
 
-  bool Init(const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,
-            const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
+  bool Init(const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner)
       override {
-    DCHECK(glib_task_runner->BelongsToCurrentThread());
+    DCHECK(glib_task_runner->RunsTasksInCurrentSequence());
     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_ = nullptr;
       return false;
@@ skipping 19 matching lines @@
     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());
+      DCHECK(task_runner_->RunsTasksInCurrentSequence());
       // 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", nullptr);
       gconf_client_remove_dir(client_, "/system/proxy", nullptr);
       g_object_unref(client_);
       client_ = nullptr;
       task_runner_ = nullptr;
     }
     debounce_timer_.reset();
   }
 
   bool SetUpNotifications(
       ProxyConfigServiceLinux::Delegate* delegate) override {
     DCHECK(client_);
-    DCHECK(task_runner_->BelongsToCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     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,
                                                nullptr, &error);
     if (!error) {
       system_http_proxy_id_ = gconf_client_notify_add(
           client_, "/system/http_proxy", OnGConfChangeNotification, this,
           nullptr, &error);
     }
     if (!error) {
       // 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()
+  const scoped_refptr<base::SequencedTaskRunner>& GetNotificationTaskRunner()
       override {
     return task_runner_;
   }
 
   ProxyConfigSource GetConfigSource() override {
     return PROXY_CONFIG_SOURCE_GCONF;
   }
 
   bool GetString(StringSetting key, std::string* result) override {
     switch (key) {
@@ skipping 48 matching lines @@
   bool BypassListIsReversed() override {
     // This is a KDE-specific setting.
     return false;
   }
 
   bool MatchHostsUsingSuffixMatching() override { return false; }
 
  private:
   bool GetStringByPath(base::StringPiece key, std::string* result) {
     DCHECK(client_);
-    DCHECK(task_runner_->BelongsToCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     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(base::StringPiece key, bool* result) {
     DCHECK(client_);
-    DCHECK(task_runner_->BelongsToCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     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.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(base::StringPiece key, int* result) {
     DCHECK(client_);
-    DCHECK(task_runner_->BelongsToCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     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(base::StringPiece key,
                            std::vector<std::string>* result) {
     DCHECK(client_);
-    DCHECK(task_runner_->BelongsToCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     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, 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());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     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,
@@ skipping 17 matching lines @@
   // will need in order to later call gconf_client_notify_remove().
   guint system_proxy_id_;
   guint system_http_proxy_id_;
 
   ProxyConfigServiceLinux::Delegate* notify_delegate_;
   std::unique_ptr<base::OneShotTimer> 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_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(SettingGetterImplGConf);
 };
 #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
@@ skipping 10 matching lines @@
 
   ~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()) {
+      if (task_runner_->RunsTasksInCurrentSequence()) {
         // 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_ = nullptr;
       }
     }
     DCHECK(!client_);
   }
 
   bool SchemaExists(base::StringPiece schema_name) {
     const gchar* const* schemas = libgio_loader_.g_settings_list_schemas();
     while (*schemas) {
       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,
-            const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
+  bool Init(const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner)
       override {
-    DCHECK(glib_task_runner->BelongsToCurrentThread());
+    DCHECK(glib_task_runner->RunsTasksInCurrentSequence());
     DCHECK(!client_);
     DCHECK(!task_runner_.get());
 
     if (!SchemaExists(kProxyGConfSchema) ||
         !(client_ = libgio_loader_.g_settings_new(kProxyGConfSchema))) {
       // It's not clear whether/when this can return NULL.
       LOG(ERROR) << "Unable to create a gsettings client";
       return false;
     }
     task_runner_ = glib_task_runner;
     // We assume these all work if the above call worked.
     http_client_ = libgio_loader_.g_settings_get_child(client_, "http");
     https_client_ = libgio_loader_.g_settings_get_child(client_, "https");
     ftp_client_ = libgio_loader_.g_settings_get_child(client_, "ftp");
     socks_client_ = libgio_loader_.g_settings_get_child(client_, "socks");
     DCHECK(http_client_ && https_client_ && ftp_client_ && socks_client_);
     return true;
   }
 
   void ShutDown() override {
     if (client_) {
-      DCHECK(task_runner_->BelongsToCurrentThread());
+      DCHECK(task_runner_->RunsTasksInCurrentSequence());
       // 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_ = nullptr;
       task_runner_ = nullptr;
     }
     debounce_timer_.reset();
   }
 
   bool SetUpNotifications(
       ProxyConfigServiceLinux::Delegate* delegate) override {
     DCHECK(client_);
-    DCHECK(task_runner_->BelongsToCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     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.
     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",
                      G_CALLBACK(OnGSettingsChangeNotification), this);
     g_signal_connect(G_OBJECT(socks_client_), "changed",
                      G_CALLBACK(OnGSettingsChangeNotification), this);
     // Simulate a change to avoid possibly losing updates before this point.
     OnChangeNotification();
     return true;
   }
 
-  const scoped_refptr<base::SingleThreadTaskRunner>& GetNotificationTaskRunner()
+  const scoped_refptr<base::SequencedTaskRunner>& GetNotificationTaskRunner()
       override {
     return task_runner_;
   }
 
   ProxyConfigSource GetConfigSource() override {
     return PROXY_CONFIG_SOURCE_GSETTINGS;
   }
 
   bool GetString(StringSetting key, std::string* result) override {
     DCHECK(client_);
@@ skipping 59 matching lines @@
     // This is a KDE-specific setting.
     return false;
   }
 
   bool MatchHostsUsingSuffixMatching() override { return false; }
 
  private:
   bool GetStringByPath(GSettings* client,
                        base::StringPiece key,
                        std::string* result) {
-    DCHECK(task_runner_->BelongsToCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     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, base::StringPiece key, bool* result) {
-    DCHECK(task_runner_->BelongsToCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     *result = static_cast<bool>(
         libgio_loader_.g_settings_get_boolean(client, key.data()));
     return true;
   }
   bool GetIntByPath(GSettings* client, base::StringPiece key, int* result) {
-    DCHECK(task_runner_->BelongsToCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     *result = libgio_loader_.g_settings_get_int(client, key.data());
     return true;
   }
   bool GetStringListByPath(GSettings* client,
                            base::StringPiece key,
                            std::vector<std::string>* result) {
-    DCHECK(task_runner_->BelongsToCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     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;
   }
 
   // This is the callback from the debounce timer.
   void OnDebouncedNotification() {
-    DCHECK(task_runner_->BelongsToCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     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,
@@ skipping 15 matching lines @@
   GSettings* http_client_;
   GSettings* https_client_;
   GSettings* ftp_client_;
   GSettings* socks_client_;
   ProxyConfigServiceLinux::Delegate* notify_delegate_;
   std::unique_ptr<base::OneShotTimer> 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_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   LibGioLoader libgio_loader_;
 
   DISALLOW_COPY_AND_ASSIGN(SettingGetterImplGSettings);
 };
 
 bool SettingGetterImplGSettings::LoadAndCheckVersion(
     base::Environment* env) {
   // LoadAndCheckVersion() must be called *before* Init()!
   DCHECK(!client_);
@@ skipping 136 matching lines @@
     // 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_LT(inotify_fd_, 0);
   }
 
-  bool Init(const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,
-            const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
+  bool Init(const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner)
       override {
     // This has to be called on the UI thread (http://crbug.com/69057).
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     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;
     }
-    file_task_runner_ = file_task_runner;
+
+    constexpr base::TaskTraits kTraits = {base::TaskPriority::USER_VISIBLE,
+                                          base::MayBlock()};
+    file_task_runner_ = base::CreateSequencedTaskRunnerWithTraits(kTraits);
+
     // The initial read is done on the current thread, not
     // |file_task_runner_|, since we will need to have it for
     // SetUpAndFetchInitialConfig().
     UpdateCachedSettings();
     return true;
   }
 
   void ShutDown() override {
     if (inotify_fd_ >= 0) {
       ResetCachedSettings();
       inotify_watcher_.reset();
       close(inotify_fd_);
       inotify_fd_ = -1;
     }
     debounce_timer_.reset();
   }
 
   bool SetUpNotifications(
       ProxyConfigServiceLinux::Delegate* delegate) override {
     DCHECK_GE(inotify_fd_, 0);
-    DCHECK(file_task_runner_->BelongsToCurrentThread());
+    DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
     // 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.
     // TODO(eroman): What if the file is deleted? (handle with IN_DELETE).
     if (inotify_add_watch(inotify_fd_, kde_config_dir_.value().c_str(),
                           IN_MODIFY | IN_MOVED_TO) < 0) {
       return false;
     }
     notify_delegate_ = delegate;
     inotify_watcher_ = base::FileDescriptorWatcher::WatchReadable(
         inotify_fd_, base::Bind(&SettingGetterImplKDE::OnChangeNotification,
                                 base::Unretained(this)));
     // Simulate a change to avoid possibly losing updates before this point.
     OnChangeNotification();
     return true;
   }
 
-  const scoped_refptr<base::SingleThreadTaskRunner>& GetNotificationTaskRunner()
+  const scoped_refptr<base::SequencedTaskRunner>& GetNotificationTaskRunner()
       override {
     return file_task_runner_;
   }
 
   ProxyConfigSource GetConfigSource() override {
     return PROXY_CONFIG_SOURCE_KDE;
   }
 
   bool GetString(StringSetting key, std::string* result) override {
     string_map_type::iterator it = string_table_.find(key);
@@ skipping 239 matching lines @@
         AddKDESetting(key, value);
       }
     }
     if (ferror(input.get()))
       LOG(ERROR) << "error reading " << kioslaverc.value();
     ResolveModeEffects();
   }
 
   // This is the callback from the debounce timer.
   void OnDebouncedNotification() {
-    DCHECK(file_task_runner_->BelongsToCurrentThread());
+    DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
     VLOG(1) << "inotify change notification for kioslaverc";
     UpdateCachedSettings();
     CHECK(notify_delegate_);
     // Forward to a method on the proxy config service delegate object.
     notify_delegate_->OnCheckProxyConfigSettings();
   }
 
   // Called by OnFileCanReadWithoutBlocking() on the file thread. Reads
   // from the inotify file descriptor and starts up a debounce timer if
   // an event for kioslaverc is seen.
   void OnChangeNotification() {
     DCHECK_GE(inotify_fd_,  0);
-    DCHECK(file_task_runner_->BelongsToCurrentThread());
+    DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
     char event_buf[(sizeof(inotify_event) + NAME_MAX + 1) * 4];
     bool kioslaverc_touched = false;
     ssize_t r;
     while ((r = read(inotify_fd_, event_buf, sizeof(event_buf))) > 0) {
       // inotify returns variable-length structures, which is why we have
       // this strange-looking loop instead of iterating through an array.
       char* event_ptr = event_buf;
       while (event_ptr < event_buf + r) {
         inotify_event* event = reinterpret_cast<inotify_event*>(event_ptr);
         // The kernel always feeds us whole events.
@@ skipping 50 matching lines @@
   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.
   string_map_type string_table_;
   strings_map_type strings_table_;
 
-  // Task runner of the file thread, for reading kioslaverc. If NULL,
-  // just read it directly (for testing). We also handle inotify events
-  // on this thread.
-  scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
+  // Task runner for doing blocking file IO on, as well as handling inotify
+  // events on.
+  scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(SettingGetterImplKDE);
 };
 
 }  // namespace
 
 bool ProxyConfigServiceLinux::Delegate::GetProxyFromSettings(
     SettingGetter::StringSetting host_key,
     ProxyServer* result_server) {
   std::string host;
@@ skipping 200 matching lines @@
 }
 
 ProxyConfigServiceLinux::Delegate::Delegate(
     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) {
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_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());
+  DCHECK(glib_task_runner->RunsTasksInCurrentSequence());
   glib_task_runner_ = glib_task_runner;
   io_task_runner_ = io_task_runner;
 
-  // If we are passed a NULL |io_task_runner| or |file_task_runner|, 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_task_runner_.get() || !file_task_runner.get())
+  // If we are passed a NULL |io_task_runner|, then don't set up proxy
+  // setting change notifications. This should not be the usual case but is
+  // intended to/ simplify test setups.
+  if (!io_task_runner_.get())
     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_ &&
-      setting_getter_->Init(glib_task_runner, file_task_runner) &&
+  if (setting_getter_ && setting_getter_->Init(glib_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
     // 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_task_runner.get() && file_task_runner.get()) {
-      scoped_refptr<base::SingleThreadTaskRunner> required_loop =
+    if (io_task_runner.get()) {
+      scoped_refptr<base::SequencedTaskRunner> required_loop =
           setting_getter_->GetNotificationTaskRunner();
-      if (!required_loop.get() || required_loop->BelongsToCurrentThread()) {
+      if (!required_loop.get() || required_loop->RunsTasksInCurrentSequence()) {
         // 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.
       VLOG(1) << "Obtained proxy settings from environment variables";
     }
   }
 }
 
 // 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 =
+  scoped_refptr<base::SequencedTaskRunner> required_loop =
       setting_getter_->GetNotificationTaskRunner();
-  DCHECK(!required_loop.get() || required_loop->BelongsToCurrentThread());
+  DCHECK(!required_loop.get() || required_loop->RunsTasksInCurrentSequence());
   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_task_runner_.get() ||
-         io_task_runner_->BelongsToCurrentThread());
+         io_task_runner_->RunsTasksInCurrentSequence());
 
   // 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.
   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 =
+  scoped_refptr<base::SequencedTaskRunner> required_loop =
       setting_getter_->GetNotificationTaskRunner();
-  DCHECK(!required_loop.get() || required_loop->BelongsToCurrentThread());
+  DCHECK(!required_loop.get() || required_loop->RunsTasksInCurrentSequence());
   ProxyConfig new_config;
   bool valid = GetConfigFromSettings(&new_config);
   if (valid)
     new_config.set_id(1);  // mark it as valid
 
   // See if it is different from what we had before.
   if (new_config.is_valid() != reference_config_.is_valid() ||
       !new_config.Equals(reference_config_)) {
     // Post a task to the IO thread with the new configuration, so it can
     // update |cached_config_|.
     io_task_runner_->PostTask(FROM_HERE, base::Bind(
         &ProxyConfigServiceLinux::Delegate::SetNewProxyConfig,
         this, new_config));
     // Update the thread-private copy in |reference_config_| as well.
     reference_config_ = new_config;
   } else {
     VLOG(1) << "Detected no-op change to proxy settings. Doing nothing.";
   }
 }
 
 void ProxyConfigServiceLinux::Delegate::SetNewProxyConfig(
     const ProxyConfig& new_config) {
-  DCHECK(io_task_runner_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   VLOG(1) << "Proxy configuration changed";
   cached_config_ = new_config;
   for (auto& observer : observers_)
     observer.OnProxyConfigChanged(new_config, ProxyConfigService::CONFIG_VALID);
 }
 
 void ProxyConfigServiceLinux::Delegate::PostDestroyTask() {
   if (!setting_getter_)
     return;
 
-  scoped_refptr<base::SingleThreadTaskRunner> shutdown_loop =
+  scoped_refptr<base::SequencedTaskRunner> shutdown_loop =
       setting_getter_->GetNotificationTaskRunner();
-  if (!shutdown_loop.get() || shutdown_loop->BelongsToCurrentThread()) {
+  if (!shutdown_loop.get() || shutdown_loop->RunsTasksInCurrentSequence()) {
     // 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 =
+  scoped_refptr<base::SequencedTaskRunner> shutdown_loop =
       setting_getter_->GetNotificationTaskRunner();
-  DCHECK(!shutdown_loop.get() || shutdown_loop->BelongsToCurrentThread());
+  DCHECK(!shutdown_loop.get() || shutdown_loop->RunsTasksInCurrentSequence());
   setting_getter_->ShutDown();
 }
 
 ProxyConfigServiceLinux::ProxyConfigServiceLinux()
     : delegate_(new Delegate(base::Environment::Create())) {
 }
 
 ProxyConfigServiceLinux::~ProxyConfigServiceLinux() {
   delegate_->PostDestroyTask();
 }
@@ skipping 14 matching lines @@
 void ProxyConfigServiceLinux::RemoveObserver(Observer* observer) {
   delegate_->RemoveObserver(observer);
 }
 
 ProxyConfigService::ConfigAvailability
     ProxyConfigServiceLinux::GetLatestProxyConfig(ProxyConfig* config) {
   return delegate_->GetLatestProxyConfig(config);
 }
 
 }  // namespace net