Move ProxyConfigService construction onto the IO thread.

net/tools/get_server_time/get_server_time.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.
 
 // This is a small utility that snarfs the server time from the
 // response headers of an http/https HEAD request and compares it to
 // the local time.
 //
 // TODO(akalin): Also snarf the server time from the TLS handshake, if
 // any (http://crbug.com/146090).
@@ skipping 23 matching lines @@
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_builder.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
+#if defined(OS_LINUX) || defined(OS_OPENBSD)

[digit1, 2012/10/19 10:32:46]

Any reason to include OS_OPENBSD here? It looks like when this macro is defined,
only g_type_init() is called. Apart from that, all the Glibc-specific code is
protected inside mere #ifdef OS_LINUX ... #endif block and don't seem to be
compiled for BSD builds.

+#include <glib-object.h>
+#endif
+
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #elif defined(OS_LINUX)
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #endif
 
 namespace {
 
 // base::TimeTicks::Now() is documented to have a resolution of
@@ skipping 109 matching lines @@
     NOTIMPLEMENTED();
   }
 
  private:
   uint32 next_id_;
 
   DISALLOW_COPY_AND_ASSIGN(PrintingLog);
 };
 
 // Builds a URLRequestContext assuming there's only a single loop.
-scoped_ptr<net::URLRequestContext> BuildURLRequestContext() {
+scoped_ptr<net::URLRequestContext> BuildURLRequestContext(
+    const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner) {
   net::URLRequestContextBuilder builder;
 #if defined(OS_LINUX)
-  // On Linux, use a fixed ProxyConfigService, since the default one
-  // depends on glib.
-  //
-  // TODO(akalin): Remove this once http://crbug.com/146421 is fixed.
-  builder.set_proxy_config_service(
-      new net::ProxyConfigServiceFixed(net::ProxyConfig()));
+  builder.set_glib_task_runner(main_task_runner);
 #endif
   scoped_ptr<net::URLRequestContext> context(builder.Build());
   context->set_net_log(new PrintingLog());
   return context.Pass();
 }
 
 class SingleThreadRequestContextGetter : public net::URLRequestContextGetter {
  public:
   // Since there's only a single thread, there's no need to worry
   // about when |context_| gets created.
   explicit SingleThreadRequestContextGetter(
       const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner)
-      : context_(BuildURLRequestContext()),
+      : context_(BuildURLRequestContext(main_task_runner)),
         main_task_runner_(main_task_runner) {}
 
   virtual net::URLRequestContext* GetURLRequestContext() OVERRIDE {
     return context_.get();
   }
 
   virtual scoped_refptr<base::SingleThreadTaskRunner>
   GetNetworkTaskRunner() const OVERRIDE {
     return main_task_runner_;
   }
@@ skipping 40 matching lines @@
   *skew = server_now - now;
   *skew_uncertainty = server_now_uncertainty + now_uncertainty;
 }
 
 }  // namespace
 
 int main(int argc, char* argv[]) {
 #if defined(OS_MACOSX)
   base::mac::ScopedNSAutoreleasePool pool;
 #endif
+#if defined(OS_LINUX) || defined(OS_OPENBSD)
+  // Needed so ProxyConfigServiceLinux can use gconf.
+  // Normally handled by BrowserMainLoop::InitializeToolkit().
+  g_type_init();
+#endif
 
   base::AtExitManager exit_manager;
   CommandLine::Init(argc, argv);
   logging::InitLogging(
       NULL,
       logging::LOG_ONLY_TO_SYSTEM_DEBUG_LOG,
       logging::LOCK_LOG_FILE,
       logging::DELETE_OLD_LOG_FILE,
       logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS);
 
@@ skipping 100 matching lines @@
                &skew, &skew_uncertainty);
 
   std::printf(
       "An estimate for the local clock skew is %.2f ms with "
       "uncertainty %.2f ms\n",
       skew.InMillisecondsF(),
       skew_uncertainty.InMillisecondsF());
 
   return EXIT_SUCCESS;
 }