[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"
 #include "base/stringprintf.h"
 #include "net/base/net_errors.h"
 #include "net/base/load_flags.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 typedef base::hash_map<std::string, const MockTransaction*> MockTransactionMap;
 static MockTransactionMap mock_transactions;
+
+// Utility class that delegates to another HttpTransaction. Useful to
+// pass to classes that take ownership of the HttpTransaction.

[mmenke, 2013/03/21 15:39:23]

I think this comment should be much more specific.

Maybe replace the second sentence with "Allows the state of a
MockNetworkTransaction to be queried after their owner would normally destroy
it."

[akalin, 2013/03/21 23:43:48]

moot.

+class DelegatingTransaction : public net::HttpTransaction {
+ public:
+  // Assumes |delegate| will outlive this object.
+  explicit DelegatingTransaction(net::HttpTransaction* delegate)

[mmenke, 2013/03/21 15:39:23]

Think this should be a MockHttpTransaction.

The usual transaction types do stuff on destruction, so seems like a good idea
to make it explicit that this doesn't take one of them as an argument.  Maybe
also a comment to that effect.

[akalin, 2013/03/21 23:43:48]

moot.

+      : delegate_(delegate) {}
+
+  virtual ~DelegatingTransaction() {}
+
+  // net::HttpTransaction implementation.
+  virtual int Start(const net::HttpRequestInfo* request_info,
+                    const net::CompletionCallback& callback,
+                    const net::BoundNetLog& net_log) OVERRIDE {
+    return delegate_->Start(request_info, callback, net_log);
+  }
+
+  virtual int RestartIgnoringLastError(
+      const net::CompletionCallback& callback) OVERRIDE {
+    return delegate_->RestartIgnoringLastError(callback);
+  }
+
+  virtual int RestartWithCertificate(
+      net::X509Certificate* client_cert,
+      const net::CompletionCallback& callback) OVERRIDE {
+    return delegate_->RestartWithCertificate(client_cert, callback);
+  }
+
+  virtual int RestartWithAuth(
+      const net::AuthCredentials& credentials,
+      const net::CompletionCallback& callback) OVERRIDE {
+    return delegate_->RestartWithAuth(credentials, callback);
+  }
+
+  virtual bool IsReadyToRestartForAuth() OVERRIDE {
+    return delegate_->IsReadyToRestartForAuth();
+  }
+
+  virtual int Read(net::IOBuffer* buf, int buf_len,
+                   const net::CompletionCallback& callback) OVERRIDE {
+    return delegate_->Read(buf, buf_len, callback);
+  }
+
+  virtual void StopCaching() OVERRIDE {
+    delegate_->StopCaching();
+  }
+
+  virtual void DoneReading() OVERRIDE {
+    delegate_->DoneReading();
+  }
+
+  virtual const net::HttpResponseInfo* GetResponseInfo() const OVERRIDE {
+    return delegate_->GetResponseInfo();
+  }
+
+  virtual net::LoadState GetLoadState() const OVERRIDE {
+    return delegate_->GetLoadState();
+  }
+
+  virtual net::UploadProgress GetUploadProgress() const OVERRIDE {
+    return delegate_->GetUploadProgress();
+  }
+
+  virtual bool GetLoadTimingInfo(
+      net::LoadTimingInfo* load_timing_info) const OVERRIDE {
+    return delegate_->GetLoadTimingInfo(load_timing_info);
+  }
+
+  virtual void SetPriority(net::RequestPriority priority) OVERRIDE {
+    return delegate_->SetPriority(priority);
+  }
+
+ private:
+  net::HttpTransaction* const delegate_;
+};
+
 }  // namespace
 
 //-----------------------------------------------------------------------------
 // mock transaction data
 
 const MockTransaction kSimpleGET_Transaction = {
   "http://www.google.com/",
   "GET",
   base::Time(),
   "",
@@ skipping 180 matching lines @@
     default:
       NOTREACHED();
   }
 }
 
 MockNetworkTransaction::MockNetworkTransaction(
     net::RequestPriority priority,
     MockNetworkLayer* factory)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       data_cursor_(0),
+      priority_(priority),
       transaction_factory_(factory->AsWeakPtr()) {
 }
 
 MockNetworkTransaction::~MockNetworkTransaction() {}
 
 int MockNetworkTransaction::Start(const net::HttpRequestInfo* request,
                                   const net::CompletionCallback& callback,
                                   const net::BoundNetLog& net_log) {
   const MockTransaction* t = FindMockTransaction(request->url);
   if (!t)
@@ skipping 87 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) {}
 
 MockNetworkLayer::~MockNetworkLayer() {}
 
 void MockNetworkLayer::TransactionDoneReading() {
   done_reading_called_ = true;
 }
 
 int MockNetworkLayer::CreateTransaction(
     net::RequestPriority priority,
     scoped_ptr<net::HttpTransaction>* trans,
     net::HttpTransactionDelegate* delegate) {
   transaction_count_++;
-  trans->reset(new MockNetworkTransaction(priority, this));
+  last_transaction_.reset(new MockNetworkTransaction(priority, this));
+  // Assume |trans| won't outlive us.
+  trans->reset(new DelegatingTransaction(last_transaction_.get()));
   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;
 }