Use FilterContext to allow filters to access URLRequestJob data...

net/url_request/url_request_job.cc

 // Copyright (c) 2006-2008 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_job.h"
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/auth.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job_metrics.h"
 #include "net/url_request/url_request_job_tracker.h"
 
 using base::Time;
 using base::TimeTicks;
 
 // Buffer size allocated when de-compressing data.
-static const int kFilterBufSize = 32 * 1024;
+// static
+const int URLRequestJob::kFilterBufSize = 32 * 1024;
 
 URLRequestJob::URLRequestJob(URLRequest* request)
     : request_(request),
       done_(false),
       filter_needs_more_output_space_(false),
       read_buffer_(NULL),
       read_buffer_len_(0),
       has_handled_response_(false),
       expected_content_size_(-1) {
   is_profiling_ = request->enable_profiling();
@@ skipping 15 matching lines @@
     NotifyCanceled();
 }
 
 void URLRequestJob::DetachRequest() {
   request_ = NULL;
 }
 
 void URLRequestJob::SetupFilter() {
   std::vector<Filter::FilterType> encoding_types;
   if (GetContentEncodings(&encoding_types)) {
-    filter_.reset(Filter::Factory(encoding_types, kFilterBufSize));
-    if (filter_.get()) {
-      std::string mime_type;
-      GetMimeType(&mime_type);
-      filter_->SetURL(request_->url());
-      filter_->SetMimeType(mime_type);
-      // Approximate connect time with request_time. If it is not cached, then
-      // this is a good approximation for when the first bytes went on the
-      // wire.
-      filter_->SetConnectTime(request_->response_info_.request_time,
-                              request_->response_info_.was_cached);
-    }
+    filter_.reset(Filter::Factory(encoding_types, *this));
   }
 }
 
 void URLRequestJob::GetAuthChallengeInfo(
     scoped_refptr<net::AuthChallengeInfo>* auth_info) {
   // This will only be called if NeedsAuth() returns true, in which
   // case the derived class should implement this!
   NOTREACHED();
 }
 
@@ skipping 10 matching lines @@
   NOTREACHED();
 }
 
 void URLRequestJob::ContinueDespiteLastError() {
   // Implementations should know how to recover from errors they generate.
   // If this code was reached, we are trying to recover from an error that
   // we don't know how to recover from.
   NOTREACHED();
 }
 
+bool URLRequestJob::GetURL(GURL* gurl) const {
+  if (!request_)
+    return false;
+  *gurl = request_->url();
+  return true;
+}
+
+base::Time URLRequestJob::GetRequestTime() const {
+  if (!request_)
+    return base::Time();
+  return request_->request_time();
+};
+
+bool URLRequestJob::IsCachedContent() const {
+  if (!request_)
+    return false;
+  return request_->was_cached();
+};
+
 // This function calls ReadData to get stream data. If a filter exists, passes
 // the data to the attached filter. Then returns the output from filter back to
 // the caller.
 bool URLRequestJob::Read(net::IOBuffer* buf, int buf_size, int *bytes_read) {
   bool rv = false;
 
   DCHECK_LT(buf_size, 1000000);  // sanity check
   DCHECK(buf);
   DCHECK(bytes_read);
 
@@ skipping 395 matching lines @@
     return request_->status();
   // If the request is gone, we must be cancelled.
   return URLRequestStatus(URLRequestStatus::CANCELED,
                           net::ERR_ABORTED);
 }
 
 void URLRequestJob::SetStatus(const URLRequestStatus &status) {
   if (request_)
     request_->set_status(status);
 }