Make SdchManager per-profile.

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 48 matching lines @@
   // FilterContext implementation.
   virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
   virtual bool GetURL(GURL* gurl) const OVERRIDE;
   virtual bool GetContentDisposition(std::string* disposition) const OVERRIDE;
   virtual base::Time GetRequestTime() const OVERRIDE;
   virtual bool IsCachedContent() const OVERRIDE;
   virtual bool IsDownload() const OVERRIDE;
   virtual bool IsSdchResponse() const OVERRIDE;
   virtual int64 GetByteReadCount() const OVERRIDE;
   virtual int GetResponseCode() const OVERRIDE;
+  virtual const URLRequestContext* GetURLRequestContext() const OVERRIDE;
   virtual void RecordPacketStats(StatisticSelector statistic) const OVERRIDE;
 
   // Method to allow us to reset filter context for a response that should have
   // been SDCH encoded when there is an update due to an explicit HTTP header.
   void ResetSdchResponseToFalse();
 
  private:
   URLRequestHttpJob* job_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpFilterContext);
@@ skipping 48 matching lines @@
 }
 
 int64 URLRequestHttpJob::HttpFilterContext::GetByteReadCount() const {
   return job_->filter_input_byte_count();
 }
 
 int URLRequestHttpJob::HttpFilterContext::GetResponseCode() const {
   return job_->GetResponseCode();
 }
 
