Revert 49600 - Http cache: Remove deprecated code.

BUG=26729
TEST=current tests

Review URL: http://codereview.chromium.org/2776007

TBR=rvargas@google.com
Review URL: http://codereview.chromium.org/2779020

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

3 files changed, 84 insertions, 16 deletions

diff --git a/net/http/http_cache.cc b/net/http/http_cache.cc
index 162cc26..585f9b5 100644
--- a/net/http/http_cache.cc
+++ b/net/http/http_cache.cc
@@ -37,8 +37,18 @@ namespace net {
 int HttpCache::DefaultBackend::CreateBackend(disk_cache::Backend** backend,
                                              CompletionCallback* callback) {
   DCHECK_GE(max_bytes_, 0);
-  return disk_cache::CreateCacheBackend(type_, path_, max_bytes_, true,
-                                        thread_, backend, callback);
+  if (callback)
+    return disk_cache::CreateCacheBackend(type_, path_, max_bytes_, true,
+                                          thread_, backend, callback);
+
+  // This is just old code needed to support synchronous cache creation.
+  // TODO(rvargas): Remove this once all callers provide a callback.
+  if (type_ == MEMORY_CACHE) {
+    *backend = disk_cache::CreateInMemoryCacheBackend(max_bytes_);
+  } else {
+    *backend = disk_cache::CreateCacheBackend(path_, true, max_bytes_, type_);
+  }
+  return (*backend ? OK : ERR_FAILED);
 }
 
 //-----------------------------------------------------------------------------
@@ -291,6 +301,19 @@ HttpCache::~HttpCache() {
   }
 }
 
