Move ProxyConfigService construction onto the IO thread.

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 244 matching lines @@
 
 // This helper class runs ProxyConfigServiceLinux::GetLatestProxyConfig() on
 // the IO thread and synchronously waits for the result.
 // Some code duplicated from proxy_script_fetcher_unittest.cc.
 class SynchConfigGetter {
  public:
   // Takes ownership of |config_service|.
   explicit SynchConfigGetter(net::ProxyConfigServiceLinux* config_service)
       : event_(false, false),
         io_thread_("IO_Thread"),
+        glib_task_runner_(base::MessageLoopProxy::current()),
         config_service_(config_service) {
     // Start an IO thread.
     base::Thread::Options options;
     options.message_loop_type = MessageLoop::TYPE_IO;
     io_thread_.StartWithOptions(options);
 
     // Make sure the thread started.
     io_thread_.message_loop()->PostTask(FROM_HERE,
         base::Bind(&SynchConfigGetter::Init, base::Unretained(this)));
     Wait();
   }
 
   ~SynchConfigGetter() {
     // Let the config service post a destroy message to the IO thread
     // before cleaning up that thread.
     delete config_service_;
     // 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).
+  // Does gconf setup and initial fetch of the proxy config.
   void SetupAndInitialFetch() {
-    MessageLoop* file_loop = io_thread_.message_loop();
-    DCHECK_EQ(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(), io_thread_.message_loop_proxy(),
-        static_cast<MessageLoopForIO*>(file_loop));
+    io_thread_.message_loop()->PostTask(FROM_HERE,
+        base::Bind(&SynchConfigGetter::SetupAndInitialFetchOnIOThread,
+                   base::Unretained(this)));
+    Wait();
+    // ProxyConfigServiceLinux will post back to the UI thread, so let it run
+    MessageLoop::current()->RunAllPending();
+    // ProxyConfigServiceLinux will post back to the IO thread, so let it run
+    io_thread_.message_loop()->PostTask(FROM_HERE,
+        base::Bind(&SynchConfigGetter::CleanUp, base::Unretained(this)));
+    Wait();
   }
   // 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_;
   }
 
  private:
   // [Runs on |io_thread_|]
   void Init() {
     event_.Signal();
   }
 
   // Calls GetLatestProxyConfig, running on |io_thread_| Signals |event_|
   // on completion.
   void GetLatestConfigOnIOThread() {
     get_latest_config_result_ =
         config_service_->GetLatestProxyConfig(&proxy_config_);
     event_.Signal();
   }
 
+  void SetupAndInitialFetchOnIOThread() {
+    MessageLoop* file_loop = io_thread_.message_loop();
+    DCHECK_EQ(MessageLoop::TYPE_IO, file_loop->type());
+    DCHECK(io_thread_.message_loop_proxy()->RunsTasksOnCurrentThread());
+    // We pass the mock IO thread as both the IO and file threads.
+    config_service_->SetupAndFetchInitialConfig(
+        glib_task_runner_, io_thread_.message_loop_proxy(),
+        static_cast<MessageLoopForIO*>(file_loop));
+    event_.Signal();
+  }
+
   // [Runs on |io_thread_|] Signals |event_| on cleanup completion.
   void CleanUp() {
     MessageLoop::current()->RunAllPending();
     event_.Signal();
   }
 
   void Wait() {
     event_.Wait();
     event_.Reset();
   }
 
   base::WaitableEvent event_;
   base::Thread io_thread_;
+  base::SingleThreadTaskRunner *glib_task_runner_;
 
   net::ProxyConfigServiceLinux* config_service_;
 
   // The config obtained by |io_thread_| and read back by the main
   // thread.
   net::ProxyConfig proxy_config_;
 
   // Return value from GetLatestProxyConfig().
   net::ProxyConfigService::ConfigAvailability get_latest_config_result_;
 };
@@ skipping 1261 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