Create a TrivialURLRequestContextGetter to shim an existing URLRequestContext.

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 132 matching lines @@
   //
   // TODO(akalin): Remove this once http://crbug.com/146421 is fixed.
   builder.set_proxy_config_service(
       new net::ProxyConfigServiceFixed(net::ProxyConfig()));
 #endif
   scoped_ptr<net::URLRequestContext> context(builder.Build());
   context->set_net_log(net_log);
   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.
-  SingleThreadRequestContextGetter(
-      net::NetLog* net_log,
-      const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner)
-      : context_(BuildURLRequestContext(net_log)),
-        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_;
-  }
-
- private:
-  virtual ~SingleThreadRequestContextGetter() {}
-
-  const scoped_ptr<net::URLRequestContext> context_;
-  const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
-};
-
 // Assuming that the time |server_time| was received from a server,
 // that the request for the server was started on |start_ticks|, and
 // that it ended on |end_ticks|, fills |server_now| with an estimate
 // of the current time and |server_now_uncertainty| with a
 // conservative estimate of the uncertainty.
 void EstimateServerTimeNow(base::Time server_time,
                            base::TimeTicks start_ticks,
                            base::TimeTicks end_ticks,
                            base::Time* server_now,
                            base::TimeDelta* server_now_uncertainty) {
@@ skipping 55 matching lines @@
   // which causes the DNS resolution to abort.  It's simpler to just
   // not instantiate one, since only a single request is sent anyway.
 
   // The declaration order for net_log and printing_log_observer is
   // important. The destructor of PrintingLogObserver removes itself
   // from net_log, so net_log must be available for entire lifetime of
   // printing_log_observer.
   net::NetLog net_log;
   PrintingLogObserver printing_log_observer;
   net_log.AddThreadSafeObserver(&printing_log_observer, net::NetLog::LOG_ALL);
-  scoped_refptr<SingleThreadRequestContextGetter> context_getter(
-      new SingleThreadRequestContextGetter(&net_log,
-                                           main_loop.message_loop_proxy()));
 
   QuitDelegate delegate;
   scoped_ptr<net::URLFetcher> fetcher(
       net::URLFetcher::Create(url, net::URLFetcher::HEAD, &delegate));
-  fetcher->SetRequestContext(context_getter.get());
-
+  scoped_ptr<net::URLRequestContext> url_request_context(
+      BuildURLRequestContext(&net_log));
+  fetcher->SetRequestContext(
+      // Since there's only a single thread, there's no need to worry
+      // about when the URLRequestContext gets created.
+      // The URLFetcher will take a reference on the object, and hence
+      // implicitly take ownership.
+      new net::TrivialURLRequestContextGetter(url_request_context.get(),
+                                              main_loop.message_loop_proxy()));
   const base::Time start_time = base::Time::Now();
   const base::TimeTicks start_ticks = base::TimeTicks::Now();
 
   fetcher->Start();
   std::printf(
       "Request started at %s (ticks = %" PRId64 ")\n",
       UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime(start_time)).c_str(),
       start_ticks.ToInternalValue());
 
   // |delegate| quits |main_loop| when the request is done.
@@ skipping 63 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;
 }