+const URLRequestContext*
+URLRequestHttpJob::HttpFilterContext::GetURLRequestContext() const {
+  return job_->request()->context();
+}
+
 void URLRequestHttpJob::HttpFilterContext::RecordPacketStats(
     StatisticSelector statistic) const {
   job_->RecordPacketStats(statistic);
 }
 
 // TODO(darin): make sure the port blocking code is not lost
 // static
 URLRequestJob* URLRequestHttpJob::Factory(URLRequest* request,
                                           NetworkDelegate* network_delegate,
                                           const std::string& scheme) {
@@ skipping 66 matching lines @@
   if (!is_cached_content_) {
     if (sdch_test_control_)
       RecordPacketStats(FilterContext::SDCH_EXPERIMENT_HOLDBACK);
     if (sdch_test_activated_)
       RecordPacketStats(FilterContext::SDCH_EXPERIMENT_DECODE);
   }
   // Make sure SDCH filters are told to emit histogram data while
   // filter_context_ is still alive.
   DestroyFilters();
 
-  if (sdch_dictionary_url_.is_valid()) {
-    // Prior to reaching the destructor, request_ has been set to a NULL
-    // pointer, so request_->url() is no longer valid in the destructor, and we
-    // use an alternate copy |request_info_.url|.
-    SdchManager* manager = SdchManager::Global();
-    // To be extra safe, since this is a "different time" from when we decided
-    // to get the dictionary, we'll validate that an SdchManager is available.
-    // At shutdown time, care is taken to be sure that we don't delete this
-    // globally useful instance "too soon," so this check is just defensive
-    // coding to assure that IF the system is shutting down, we don't have any
-    // problem if the manager was deleted ahead of time.
-    if (manager)  // Defensive programming.
-      manager->FetchDictionary(request_info_.url, sdch_dictionary_url_);
-  }
   DoneWithRequest(ABORTED);
 }
 
 void URLRequestHttpJob::SetPriority(RequestPriority priority) {
   priority_ = priority;
   if (transaction_)
     transaction_->SetPriority(priority_);
 }
 
 void URLRequestHttpJob::Start() {
@@ skipping 59 matching lines @@
   if (!is_cached_content_ && throttling_entry_.get()) {
     URLRequestThrottlerHeaderAdapter response_adapter(GetResponseHeaders());
     throttling_entry_->UpdateWithResponse(request_info_.url.host(),
                                           &response_adapter);
   }
 
   // The ordering of these calls is not important.
   ProcessStrictTransportSecurityHeader();
   ProcessPublicKeyPinsHeader();
 
-  if (SdchManager::Global() &&
-      SdchManager::Global()->IsInSupportedDomain(request_->url())) {
+  SdchManager* manager(request()->context()->sdch_manager());
+  if (manager && manager->IsInSupportedDomain(request_->url())) {
     const std::string name = "Get-Dictionary";
     std::string url_text;
     void* iter = NULL;
     // TODO(jar): We need to not fetch dictionaries the first time they are
     // seen, but rather wait until we can justify their usefulness.
     // For now, we will only fetch the first dictionary, which will at least
     // require multiple suggestions before we get additional ones for this site.
     // Eventually we should wait until a dictionary is requested several times
     // before we even download it (so that we don't waste memory or bandwidth).
     if (GetResponseHeaders()->EnumerateHeader(&iter, name, &url_text)) {
       // request_->url() won't be valid in the destructor, so we use an
       // alternate copy.
       DCHECK_EQ(request_->url(), request_info_.url);
       // Resolve suggested URL relative to request url.
-      sdch_dictionary_url_ = request_info_.url.Resolve(url_text);
+      GURL sdch_dictionary_url = request_info_.url.Resolve(url_text);
+      if (sdch_dictionary_url.is_valid()) {
+        SdchManager* manager = request()->context()->sdch_manager();
+        if (manager)
+          manager->FetchDictionary(request_info_.url, sdch_dictionary_url);
+      }
     }
   }
 
   // The HTTP transaction may be restarted several times for the purposes
   // of sending authorization information. Each time it restarts, we get
   // notified of the headers completion so that we can update the cookie store.
   if (transaction_->IsReadyToRestartForAuth()) {
     DCHECK(!response_info_->auth_challenge.get());
     // TODO(battre): This breaks the webrequest API for
     // URLRequestTestHTTP.BasicAuthWithCookies
@@ skipping 113 matching lines @@
 
   // The transaction started synchronously, but we need to notify the
   // URLRequest delegate via the message loop.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&URLRequestHttpJob::OnStartCompleted,
                  weak_factory_.GetWeakPtr(), rv));
 }
 
 void URLRequestHttpJob::AddExtraHeaders() {
+  SdchManager* sdch_manager = request()->context()->sdch_manager();
+
   // Supply Accept-Encoding field only if it is not already provided.
   // It should be provided IF the content is known to have restrictions on
   // potential encoding, such as streaming multi-media.
   // For details see bug 47381.
   // TODO(jar, enal): jpeg files etc. should set up a request header if
   // possible. Right now it is done only by buffered_resource_loader and
   // simple_data_source.
   if (!request_info_.extra_headers.HasHeader(
       HttpRequestHeaders::kAcceptEncoding)) {
-    bool advertise_sdch = SdchManager::Global() &&
-        SdchManager::Global()->IsInSupportedDomain(request_->url());
+    bool advertise_sdch = sdch_manager &&
+        sdch_manager->IsInSupportedDomain(request_->url());
     std::string avail_dictionaries;
     if (advertise_sdch) {
-      SdchManager::Global()->GetAvailDictionaryList(request_->url(),
-                                                    &avail_dictionaries);
+      sdch_manager->GetAvailDictionaryList(request_->url(),
+                                           &avail_dictionaries);
 
       // The AllowLatencyExperiment() is only true if we've successfully done a
       // full SDCH compression recently in this browser session for this host.
       // Note that for this path, there might be no applicable dictionaries,
       // and hence we can't participate in the experiment.
       if (!avail_dictionaries.empty() &&
-          SdchManager::Global()->AllowLatencyExperiment(request_->url())) {
+          sdch_manager->AllowLatencyExperiment(request_->url())) {
         // We are participating in the test (or control), and hence we'll
         // eventually record statistics via either SDCH_EXPERIMENT_DECODE or
         // SDCH_EXPERIMENT_HOLDBACK, and we'll need some packet timing data.
         packet_timing_enabled_ = true;
         if (base::RandDouble() < .01) {
           sdch_test_control_ = true;  // 1% probability.
           advertise_sdch = false;
         } else {
           sdch_test_activated_ = true;
         }
@@ skipping 1006 matching lines @@
   return override_response_headers_.get() ?
              override_response_headers_.get() :
              transaction_->GetResponseInfo()->headers.get();
 }
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
   awaiting_callback_ = false;
 }
 
 }  // namespace net