+disk_cache::Backend* HttpCache::GetBackend() {
+  if (disk_cache_.get())
+    return disk_cache_.get();
+
+  if (backend_factory_.get()) {
+    disk_cache::Backend* backend;
+    if (OK == backend_factory_->CreateBackend(&backend, NULL))
+      disk_cache_.reset(backend);
+    backend_factory_.reset();  // Reclaim memory.
+  }
+  return disk_cache_.get();
+}
+
 int HttpCache::GetBackend(disk_cache::Backend** backend,
                           CompletionCallback* callback) {
   DCHECK(callback != NULL);
@@ -331,6 +354,40 @@ void HttpCache::Suspend(bool suspend) {
 }
 
 // static
+bool HttpCache::ReadResponseInfo(disk_cache::Entry* disk_entry,
+                                 HttpResponseInfo* response_info,
+                                 bool* response_truncated) {
+  int size = disk_entry->GetDataSize(kResponseInfoIndex);
+
+  scoped_refptr<IOBuffer> buffer = new IOBuffer(size);
+  int rv = disk_entry->ReadData(kResponseInfoIndex, 0, buffer, size, NULL);
+  if (rv != size) {
+    DLOG(ERROR) << "ReadData failed: " << rv;
+    return false;
+  }
+
+  return ParseResponseInfo(buffer->data(), size, response_info,
+                           response_truncated);
+}
+
+// static
+bool HttpCache::WriteResponseInfo(disk_cache::Entry* disk_entry,
+                                  const HttpResponseInfo* response_info,
+                                  bool skip_transient_headers,
+                                  bool response_truncated) {
+  Pickle pickle;
+  response_info->Persist(
+      &pickle, skip_transient_headers, response_truncated);
+
+  scoped_refptr<WrappedIOBuffer> data = new WrappedIOBuffer(
+      reinterpret_cast<const char*>(pickle.data()));
+  int len = static_cast<int>(pickle.size());
+
+  return disk_entry->WriteData(kResponseInfoIndex, 0, data, len, NULL,
+                               true) == len;
+}
+
+// static
 bool HttpCache::ParseResponseInfo(const char* data, int len,
                                   HttpResponseInfo* response_info,
                                   bool* response_truncated) {
@@ -344,10 +401,7 @@ void HttpCache::WriteMetadata(const GURL& url,
   if (!buf_len)
     return;
 
-  // Do lazy initialization of disk cache if needed.
-  if (!disk_cache_.get())
-    CreateBackend(NULL, NULL);  // We don't care about the result.
-
+  GetBackend();
   HttpCache::Transaction* trans =
       new HttpCache::Transaction(this, enable_range_support_);
   MetadataWriter* writer = new MetadataWriter(trans);
diff --git a/net/http/http_cache.h b/net/http/http_cache.h
index 04dc144..79c2134 100644
--- a/net/http/http_cache.h
+++ b/net/http/http_cache.h
@@ -135,6 +135,12 @@ class HttpCache : public HttpTransactionFactory,
 
   HttpTransactionFactory* network_layer() { return network_layer_.get(); }
 
+  // Returns the cache backend for this HttpCache instance. If the backend
+  // is not initialized yet, this method will initialize it. If the return
+  // value is NULL then the backend cannot be initialized.
+  // This method is deprecated.
+  disk_cache::Backend* GetBackend();
+
   // Retrieves the cache backend for this HttpCache instance. If the backend
   // is not initialized yet, this method will initialize it. The return value is
   // a network error code, and it could be ERR_IO_PENDING, in which case the
@@ -151,6 +157,21 @@ class HttpCache : public HttpTransactionFactory,
   virtual HttpNetworkSession* GetSession();
   virtual void Suspend(bool suspend);
 
+  // Helper function for reading response info from the disk cache.  If the
+  // cache doesn't have the whole resource *|request_truncated| is set to true.
+  // NOTE: This method is deprecated.
+  static bool ReadResponseInfo(disk_cache::Entry* disk_entry,
+                               HttpResponseInfo* response_info,
+                               bool* response_truncated);
+
+  // Helper function for writing response info into the disk cache.  If the
+  // cache doesn't have the whole resource |request_truncated| should be true.
+  // NOTE: This method is deprecated.
+  static bool WriteResponseInfo(disk_cache::Entry* disk_entry,
+                                const HttpResponseInfo* response_info,
+                                bool skip_transient_headers,
+                                bool response_truncated);
+
   // Given a header data blob, convert it to a response info object.
   static bool ParseResponseInfo(const char* data, int len,
                                 HttpResponseInfo* response_info,
diff --git a/net/http/http_cache_unittest.cc b/net/http/http_cache_unittest.cc
index ed2f377..4337d3b 100644
--- a/net/http/http_cache_unittest.cc
+++ b/net/http/http_cache_unittest.cc
@@ -591,11 +591,7 @@ class MockHttpCache {
     return static_cast<MockNetworkLayer*>(http_cache_.network_layer());
   }
   MockDiskCache* disk_cache() {
-    TestCompletionCallback cb;
-    disk_cache::Backend* backend;
-    int rv = http_cache_.GetBackend(&backend, &cb);
-    rv = cb.GetResult(rv);
-    return (rv == net::OK) ? static_cast<MockDiskCache*>(backend) : NULL;
+    return static_cast<MockDiskCache*>(http_cache_.GetBackend());
   }
 
   // Helper function for reading response info from the disk cache.
@@ -1022,11 +1018,8 @@ TEST(HttpCache, CreateThenDestroy) {
 TEST(HttpCache, GetBackend) {
   MockHttpCache cache(net::HttpCache::DefaultBackend::InMemory(0));
 
-  disk_cache::Backend* backend;
-  TestCompletionCallback cb;
   // This will lazily initialize the backend.
-  int rv = cache.http_cache()->GetBackend(&backend, &cb);
-  EXPECT_EQ(net::OK, cb.GetResult(rv));
+  EXPECT_TRUE(cache.http_cache()->GetBackend());
 }
 
 TEST(HttpCache, SimpleGET) {
@@ -1083,7 +1076,7 @@ TEST(HttpCache, SimpleGETNoDiskCache2) {
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
-  EXPECT_FALSE(cache.http_cache()->GetCurrentBackend());
+  EXPECT_FALSE(cache.http_cache()->GetBackend());
 }
 
 TEST(HttpCache, SimpleGETWithDiskFailures) {