Introduce MockHttpCache::backend() and move a few callers to it.

net/http/mock_http_cache.cc

 // Copyright (c) 2012 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/mock_http_cache.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
@@ skipping 490 matching lines @@
 //-----------------------------------------------------------------------------
 
 MockHttpCache::MockHttpCache()
     : http_cache_(new MockNetworkLayer(), NULL, new MockBackendFactory()) {
 }
 
 MockHttpCache::MockHttpCache(net::HttpCache::BackendFactory* disk_cache_factory)
     : http_cache_(new MockNetworkLayer(), NULL, disk_cache_factory) {
 }
 
-MockDiskCache* MockHttpCache::disk_cache() {
+disk_cache::Backend* MockHttpCache::backend() {
   net::TestCompletionCallback cb;
   disk_cache::Backend* backend;
   int rv = http_cache_.GetBackend(&backend, cb.callback());
   rv = cb.GetResult(rv);
-  return (rv == net::OK) ? static_cast<MockDiskCache*>(backend) : NULL;
+  return (rv == net::OK) ? backend : NULL;
+}
+
+MockDiskCache* MockHttpCache::disk_cache() {
+  return static_cast<MockDiskCache*>(backend());
 }
 
 int MockHttpCache::CreateTransaction(scoped_ptr<net::HttpTransaction>* trans) {
   return http_cache_.CreateTransaction(net::DEFAULT_PRIORITY, trans);
 }
 
 void MockHttpCache::BypassCacheLock() {
   http_cache_.BypassLockForTest();
 }
 
@@ skipping 30 matching lines @@
   int len = static_cast<int>(pickle.size());
 
   int rv = disk_entry->WriteData(0, 0, data.get(), len, cb.callback(), true);
   rv = cb.GetResult(rv);
   return (rv == len);
 }
 
 bool MockHttpCache::OpenBackendEntry(const std::string& key,
                                      disk_cache::Entry** entry) {
   net::TestCompletionCallback cb;
-  int rv = disk_cache()->OpenEntry(key, entry, cb.callback());
+  int rv = backend()->OpenEntry(key, entry, cb.callback());
   return (cb.GetResult(rv) == net::OK);
 }
 
 bool MockHttpCache::CreateBackendEntry(const std::string& key,
                                        disk_cache::Entry** entry,
                                        net::NetLog* net_log) {
   net::TestCompletionCallback cb;
-  int rv = disk_cache()->CreateEntry(key, entry, cb.callback());
+  int rv = backend()->CreateEntry(key, entry, cb.callback());
   return (cb.GetResult(rv) == net::OK);
 }
 
 // Static.
 int MockHttpCache::GetTestMode(int test_mode) {
   if (!g_test_mode)
     return test_mode;
 
   return g_test_mode;
 }
@@ skipping 48 matching lines @@
 void MockBlockingBackendFactory::FinishCreation() {
   block_ = false;
   if (!callback_.is_null()) {
     if (!fail_)
       backend_->reset(new MockDiskCache());
     net::CompletionCallback cb = callback_;
     callback_.Reset();
     cb.Run(Result());  // This object can be deleted here.
   }
 }