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 21 matching lines @@
 #include "net/http/http_network_session.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)
+URLRequestHttpJob::URLRequestHttpJob(
+    URLRequest* request,
+    NetworkDelegate* network_delegate,
+    const HttpUserAgentSettings* http_user_agent_settings)
     : 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) {
   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()) {
-    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());
+  if (http_user_agent_settings_) {
+    // Only add default Accept-Language and Accept-Charset if the request
+    // didn't have them specified.
+    std::string accept_language =
+        http_user_agent_settings_->GetAcceptLanguage();
+    if (!accept_language.empty()) {
+      request_info_.extra_headers.SetHeaderIfMissing(
+          HttpRequestHeaders::kAcceptLanguage,
+          accept_language);
+    }
+    std::string accept_charset = http_user_agent_settings_->GetAcceptCharset();
+    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_)
@@ skipping 418 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_ ?
+          http_user_agent_settings_->GetUserAgent(request_->url()) :
+          EmptyString());
 
   AddExtraHeaders();
   AddCookieHeaderAndStart();
 }
 
 void URLRequestHttpJob::Kill() {
   http_transaction_delegate_->OnDetachRequest();
 
   if (!transaction_.get())
     return;
@@ skipping 628 matching lines @@
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
   awaiting_callback_ = false;
 }
 
 void URLRequestHttpJob::OnDetachRequest() {
   http_transaction_delegate_->OnDetachRequest();
 }
 
 }  // namespace net