Make URLRequestJob::SetStatus private.

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 452 matching lines @@
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "456327 URLRequestHttpJob::MaybeStartTransactionInternal"));
 
   OnCallToDelegateComplete();
   if (result == OK) {
     StartTransactionInternal();
   } else {
     std::string source("delegate");
     request_->net_log().AddEvent(NetLog::TYPE_CANCELLED,
                                  NetLog::StringCallback("source", &source));
-    NotifyCanceled();
     NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, result));
   }
 }
 
 void URLRequestHttpJob::StartTransactionInternal() {
   // This should only be called while the request's status is IO_PENDING.
   DCHECK_EQ(URLRequestStatus::IO_PENDING, request_->status().status());
 
   // NOTE: This method assumes that request_info_ is already setup properly.
 
@@ skipping 160 matching lines @@
         http_user_agent_settings_->GetAcceptLanguage();
     if (!accept_language.empty()) {
       request_info_.extra_headers.SetHeaderIfMissing(
           HttpRequestHeaders::kAcceptLanguage,
           accept_language);
     }
   }
 }
 
 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_)
     return;
 
   CookieStore* cookie_store = request_->context()->cookie_store();
   if (cookie_store && !(request_info_.load_flags & LOAD_DO_NOT_SEND_COOKIES)) {
     cookie_store->GetAllCookiesForURLAsync(
         request_->url(),
         base::Bind(&URLRequestHttpJob::CheckCookiePolicyAndLoad,
                    weak_factory_.GetWeakPtr()));
@@ skipping 75 matching lines @@
   SaveNextCookie();
 }
 
 // If the save occurs synchronously, SaveNextCookie will loop and save the next
 // cookie. If the save is deferred, the callback is responsible for continuing
 // to iterate through the cookies.
 // TODO(erikwright): Modify the CookieStore API to indicate via return value
 // whether it completed synchronously or asynchronously.
 // See http://crbug.com/131066.
 void URLRequestHttpJob::SaveNextCookie() {
-  // 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));
-
   // Used to communicate with the callback. See the implementation of
   // OnCookieSaved.
   scoped_refptr<SharedBoolean> callback_pending = new SharedBoolean(false);
   scoped_refptr<SharedBoolean> save_next_cookie_running =
       new SharedBoolean(true);
 
   if (!(request_info_.load_flags & LOAD_DO_NOT_SAVE_COOKIES) &&
       request_->context()->cookie_store() && response_cookies_.size() > 0) {
     CookieOptions options;
     options.set_include_httponly();
@@ skipping 21 matching lines @@
       }
       ++response_cookies_save_index_;
     }
   }
 
   save_next_cookie_running->data = false;
 
   if (!callback_pending->data) {
     response_cookies_.clear();
     response_cookies_save_index_ = 0;
-    SetStatus(URLRequestStatus());  // Clear the IO_PENDING status
     NotifyHeadersComplete();
     return;
   }
 }
 
 // |save_next_cookie_running| is true when the callback is bound and set to
 // false when SaveNextCookie exits, allowing the callback to determine if the
 // save occurred synchronously or asynchronously.
 // |callback_pending| is false when the callback is invoked and will be set to
 // true by the callback, allowing SaveNextCookie to detect whether the save
@@ skipping 120 matching lines @@
   if (!request_)
     return;
 
   // If the job is done (due to cancellation), can just ignore this
   // notification.
   if (done_)
     return;
 
   receive_headers_end_ = base::TimeTicks::Now();
 
-  // Clear the IO_PENDING status
-  SetStatus(URLRequestStatus());
-
   const URLRequestContext* context = request_->context();
 
   if (result == OK) {
     if (transaction_ && transaction_->GetResponseInfo()) {
       SetProxyServer(transaction_->GetResponseInfo()->proxy_server);
     }
     scoped_refptr<HttpResponseHeaders> headers = GetResponseHeaders();
 
     if (headers) {
       void* iter = NULL;
@@ skipping 346 matching lines @@
 void URLRequestHttpJob::ContinueWithCertificate(
     X509Certificate* client_cert,
     SSLPrivateKey* client_private_key) {
   DCHECK(transaction_.get());
 
   DCHECK(!response_info_) << "should not have a response yet";
   receive_headers_end_ = base::TimeTicks();
 
   ResetTimer();
 
-  // 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));
-
   int rv = transaction_->RestartWithCertificate(client_cert, client_private_key,
                                                 start_callback_);
   if (rv == ERR_IO_PENDING)
     return;
 
   // The transaction started synchronously, but we need to notify the
   // URLRequest delegate via the message loop.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&URLRequestHttpJob::OnStartCompleted,
                             weak_factory_.GetWeakPtr(), rv));
 }
 
 void URLRequestHttpJob::ContinueDespiteLastError() {
   // If the transaction was destroyed, then the job was cancelled.
   if (!transaction_.get())
     return;
 
   DCHECK(!response_info_) << "should not have a response yet";
   receive_headers_end_ = base::TimeTicks();
 
   ResetTimer();
 
-  // 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));
-
   int rv = transaction_->RestartIgnoringLastError(start_callback_);
   if (rv == ERR_IO_PENDING)
     return;
 
   // The transaction started synchronously, but we need to notify the
   // URLRequest delegate via the message loop.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&URLRequestHttpJob::OnStartCompleted,
                             weak_factory_.GetWeakPtr(), rv));
 }
@@ skipping 262 matching lines @@
   return override_response_headers_.get() ?
              override_response_headers_.get() :
              transaction_->GetResponseInfo()->headers.get();
 }
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
   awaiting_callback_ = false;
 }
 
 }  // namespace net