Replace some net::ERR_FAILED generic error codes with more specific codes....

net/http/http_cache_unittest.cc

 // Copyright (c) 2006-2009 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_cache.h"
 
 #include "base/hash_tables.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
@@ skipping 376 matching lines @@
 
 void RunTransactionTestWithRequestAndLog(net::HttpCache* cache,
                                          const MockTransaction& trans_info,
                                          const MockHttpRequest& request,
                                          net::HttpResponseInfo* response_info,
                                          net::LoadLog* load_log) {
   TestCompletionCallback callback;
 
   // write to the cache
 
-  scoped_ptr<net::HttpTransaction> trans(cache->CreateTransaction());
+  scoped_ptr<net::HttpTransaction> trans;
+  int rv = cache->CreateTransaction(&trans);
+  EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 
-  int rv = trans->Start(&request, &callback, load_log);
+  rv = trans->Start(&request, &callback, load_log);
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(net::OK, rv);
 
   const net::HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
 
   if (response_info)
     *response_info = *response;
 
@@ skipping 233 matching lines @@
 }  // namespace
 
 
 //-----------------------------------------------------------------------------
 // tests
 
 
 TEST(HttpCache, CreateThenDestroy) {
   MockHttpCache cache;
 
-  scoped_ptr<net::HttpTransaction> trans(
-      cache.http_cache()->CreateTransaction());
+  scoped_ptr<net::HttpTransaction> trans;
+  int rv = cache.http_cache()->CreateTransaction(&trans);
+  EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 }
 
 TEST(HttpCache, SimpleGET) {
   MockHttpCache cache;
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
@@ skipping 102 matching lines @@
 TEST(HttpCache, SimpleGET_LoadOnlyFromCache_Miss) {
   MockHttpCache cache;
 
   // force this transaction to read from the cache
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
 
-  scoped_ptr<net::HttpTransaction> trans(
-      cache.http_cache()->CreateTransaction());
+  scoped_ptr<net::HttpTransaction> trans;
+  int rv = cache.http_cache()->CreateTransaction(&trans);
+  EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 
-  int rv = trans->Start(&request, &callback, NULL);
+  rv = trans->Start(&request, &callback, NULL);
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(net::ERR_CACHE_MISS, rv);
 
   trans.reset();
 
   EXPECT_EQ(0, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 }
@@ skipping 118 matching lines @@
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 struct Context {
   int result;
   TestCompletionCallback callback;
   scoped_ptr<net::HttpTransaction> trans;
 
-  explicit Context(net::HttpTransaction* t)
-      : result(net::ERR_IO_PENDING), trans(t) {
+  Context() : result(net::ERR_IO_PENDING) {
   }
 };
 
 TEST(HttpCache, SimpleGET_ManyReaders) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   std::vector<Context*> context_list;
   const int kNumTransactions = 5;
 
   for (int i = 0; i < kNumTransactions; ++i) {
-    context_list.push_back(
-        new Context(cache.http_cache()->CreateTransaction()));
+    context_list.push_back(new Context());
+    Context* c = context_list[i];
 
-    Context* c = context_list[i];
-    int rv = c->trans->Start(&request, &c->callback, NULL);
-    if (rv != net::ERR_IO_PENDING)
-      c->result = rv;
+    c->result = cache.http_cache()->CreateTransaction(&c->trans);
+    EXPECT_EQ(net::OK, c->result);
+
+    c->result = c->trans->Start(&request, &c->callback, NULL);
   }
 
   // the first request should be a writer at this point, and the subsequent
   // requests should be pending.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   for (int i = 0; i < kNumTransactions; ++i) {
@@ skipping 23 matching lines @@
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
   MockHttpRequest reader_request(kSimpleGET_Transaction);
   reader_request.load_flags = net::LOAD_ONLY_FROM_CACHE;
 
   std::vector<Context*> context_list;
   const int kNumTransactions = 5;
 
   for (int i = 0; i < kNumTransactions; ++i) {
-    context_list.push_back(
-        new Context(cache.http_cache()->CreateTransaction()));
+    context_list.push_back(new Context());
+    Context* c = context_list[i];
 
-    Context* c = context_list[i];
+    c->result = cache.http_cache()->CreateTransaction(&c->trans);
+    EXPECT_EQ(net::OK, c->result);
+
     MockHttpRequest* this_request = &request;
     if (i == 1 || i == 2)
       this_request = &reader_request;
 
-    int rv = c->trans->Start(this_request, &c->callback, NULL);
-    if (rv != net::ERR_IO_PENDING)
-      c->result = rv;
+    c->result = c->trans->Start(this_request, &c->callback, NULL);
   }
 
   // The first request should be a writer at this point, and the subsequent
   // requests should be pending.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   Context* c = context_list[0];
@@ skipping 45 matching lines @@
 
   // The headers will be served right from the call to Start() the request.
   MockHttpRequest request(kFastNoStoreGET_Transaction);
   FastTransactionServer request_handler;
   AddMockTransaction(&kFastNoStoreGET_Transaction);
 
   std::vector<Context*> context_list;
   const int kNumTransactions = 3;
 
   for (int i = 0; i < kNumTransactions; ++i) {
-    context_list.push_back(
-        new Context(cache.http_cache()->CreateTransaction()));
+    context_list.push_back(new Context());
+    Context* c = context_list[i];
 
-    Context* c = context_list[i];
-    int rv = c->trans->Start(&request, &c->callback, NULL);
-    if (rv != net::ERR_IO_PENDING)
-      c->result = rv;
+    c->result = cache.http_cache()->CreateTransaction(&c->trans);
+    EXPECT_EQ(net::OK, c->result);
+
+    c->result = c->trans->Start(&request, &c->callback, NULL);
   }
 
   // The first request should be a writer at this point, and the subsequent
   // requests should be pending.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Now, make sure that the second request asks for the entry not to be stored.
@@ skipping 16 matching lines @@
 
 TEST(HttpCache, SimpleGET_ManyWriters_CancelFirst) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   std::vector<Context*> context_list;
   const int kNumTransactions = 2;
 
   for (int i = 0; i < kNumTransactions; ++i) {
-    context_list.push_back(
-        new Context(cache.http_cache()->CreateTransaction()));
+    context_list.push_back(new Context());
+    Context* c = context_list[i];
 
-    Context* c = context_list[i];
-    int rv = c->trans->Start(&request, &c->callback, NULL);
-    if (rv != net::ERR_IO_PENDING)
-      c->result = rv;
+    c->result = cache.http_cache()->CreateTransaction(&c->trans);
+    EXPECT_EQ(net::OK, c->result);
+
+    c->result = c->trans->Start(&request, &c->callback, NULL);
   }
 
   // the first request should be a writer at this point, and the subsequent
   // requests should be pending.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   for (int i = 0; i < kNumTransactions; ++i) {
@@ skipping 27 matching lines @@
 
 TEST(HttpCache, SimpleGET_AbandonedCacheRead) {
   MockHttpCache cache;
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   MockHttpRequest request(kSimpleGET_Transaction);
   TestCompletionCallback callback;
 
-  scoped_ptr<net::HttpTransaction> trans(
-      cache.http_cache()->CreateTransaction());
-  int rv = trans->Start(&request, &callback, NULL);
+  scoped_ptr<net::HttpTransaction> trans;
+  int rv = cache.http_cache()->CreateTransaction(&trans);
+  EXPECT_EQ(net::OK, rv);
+  rv = trans->Start(&request, &callback, NULL);
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(net::OK, rv);
 
   scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(256);
   rv = trans->Read(buf, 256, &callback);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   // Test that destroying the transaction while it is reading from the cache
   // works properly.
@@ skipping 490 matching lines @@
   // Test that we skip the cache for POST requests.  Eventually, we will want
   // to cache these, but we'll still have cases where skipping the cache makes
   // sense, so we want to make sure that it works properly.
 
   MockTransaction transaction(kSimplePOST_Transaction);
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
 
-  scoped_ptr<net::HttpTransaction> trans(
-      cache.http_cache()->CreateTransaction());
+  scoped_ptr<net::HttpTransaction> trans;
+  int rv = cache.http_cache()->CreateTransaction(&trans);
+  EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 
-  int rv = trans->Start(&request, &callback, NULL);
+  rv = trans->Start(&request, &callback, NULL);
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(net::ERR_CACHE_MISS, rv);
 
   trans.reset();
 
   EXPECT_EQ(0, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 }
@@ skipping 613 matching lines @@
 }
 
 // Tests that we don't delete a sparse entry when we cancel a request.
 TEST(HttpCache, RangeGET_Cancel) {
   MockHttpCache cache;
   cache.http_cache()->set_enable_range_support(true);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   MockHttpRequest request(kRangeGET_TransactionOK);
 
-  Context* c =  new Context(cache.http_cache()->CreateTransaction());
+  Context* c = new Context();
+  int rv = cache.http_cache()->CreateTransaction(&c->trans);
+  EXPECT_EQ(net::OK, rv);
 
-  int rv = c->trans->Start(&request, &c->callback, NULL);
+  rv = c->trans->Start(&request, &c->callback, NULL);
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure that the entry has some data stored.
   scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(10);
   rv = c->trans->Read(buf, buf->size(), &c->callback);
@@ skipping 25 matching lines @@
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Force this transaction to read from the cache.
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
 
-  scoped_ptr<net::HttpTransaction> trans(
-      cache.http_cache()->CreateTransaction());
+  scoped_ptr<net::HttpTransaction> trans;
+  int rv = cache.http_cache()->CreateTransaction(&trans);
+  EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 
   int rv = trans->Start(&request, &callback, NULL);
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(net::ERR_CACHE_MISS, rv);
 
   trans.reset();
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
@@ skipping 30 matching lines @@
 }
 
 // Tests that we delete an entry when the request is cancelled before starting
 // to read from the network.
 TEST(HttpCache, DoomOnDestruction) {
   MockHttpCache cache;
   cache.http_cache()->set_enable_range_support(true);
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
-  Context* c =  new Context(cache.http_cache()->CreateTransaction());
+  Context* c = new Context();
+  int rv = cache.http_cache()->CreateTransaction(&c->trans);
+  EXPECT_EQ(net::OK, rv);
 
-  int rv = c->trans->Start(&request, &c->callback, NULL);
+  rv = c->trans->Start(&request, &c->callback, NULL);
   if (rv == net::ERR_IO_PENDING)
     c->result = c->callback.WaitForResult();
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Destroy the transaction. We only have the headers so we should delete this
   // entry.
   delete c;
 
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 // Tests that we mark an entry as incomplete when the request is cancelled.
 TEST(HttpCache, Set_Truncated_Flag) {
   MockHttpCache cache;
   cache.http_cache()->set_enable_range_support(true);
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
-  Context* c =  new Context(cache.http_cache()->CreateTransaction());
+  Context* c = new Context();
+  int rv = cache.http_cache()->CreateTransaction(&c->trans);
+  EXPECT_EQ(net::OK, rv);
 
-  int rv = c->trans->Start(&request, &c->callback, NULL);
+  rv = c->trans->Start(&request, &c->callback, NULL);
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure that the entry has some data stored.
   scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(10);
   rv = c->trans->Read(buf, buf->size(), &c->callback);
@@ skipping 136 matching lines @@
 
   ScopedMockTransaction kTestTransaction(kSimpleGET_Transaction);
   kTestTransaction.status = "HTTP/1.1 301 Moved Permanently";
   kTestTransaction.response_headers = "Location: http://www.bar.com/\n";
 
   MockHttpRequest request(kTestTransaction);
   TestCompletionCallback callback;
 
   // write to the cache
   {
-    scoped_ptr<net::HttpTransaction> trans(
-        cache.http_cache()->CreateTransaction());
+    scoped_ptr<net::HttpTransaction> trans;
+    int rv = cache.http_cache()->CreateTransaction(&trans);
+    EXPECT_EQ(net::OK, rv);
     ASSERT_TRUE(trans.get());
 
-    int rv = trans->Start(&request, &callback, NULL);
+    rv = trans->Start(&request, &callback, NULL);
     if (rv == net::ERR_IO_PENDING)
       rv = callback.WaitForResult();
     ASSERT_EQ(net::OK, rv);
 
     const net::HttpResponseInfo* info = trans->GetResponseInfo();
     ASSERT_TRUE(info);
 
     EXPECT_EQ(info->headers->response_code(), 301);
 
     std::string location;
     info->headers->EnumerateHeader(NULL, "Location", &location);
     EXPECT_EQ(location, "http://www.bar.com/");
 
     // Destroy transaction when going out of scope. We have not actually
     // read the response body -- want to test that it is still getting cached.
   }
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // read from the cache
   {
-    scoped_ptr<net::HttpTransaction> trans(
-        cache.http_cache()->CreateTransaction());
+    scoped_ptr<net::HttpTransaction> trans;
+    int rv = cache.http_cache()->CreateTransaction(&trans);
+    EXPECT_EQ(net::OK, rv);
     ASSERT_TRUE(trans.get());
 
-    int rv = trans->Start(&request, &callback, NULL);
+    rv = trans->Start(&request, &callback, NULL);
     if (rv == net::ERR_IO_PENDING)
       rv = callback.WaitForResult();
     ASSERT_EQ(net::OK, rv);
 
     const net::HttpResponseInfo* info = trans->GetResponseInfo();
     ASSERT_TRUE(info);
 
     EXPECT_EQ(info->headers->response_code(), 301);
 
     std::string location;
@@ skipping 102 matching lines @@
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Test that it was not cached.
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
 
-  scoped_ptr<net::HttpTransaction> trans(
-      cache.http_cache()->CreateTransaction());
+  scoped_ptr<net::HttpTransaction> trans;
+  int rv = cache.http_cache()->CreateTransaction(&trans);
+  EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 
-  int rv = trans->Start(&request, &callback, NULL);
+  rv = trans->Start(&request, &callback, NULL);
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(net::ERR_CACHE_MISS, rv);
 }
 
 // Ensure that we don't crash by if left-behind transactions.
 TEST(HttpCache, OutlivedTransactions) {
   MockHttpCache* cache = new MockHttpCache;
 
-  net::HttpTransaction* trans = cache->http_cache()->CreateTransaction();
+  scoped_ptr<net::HttpTransaction> trans;
+  int rv = cache->http_cache()->CreateTransaction(&trans);
+  EXPECT_EQ(net::OK, rv);
+
   delete cache;
-  delete trans;
+  trans.reset();
 }
 
 // Test that the disabled mode works.
 TEST(HttpCache, CacheDisabledMode) {
   MockHttpCache cache;
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   // go into disabled mode
@@ skipping 75 matching lines @@
   std::string headers;
   response.headers->GetNormalizedHeaders(&headers);
 
   EXPECT_EQ("HTTP/1.1 200 OK\n"
             "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
             "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
             headers);
 
   RemoveMockTransaction(&mock_network_response);
 }