Use base::MessageLoopProxy instead of MessageLoop in ProxyConfigServiceLinux.

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 12 matching lines @@
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/environment.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
+#include "base/message_loop_proxy.h"
 #include "base/nix/xdg_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/timer.h"
 #include "googleurl/src/url_canon.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_util.h"
 #include "net/proxy/proxy_config.h"
@@ skipping 162 matching lines @@
   }
 
   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.
     if (client_) {
       // gconf client was not cleaned up.
-      if (MessageLoop::current() == loop_) {
+      if (loop_->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
         // 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_);
   }
 
-  virtual bool Init(MessageLoop* glib_default_loop,
+  virtual bool Init(base::MessageLoopProxy* glib_default_loop,
                     MessageLoopForIO* file_loop) OVERRIDE {
-    DCHECK(MessageLoop::current() == glib_default_loop);
+    DCHECK(glib_default_loop->BelongsToCurrentThread());
     DCHECK(!client_);
     DCHECK(!loop_);
     loop_ = glib_default_loop;
     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";
       loop_ = NULL;
       return false;
     }
@@ skipping 18 matching lines @@
       g_object_unref(client_);
       client_ = NULL;
       loop_ = NULL;
       return false;
     }
     return true;
   }
 
   void ShutDown() {
     if (client_) {
-      DCHECK(MessageLoop::current() == loop_);
+      DCHECK(loop_->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);
       g_object_unref(client_);
       client_ = NULL;
       loop_ = NULL;
     }
   }
 
   bool SetUpNotifications(ProxyConfigServiceLinux::Delegate* delegate) {
     DCHECK(client_);
-    DCHECK(MessageLoop::current() == loop_);
+    DCHECK(loop_->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
     // 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",
           OnGConfChangeNotification, this,
           NULL, &error);
     }
     if (error != NULL) {
       LOG(ERROR) << "Error requesting gconf notifications: " << error->message;
       g_error_free(error);
       ShutDown();
       return false;
     }
     // Simulate a change to avoid possibly losing updates before this point.
     OnChangeNotification();
     return true;
   }
 
