[Net] Propagate priority changes from URLRequest to HttpTransaction

net/url_request/url_request_ftp_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_ftp_job.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/auth.h"
@@ skipping 10 matching lines @@
 #include "net/url_request/url_request_error_job.h"
 
 namespace net {
 
 URLRequestFtpJob::URLRequestFtpJob(
     URLRequest* request,
     NetworkDelegate* network_delegate,
     FtpTransactionFactory* ftp_transaction_factory,
     FtpAuthCache* ftp_auth_cache)
     : URLRequestJob(request, network_delegate),
+      priority_(DEFAULT_PRIORITY),
       pac_request_(NULL),
       response_info_(NULL),
       read_in_progress_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       ftp_transaction_factory_(ftp_transaction_factory),
       ftp_auth_cache_(ftp_auth_cache) {
   DCHECK(ftp_transaction_factory);
   DCHECK(ftp_auth_cache);
 }
 
+URLRequestFtpJob::~URLRequestFtpJob() {
+  if (pac_request_)
+    request_->context()->proxy_service()->CancelPacRequest(pac_request_);
+}
+
 // static
 URLRequestJob* URLRequestFtpJob::Factory(URLRequest* request,
                                          NetworkDelegate* network_delegate,
                                          const std::string& scheme) {
   DCHECK_EQ(scheme, "ftp");
 
   int port = request->url().IntPort();
   if (request->url().has_port() &&
       !IsPortAllowedByFtp(port) && !IsPortAllowedByOverride(port)) {
     return new URLRequestErrorJob(request,
@@ skipping 37 matching lines @@
     if (!ftp_transaction_)
       return HostPortPair();
     return ftp_transaction_->GetResponseInfo()->socket_address;
   } else {
     if (!http_transaction_)
       return HostPortPair();
     return http_transaction_->GetResponseInfo()->socket_address;
   }
 }
 
-URLRequestFtpJob::~URLRequestFtpJob() {
-  if (pac_request_)
-    request_->context()->proxy_service()->CancelPacRequest(pac_request_);
+void URLRequestFtpJob::SetPriority(RequestPriority priority) {
+  priority_ = priority;
+  if (http_transaction_)
+    http_transaction_->SetPriority(priority);
+}
+
+void URLRequestFtpJob::Start() {
+  DCHECK(!pac_request_);
+  DCHECK(!ftp_transaction_);
+  DCHECK(!http_transaction_);
+
+  int rv = OK;
+  if (request_->load_flags() & LOAD_BYPASS_PROXY) {
+    proxy_info_.UseDirect();
+  } else {
+    rv = request_->context()->proxy_service()->ResolveProxy(
+        request_->url(),
+        &proxy_info_,
+        base::Bind(&URLRequestFtpJob::OnResolveProxyComplete,
+                   base::Unretained(this)),
+        &pac_request_,
+        request_->net_log());
+
+    if (rv == ERR_IO_PENDING)
+      return;
+  }
+  OnResolveProxyComplete(rv);
+}
+
+void URLRequestFtpJob::Kill() {
+  if (ftp_transaction_)
+    ftp_transaction_.reset();
+  if (http_transaction_)
+    http_transaction_.reset();
+  URLRequestJob::Kill();
+  weak_factory_.InvalidateWeakPtrs();
 }
 
 void URLRequestFtpJob::OnResolveProxyComplete(int result) {
   pac_request_ = NULL;
 
   if (result != OK) {
     OnStartCompletedAsync(result);
     return;
   }
 
@@ skipping 50 matching lines @@
                            LOAD_DO_NOT_SAVE_COOKIES |
                            LOAD_DO_NOT_SEND_AUTH_DATA |
                            LOAD_DO_NOT_SEND_COOKIES);
 
   http_request_info_.url = request_->url();
   http_request_info_.method = request_->method();
   http_request_info_.load_flags = request_->load_flags();
   http_request_info_.request_id = request_->identifier();
 
   int rv = request_->context()->http_transaction_factory()->CreateTransaction(
-      request_->priority(), &http_transaction_, NULL);
+      priority_, &http_transaction_, NULL);
   if (rv == OK) {
     rv = http_transaction_->Start(
         &http_request_info_,
         base::Bind(&URLRequestFtpJob::OnStartCompleted,
                    base::Unretained(this)),
         request_->net_log());
     if (rv == ERR_IO_PENDING)
       return;
   }
   // The transaction started synchronously, but we need to notify the
@@ skipping 71 matching lines @@
   int rv = ftp_transaction_->RestartWithAuth(
       server_auth_->credentials,
       base::Bind(&URLRequestFtpJob::OnStartCompleted,
                  base::Unretained(this)));
   if (rv == ERR_IO_PENDING)
     return;
 
   OnStartCompletedAsync(rv);
 }
 
-void URLRequestFtpJob::Start() {
-  DCHECK(!pac_request_);
-  DCHECK(!ftp_transaction_);
-  DCHECK(!http_transaction_);
-
-  int rv = OK;
-  if (request_->load_flags() & LOAD_BYPASS_PROXY) {
-    proxy_info_.UseDirect();
-  } else {
-    rv = request_->context()->proxy_service()->ResolveProxy(
-        request_->url(),
-        &proxy_info_,
-        base::Bind(&URLRequestFtpJob::OnResolveProxyComplete,
-                   base::Unretained(this)),
-        &pac_request_,
-        request_->net_log());
-
-    if (rv == ERR_IO_PENDING)
-      return;
-  }
-  OnResolveProxyComplete(rv);
-}
-
-void URLRequestFtpJob::Kill() {
-  if (ftp_transaction_)
-    ftp_transaction_.reset();
-  if (http_transaction_)
-    http_transaction_.reset();
-  URLRequestJob::Kill();
-  weak_factory_.InvalidateWeakPtrs();
-}
-
 LoadState URLRequestFtpJob::GetLoadState() const {
   if (proxy_info_.is_direct()) {
     return ftp_transaction_ ?
         ftp_transaction_->GetLoadState() : LOAD_STATE_IDLE;
   } else {
     return http_transaction_ ?
         http_transaction_->GetLoadState() : LOAD_STATE_IDLE;
   }
 }
 
@@ skipping 74 matching lines @@
   if (rv == ERR_IO_PENDING) {
     read_in_progress_ = true;
     SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
   } else {
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
   }
   return false;
 }
 
 }  // namespace net