Provide mutable members of UrlRequestContext via pure-virtual interface

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 20 matching lines @@
 #include "net/cookies/cookie_monster.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_status_code.h"
 #include "net/http/http_transaction.h"
 #include "net/http/http_transaction_delegate.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/http/http_util.h"
 #include "net/url_request/fraudulent_certificate_reporter.h"
+#include "net/url_request/http_user_agent_settings.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_redirect_job.h"
 #include "net/url_request/url_request_throttler_header_adapter.h"
 #include "net/url_request/url_request_throttler_manager.h"
 
 static const char kAvailDictionaryHeader[] = "Avail-Dictionary";
 
 namespace net {
@@ skipping 152 matching lines @@
 
   if (!request->context()->http_transaction_factory()) {
     NOTREACHED() << "requires a valid context";
     return new URLRequestErrorJob(
         request, network_delegate, ERR_INVALID_ARGUMENT);
   }
 
   GURL redirect_url;
   if (request->GetHSTSRedirect(&redirect_url))
     return new URLRequestRedirectJob(request, network_delegate, redirect_url);
-  return new URLRequestHttpJob(request, network_delegate);
+  return new URLRequestHttpJob(request,
+                               network_delegate,
+                               request->context()->http_user_agent_settings());
 }
 
 
 URLRequestHttpJob::URLRequestHttpJob(URLRequest* request,
-                                     NetworkDelegate* network_delegate)
+                                     NetworkDelegate* network_delegate,
+                                     HttpUserAgentSettings*
+                                         http_user_agent_settings)

[willchan no longer on Chromium, 2012/10/24 03:40:10]

we don't format like this, move all the other parameters to their own indent,
instead of aligning with the '('.

     : 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,
@@ skipping 11 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_user_agent_settings_(http_user_agent_settings) {

[willchan no longer on Chromium, 2012/10/24 03:40:10]

Should we DCHECK() that it's non-NULL?

   URLRequestThrottlerManager* manager = request->context()->throttler_manager();
   if (manager)
     throttling_entry_ = manager->RegisterRequestUrl(request->url());
 
   ResetTimer();
 }
 
 void URLRequestHttpJob::NotifyHeadersComplete() {
   DCHECK(!response_info_);
 
@@ skipping 202 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();
   // Only add default Accept-Language and Accept-Charset if the request
   // didn't have them specified.
-  if (!context->accept_language().empty()) {
+  std::string accept_language = http_user_agent_settings_->GetAcceptLanguage();

[erikwright (departed), 2012/10/24 13:14:33]

It seems from the unit test that the settings object is nullable... so should we
be checking for null here?

+  if (!accept_language.empty()) {
     request_info_.extra_headers.SetHeaderIfMissing(
         HttpRequestHeaders::kAcceptLanguage,
-        context->accept_language());
+        accept_language);
   }
-  if (!context->accept_charset().empty()) {
+  std::string accept_charset = http_user_agent_settings_->GetAcceptCharset();
+  if (!accept_charset.empty()) {
     request_info_.extra_headers.SetHeaderIfMissing(
         HttpRequestHeaders::kAcceptCharset,
-        context->accept_charset());
+        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_)
@@ skipping 405 matching lines @@
 
   // 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());
   }
 
   request_info_.extra_headers.SetHeaderIfMissing(
       HttpRequestHeaders::kUserAgent,
-      request_->context()->GetUserAgent(request_->url()));
+      http_user_agent_settings_->GetUserAgent(request_->url()));
 
   AddExtraHeaders();
   AddCookieHeaderAndStart();
 }
 
 void URLRequestHttpJob::Kill() {
   http_transaction_delegate_->OnDetachRequest();
 
   if (!transaction_.get())
     return;
@@ skipping 583 matching lines @@
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
   awaiting_callback_ = false;
 }
 
 void URLRequestHttpJob::OnDetachRequest() {
   http_transaction_delegate_->OnDetachRequest();
 }
 
 }  // namespace net