Revert 189829 "[Net] Propagate priority changes from URLRequest ..."

See heapcheck failures:
http://build.chromium.org/p/chromium.memory.fyi/builders/Linux%20Heapcheck/builds/25563
http://build.chromium.org/p/chromium.memory.fyi/builders/Linux%20Heapcheck/builds/25563/steps/heapcheck%20test%3A%20net/logs/stdio

Example (one of many):
Leak of 792 bytes in 1 objects allocated from:
	@ 10d675b URLRequestFtpJobPriorityTest
	@ 10d68e7 URLRequestFtpJobPriorityTest_SetPriorityBasic_Test
	@ 10de383 CreateTest

Suppression (error hash=#0A68FF60C5D043B8#):
{
   <insert_a_suppression_name_here>
   Heapcheck:Leak
   fun:URLRequestFtpJobPriorityTest
   fun:URLRequestFtpJobPriorityTest_SetPriorityBasic_Test
   fun:CreateTest
}

> [Net] Propagate priority changes from URLRequest to HttpTransaction
> 
> This is in preparation for propagating priority changes from
> ResourceScheduler all the way to HostResolver and ClientSocketPool.
> 
> Add some NetLog events and parameters for priority.
> 
> BUG=166689
> TBR=simonjam@chromium.org,sky@chromium.org
> 
> Review URL: https://codereview.chromium.org/12701011

TBR=akalin@chromium.org
Review URL: https://codereview.chromium.org/12676022

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@189872 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 21 insertions, 168 deletions

diff --git a/net/http/http_cache_transaction.cc b/net/http/http_cache_transaction.cc
index c45a8a0..683dff3 100644
--- a/net/http/http_cache_transaction.cc
+++ b/net/http/http_cache_transaction.cc
@@ -467,12 +467,6 @@ bool HttpCache::Transaction::GetLoadTimingInfo(
   return false;
 }
 
-void HttpCache::Transaction::SetPriority(RequestPriority priority) {
-  priority_ = priority;
-  if (network_trans_)
-    network_trans_->SetPriority(priority_);
-}
-
 //-----------------------------------------------------------------------------
 
 void HttpCache::Transaction::DoCallback(int rv) {
diff --git a/net/http/http_cache_transaction.h b/net/http/http_cache_transaction.h
index 65ca970..4f3965e 100644
--- a/net/http/http_cache_transaction.h
+++ b/net/http/http_cache_transaction.h
@@ -127,7 +127,6 @@ class HttpCache::Transaction : public HttpTransaction {
   virtual UploadProgress GetUploadProgress(void) const OVERRIDE;
   virtual bool GetLoadTimingInfo(
       LoadTimingInfo* load_timing_info) const OVERRIDE;
-  virtual void SetPriority(RequestPriority priority) OVERRIDE;
 
  private:
   static const size_t kNumValidationHeaders = 2;
diff --git a/net/http/http_cache_unittest.cc b/net/http/http_cache_unittest.cc
index a97ba8a..0d38d86 100644
--- a/net/http/http_cache_unittest.cc
+++ b/net/http/http_cache_unittest.cc
@@ -5567,88 +5567,3 @@ TEST(HttpCache, SimpleGET_LoadOnlyFromCache_Hit_TransactionDelegate) {
                                  5,
                                  0);
 }
-
-// Make sure that calling SetPriority on a cache transaction passes on
-// its priority updates to its underlying network transaction.
-TEST(HttpCache, SetPriority) {
-  MockHttpCache cache;
-
-  scoped_ptr<net::HttpTransaction> trans;
-  EXPECT_EQ(net::OK, cache.http_cache()->CreateTransaction(
-      net::IDLE, &trans, NULL));
-  ASSERT_TRUE(trans.get());
-
-  // Shouldn't crash, but doesn't do anything either.
-  trans->SetPriority(net::LOW);
-
-  EXPECT_FALSE(cache.network_layer()->last_transaction());
-  EXPECT_EQ(net::DEFAULT_PRIORITY,
-            cache.network_layer()->last_create_transaction_priority());
-
-  net::HttpRequestInfo info;
-  info.url = GURL(kSimpleGET_Transaction.url);
-  net::TestCompletionCallback callback;
-  EXPECT_EQ(net::ERR_IO_PENDING,
-            trans->Start(&info, callback.callback(), net::BoundNetLog()));
-
-  ASSERT_TRUE(cache.network_layer()->last_transaction());
-  EXPECT_EQ(net::LOW,
-            cache.network_layer()->last_create_transaction_priority());
-  EXPECT_EQ(net::LOW,
-            cache.network_layer()->last_transaction()->priority());
-
-  trans->SetPriority(net::HIGHEST);
-  EXPECT_EQ(net::LOW,
-            cache.network_layer()->last_create_transaction_priority());
-  EXPECT_EQ(net::HIGHEST,
-            cache.network_layer()->last_transaction()->priority());
-
-  EXPECT_EQ(net::OK, callback.WaitForResult());
-}
-
-// Make sure that a cache transaction passes on its priority to
-// newly-created network transactions.
-TEST(HttpCache, SetPriorityNewTransaction) {
-  MockHttpCache cache;
-  AddMockTransaction(&kRangeGET_TransactionOK);
-
-  std::string raw_headers("HTTP/1.1 200 OK\n"
-                          "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
-                          "ETag: \"foo\"\n"
-                          "Accept-Ranges: bytes\n"
-                          "Content-Length: 80\n");
-  CreateTruncatedEntry(raw_headers, &cache);
-
-  // Now make a regular request.
-  std::string headers;
-  MockTransaction transaction(kRangeGET_TransactionOK);
-  transaction.request_headers = EXTRA_HEADER;
-  transaction.data = "rg: 00-09 rg: 10-19 rg: 20-29 rg: 30-39 rg: 40-49 "
-                     "rg: 50-59 rg: 60-69 rg: 70-79 ";
-
-  scoped_ptr<net::HttpTransaction> trans;
-  EXPECT_EQ(net::OK, cache.http_cache()->CreateTransaction(
-      net::MEDIUM, &trans, NULL));
-  ASSERT_TRUE(trans.get());
-  EXPECT_EQ(net::DEFAULT_PRIORITY,
-            cache.network_layer()->last_create_transaction_priority());
-
-  MockHttpRequest info(transaction);
-  net::TestCompletionCallback callback;
-  EXPECT_EQ(net::ERR_IO_PENDING,
-            trans->Start(&info, callback.callback(), net::BoundNetLog()));
-  EXPECT_EQ(net::OK, callback.WaitForResult());
-
-  EXPECT_EQ(net::MEDIUM,
-            cache.network_layer()->last_create_transaction_priority());
-
-  trans->SetPriority(net::HIGHEST);
-  // Should trigger a new network transaction and pick up the new
-  // priority.
-  ReadAndVerifyTransaction(trans.get(), transaction);
-
-  EXPECT_EQ(net::HIGHEST,
-            cache.network_layer()->last_create_transaction_priority());
-
-  RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
diff --git a/net/http/http_network_transaction.cc b/net/http/http_network_transaction.cc
index 3c2596d..4393c57 100644
--- a/net/http/http_network_transaction.cc
+++ b/net/http/http_network_transaction.cc
@@ -387,26 +387,6 @@ UploadProgress HttpNetworkTransaction::GetUploadProgress() const {
   return static_cast<HttpStream*>(stream_.get())->GetUploadProgress();
 }
 
-bool HttpNetworkTransaction::GetLoadTimingInfo(
-    LoadTimingInfo* load_timing_info) const {
-  if (!stream_ || !stream_->GetLoadTimingInfo(load_timing_info))
-    return false;
-
-  load_timing_info->proxy_resolve_start =
-      proxy_info_.proxy_resolve_start_time();
-  load_timing_info->proxy_resolve_end = proxy_info_.proxy_resolve_end_time();
-  load_timing_info->send_start = send_start_time_;
-  load_timing_info->send_end = send_end_time_;
-  load_timing_info->receive_headers_end = receive_headers_end_;
-  return true;
-}
-
-void HttpNetworkTransaction::SetPriority(RequestPriority priority) {
-  priority_ = priority;
-  // TODO(akalin): Plumb this through to |stream_request_| and
-  // |stream_|.
-}
-
 void HttpNetworkTransaction::OnStreamReady(const SSLConfig& used_ssl_config,
                                            const ProxyInfo& used_proxy_info,
                                            HttpStreamBase* stream) {
@@ -504,6 +484,20 @@ void HttpNetworkTransaction::OnHttpsProxyTunnelResponse(
   OnIOComplete(ERR_HTTPS_PROXY_TUNNEL_RESPONSE);
 }
 
+bool HttpNetworkTransaction::GetLoadTimingInfo(
+    LoadTimingInfo* load_timing_info) const {
+  if (!stream_ || !stream_->GetLoadTimingInfo(load_timing_info))
+    return false;
+
+  load_timing_info->proxy_resolve_start =
+      proxy_info_.proxy_resolve_start_time();
+  load_timing_info->proxy_resolve_end = proxy_info_.proxy_resolve_end_time();
+  load_timing_info->send_start = send_start_time_;
+  load_timing_info->send_end = send_end_time_;
+  load_timing_info->receive_headers_end = receive_headers_end_;
+  return true;
+}
+
 bool HttpNetworkTransaction::is_https_request() const {
   return request_->url.SchemeIs("https");
 }
diff --git a/net/http/http_network_transaction.h b/net/http/http_network_transaction.h
index ca7a79d..9754aff 100644
--- a/net/http/http_network_transaction.h
+++ b/net/http/http_network_transaction.h
@@ -61,9 +61,6 @@ class NET_EXPORT_PRIVATE HttpNetworkTransaction
   virtual const HttpResponseInfo* GetResponseInfo() const OVERRIDE;
   virtual LoadState GetLoadState() const OVERRIDE;
   virtual UploadProgress GetUploadProgress() const OVERRIDE;
-  virtual bool GetLoadTimingInfo(
-      LoadTimingInfo* load_timing_info) const OVERRIDE;
-  virtual void SetPriority(RequestPriority priority) OVERRIDE;
 
   // HttpStreamRequest::Delegate methods:
   virtual void OnStreamReady(const SSLConfig& used_ssl_config,
@@ -86,6 +83,9 @@ class NET_EXPORT_PRIVATE HttpNetworkTransaction
                                           const ProxyInfo& used_proxy_info,
                                           HttpStreamBase* stream) OVERRIDE;
 
+  virtual bool GetLoadTimingInfo(
+      LoadTimingInfo* load_timing_info) const OVERRIDE;
+
  private:
   FRIEND_TEST_ALL_PREFIXES(HttpNetworkTransactionSpdy2Test,
                            ResetStateForRestart);
diff --git a/net/http/http_stream_factory_impl_job.cc b/net/http/http_stream_factory_impl_job.cc
index 6a906d2..6072fa9 100644
--- a/net/http/http_stream_factory_impl_job.cc
+++ b/net/http/http_stream_factory_impl_job.cc
@@ -44,12 +44,10 @@ namespace net {
 // Returns parameters associated with the start of a HTTP stream job.
 Value* NetLogHttpStreamJobCallback(const GURL* original_url,
                                    const GURL* url,
-                                   RequestPriority priority,
                                    NetLog::LogLevel /* log_level */) {
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString("original_url", original_url->GetOrigin().spec());
   dict->SetString("url", url->GetOrigin().spec());
-  dict->SetInteger("priority", priority);
   return dict;
 }
 
@@ -580,8 +578,7 @@ int HttpStreamFactoryImpl::Job::DoStart() {
 
   net_log_.BeginEvent(NetLog::TYPE_HTTP_STREAM_JOB,
                       base::Bind(&NetLogHttpStreamJobCallback,
-                                 &request_info_.url, &origin_url_,
-                                 priority_));
+                                 &request_info_.url, &origin_url_));
 
   // Don't connect to restricted ports.
   bool is_port_allowed = IsPortAllowedByDefault(port);
diff --git a/net/http/http_transaction.h b/net/http/http_transaction.h
index c162b01..7b4ab99 100644
--- a/net/http/http_transaction.h
+++ b/net/http/http_transaction.h
@@ -8,7 +8,6 @@
 #include "net/base/completion_callback.h"
 #include "net/base/load_states.h"
 #include "net/base/net_export.h"
-#include "net/base/request_priority.h"
 #include "net/base/upload_progress.h"
 
 namespace net {
@@ -117,9 +116,6 @@ class NET_EXPORT_PRIVATE HttpTransaction {
   // |load_timing_info| must have all null times when called.  Returns false and
   // does not modify |load_timing_info| if not currently connected.
   virtual bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const = 0;
-
-  // Called when the priority of the parent job changes.
-  virtual void SetPriority(RequestPriority priority) = 0;
 };
 
 }  // namespace net
diff --git a/net/http/http_transaction_unittest.cc b/net/http/http_transaction_unittest.cc
index 3d96628..84cba0b 100644
--- a/net/http/http_transaction_unittest.cc
+++ b/net/http/http_transaction_unittest.cc
@@ -221,7 +221,6 @@ MockNetworkTransaction::MockNetworkTransaction(
     MockNetworkLayer* factory)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       data_cursor_(0),
-      priority_(priority),
       transaction_factory_(factory->AsWeakPtr()) {
 }
 
@@ -329,10 +328,6 @@ bool MockNetworkTransaction::GetLoadTimingInfo(
   return false;
 }
 
-void MockNetworkTransaction::SetPriority(net::RequestPriority priority) {
-  priority_ = priority;
-}
-
 void MockNetworkTransaction::CallbackLater(
     const net::CompletionCallback& callback, int result) {
   MessageLoop::current()->PostTask(
@@ -346,9 +341,7 @@ void MockNetworkTransaction::RunCallback(
 }
 
 MockNetworkLayer::MockNetworkLayer()
-    : transaction_count_(0),
-      done_reading_called_(false),
-      last_create_transaction_priority_(net::DEFAULT_PRIORITY) {}
+    : transaction_count_(0), done_reading_called_(false) {}
 
 MockNetworkLayer::~MockNetworkLayer() {}
 
@@ -361,11 +354,7 @@ int MockNetworkLayer::CreateTransaction(
     scoped_ptr<net::HttpTransaction>* trans,
     net::HttpTransactionDelegate* delegate) {
   transaction_count_++;
-  last_create_transaction_priority_ = priority;
-  scoped_ptr<MockNetworkTransaction> mock_transaction(
-      new MockNetworkTransaction(priority, this));
-  last_transaction_ = mock_transaction->AsWeakPtr();
-  *trans = mock_transaction.Pass();
+  trans->reset(new MockNetworkTransaction(priority, this));
   return net::OK;
 }
 
diff --git a/net/http/http_transaction_unittest.h b/net/http/http_transaction_unittest.h
index 29d558d8..693b720 100644
--- a/net/http/http_transaction_unittest.h
+++ b/net/http/http_transaction_unittest.h
@@ -11,7 +11,6 @@
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
-#include "base/memory/weak_ptr.h"
 #include "base/string16.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
@@ -154,9 +153,7 @@ class MockNetworkLayer;
 // find data for the request URL.  It supports IO operations that complete
 // synchronously or asynchronously to help exercise different code paths in the
 // HttpCache implementation.
-class MockNetworkTransaction
-    : public net::HttpTransaction,
-      public base::SupportsWeakPtr<MockNetworkTransaction> {
+class MockNetworkTransaction : public net::HttpTransaction {
  public:
   MockNetworkTransaction(net::RequestPriority priority,
                          MockNetworkLayer* factory);
@@ -195,10 +192,6 @@ class MockNetworkTransaction
   virtual bool GetLoadTimingInfo(
       net::LoadTimingInfo* load_timing_info) const OVERRIDE;
 
-  virtual void SetPriority(net::RequestPriority priority) OVERRIDE;
-
-  net::RequestPriority priority() const { return priority_; }
-
  private:
   void CallbackLater(const net::CompletionCallback& callback, int result);
   void RunCallback(const net::CompletionCallback& callback, int result);
@@ -208,7 +201,6 @@ class MockNetworkTransaction
   std::string data_;
   int data_cursor_;
   int test_mode_;
-  net::RequestPriority priority_;
   base::WeakPtr<MockNetworkLayer> transaction_factory_;
 };
 
@@ -222,27 +214,6 @@ class MockNetworkLayer : public net::HttpTransactionFactory,
   bool done_reading_called() const { return done_reading_called_; }
   void TransactionDoneReading();
 
-  // Returns the last priority passed to CreateTransaction, or
-  // DEFAULT_PRIORITY if it hasn't been called yet.
-  net::RequestPriority last_create_transaction_priority() const {
-    return last_create_transaction_priority_;
-  }
-
-  // Returns the last transaction created by
-  // CreateTransaction. Returns a NULL WeakPtr if one has not been
-  // created yet, or the last transaction has been destroyed, or
-  // ClearLastTransaction() has been called and a new transaction
-  // hasn't been created yet.
-  base::WeakPtr<MockNetworkTransaction> last_transaction() {
-    return last_transaction_;
-  }
-
-  // Makes last_transaction() return NULL until the next transaction
-  // is created.
-  void ClearLastTransaction() {
-    last_transaction_.reset();
-  }
-
   // net::HttpTransactionFactory:
   virtual int CreateTransaction(
       net::RequestPriority priority,
@@ -254,8 +225,6 @@ class MockNetworkLayer : public net::HttpTransactionFactory,
  private:
   int transaction_count_;
   bool done_reading_called_;
-  net::RequestPriority last_create_transaction_priority_;
-  base::WeakPtr<MockNetworkTransaction> last_transaction_;
 };
 
 //-----------------------------------------------------------------------------