Create a TrivialURLRequestContextGetter to shim an existing URLRequestContext.

components/domain_reliability/monitor.cc

 // Copyright 2014 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 "components/domain_reliability/monitor.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "components/domain_reliability/baked_in_configs.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace {
 
 bool OnIOThread() {
   return content::BrowserThread::CurrentlyOn(content::BrowserThread::IO);
 }
 
-// Shamelessly stolen from net/tools/get_server_time/get_server_time.cc.
-// TODO(ttuttle): Merge them, if possible.
-class TrivialURLRequestContextGetter : public net::URLRequestContextGetter {
- public:
-  TrivialURLRequestContextGetter(
-      net::URLRequestContext* context,
-      const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner)
-      : context_(context),
-        main_task_runner_(main_task_runner) {}
-
-  // net::URLRequestContextGetter implementation:
-  virtual net::URLRequestContext* GetURLRequestContext() OVERRIDE {
-    return context_;
-  }
-
-  virtual scoped_refptr<base::SingleThreadTaskRunner>
-  GetNetworkTaskRunner() const OVERRIDE {
-    return main_task_runner_;
-  }
-
- private:
-  virtual ~TrivialURLRequestContextGetter() {}
-
-  net::URLRequestContext* context_;
-  const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
-};
-
 }  // namespace
 
 namespace domain_reliability {
 
 DomainReliabilityMonitor::DomainReliabilityMonitor(
     net::URLRequestContext* url_request_context,
     const std::string& upload_reporter_string)
     : time_(new ActualTime()),
       url_request_context_getter_(scoped_refptr<net::URLRequestContextGetter>(
-          new TrivialURLRequestContextGetter(
+          new net::TrivialURLRequestContextGetter(
               url_request_context,
               content::BrowserThread::GetMessageLoopProxyForThread(
                   content::BrowserThread::IO)))),
       upload_reporter_string_(upload_reporter_string),
       scheduler_params_(
           DomainReliabilityScheduler::Params::GetFromFieldTrialsOrDefaults()),
       dispatcher_(time_.get()),
       uploader_(
           DomainReliabilityUploader::Create(url_request_context_getter_)),
       was_cleared_(false),
       cleared_mode_(MAX_CLEAR_MODE) {
   DCHECK(OnIOThread());
 }
 
 DomainReliabilityMonitor::DomainReliabilityMonitor(
     net::URLRequestContext* url_request_context,
     const std::string& upload_reporter_string,
     scoped_ptr<MockableTime> time)
     : time_(time.Pass()),
       url_request_context_getter_(scoped_refptr<net::URLRequestContextGetter>(
-          new TrivialURLRequestContextGetter(
+          new net::TrivialURLRequestContextGetter(
               url_request_context,
               content::BrowserThread::GetMessageLoopProxyForThread(
                   content::BrowserThread::IO)))),
       upload_reporter_string_(upload_reporter_string),
       scheduler_params_(
           DomainReliabilityScheduler::Params::GetFromFieldTrialsOrDefaults()),
       dispatcher_(time_.get()),
       uploader_(
           DomainReliabilityUploader::Create(url_request_context_getter_)),
       was_cleared_(false),
@@ skipping 155 matching lines @@
     beacon.server_ip = request.response_info.socket_address.host();
   else
     beacon.server_ip.clear();
   beacon.http_response_code = response_code;
   beacon.start_time = request.load_timing_info.request_start;
   beacon.elapsed = time_->NowTicks() - beacon.start_time;
   context_it->second->OnBeacon(request.url, beacon);
 }
 
 }  // namespace domain_reliability