Use scoped_refptr<SingleThreadTaskRunner> when initializing ProxyConfigService

net/proxy/proxy_config_service_linux_unittest.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 <map>
 #include <string>
 #include <vector>
 
@@ skipping 157 matching lines @@
         &values.ignore_hosts;
     Reset();
   }
 
   // Zeros all environment values.
   void Reset() {
     GConfValues zero_values = { 0 };
     values = zero_values;
   }
 
-  virtual bool Init(base::SingleThreadTaskRunner* glib_thread_task_runner,
-                    base::MessageLoopForIO* file_loop) OVERRIDE {
+  virtual bool Init(
+      const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,
+      const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
+      OVERRIDE {
+    task_runner_ = glib_task_runner;
     return true;
   }
 
   virtual void ShutDown() OVERRIDE {}
 
   virtual bool SetUpNotifications(ProxyConfigServiceLinux::Delegate* delegate)
       OVERRIDE {
     return true;
   }
 
-  virtual base::SingleThreadTaskRunner* GetNotificationTaskRunner() OVERRIDE {
-    return NULL;
+  virtual const scoped_refptr<base::SingleThreadTaskRunner>&
+  GetNotificationTaskRunner() OVERRIDE {
+    return task_runner_;
   }
 
   virtual ProxyConfigSource GetConfigSource() OVERRIDE {
     return PROXY_CONFIG_SOURCE_TEST;
   }
 
   virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
     const char* value = strings_table.Get(key);
     if (value) {
       *result = value;
@@ skipping 34 matching lines @@
   }
 
   virtual bool MatchHostsUsingSuffixMatching() OVERRIDE {
     return false;
   }
 
   // Intentionally public, for convenience when setting up a test.
   GConfValues values;
 
  private:
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   SettingsTable<StringSetting, const char*> strings_table;
   SettingsTable<BoolSetting, BoolSettingValue> bools_table;
   SettingsTable<IntSetting, int> ints_table;
   SettingsTable<StringListSetting,
                 std::vector<std::string> > string_lists_table;
 };
 
 }  // namespace
 }  // namespace net
 
@@ skipping 25 matching lines @@
     // Clean up the IO thread.
     io_thread_.message_loop()->PostTask(FROM_HERE,
         base::Bind(&SynchConfigGetter::CleanUp, base::Unretained(this)));
     Wait();
   }
 
   // Does gconf setup and initial fetch of the proxy config,
   // all on the calling thread (meant to be the thread with the
   // default glib main loop, which is the UI thread).
   void SetupAndInitialFetch() {
-    base::MessageLoop* file_loop = io_thread_.message_loop();
-    DCHECK_EQ(base::MessageLoop::TYPE_IO, file_loop->type());
     // We pass the mock IO thread as both the IO and file threads.
     config_service_->SetupAndFetchInitialConfig(
-        base::MessageLoopProxy::current().get(),
-        io_thread_.message_loop_proxy().get(),
-        static_cast<base::MessageLoopForIO*>(file_loop));
+        base::MessageLoopProxy::current(),
+        io_thread_.message_loop_proxy(),
+        io_thread_.message_loop_proxy());
   }
   // Synchronously gets the proxy config.
   net::ProxyConfigService::ConfigAvailability SyncGetLatestProxyConfig(
       net::ProxyConfig* config) {
     io_thread_.message_loop()->PostTask(FROM_HERE,
         base::Bind(&SynchConfigGetter::GetLatestConfigOnIOThread,
                    base::Unretained(this)));
     Wait();
     *config = proxy_config_;
     return get_latest_config_result_;
@@ skipping 1300 matching lines @@
     ProxyConfig config;
     sync_config_getter.SetupAndInitialFetch();
     EXPECT_EQ(ProxyConfigService::CONFIG_VALID,
               sync_config_getter.SyncGetLatestProxyConfig(&config));
     EXPECT_TRUE(config.auto_detect());
     EXPECT_EQ(GURL(), config.pac_url());
   }
 }
 
 }  // namespace net