6 files changed, 6 insertions, 55 deletions
diff --git a/net/http/http_cache.cc b/net/http/http_cache.cc
index 61e5a91..3758a51 100644
--- a/net/http/http_cache.cc
+++ b/net/http/http_cache.cc
@@ -775,19 +775,6 @@ void HttpCache::ConvertWriterToReader(ActiveEntry* entry) {
   ProcessPendingQueue(entry);
 }
 
-LoadState HttpCache::GetLoadStateForPendingTransaction(
-      const Transaction* trans) {
-  ActiveEntriesMap::const_iterator i = active_entries_.find(trans->key());
-  if (i == active_entries_.end()) {
-    // If this is really a pending transaction, and it is not part of
-    // active_entries_, we should be creating the backend or the entry.
-    return LOAD_STATE_WAITING_FOR_CACHE;
-  }
-
-  Transaction* writer = i->second->writer;
-  return writer->GetWriterLoadState();
-}
-
 void HttpCache::RemovePendingTransaction(Transaction* trans) {
   ActiveEntriesMap::const_iterator i = active_entries_.find(trans->key());
   bool found = false;
diff --git a/net/http/http_cache.h b/net/http/http_cache.h
index daa6d28..7961343 100644
--- a/net/http/http_cache.h
+++ b/net/http/http_cache.h
@@ -28,7 +28,6 @@
 #include "base/weak_ptr.h"
 #include "net/base/cache_type.h"
 #include "net/base/completion_callback.h"
-#include "net/base/load_states.h"
 #include "net/http/http_transaction_factory.h"
 
 class GURL;
@@ -311,9 +310,6 @@ class HttpCache : public HttpTransactionFactory,
   // transactions can start reading from this entry.
   void ConvertWriterToReader(ActiveEntry* entry);
 
-  // Returns the LoadState of the provided pending transaction.
-  LoadState GetLoadStateForPendingTransaction(const Transaction* trans);
-
   // Removes the transaction |trans|, from the pending list of an entry
   // (PendingOp, active or doomed entry).
   void RemovePendingTransaction(Transaction* trans);
diff --git a/net/http/http_cache_transaction.cc b/net/http/http_cache_transaction.cc
index f524c60..96a3622 100644
--- a/net/http/http_cache_transaction.cc
+++ b/net/http/http_cache_transaction.cc
@@ -314,14 +314,11 @@ const HttpResponseInfo* HttpCache::Transaction::GetResponseInfo() const {
 }
 
 LoadState HttpCache::Transaction::GetLoadState() const {
-  LoadState state = GetWriterLoadState();
-  if (state != LOAD_STATE_WAITING_FOR_CACHE)
-    return state;
-
-  if (cache_)
-    return cache_->GetLoadStateForPendingTransaction(this);
-
-  return LOAD_STATE_IDLE;
+  if (network_trans_.get())
+    return network_trans_->GetLoadState();
+  if (entry_ || !request_)
+    return LOAD_STATE_IDLE;
+  return LOAD_STATE_WAITING_FOR_CACHE;
 }
 
 uint64 HttpCache::Transaction::GetUploadProgress() const {
@@ -369,14 +366,6 @@ bool HttpCache::Transaction::AddTruncatedFlag() {
   return true;
 }
 
-LoadState HttpCache::Transaction::GetWriterLoadState() const {
-  if (network_trans_.get())
-    return network_trans_->GetLoadState();
-  if (entry_ || !request_)
-    return LOAD_STATE_IDLE;
-  return LOAD_STATE_WAITING_FOR_CACHE;
-}
-
 //-----------------------------------------------------------------------------
 
 void HttpCache::Transaction::DoCallback(int rv) {
diff --git a/net/http/http_cache_transaction.h b/net/http/http_cache_transaction.h
index f19f76a..a458379 100644
--- a/net/http/http_cache_transaction.h
+++ b/net/http/http_cache_transaction.h
@@ -97,12 +97,6 @@ class HttpCache::Transaction : public HttpTransaction {
   // success.
   bool AddTruncatedFlag();
 
-  // Returns the LoadState of the writer transaction of a given ActiveEntry. In
-  // other words, returns the LoadState of this transaction without asking the
-  // http cache, because this transaction should be the one currently writing
-  // to the cache entry.
-  LoadState GetWriterLoadState() const;
-
   CompletionCallback* io_callback() { return &io_callback_; }
 
  private:
diff --git a/net/http/http_cache_unittest.cc b/net/http/http_cache_unittest.cc
index e341674..dc114da 100644
--- a/net/http/http_cache_unittest.cc
+++ b/net/http/http_cache_unittest.cc
@@ -1401,17 +1401,10 @@ TEST(HttpCache, SimpleGET_ManyReaders) {
 
     c->result = cache.http_cache()->CreateTransaction(&c->trans);
     EXPECT_EQ(net::OK, c->result);
-    EXPECT_EQ(net::LOAD_STATE_IDLE, c->trans->GetLoadState());
 
     c->result = c->trans->Start(&request, &c->callback, net::BoundNetLog());
   }
 
-  // All requests are waiting for the active entry.
-  for (int i = 0; i < kNumTransactions; ++i) {
-    Context* c = context_list[i];
-    EXPECT_EQ(net::LOAD_STATE_WAITING_FOR_CACHE, c->trans->GetLoadState());
-  }
-
   // Allow all requests to move from the Create queue to the active entry.
   MessageLoop::current()->RunAllPending();
 
@@ -1422,13 +1415,6 @@ TEST(HttpCache, SimpleGET_ManyReaders) {
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
-  // All requests depend on the writer, and the writer is between Start and
-  // Read, i.e. idle.
-  for (int i = 0; i < kNumTransactions; ++i) {
-    Context* c = context_list[i];
-    EXPECT_EQ(net::LOAD_STATE_IDLE, c->trans->GetLoadState());
-  }
-
   for (int i = 0; i < kNumTransactions; ++i) {
     Context* c = context_list[i];
     if (c->result == net::ERR_IO_PENDING)
diff --git a/net/http/http_transaction_unittest.h b/net/http/http_transaction_unittest.h
index e550903..baed540 100644
--- a/net/http/http_transaction_unittest.h
+++ b/net/http/http_transaction_unittest.h
@@ -291,8 +291,7 @@ class MockNetworkTransaction : public net::HttpTransaction {
   }
 
   virtual net::LoadState GetLoadState() const {
-    if (data_cursor_)
-      return net::LOAD_STATE_READING_RESPONSE;
+    NOTREACHED() << "define some mock state transitions";
     return net::LOAD_STATE_IDLE;
   }