Add a new GetInstance() method for singleton classes under chrome/service and /net.

net/url_request/url_request.cc

 // Copyright (c) 2010 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/url_request/url_request.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/metrics/stats_counters.h"
 #include "base/singleton.h"
@@ skipping 11 matching lines @@
 
 using base::Time;
 using net::UploadData;
 using std::string;
 
 namespace {
 
 // Max number of http redirects to follow.  Same number as gecko.
 const int kMaxRedirects = 20;
 
-URLRequestJobManager* GetJobManager() {
-  return Singleton<URLRequestJobManager>::get();
-}
-
 // Discard headers which have meaning in POST (Content-Length, Content-Type,
 // Origin).
 void StripPostSpecificHeaders(net::HttpRequestHeaders* headers) {
   // These are headers that may be attached to a POST.
   headers->RemoveHeader(net::HttpRequestHeaders::kContentLength);
   headers->RemoveHeader(net::HttpRequestHeaders::kContentType);
   headers->RemoveHeader(net::HttpRequestHeaders::kOrigin);
 }
 
 }  // namespace
@@ skipping 77 matching lines @@
 
   if (job_)
     OrphanJob();
 
   set_context(NULL);
 }
 
 // static
 URLRequest::ProtocolFactory* URLRequest::RegisterProtocolFactory(
     const string& scheme, ProtocolFactory* factory) {
-  return GetJobManager()->RegisterProtocolFactory(scheme, factory);
+  return URLRequestJobManager::GetInstance()->RegisterProtocolFactory(scheme,
+                                                                      factory);
 }
 
 // static
 void URLRequest::RegisterRequestInterceptor(Interceptor* interceptor) {
-  GetJobManager()->RegisterRequestInterceptor(interceptor);
+  URLRequestJobManager::GetInstance()->RegisterRequestInterceptor(interceptor);
 }
 
 // static
 void URLRequest::UnregisterRequestInterceptor(Interceptor* interceptor) {
-  GetJobManager()->UnregisterRequestInterceptor(interceptor);
+  URLRequestJobManager::GetInstance()->UnregisterRequestInterceptor(
+      interceptor);
 }
 
 void URLRequest::AppendBytesToUpload(const char* bytes, int bytes_len) {
   DCHECK(bytes_len > 0 && bytes);
   if (!upload_)
     upload_ = new UploadData();
   upload_->AppendBytes(bytes, bytes_len);
 }
 
 void URLRequest::AppendFileRangeToUpload(
@@ skipping 103 matching lines @@
   job_->GetCharset(charset);
 }
 
 int URLRequest::GetResponseCode() {
   DCHECK(job_);
   return job_->GetResponseCode();
 }
 
 // static
 bool URLRequest::IsHandledProtocol(const std::string& scheme) {
-  return GetJobManager()->SupportsScheme(scheme);
+  return URLRequestJobManager::GetInstance()->SupportsScheme(scheme);
 }
 
 // static
 bool URLRequest::IsHandledURL(const GURL& url) {
   if (!url.is_valid()) {
     // We handle error cases.
     return true;
   }
 
   return IsHandledProtocol(url.scheme());
 }
 
 // static
 void URLRequest::AllowFileAccess() {
-  GetJobManager()->set_enable_file_access(true);
+  URLRequestJobManager::GetInstance()->set_enable_file_access(true);
 }
 
 // static
 bool URLRequest::IsFileAccessAllowed() {
-  return GetJobManager()->enable_file_access();
+  return URLRequestJobManager::GetInstance()->enable_file_access();
 }
 
 
 void URLRequest::set_first_party_for_cookies(
     const GURL& first_party_for_cookies) {
   first_party_for_cookies_ = first_party_for_cookies;
 }
 
 void URLRequest::set_method(const std::string& method) {
   DCHECK(!is_pending_);
@@ skipping 13 matching lines @@
     GURL::Replacements referrer_mods;
     referrer_mods.ClearUsername();
     referrer_mods.ClearPassword();
     ret = ret.ReplaceComponents(referrer_mods);
   }
 
   return ret;
 }
 
 void URLRequest::Start() {
-  StartJob(GetJobManager()->CreateJob(this));
+  StartJob(URLRequestJobManager::GetInstance()->CreateJob(this));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void URLRequest::StartJob(URLRequestJob* job) {
   DCHECK(!is_pending_);
   DCHECK(!job_);
 
   net_log_.BeginEvent(
       net::NetLog::TYPE_URL_REQUEST_START_JOB,
@@ skipping 14 matching lines @@
   // Don't allow errors to be sent from within Start().
   // TODO(brettw) this may cause NotifyDone to be sent synchronously,
   // we probably don't want this: they should be sent asynchronously so
   // the caller does not get reentered.
   job_->Start();
 }
 
 void URLRequest::Restart() {
   // Should only be called if the original job didn't make any progress.
   DCHECK(job_ && !job_->has_response_started());
-  RestartWithJob(GetJobManager()->CreateJob(this));
+  RestartWithJob(URLRequestJobManager::GetInstance()->CreateJob(this));
 }
 
 void URLRequest::RestartWithJob(URLRequestJob *job) {
   DCHECK(job->request() == this);
   PrepareToRestart();
   StartJob(job);
 }
 
 void URLRequest::Cancel() {
   DoCancel(net::ERR_ABORTED, net::SSLInfo());
@@ skipping 53 matching lines @@
 
   return job_->Read(dest, dest_size, bytes_read);
 }
 
 void URLRequest::StopCaching() {
   DCHECK(job_);
   job_->StopCaching();
 }
 
 void URLRequest::ReceivedRedirect(const GURL& location, bool* defer_redirect) {
-  URLRequestJob* job = GetJobManager()->MaybeInterceptRedirect(this, location);
+  URLRequestJob* job =
+      URLRequestJobManager::GetInstance()->MaybeInterceptRedirect(this,
+                                                                  location);
   if (job) {
     RestartWithJob(job);
   } else if (delegate_) {
     delegate_->OnReceivedRedirect(this, location, defer_redirect);
   }
 }
 
 void URLRequest::ResponseStarted() {
   scoped_refptr<net::NetLog::EventParameters> params;
   if (!status_.is_success())
     params = new net::NetLogIntegerParameter("net_error", status_.os_error());
   net_log_.EndEvent(net::NetLog::TYPE_URL_REQUEST_START_JOB, params);
 
-  URLRequestJob* job = GetJobManager()->MaybeInterceptResponse(this);
+  URLRequestJob* job =
+      URLRequestJobManager::GetInstance()->MaybeInterceptResponse(this);
   if (job) {
     RestartWithJob(job);
   } else if (delegate_) {
     delegate_->OnResponseStarted(this);
   }
 }
 
 void URLRequest::FollowDeferredRedirect() {
   CHECK(job_);
   CHECK(status_.is_success());
@@ skipping 140 matching lines @@
   if (found != user_data_.end())
     return found->second.get();
   return NULL;
 }
 
 void URLRequest::SetUserData(const void* key, UserData* data) {
   user_data_[key] = linked_ptr<UserData>(data);
 }
 
 }  // namespace net