Replaced static URLRequestHTTPJob factory with non-static protocol handler for HTTP jobs.

net/url_request/url_request_http_job.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/url_request/url_request_http_job.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 154 matching lines @@
     StatisticSelector statistic) const {
   job_->RecordPacketStats(statistic);
 }
 
 // TODO(darin): make sure the port blocking code is not lost
 // static
 URLRequestJob* URLRequestHttpJob::Factory(URLRequest* request,
                                           const std::string& scheme) {
   DCHECK(scheme == "http" || scheme == "https");
 
-  if (!request->context() ||
-      !request->context()->http_transaction_factory()) {
+  if (!request->context()->http_transaction_factory()) {
     NOTREACHED() << "requires a valid context";
     return new URLRequestErrorJob(request, ERR_INVALID_ARGUMENT);
   }
 
   GURL redirect_url;
   if (request->GetHSTSRedirect(&redirect_url))
     return new URLRequestRedirectJob(request, redirect_url);
-  return new URLRequestHttpJob(request);
+  return new URLRequestHttpJob(
+      request,
+      request->context()->http_transaction_factory(),
+      request->context()->network_delegate(),
+      request->context()->throttler_manager(),
+      request->context()->accept_language(),
+      request->context()->accept_charset(),
+      request->context()->cookie_store(),
+      request->context()->fraudulent_certificate_reporter(),
+      request->context()->ssl_config_service(),
+      request->context()->transport_security_state());
 }
 
 
-URLRequestHttpJob::URLRequestHttpJob(URLRequest* request)
-    : URLRequestJob(request, request->context()->network_delegate()),
+URLRequestHttpJob::URLRequestHttpJob(
+    URLRequest* request,
+    HttpTransactionFactory* http_transaction_factory,
+    NetworkDelegate* network_delegate,
+    URLRequestThrottlerManager* throttler_manager,
+    const std::string& accept_language,
+    const std::string& accept_charset,
+    CookieStore* cookie_store,
+    FraudulentCertificateReporter* fraudulent_certificate_reporter,
+    SSLConfigService* ssl_config_service,
+    TransportSecurityState* transport_security_state)
+    : URLRequestJob(request, network_delegate),
       response_info_(NULL),
       response_cookies_save_index_(0),
       proxy_auth_state_(AUTH_STATE_DONT_NEED_AUTH),
       server_auth_state_(AUTH_STATE_DONT_NEED_AUTH),
       ALLOW_THIS_IN_INITIALIZER_LIST(start_callback_(
           base::Bind(&URLRequestHttpJob::OnStartCompleted,
                      base::Unretained(this)))),
       ALLOW_THIS_IN_INITIALIZER_LIST(notify_before_headers_sent_callback_(
           base::Bind(&URLRequestHttpJob::NotifyBeforeSendHeadersCallback,
                      base::Unretained(this)))),
@@ skipping 10 matching lines @@
       bytes_observed_in_packets_(0),
       request_time_snapshot_(),
       final_packet_time_(),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           filter_context_(new HttpFilterContext(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(on_headers_received_callback_(
           base::Bind(&URLRequestHttpJob::OnHeadersReceivedCallback,
                      base::Unretained(this)))),
       awaiting_callback_(false),
-      http_transaction_delegate_(new HttpTransactionDelegateImpl(request)) {
+      http_transaction_delegate_(new HttpTransactionDelegateImpl(request)),
+      http_transaction_factory_(http_transaction_factory),
+      network_delegate_(network_delegate),
+      accept_language_(accept_language),
+      accept_charset_(accept_charset),
+      cookie_store_(cookie_store),
+      fraudulent_certificate_reporter_(fraudulent_certificate_reporter),
+      ssl_config_service_(ssl_config_service),
+      transport_security_state_(transport_security_state) {
+  DCHECK(http_transaction_factory_);
   URLRequestThrottlerManager* manager = request->context()->throttler_manager();
   if (manager)
     throttling_entry_ = manager->RegisterRequestUrl(request->url());
 
   ResetTimer();
 }
 
 void URLRequestHttpJob::NotifyHeadersComplete() {
   DCHECK(!response_info_);
 
@@ skipping 56 matching lines @@
 
 void URLRequestHttpJob::DestroyTransaction() {
   DCHECK(transaction_.get());
 
   DoneWithRequest(ABORTED);
   transaction_.reset();
   response_info_ = NULL;
 }
 
 void URLRequestHttpJob::StartTransaction() {
-  if (request_->context() && request_->context()->network_delegate()) {
-    int rv = request_->context()->network_delegate()->NotifyBeforeSendHeaders(
+  if (network_delegate_) {
+    int rv = network_delegate_->NotifyBeforeSendHeaders(
         request_, notify_before_headers_sent_callback_,
         &request_info_.extra_headers);
     // If an extension blocks the request, we rely on the callback to
     // StartTransactionInternal().
     if (rv == ERR_IO_PENDING) {
       SetBlockedOnDelegate();
       return;
     }
   }
   StartTransactionInternal();
@@ skipping 16 matching lines @@
 }
 
 void URLRequestHttpJob::StartTransactionInternal() {
   // NOTE: This method assumes that request_info_ is already setup properly.
 
   // If we already have a transaction, then we should restart the transaction
   // with auth provided by auth_credentials_.
 
   int rv;
 
-  if (request_->context() && request_->context()->network_delegate()) {
-    request_->context()->network_delegate()->NotifySendHeaders(
-        request_, request_info_.extra_headers);
-  }
+  if (network_delegate_)
+    network_delegate_->NotifySendHeaders(request_, request_info_.extra_headers);
 
   if (transaction_.get()) {
     rv = transaction_->RestartWithAuth(auth_credentials_, start_callback_);
     auth_credentials_ = AuthCredentials();
   } else {
-    DCHECK(request_->context());
-    DCHECK(request_->context()->http_transaction_factory());
-
-    rv = request_->context()->http_transaction_factory()->CreateTransaction(
+    rv = http_transaction_factory_->CreateTransaction(
         &transaction_, http_transaction_delegate_.get());
     if (rv == OK) {
       if (!throttling_entry_ ||
           !throttling_entry_->ShouldRejectRequest(*request_)) {
         rv = transaction_->Start(
             &request_info_, start_callback_, request_->net_log());
         start_time_ = base::TimeTicks::Now();
       } else {
         // Special error code for the exponential back-off module.
         rv = ERR_TEMPORARILY_THROTTLED;
@@ skipping 69 matching lines @@
         // Since we're tagging this transaction as advertising a dictionary,
         // we'll definitely employ an SDCH filter (or tentative sdch filter)
         // when we get a response.  When done, we'll record histograms via
         // SDCH_DECODE or SDCH_PASSTHROUGH.  Hence we need to record packet
         // arrival times.
         packet_timing_enabled_ = true;
       }
     }
   }
 
-  const URLRequestContext* context = request_->context();
-  if (context) {
-    // Only add default Accept-Language and Accept-Charset if the request
-    // didn't have them specified.
-    if (!context->accept_language().empty()) {
-      request_info_.extra_headers.SetHeaderIfMissing(
-          HttpRequestHeaders::kAcceptLanguage,
-          context->accept_language());
-    }
-    if (!context->accept_charset().empty()) {
-      request_info_.extra_headers.SetHeaderIfMissing(
-          HttpRequestHeaders::kAcceptCharset,
-          context->accept_charset());
-    }
+  // Only add default Accept-Language and Accept-Charset if the request
+  // didn't have them specified.
+  if (!accept_language_.empty()) {
+    request_info_.extra_headers.SetHeaderIfMissing(
+        HttpRequestHeaders::kAcceptLanguage,
+        accept_language_);
+  }
+  if (!accept_charset_.empty()) {
+    request_info_.extra_headers.SetHeaderIfMissing(
+        HttpRequestHeaders::kAcceptCharset,
+        accept_charset_);
   }
 }
 
 void URLRequestHttpJob::AddCookieHeaderAndStart() {
   // No matter what, we want to report our status as IO pending since we will
   // be notifying our consumer asynchronously via OnStartCompleted.
   SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
 
   // If the request was destroyed, then there is no more work to do.
   if (!request_)
     return;
 
-  CookieStore* cookie_store =
-      request_->context()->cookie_store();
-  if (cookie_store && !(request_info_.load_flags & LOAD_DO_NOT_SEND_COOKIES)) {
-    net::CookieMonster* cookie_monster = cookie_store->GetCookieMonster();
+  if (cookie_store_ && !(request_info_.load_flags & LOAD_DO_NOT_SEND_COOKIES)) {
+    net::CookieMonster* cookie_monster = cookie_store_->GetCookieMonster();
     if (cookie_monster) {
       cookie_monster->GetAllCookiesForURLAsync(
           request_->url(),
           base::Bind(&URLRequestHttpJob::CheckCookiePolicyAndLoad,
                      weak_factory_.GetWeakPtr()));
     } else {
       DoLoadCookies();
     }
   } else {
     DoStartTransaction();
   }
 }
 
 void URLRequestHttpJob::DoLoadCookies() {
   CookieOptions options;
   options.set_include_httponly();
-  request_->context()->cookie_store()->GetCookiesWithInfoAsync(
+  cookie_store_->GetCookiesWithInfoAsync(
       request_->url(), options,
       base::Bind(&URLRequestHttpJob::OnCookiesLoaded,
                  weak_factory_.GetWeakPtr()));
 }
 
 void URLRequestHttpJob::CheckCookiePolicyAndLoad(
     const CookieList& cookie_list) {
   if (CanGetCookies(cookie_list))
     DoLoadCookies();
   else
@@ skipping 56 matching lines @@
   // be notifying our consumer asynchronously via OnStartCompleted.
   SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
 
   // Used to communicate with the callback. See the implementation of
   // OnCookieSaved.
   scoped_refptr<SharedBoolean> callback_pending = new SharedBoolean(false);
   scoped_refptr<SharedBoolean> save_next_cookie_running =
       new SharedBoolean(true);
 
   if (!(request_info_.load_flags & LOAD_DO_NOT_SAVE_COOKIES) &&
-      request_->context()->cookie_store() &&
+      cookie_store_ &&
       response_cookies_.size() > 0) {
     CookieOptions options;
     options.set_include_httponly();
     options.set_server_time(response_date_);
 
     net::CookieStore::SetCookiesCallback callback(
         base::Bind(&URLRequestHttpJob::OnCookieSaved,
                    weak_factory_.GetWeakPtr(),
                    save_next_cookie_running,
                    callback_pending));
 
     // Loop through the cookies as long as SetCookieWithOptionsAsync completes
     // synchronously.
     while (!callback_pending->data &&
            response_cookies_save_index_ < response_cookies_.size()) {
       if (CanSetCookie(
           response_cookies_[response_cookies_save_index_], &options)) {
         callback_pending->data = true;
-        request_->context()->cookie_store()->SetCookieWithOptionsAsync(
+        cookie_store_->SetCookieWithOptionsAsync(
             request_->url(), response_cookies_[response_cookies_save_index_],
             options, callback);
       }
       ++response_cookies_save_index_;
     }
   }
 
   save_next_cookie_running->data = false;
 
   if (!callback_pending->data) {
@@ skipping 47 matching lines @@
 
 // NOTE: |ProcessStrictTransportSecurityHeader| and
 // |ProcessPublicKeyPinsHeader| have very similar structures, by design.
 // They manipulate different parts of |TransportSecurityState::DomainState|,
 // and they must remain complementary. If, in future changes here, there is
 // any conflict between their policies (such as in |domain_state.mode|), you
 // should resolve the conflict in favor of the more strict policy.
 void URLRequestHttpJob::ProcessStrictTransportSecurityHeader() {
   DCHECK(response_info_);
 
-  const URLRequestContext* ctx = request_->context();
   const SSLInfo& ssl_info = response_info_->ssl_info;
 
   // Only accept strict transport security headers on HTTPS connections that
   // have no certificate errors.
   if (!ssl_info.is_valid() || IsCertStatusError(ssl_info.cert_status) ||
-      !ctx || !ctx->transport_security_state()) {
+      !transport_security_state_) {
     return;
   }
 
-  TransportSecurityState* security_state = ctx->transport_security_state();
   TransportSecurityState::DomainState domain_state;
   const std::string& host = request_info_.url.host();
 
   bool sni_available =
-      SSLConfigService::IsSNIAvailable(ctx->ssl_config_service());
-  if (!security_state->GetDomainState(host, sni_available, &domain_state))
+      SSLConfigService::IsSNIAvailable(ssl_config_service_);
+  if (!transport_security_state_->GetDomainState(
+          host, sni_available, &domain_state)) {
     // |GetDomainState| may have altered |domain_state| while searching. If
     // not found, start with a fresh state.
     domain_state.upgrade_mode =
         TransportSecurityState::DomainState::MODE_FORCE_HTTPS;
+  }
 
   HttpResponseHeaders* headers = GetResponseHeaders();
   std::string value;
   void* iter = NULL;
   base::Time now = base::Time::Now();
 
   while (headers->EnumerateHeader(&iter, "Strict-Transport-Security", &value)) {
     TransportSecurityState::DomainState domain_state;
     if (domain_state.ParseSTSHeader(now, value))
-      security_state->EnableHost(host, domain_state);
+      transport_security_state_->EnableHost(host, domain_state);
   }
 }
 
 void URLRequestHttpJob::ProcessPublicKeyPinsHeader() {
   DCHECK(response_info_);
 
-  const URLRequestContext* ctx = request_->context();
   const SSLInfo& ssl_info = response_info_->ssl_info;
 
   // Only accept public key pins headers on HTTPS connections that have no
   // certificate errors.
   if (!ssl_info.is_valid() || IsCertStatusError(ssl_info.cert_status) ||
-      !ctx || !ctx->transport_security_state()) {
+      !transport_security_state_) {
     return;
   }
 
-  TransportSecurityState* security_state = ctx->transport_security_state();
   TransportSecurityState::DomainState domain_state;
   const std::string& host = request_info_.url.host();
 
   bool sni_available =
-      SSLConfigService::IsSNIAvailable(ctx->ssl_config_service());
-  if (!security_state->GetDomainState(host, sni_available, &domain_state))
+      SSLConfigService::IsSNIAvailable(ssl_config_service_);
+  if (!transport_security_state_->GetDomainState(
+          host, sni_available, &domain_state)) {
     // |GetDomainState| may have altered |domain_state| while searching. If
     // not found, start with a fresh state.
     domain_state.upgrade_mode =
         TransportSecurityState::DomainState::MODE_DEFAULT;
+  }
 
   HttpResponseHeaders* headers = GetResponseHeaders();
   void* iter = NULL;
   std::string value;
   base::Time now = base::Time::Now();
 
   while (headers->EnumerateHeader(&iter, "Public-Key-Pins", &value)) {
     // Note that ParsePinsHeader updates |domain_state| (iff the header parses
     // correctly), but does not completely overwrite it. It just updates the
     // dynamic pinning metadata.
     if (domain_state.ParsePinsHeader(now, value, ssl_info))
-      security_state->EnableHost(host, domain_state);
+      transport_security_state_->EnableHost(host, domain_state);
   }
 }
 
 void URLRequestHttpJob::OnStartCompleted(int result) {
   RecordTimer();
 
   // If the request was destroyed, then there is no more work to do.
   if (!request_)
     return;
 
   // If the transaction was destroyed, then the job was cancelled, and
   // we can just ignore this notification.
   if (!transaction_.get())
     return;
 
   // Clear the IO_PENDING status
   SetStatus(URLRequestStatus());
 
-  const URLRequestContext* context = request_->context();
-
   if (result == ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN &&
       transaction_->GetResponseInfo() != NULL) {
-    FraudulentCertificateReporter* reporter =
-      context->fraudulent_certificate_reporter();
-    if (reporter != NULL) {
+    if (fraudulent_certificate_reporter_) {
       const SSLInfo& ssl_info = transaction_->GetResponseInfo()->ssl_info;
       bool sni_available = SSLConfigService::IsSNIAvailable(
-          context->ssl_config_service());
+          ssl_config_service_);
       const std::string& host = request_->url().host();
 
-      reporter->SendReport(host, ssl_info, sni_available);
+      fraudulent_certificate_reporter_->SendReport(
+          host, ssl_info, sni_available);
     }
   }
 
   if (result == OK) {
     scoped_refptr<HttpResponseHeaders> headers = GetResponseHeaders();
-    if (context && context->network_delegate()) {
+    if (network_delegate_) {
       // Note that |this| may not be deleted until
       // |on_headers_received_callback_| or
       // |NetworkDelegate::URLRequestDestroyed()| has been called.
-      int error = context->network_delegate()->
+      int error = network_delegate_->
           NotifyHeadersReceived(request_, on_headers_received_callback_,
                                 headers, &override_response_headers_);
       if (error != net::OK) {
         if (error == net::ERR_IO_PENDING) {
           awaiting_callback_ = true;
           request_->net_log().BeginEvent(
               NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE);
         } else {
           std::string source("delegate");
           request_->net_log().AddEvent(NetLog::TYPE_CANCELLED,
                                        NetLog::StringCallback("source",
                                                               &source));
           NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, error));
         }
         return;
       }
     }
 
     SaveCookiesAndNotifyHeadersComplete(net::OK);
   } else if (IsCertificateError(result)) {
     // We encountered an SSL certificate error.  Ask our delegate to decide
     // what we should do.
 
     TransportSecurityState::DomainState domain_state;
-    const URLRequestContext* context = request_->context();
     const bool fatal =
-        context->transport_security_state() &&
-        context->transport_security_state()->GetDomainState(
+        transport_security_state_ &&
+        transport_security_state_->GetDomainState(
             request_info_.url.host(),
-            SSLConfigService::IsSNIAvailable(context->ssl_config_service()),
+            SSLConfigService::IsSNIAvailable(ssl_config_service_),
             &domain_state);
     NotifySSLCertificateError(transaction_->GetResponseInfo()->ssl_info, fatal);
   } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
     NotifyCertificateRequested(
         transaction_->GetResponseInfo()->cert_request_info);
   } else {
     NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, result));
   }
 }
 
@@ skipping 71 matching lines @@
   // plugin could set a referrer although sending the referrer is inhibited.
   request_info_.extra_headers.RemoveHeader(HttpRequestHeaders::kReferer);
 
   // Our consumer should have made sure that this is a safe referrer.  See for
   // instance WebCore::FrameLoader::HideReferrer.
   if (referrer.is_valid()) {
     request_info_.extra_headers.SetHeader(HttpRequestHeaders::kReferer,
                                           referrer.spec());
   }
 
-  if (request_->context()) {
-    request_info_.extra_headers.SetHeaderIfMissing(
-        HttpRequestHeaders::kUserAgent,
-        request_->context()->GetUserAgent(request_->url()));
-  }
+  // TODO(shalev): Fix this to not go through URLRequestContext.
+  request_info_.extra_headers.SetHeaderIfMissing(
+      HttpRequestHeaders::kUserAgent,
+      request_->context()->GetUserAgent(request_->url()));
 
   AddExtraHeaders();
   AddCookieHeaderAndStart();
 }
 
 void URLRequestHttpJob::Kill() {
   if (!transaction_.get())
     return;
 
   weak_factory_.InvalidateWeakPtrs();
@@ skipping 580 matching lines @@
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
   awaiting_callback_ = false;
 }
 
 void URLRequestHttpJob::OnDetachRequest() {
   http_transaction_delegate_->OnDetachRequest();
 }
 
 }  // namespace net