[Net] Propagate priority changes from URLRequest to HttpTransaction

net/http/http_transaction_unittest.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/http/http_transaction_unittest.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
@@ skipping 200 matching lines @@
       DidRead(result);
       break;
     default:
       NOTREACHED();
   }
 }
 
 MockNetworkTransaction::MockNetworkTransaction(MockNetworkLayer* factory)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       data_cursor_(0),
+      priority_(net::IDLE),
       transaction_factory_(factory->AsWeakPtr()) {
 }
 
 MockNetworkTransaction::~MockNetworkTransaction() {}
 
 int MockNetworkTransaction::Start(const net::HttpRequestInfo* request,
                                   const net::CompletionCallback& callback,
                                   const net::BoundNetLog& net_log) {
+  priority_ = request->priority;
+
   const MockTransaction* t = FindMockTransaction(request->url);
   if (!t)
     return net::ERR_FAILED;
 
   std::string resp_status = t->status;
   std::string resp_headers = t->response_headers;
   std::string resp_data = t->data;
   if (t->handler)
     (t->handler)(request, &resp_status, &resp_headers, &resp_data);
 
@@ skipping 79 matching lines @@
 
 net::UploadProgress MockNetworkTransaction::GetUploadProgress() const {
   return net::UploadProgress();
 }
 
 bool MockNetworkTransaction::GetLoadTimingInfo(
     net::LoadTimingInfo* load_timing_info) const {
   return false;
 }
 
+void MockNetworkTransaction::SetPriority(net::RequestPriority priority) {
+  priority_ = priority;
+}
+
 void MockNetworkTransaction::CallbackLater(
     const net::CompletionCallback& callback, int result) {
   MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&MockNetworkTransaction::RunCallback,
                             weak_factory_.GetWeakPtr(), callback, result));
 }
 
 void MockNetworkTransaction::RunCallback(
     const net::CompletionCallback& callback, int result) {
   callback.Run(result);
 }
 
 MockNetworkLayer::MockNetworkLayer()
-    : transaction_count_(0), done_reading_called_(false) {}
+    : transaction_count_(0),
+      done_reading_called_(false),
+      last_transaction_(NULL) {}
 
 MockNetworkLayer::~MockNetworkLayer() {}
 
 void MockNetworkLayer::TransactionDoneReading() {
   done_reading_called_ = true;
 }
 
 int MockNetworkLayer::CreateTransaction(
     scoped_ptr<net::HttpTransaction>* trans,
     net::HttpTransactionDelegate* delegate) {
   transaction_count_++;
-  trans->reset(new MockNetworkTransaction(this));
+  last_transaction_ = new MockNetworkTransaction(this);
+  trans->reset(last_transaction_);
   return net::OK;
 }
 
 net::HttpCache* MockNetworkLayer::GetCache() {
   return NULL;
 }
 
 net::HttpNetworkSession* MockNetworkLayer::GetSession() {
   return NULL;
 }
@@ skipping 15 matching lines @@
 
     if (rv > 0)
       content.append(buf->data(), rv);
     else if (rv < 0)
       return rv;
   } while (rv > 0);
 
   result->swap(content);
   return net::OK;
 }