-  virtual MessageLoop* GetNotificationLoop() OVERRIDE {
+  virtual base::MessageLoopProxy* GetNotificationLoop() OVERRIDE {
     return loop_;
   }
 
   virtual const char* GetDataSource() OVERRIDE {
     return "gconf";
   }
 
   virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
     switch (key) {
       case PROXY_MODE:
@@ skipping 49 matching lines @@
     return false;
   }
 
   virtual bool MatchHostsUsingSuffixMatching() OVERRIDE {
     return false;
   }
 
  private:
   bool GetStringByPath(const char* key, std::string* result) {
     DCHECK(client_);
-    DCHECK(MessageLoop::current() == loop_);
+    DCHECK(loop_->BelongsToCurrentThread());
     GError* error = NULL;
     gchar* value = gconf_client_get_string(client_, key, &error);
     if (HandleGError(error, key))
       return false;
     if (!value)
       return false;
     *result = value;
     g_free(value);
     return true;
   }
   bool GetBoolByPath(const char* key, bool* result) {
     DCHECK(client_);
-    DCHECK(MessageLoop::current() == loop_);
+    DCHECK(loop_->BelongsToCurrentThread());
     GError* error = NULL;
     // 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))
       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) {
     DCHECK(client_);
-    DCHECK(MessageLoop::current() == loop_);
+    DCHECK(loop_->BelongsToCurrentThread());
     GError* error = NULL;
     int value = gconf_client_get_int(client_, key, &error);
     if (HandleGError(error, key))
       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) {
     DCHECK(client_);
-    DCHECK(MessageLoop::current() == loop_);
+    DCHECK(loop_->BelongsToCurrentThread());
     GError* error = NULL;
     GSList* list = gconf_client_get_list(client_, key,
                                          GCONF_VALUE_STRING, &error);
     if (HandleGError(error, key))
       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;
   }
 
   // This is the callback from the debounce timer.
   void OnDebouncedNotification() {
-    DCHECK(MessageLoop::current() == loop_);
+    DCHECK(loop_->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,
@@ 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_;
   base::OneShotTimer<SettingGetterImplGConf> debounce_timer_;
 
   // Message loop of 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.
-  MessageLoop* loop_;
+  scoped_refptr<base::MessageLoopProxy> loop_;
 
   DISALLOW_COPY_AND_ASSIGN(SettingGetterImplGConf);
 };
 #endif  // defined(USE_GCONF)
 
 #if defined(USE_GIO)
 // This setting getter uses gsettings, as used in most GNOME 3 desktops.
 class SettingGetterImplGSettings
     : public ProxyConfigServiceLinux::SettingGetter {
  public:
@@ skipping 19 matching lines @@
 
   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.
     if (client_) {
       // gconf client was not cleaned up.
-      if (MessageLoop::current() == loop_) {
+      if (loop_->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;
       }
     }
@@ skipping 12 matching lines @@
       if (strcmp(schema_name, static_cast<const char*>(*schemas)) == 0)
         return true;
       schemas++;
     }
     return false;
   }
 
   // LoadAndCheckVersion() must be called *before* Init()!
   bool LoadAndCheckVersion(base::Environment* env);
 
-  virtual bool Init(MessageLoop* glib_default_loop,
+  virtual bool Init(base::MessageLoopProxy* glib_default_loop,
                     MessageLoopForIO* file_loop) OVERRIDE {
-    DCHECK(MessageLoop::current() == glib_default_loop);
+    DCHECK(glib_default_loop->BelongsToCurrentThread());
     DCHECK(!client_);
     DCHECK(!loop_);
 
     if (!SchemaExists("org.gnome.system.proxy") ||
         !(client_ = g_settings_new("org.gnome.system.proxy"))) {
       // It's not clear whether/when this can return NULL.
       LOG(ERROR) << "Unable to create a gsettings client";
       return false;
     }
     loop_ = glib_default_loop;
     // We assume these all work if the above call worked.
     http_client_ = g_settings_get_child(client_, "http");
     https_client_ = g_settings_get_child(client_, "https");
     ftp_client_ = g_settings_get_child(client_, "ftp");
     socks_client_ = g_settings_get_child(client_, "socks");
     DCHECK(http_client_ && https_client_ && ftp_client_ && socks_client_);
     return true;
   }
 
   void ShutDown() {
     if (client_) {
-      DCHECK(MessageLoop::current() == loop_);
+      DCHECK(loop_->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;
       loop_ = NULL;
     }
   }
 
   bool SetUpNotifications(ProxyConfigServiceLinux::Delegate* delegate) {
     DCHECK(client_);
-    DCHECK(MessageLoop::current() == loop_);
+    DCHECK(loop_->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.
     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;
   }
 
-  virtual MessageLoop* GetNotificationLoop() OVERRIDE {
+  virtual base::MessageLoopProxy* GetNotificationLoop() OVERRIDE {
     return loop_;
   }
 
   virtual const char* GetDataSource() OVERRIDE {
     return "gsettings";
   }
 
   virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
     DCHECK(client_);
     switch (key) {
@@ skipping 90 matching lines @@
     if (error) {
       VLOG(1) << "Unable to load symbol " << name << ": " << error;
       return false;
     }
     return true;
   }
 #endif  // defined(DLOPEN_GSETTINGS)
 
   bool GetStringByPath(GSettings* client, const char* key,
                        std::string* result) {
-    DCHECK(MessageLoop::current() == loop_);
+    DCHECK(loop_->BelongsToCurrentThread());
     gchar* value = g_settings_get_string(client, key);
     if (!value)
       return false;
     *result = value;
     g_free(value);
     return true;
   }
   bool GetBoolByPath(GSettings* client, const char* key, bool* result) {
-    DCHECK(MessageLoop::current() == loop_);
+    DCHECK(loop_->BelongsToCurrentThread());
     *result = static_cast<bool>(g_settings_get_boolean(client, key));
     return true;
   }
   bool GetIntByPath(GSettings* client, const char* key, int* result) {
-    DCHECK(MessageLoop::current() == loop_);
+    DCHECK(loop_->BelongsToCurrentThread());
     *result = g_settings_get_int(client, key);
     return true;
   }
   bool GetStringListByPath(GSettings* client, const char* key,
                            std::vector<std::string>* result) {
-    DCHECK(MessageLoop::current() == loop_);
+    DCHECK(loop_->BelongsToCurrentThread());
     gchar** list = g_settings_get_strv(client, key);
     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(MessageLoop::current() == loop_);
+    DCHECK(loop_->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,
@@ skipping 15 matching lines @@
   GSettings* http_client_;
   GSettings* https_client_;
   GSettings* ftp_client_;
   GSettings* socks_client_;
   ProxyConfigServiceLinux::Delegate* notify_delegate_;
   base::OneShotTimer<SettingGetterImplGSettings> debounce_timer_;
 
   // Message loop of 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.
-  MessageLoop* loop_;
+  scoped_refptr<base::MessageLoopProxy> loop_;
 
   DISALLOW_COPY_AND_ASSIGN(SettingGetterImplGSettings);
 };
 
 bool SettingGetterImplGSettings::LoadAndCheckVersion(
     base::Environment* env) {
   // LoadAndCheckVersion() must be called *before* Init()!
   DCHECK(!client_);
 
   // The APIs to query gsettings were introduced after the minimum glib
@@ skipping 143 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(inotify_fd_ < 0);
   }
 
-  virtual bool Init(MessageLoop* glib_default_loop,
+  virtual bool Init(base::MessageLoopProxy* glib_default_loop,
                     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);
     inotify_fd_ = inotify_init();
     if (inotify_fd_ < 0) {
       PLOG(ERROR) << "inotify_init failed";
       return false;
     }
     int flags = fcntl(inotify_fd_, F_GETFL);
@@ skipping 32 matching lines @@
       return false;
     notify_delegate_ = delegate;
     if (!file_loop_->WatchFileDescriptor(inotify_fd_, true,
             MessageLoopForIO::WATCH_READ, &inotify_watcher_, this))
       return false;
     // Simulate a change to avoid possibly losing updates before this point.
     OnChangeNotification();
     return true;
   }
 
-  virtual MessageLoop* GetNotificationLoop() OVERRIDE {
-    return file_loop_;
+  virtual base::MessageLoopProxy* GetNotificationLoop() OVERRIDE {
+    return file_loop_->message_loop_proxy();
   }
 
   // Implement base::MessagePumpLibevent::Watcher.
   void OnFileCanReadWithoutBlocking(int fd) {
     DCHECK_EQ(fd, inotify_fd_);
     DCHECK(MessageLoop::current() == file_loop_);
     OnChangeNotification();
   }
   void OnFileCanWriteWithoutBlocking(int fd) {
     NOTREACHED();
@@ skipping 542 matching lines @@
   }
 }
 
 ProxyConfigServiceLinux::Delegate::Delegate(
     base::Environment* env_var_getter, SettingGetter* setting_getter)
     : env_var_getter_(env_var_getter), setting_getter_(setting_getter),
       glib_default_loop_(NULL), io_loop_(NULL) {
 }
 
 void ProxyConfigServiceLinux::Delegate::SetUpAndFetchInitialConfig(
-    MessageLoop* glib_default_loop, MessageLoop* io_loop,
+    base::MessageLoopProxy* glib_default_loop,
+    base::MessageLoopProxy* io_loop,
     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(MessageLoop::current() == glib_default_loop);
+  DCHECK(glib_default_loop->BelongsToCurrentThread());
   glib_default_loop_ = glib_default_loop;
   io_loop_ = io_loop;
 
   // If we are passed a NULL io_loop 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_loop_ || !file_loop)
     VLOG(1) << "Monitoring of proxy setting changes is disabled";
 
   // Fetch and cache the current proxy config. The config is left in
@@ skipping 28 matching lines @@
     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_loop && file_loop) {
-      MessageLoop* required_loop = setting_getter_->GetNotificationLoop();
-      if (!required_loop || MessageLoop::current() == required_loop) {
+      scoped_refptr<base::MessageLoopProxy> required_loop =
+          setting_getter_->GetNotificationLoop();
+      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_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() {
-  MessageLoop* required_loop = setting_getter_->GetNotificationLoop();
-  DCHECK(!required_loop || MessageLoop::current() == required_loop);
+  scoped_refptr<base::MessageLoopProxy> required_loop =
+      setting_getter_->GetNotificationLoop();
+  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_loop_ || MessageLoop::current() == io_loop_);
+  DCHECK(!io_loop_ || io_loop_->BelongsToCurrentThread());
 
   // Simply return the last proxy configuration that glib_default_loop
   // notified us of.
   *config = cached_config_.is_valid() ?
       cached_config_ : ProxyConfig::CreateDirect();
 
   // 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() {
-  MessageLoop* required_loop = setting_getter_->GetNotificationLoop();
-  DCHECK(!required_loop || MessageLoop::current() == required_loop);
+  scoped_refptr<base::MessageLoopProxy> required_loop =
+      setting_getter_->GetNotificationLoop();
+  DCHECK(!required_loop || required_loop->BelongsToCurrentThread());
   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 |io_loop| with the new configuration, so it can
     // update |cached_config_|.
     io_loop_->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(MessageLoop::current() == io_loop_);
+  DCHECK(io_loop_->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())
     return;
-  MessageLoop* shutdown_loop = setting_getter_->GetNotificationLoop();
-  if (!shutdown_loop || MessageLoop::current() == shutdown_loop) {
+  scoped_refptr<base::MessageLoopProxy> shutdown_loop =
+      setting_getter_->GetNotificationLoop();
+  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() {
-  MessageLoop* shutdown_loop = setting_getter_->GetNotificationLoop();
-  DCHECK(!shutdown_loop || MessageLoop::current() == shutdown_loop);
+  scoped_refptr<base::MessageLoopProxy> shutdown_loop =
+      setting_getter_->GetNotificationLoop();
+  DCHECK(!shutdown_loop || shutdown_loop->BelongsToCurrentThread());
   setting_getter_->ShutDown();
 }
 
 ProxyConfigServiceLinux::ProxyConfigServiceLinux()
     : delegate_(new Delegate(base::Environment::Create())) {
 }
 
 ProxyConfigServiceLinux::~ProxyConfigServiceLinux() {
   delegate_->PostDestroyTask();
 }
@@ skipping 15 matching lines @@
 void ProxyConfigServiceLinux::RemoveObserver(Observer* observer) {
   delegate_->RemoveObserver(observer);
 }
 
 ProxyConfigService::ConfigAvailability
     ProxyConfigServiceLinux::GetLatestProxyConfig(ProxyConfig* config) {
   return delegate_->GetLatestProxyConfig(config);
 }
 
 }  // namespace net