URLRequest::Interceptor enhancements...

net/url_request/url_request.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.h"
 
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/singleton.h"
 #include "base/stats_counters.h"
@@ skipping 26 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 // URLRequest
 
 URLRequest::URLRequest(const GURL& url, Delegate* delegate)
     : url_(url),
       original_url_(url),
       method_("GET"),
       load_flags_(net::LOAD_NORMAL),
       delegate_(delegate),
       is_pending_(false),
-      user_data_(NULL),
       enable_profiling_(false),
       redirect_limit_(kMaxRedirects),
       final_upload_progress_(0),
       priority_(0) {
   URLREQUEST_COUNT_CTOR();
   SIMPLE_STATS_COUNTER("URLRequestCount");
   origin_pid_ = base::GetCurrentProcId();
 
   // Sanity check out environment.
   DCHECK(MessageLoop::current()) <<
       "The current MessageLoop must exist";
   DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type()) <<
       "The current MessageLoop must be TYPE_IO";
 }
 
 URLRequest::~URLRequest() {
   URLREQUEST_COUNT_DTOR();
 
   Cancel();
 
   if (job_)
     OrphanJob();
-
-  delete user_data_;  // NULL check unnecessary for delete
 }
 
 // static
 URLRequest::ProtocolFactory* URLRequest::RegisterProtocolFactory(
     const string& scheme, ProtocolFactory* factory) {
   return GetJobManager()->RegisterProtocolFactory(scheme, factory);
 }
 
 // static
 void URLRequest::RegisterRequestInterceptor(Interceptor* interceptor) {
@@ skipping 151 matching lines @@
   DCHECK(!is_pending_);
   method_ = method;
 }
 
 void URLRequest::set_referrer(const std::string& referrer) {
   DCHECK(!is_pending_);
   referrer_ = referrer;
 }
 
 void URLRequest::Start() {
+  StartJob(GetJobManager()->CreateJob(this));
+}
+
+void URLRequest::StartJob(URLRequestJob* job) {
   DCHECK(!is_pending_);
   DCHECK(!job_);
 
-  job_ = GetJobManager()->CreateJob(this);
+  job_ = job;
   job_->SetExtraRequestHeaders(extra_request_headers_);
 
   if (upload_.get())
     job_->SetUpload(upload_.get());
 
   is_pending_ = true;
   response_info_.request_time = Time::Now();
   response_info_.was_cached = false;
 
   // Don't allow errors to be sent from within Start().
   // TODO(brettw) this may cause NotifyDone to be sent synchronously,
   // we probably don't want this: they should be sent asynchronously so
   // the caller does not get reentered.
   job_->Start();
 }
 
+void URLRequest::Restart() {
+  // Should only be called if the original job didn't make any progress.
+  DCHECK(job_ && !job_->has_response_started());
+  RestartWithJob(GetJobManager()->CreateJob(this));
+}
+
+void URLRequest::RestartWithJob(URLRequestJob *job) {
+  DCHECK(job->request() == this);
+  OrphanJob();
+  status_ = URLRequestStatus();
+  is_pending_ = false;
+  StartJob(job);
+}
+
 void URLRequest::Cancel() {
   DoCancel(net::ERR_ABORTED, net::SSLInfo());
 }
 
 void URLRequest::SimulateError(int os_error) {
   DoCancel(os_error, net::SSLInfo());
 }
 
 void URLRequest::SimulateSSLError(int os_error, const net::SSLInfo& ssl_info) {
   // This should only be called on a started request.
@@ skipping 39 matching lines @@
 
   // Once the request fails or is cancelled, read will just return 0 bytes
   // to indicate end of stream.
   if (!status_.is_success()) {
     return true;
   }
 
   return job_->Read(dest, dest_size, bytes_read);
 }
 
+void URLRequest::ReceivedRedirect(const GURL& location) {
+  URLRequestJob* job = GetJobManager()->MaybeInterceptRedirect(this, location);
+  if (job) {
+    RestartWithJob(job);
+  } else if (delegate_) {
+    delegate_->OnReceivedRedirect(this, location);
+  }
+}
+
+void URLRequest::ResponseStarted() {
+  URLRequestJob* job = GetJobManager()->MaybeInterceptResponse(this);
+  if (job) {
+    RestartWithJob(job);
+  } else if (delegate_) {
+    delegate_->OnResponseStarted(this);
+  }
+}
+
 void URLRequest::SetAuth(const wstring& username, const wstring& password) {
   DCHECK(job_);
   DCHECK(job_->NeedsAuth());
 
   job_->SetAuth(username, password);
 }
 
 void URLRequest::CancelAuth() {
   DCHECK(job_);
   DCHECK(job_->NeedsAuth());
@@ skipping 83 matching lines @@
 }
 
 int64 URLRequest::GetExpectedContentSize() const {
   int64 expected_content_size = -1;
   if (job_)
     expected_content_size = job_->expected_content_size();
 
   return expected_content_size;
 }
 
+URLRequest::UserData* URLRequest::GetUserData(void* key) const {
+  UserDataMap::const_iterator found = user_data_.find(key);
+  if (found != user_data_.end())
+    return found->second.get();
+  return NULL;
+}
+
+void URLRequest::SetUserData(void* key, UserData* data) {
+  user_data_[key] = linked_ptr<UserData>(data);
+}
+
 #ifndef NDEBUG
 
 URLRequestMetrics::~URLRequestMetrics() {
   DLOG_IF(WARNING, object_count != 0) <<
     "Leaking " << object_count << " URLRequest object(s)";
 }
 
 #endif