Http cache: Remove deprecated code.

net/http/http_cache.cc

 // Copyright (c) 2010 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 <algorithm>
 
 #include "base/compiler_specific.h"
 
@@ skipping 19 matching lines @@
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/spdy/spdy_session_pool.h"
 
 namespace net {
 
 int HttpCache::DefaultBackend::CreateBackend(disk_cache::Backend** backend,
                                              CompletionCallback* callback) {
   DCHECK_GE(max_bytes_, 0);
-  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);
+  return disk_cache::CreateCacheBackend(type_, path_, max_bytes_, true,
+                                        thread_, backend, callback);
 }
 
 //-----------------------------------------------------------------------------
 
 HttpCache::ActiveEntry::ActiveEntry(disk_cache::Entry* e)
     : disk_entry(e),
       writer(NULL),
       will_process_pending_queue(false),
       doomed(false) {
 }
@@ skipping 232 matching lines @@
     // though they are waiting for a callback that will never fire.
     PendingOp* pending_op = pending_it->second;
     delete pending_op->writer;
     delete pending_op->callback;
 
     STLDeleteElements(&pending_op->pending_queue);
     delete pending_op;
   }
 }
 
-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);
 
   if (disk_cache_.get()) {
     *backend = disk_cache_.get();
     return OK;
   }
 
   return CreateBackend(backend, callback);
@@ skipping 20 matching lines @@
   net::HttpNetworkLayer* network =
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   return network->GetSession();
 }
 
 void HttpCache::Suspend(bool suspend) {
   network_layer_->Suspend(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) {
   Pickle pickle(data, len);
   return response_info->InitFromPickle(pickle, response_truncated);
 }
 
 void HttpCache::WriteMetadata(const GURL& url,
                               base::Time expected_response_time, IOBuffer* buf,
                               int buf_len) {
   if (!buf_len)
     return;
 
-  GetBackend();
+  // Do lazy initialization of disk cache if needed.
+  if (!disk_cache_.get())
+    CreateBackend(NULL, NULL);  // We don't care about the result.
+
   HttpCache::Transaction* trans =
       new HttpCache::Transaction(this, enable_range_support_);
   MetadataWriter* writer = new MetadataWriter(trans);
 
   // The writer will self destruct when done.
   writer->Write(url, expected_response_time, buf, buf_len);
 }
 
 void HttpCache::CloseCurrentConnections() {
   net::HttpNetworkLayer* network =
@@ skipping 627 matching lines @@
     // This could be an external caller or a transaction waiting on Start().
     pending_item->DoCallback(result, temp_backend_);
     pending_item->NotifyTransaction(result, NULL);
   }
 
   DeletePendingOp(pending_op);
   building_backend_ = false;
 }
 
 }  // namespace net