Make URLRequestJob::SetStatus private.

net/url_request/url_request.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.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 640 matching lines @@
       referrer_.clear();
       std::string source("delegate");
       net_log_.AddEvent(NetLog::TYPE_CANCELLED,
                         NetLog::StringCallback("source", &source));
       RestartWithJob(new URLRequestErrorJob(
           this, network_delegate_, ERR_BLOCKED_BY_CLIENT));
       return;
     }
   }
 
-  // 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.
+  // Start() always completes asynchronously.
+  //
+  // Status is generally set by URLRequestJob itself, but Start() calls
+  // directly into the URLRequestJob subclass, so URLRequestJob can't set it
+  // here.
+  // TODO(mmenke):  Make the URLRequest manage its own status.
+  status_ = URLRequestStatus::FromError(ERR_IO_PENDING);
   job_->Start();
 }
 
 void URLRequest::Restart() {
   // Should only be called if the original job didn't make any progress.
   DCHECK(job_.get() && !job_->has_response_started());
   RestartWithJob(
       URLRequestJobManager::GetInstance()->CreateJob(this, network_delegate_));
 }
 
@@ skipping 173 matching lines @@
       NotifyRequestCompleted();
 
     OnCallToDelegate();
     delegate_->OnResponseStarted(this);
     // Nothing may appear below this line as OnResponseStarted may delete
     // |this|.
   }
 }
 
 void URLRequest::FollowDeferredRedirect() {
-  CHECK(job_.get());
-  CHECK(status_.is_success());
+  DCHECK(job_.get());
+  DCHECK(status_.is_success());
 
+  status_ = URLRequestStatus::FromError(ERR_IO_PENDING);
   job_->FollowDeferredRedirect();
 }
 
 void URLRequest::SetAuth(const AuthCredentials& credentials) {
   DCHECK(job_.get());
   DCHECK(job_->NeedsAuth());
 
+  status_ = URLRequestStatus::FromError(ERR_IO_PENDING);
   job_->SetAuth(credentials);
 }
 
 void URLRequest::CancelAuth() {
   DCHECK(job_.get());
   DCHECK(job_->NeedsAuth());
 
+  status_ = URLRequestStatus::FromError(ERR_IO_PENDING);
   job_->CancelAuth();
 }
 
 void URLRequest::ContinueWithCertificate(X509Certificate* client_cert,
                                          SSLPrivateKey* client_private_key) {
   DCHECK(job_.get());
 
+  status_ = URLRequestStatus::FromError(ERR_IO_PENDING);
   job_->ContinueWithCertificate(client_cert, client_private_key);
 }
 
 void URLRequest::ContinueDespiteLastError() {
   DCHECK(job_.get());
 
+  status_ = URLRequestStatus::FromError(ERR_IO_PENDING);
   job_->ContinueDespiteLastError();
 }
 
 void URLRequest::PrepareToRestart() {
   DCHECK(job_.get());
 
   // Close the current URL_REQUEST_START_JOB, since we will be starting a new
   // one.
   net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_START_JOB);
 
@@ skipping 206 matching lines @@
       break;
 
     case NetworkDelegate::AUTH_REQUIRED_RESPONSE_IO_PENDING:
       NOTREACHED();
       break;
   }
 }
 
 void URLRequest::NotifyCertificateRequested(
     SSLCertRequestInfo* cert_request_info) {
+  status_ = URLRequestStatus();
   delegate_->OnCertificateRequested(this, cert_request_info);
 }
 
 void URLRequest::NotifySSLCertificateError(const SSLInfo& ssl_info,
                                            bool fatal) {
+  status_ = URLRequestStatus();
   delegate_->OnSSLCertificateError(this, ssl_info, fatal);
 }
 
 bool URLRequest::CanGetCookies(const CookieList& cookie_list) const {
   DCHECK(!(load_flags_ & LOAD_DO_NOT_SEND_COOKIES));
   if (network_delegate_) {
     return network_delegate_->CanGetCookies(*this, cookie_list);
   }
   return g_default_can_use_cookies;
 }
@@ skipping 92 matching lines @@
 }
 
 void URLRequest::GetConnectionAttempts(ConnectionAttempts* out) const {
   if (job_)
     job_->GetConnectionAttempts(out);
   else
     out->clear();
 }
 
 }  // namespace net