Split DiskCacheBasedSSLHostInfo unit tests to its own

net/http/http_cache_unittest.cc

 // Copyright (c) 2011 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/bind.h"
-#include "base/hash_tables.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "net/base/cache_type.h"
 #include "net/base/cert_status_flags.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/ssl_cert_request_info.h"
-#include "net/base/ssl_config_service.h"
 #include "net/disk_cache/disk_cache.h"
-#include "net/http/disk_cache_based_ssl_host_info.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "net/http/http_transaction_unittest.h"
 #include "net/http/http_util.h"
+#include "net/http/mock_http_cache.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 
 namespace {
 
-int GetTestModeForEntry(const std::string& key) {
-  // 'key' is prefixed with an identifier if it corresponds to a cached POST.
-  // Skip past that to locate the actual URL.
-  //
-  // TODO(darin): It breaks the abstraction a bit that we assume 'key' is an
-  // URL corresponding to a registered MockTransaction.  It would be good to
-  // have another way to access the test_mode.
-  GURL url;
-  if (isdigit(key[0])) {
-    size_t slash = key.find('/');
-    DCHECK(slash != std::string::npos);
-    url = GURL(key.substr(slash + 1));
-  } else {
-    url = GURL(key);
-  }
-  const MockTransaction* t = FindMockTransaction(url);
-  DCHECK(t);
-  return t->test_mode;
-}
-
-// We can override the test mode for a given operation by setting this global
-// variable. Just remember to reset it after the test!.
-int g_test_mode = 0;
-
-// Returns the test mode after considering the global override.
-int GetEffectiveTestMode(int test_mode) {
-  if (!g_test_mode)
-    return test_mode;
-
-  return g_test_mode;
-}
-
-//-----------------------------------------------------------------------------
-// mock disk cache (a very basic memory cache implementation)
-
-static const int kNumCacheEntryDataIndices = 3;
-
-class MockDiskEntry : public disk_cache::Entry,
-                      public base::RefCounted<MockDiskEntry> {
- public:
-  MockDiskEntry()
-      : test_mode_(0), doomed_(false), sparse_(false),
-        fail_requests_(false), busy_(false), delayed_(false) {
-  }
-
-  explicit MockDiskEntry(const std::string& key)
-      : key_(key), doomed_(false), sparse_(false),
-        fail_requests_(false), busy_(false), delayed_(false) {
-    test_mode_ = GetTestModeForEntry(key);
-  }
-
-  bool is_doomed() const { return doomed_; }
-
-  virtual void Doom() {
-    doomed_ = true;
-  }
-
-  virtual void Close() {
-    Release();
-  }
-
-  virtual std::string GetKey() const {
-    if (fail_requests_)
-      return std::string();
-    return key_;
-  }
-
-  virtual Time GetLastUsed() const {
-    return Time::FromInternalValue(0);
-  }
-
-  virtual Time GetLastModified() const {
-    return Time::FromInternalValue(0);
-  }
-
-  virtual int32 GetDataSize(int index) const {
-    DCHECK(index >= 0 && index < kNumCacheEntryDataIndices);
-    return static_cast<int32>(data_[index].size());
-  }
-
-  virtual int ReadData(int index, int offset, net::IOBuffer* buf, int buf_len,
-                       net::OldCompletionCallback* callback) {
-    DCHECK(index >= 0 && index < kNumCacheEntryDataIndices);
-    DCHECK(callback);
-
-    if (fail_requests_)
-      return net::ERR_CACHE_READ_FAILURE;
-
-    if (offset < 0 || offset > static_cast<int>(data_[index].size()))
-      return net::ERR_FAILED;
-    if (static_cast<size_t>(offset) == data_[index].size())
-      return 0;
-
-    int num = std::min(buf_len, static_cast<int>(data_[index].size()) - offset);
-    memcpy(buf->data(), &data_[index][offset], num);
-
-    if (GetEffectiveTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_READ)
-      return num;
-
-    CallbackLater(callback, num);
-    return net::ERR_IO_PENDING;
-  }
-
-  virtual int WriteData(int index, int offset, net::IOBuffer* buf, int buf_len,
-                        net::OldCompletionCallback* callback, bool truncate) {
-    DCHECK(index >= 0 && index < kNumCacheEntryDataIndices);
-    DCHECK(callback);
-    DCHECK(truncate);
-
-    if (fail_requests_) {
-      CallbackLater(callback, net::ERR_CACHE_READ_FAILURE);
-      return net::ERR_IO_PENDING;
-    }
-
-    if (offset < 0 || offset > static_cast<int>(data_[index].size()))
-      return net::ERR_FAILED;
-
-    data_[index].resize(offset + buf_len);
-    if (buf_len)
-      memcpy(&data_[index][offset], buf->data(), buf_len);
-
-    if (GetEffectiveTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_WRITE)
-      return buf_len;
-
-    CallbackLater(callback, buf_len);
-    return net::ERR_IO_PENDING;
-  }
-
-  virtual int ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
-                             net::OldCompletionCallback* callback) {
-    DCHECK(callback);
-    if (!sparse_ || busy_)
-      return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
-    if (offset < 0)
-      return net::ERR_FAILED;
-
-    if (fail_requests_)
-      return net::ERR_CACHE_READ_FAILURE;
-
-    DCHECK(offset < kint32max);
-    int real_offset = static_cast<int>(offset);
-    if (!buf_len)
-      return 0;
-
-    int num = std::min(static_cast<int>(data_[1].size()) - real_offset,
-                       buf_len);
-    memcpy(buf->data(), &data_[1][real_offset], num);
-
-    if (GetEffectiveTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_READ)
-      return num;
-
-    CallbackLater(callback, num);
-    busy_ = true;
-    delayed_ = false;
-    return net::ERR_IO_PENDING;
-  }
-
-  virtual int WriteSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
-                              net::OldCompletionCallback* callback) {
-    DCHECK(callback);
-    if (busy_)
-      return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
-    if (!sparse_) {
-      if (data_[1].size())
-        return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
-      sparse_ = true;
-    }
-    if (offset < 0)
-      return net::ERR_FAILED;
-    if (!buf_len)
-      return 0;
-
-    if (fail_requests_)
-      return net::ERR_CACHE_READ_FAILURE;
-
-    DCHECK(offset < kint32max);
-    int real_offset = static_cast<int>(offset);
-
-    if (static_cast<int>(data_[1].size()) < real_offset + buf_len)
-      data_[1].resize(real_offset + buf_len);
-
-    memcpy(&data_[1][real_offset], buf->data(), buf_len);
-    if (GetEffectiveTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_WRITE)
-      return buf_len;
-
-    CallbackLater(callback, buf_len);
-    return net::ERR_IO_PENDING;
-  }
-
-  virtual int GetAvailableRange(int64 offset, int len, int64* start,
-                                net::OldCompletionCallback* callback) {
-    DCHECK(callback);
-    if (!sparse_ || busy_)
-      return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
-    if (offset < 0)
-      return net::ERR_FAILED;
-
-    if (fail_requests_)
-      return net::ERR_CACHE_READ_FAILURE;
-
-    *start = offset;
-    DCHECK(offset < kint32max);
-    int real_offset = static_cast<int>(offset);
-    if (static_cast<int>(data_[1].size()) < real_offset)
-      return 0;
-
-    int num = std::min(static_cast<int>(data_[1].size()) - real_offset, len);
-    int count = 0;
-    for (; num > 0; num--, real_offset++) {
-      if (!count) {
-        if (data_[1][real_offset]) {
-          count++;
-          *start = real_offset;
-        }
-      } else {
-        if (!data_[1][real_offset])
-          break;
-        count++;
-      }
-    }
-    if (GetEffectiveTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_WRITE)
-      return count;
-
-    CallbackLater(callback, count);
-    return net::ERR_IO_PENDING;
-  }
-
-  virtual bool CouldBeSparse() const {
-    return sparse_;
-  }
-
-  virtual void CancelSparseIO() { cancel_ = true; }
-
-  virtual int ReadyForSparseIO(net::OldCompletionCallback* completion_callback) {
-    if (!cancel_)
-      return net::OK;
-
-    cancel_ = false;
-    DCHECK(completion_callback);
-    if (GetEffectiveTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_READ)
-      return net::OK;
-
-    // The pending operation is already in the message loop (and hopefuly
-    // already in the second pass).  Just notify the caller that it finished.
-    CallbackLater(completion_callback, 0);
-    return net::ERR_IO_PENDING;
-  }
-
-  // Fail most subsequent requests.
-  void set_fail_requests() { fail_requests_ = true; }
-
-  // If |value| is true, don't deliver any completion callbacks until called
-  // again with |value| set to false.  Caution: remember to enable callbacks
-  // again or all subsequent tests will fail.
-  static void IgnoreCallbacks(bool value) {
-    if (ignore_callbacks_ == value)
-      return;
-    ignore_callbacks_ = value;
-    if (!value)
-      StoreAndDeliverCallbacks(false, NULL, NULL, 0);
-  }
-
- private:
-  friend class base::RefCounted<MockDiskEntry>;
-
-  struct CallbackInfo {
-    scoped_refptr<MockDiskEntry> entry;
-    net::OldCompletionCallback* callback;
-    int result;
-  };
-
-  ~MockDiskEntry() {}
-
-  // Unlike the callbacks for MockHttpTransaction, we want this one to run even
-  // if the consumer called Close on the MockDiskEntry.  We achieve that by
-  // leveraging the fact that this class is reference counted.
-  void CallbackLater(net::OldCompletionCallback* callback, int result) {
-    if (ignore_callbacks_)
-      return StoreAndDeliverCallbacks(true, this, callback, result);
-    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-        &MockDiskEntry::RunCallback, this, callback, result));
-  }
-  void RunCallback(net::OldCompletionCallback* callback, int result) {
-    if (busy_) {
-      // This is kind of hacky, but controlling the behavior of just this entry
-      // from a test is sort of complicated.  What we really want to do is
-      // delay the delivery of a sparse IO operation a little more so that the
-      // request start operation (async) will finish without seeing the end of
-      // this operation (already posted to the message loop)... and without
-      // just delaying for n mS (which may cause trouble with slow bots).  So
-      // we re-post this operation (all async sparse IO operations will take two
-      // trips trhough the message loop instead of one).
-      if (!delayed_) {
-        delayed_ = true;
-        return CallbackLater(callback, result);
-      }
-    }
-    busy_ = false;
-    callback->Run(result);
-  }
-
-  // When |store| is true, stores the callback to be delivered later; otherwise
-  // delivers any callback previously stored.
-  static void StoreAndDeliverCallbacks(bool store, MockDiskEntry* entry,
-                                       net::OldCompletionCallback* callback,
-                                       int result) {
-    static std::vector<CallbackInfo> callback_list;
-    if (store) {
-      CallbackInfo c = {entry, callback, result};
-      callback_list.push_back(c);
-    } else {
-      for (size_t i = 0; i < callback_list.size(); i++) {
-        CallbackInfo& c = callback_list[i];
-        c.entry->CallbackLater(c.callback, c.result);
-      }
-      callback_list.clear();
-    }
-  }
-
-  std::string key_;
-  std::vector<char> data_[kNumCacheEntryDataIndices];
-  int test_mode_;
-  bool doomed_;
-  bool sparse_;
-  bool fail_requests_;
-  bool busy_;
-  bool delayed_;
-  static bool cancel_;
-  static bool ignore_callbacks_;
-};
-
-// Statics.
-bool MockDiskEntry::cancel_ = false;
-bool MockDiskEntry::ignore_callbacks_ = false;
-
-class MockDiskCache : public disk_cache::Backend {
- public:
-  MockDiskCache()
-      : open_count_(0), create_count_(0), fail_requests_(false),
-        soft_failures_(false) {
-  }
-
-  ~MockDiskCache() {
-    ReleaseAll();
-  }
-
-  virtual int32 GetEntryCount() const {
-    return static_cast<int32>(entries_.size());
-  }
-
-  virtual int OpenEntry(const std::string& key, disk_cache::Entry** entry,
-                        net::OldCompletionCallback* callback) {
-    DCHECK(callback);
-    if (fail_requests_)
-      return net::ERR_CACHE_OPEN_FAILURE;
-
-    EntryMap::iterator it = entries_.find(key);
-    if (it == entries_.end())
-      return net::ERR_CACHE_OPEN_FAILURE;
-
-    if (it->second->is_doomed()) {
-      it->second->Release();
-      entries_.erase(it);
-      return net::ERR_CACHE_OPEN_FAILURE;
-    }
-
-    open_count_++;
-
-    it->second->AddRef();
-    *entry = it->second;
-
-    if (soft_failures_)
-      it->second->set_fail_requests();
-
-    if (GetTestModeForEntry(key) & TEST_MODE_SYNC_CACHE_START)
-      return net::OK;
-
-    CallbackLater(callback, net::OK);
-    return net::ERR_IO_PENDING;
-  }
-
-  virtual int CreateEntry(const std::string& key, disk_cache::Entry** entry,
-                          net::OldCompletionCallback* callback) {
-    DCHECK(callback);
-    if (fail_requests_)
-      return net::ERR_CACHE_CREATE_FAILURE;
-
-    EntryMap::iterator it = entries_.find(key);
-    if (it != entries_.end()) {
-      DCHECK(it->second->is_doomed());
-      it->second->Release();
-      entries_.erase(it);
-    }
-
-    create_count_++;
-
-    MockDiskEntry* new_entry = new MockDiskEntry(key);
-
-    new_entry->AddRef();
-    entries_[key] = new_entry;
-
-    new_entry->AddRef();
-    *entry = new_entry;
-
-    if (soft_failures_)
-      new_entry->set_fail_requests();
-
-    if (GetTestModeForEntry(key) & TEST_MODE_SYNC_CACHE_START)
-      return net::OK;
-
-    CallbackLater(callback, net::OK);
-    return net::ERR_IO_PENDING;
-  }
-
-  virtual int DoomEntry(const std::string& key,
-                        net::OldCompletionCallback* callback) {
-    DCHECK(callback);
-    EntryMap::iterator it = entries_.find(key);
-    if (it != entries_.end()) {
-      it->second->Release();
-      entries_.erase(it);
-    }
-
-    if (GetTestModeForEntry(key) & TEST_MODE_SYNC_CACHE_START)
-      return net::OK;
-
-    CallbackLater(callback, net::OK);
-    return net::ERR_IO_PENDING;
-  }
-
-  virtual int DoomAllEntries(net::OldCompletionCallback* callback) {
-    return net::ERR_NOT_IMPLEMENTED;
-  }
-
-  virtual int DoomEntriesBetween(const base::Time initial_time,
-                                 const base::Time end_time,
-                                 net::OldCompletionCallback* callback) {
-    return net::ERR_NOT_IMPLEMENTED;
-  }
-
-  virtual int DoomEntriesSince(const base::Time initial_time,
-                               net::OldCompletionCallback* callback) {
-    return net::ERR_NOT_IMPLEMENTED;
-  }
-
-  virtual int OpenNextEntry(void** iter, disk_cache::Entry** next_entry,
-                            net::OldCompletionCallback* callback) {
-    return net::ERR_NOT_IMPLEMENTED;
-  }
-
-  virtual void EndEnumeration(void** iter) {}
-
-  virtual void GetStats(
-      std::vector<std::pair<std::string, std::string> >* stats) {
-  }
-
-  virtual void OnExternalCacheHit(const std::string& key) {}
-
-  // returns number of times a cache entry was successfully opened
-  int open_count() const { return open_count_; }
-
-  // returns number of times a cache entry was successfully created
-  int create_count() const { return create_count_; }
-
-  // Fail any subsequent CreateEntry and OpenEntry.
-  void set_fail_requests() { fail_requests_ = true; }
-
-  // Return entries that fail some of their requests.
-  void set_soft_failures(bool value) { soft_failures_ = value; }
-
-  void ReleaseAll() {
-    EntryMap::iterator it = entries_.begin();
-    for (; it != entries_.end(); ++it)
-      it->second->Release();
-    entries_.clear();
-  }
-
- private:
-  typedef base::hash_map<std::string, MockDiskEntry*> EntryMap;
-
-  class CallbackRunner : public Task {
-   public:
-    CallbackRunner(net::OldCompletionCallback* callback, int result)
-        : callback_(callback), result_(result) {}
-    virtual void Run() {
-      callback_->Run(result_);
-    }
-
-   private:
-    net::OldCompletionCallback* callback_;
-    int result_;
-    DISALLOW_COPY_AND_ASSIGN(CallbackRunner);
-  };
-
-  void CallbackLater(net::OldCompletionCallback* callback, int result) {
-    MessageLoop::current()->PostTask(FROM_HERE,
-                                     new CallbackRunner(callback, result));
-  }
-
-  EntryMap entries_;
-  int open_count_;
-  int create_count_;
-  bool fail_requests_;
-  bool soft_failures_;
-};
-
-class MockBackendFactory : public net::HttpCache::BackendFactory {
- public:
-  virtual int CreateBackend(net::NetLog*  /* net_log */,
-                            disk_cache::Backend** backend,
-                            net::OldCompletionCallback* callback) {
-    *backend = new MockDiskCache();
-    return net::OK;
-  }
-};
-
-class MockHttpCache {
- public:
-  MockHttpCache()
-      : http_cache_(new MockNetworkLayer(), NULL, new MockBackendFactory()) {
-  }
-
-  explicit MockHttpCache(net::HttpCache::BackendFactory* disk_cache_factory)
-      : http_cache_(new MockNetworkLayer(), NULL, disk_cache_factory) {
-  }
-
-  net::HttpCache* http_cache() { return &http_cache_; }
-
-  MockNetworkLayer* network_layer() {
-    return static_cast<MockNetworkLayer*>(http_cache_.network_layer());
-  }
-  MockDiskCache* disk_cache() {
-    TestOldCompletionCallback 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;
-  }
-
-  // Helper function for reading response info from the disk cache.
-  static bool ReadResponseInfo(disk_cache::Entry* disk_entry,
-                               net::HttpResponseInfo* response_info,
-                               bool* response_truncated) {
-    int size = disk_entry->GetDataSize(0);
-
-    TestOldCompletionCallback cb;
-    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(size));
-    int rv = disk_entry->ReadData(0, 0, buffer, size, &cb);
-    rv = cb.GetResult(rv);
-    EXPECT_EQ(size, rv);
-
-    return net::HttpCache::ParseResponseInfo(buffer->data(), size,
-                                             response_info,
-                                             response_truncated);
-  }
-
-  // Helper function for writing response info into the disk cache.
-  static bool WriteResponseInfo(disk_cache::Entry* disk_entry,
-                                const net::HttpResponseInfo* response_info,
-                                bool skip_transient_headers,
-                                bool response_truncated) {
-    Pickle pickle;
-    response_info->Persist(
-        &pickle, skip_transient_headers, response_truncated);
-
-    TestOldCompletionCallback cb;
-    scoped_refptr<net::WrappedIOBuffer> data(new net::WrappedIOBuffer(
-        reinterpret_cast<const char*>(pickle.data())));
-    int len = static_cast<int>(pickle.size());
-
-    int rv =  disk_entry->WriteData(0, 0, data, len, &cb, true);
-    rv = cb.GetResult(rv);
-    return (rv == len);
-  }
-
-  // Helper function to synchronously open a backend entry.
-  bool OpenBackendEntry(const std::string& key, disk_cache::Entry** entry) {
-    TestOldCompletionCallback cb;
-    int rv = disk_cache()->OpenEntry(key, entry, &cb);
-    return (cb.GetResult(rv) == net::OK);
-  }
-
-  // Helper function to synchronously create a backend entry.
-  bool CreateBackendEntry(const std::string& key, disk_cache::Entry** entry,
-                          net::NetLog*  /* net_log */) {
-    TestOldCompletionCallback cb;
-    int rv = disk_cache()->CreateEntry(key, entry, &cb);
-    return (cb.GetResult(rv) == net::OK);
-  }
-
- private:
-  net::HttpCache http_cache_;
-};
-
-// This version of the disk cache doesn't invoke CreateEntry callbacks.
-class MockDiskCacheNoCB : public MockDiskCache {
-  virtual int CreateEntry(const std::string& key, disk_cache::Entry** entry,
-                          net::OldCompletionCallback* callback) {
-    return net::ERR_IO_PENDING;
-  }
-};
-
-class MockBackendNoCbFactory : public net::HttpCache::BackendFactory {
- public:
-  virtual int CreateBackend(net::NetLog*  /* net_log */,
-                            disk_cache::Backend** backend,
-                            net::OldCompletionCallback* callback) {
-    *backend = new MockDiskCacheNoCB();
-    return net::OK;
-  }
-};
-
-// This backend factory allows us to control the backend instantiation.
-class MockBlockingBackendFactory : public net::HttpCache::BackendFactory {
- public:
-  MockBlockingBackendFactory()
-      : backend_(NULL), callback_(NULL), block_(true), fail_(false) {}
-
-  virtual int CreateBackend(net::NetLog*  /* net_log */,
-                            disk_cache::Backend** backend,
-                            net::OldCompletionCallback* callback) {
-    if (!block_) {
-      if (!fail_)
-        *backend = new MockDiskCache();
-      return Result();
-    }
-
-    backend_ =  backend;
-    callback_ = callback;
-    return net::ERR_IO_PENDING;
-  }
-
-  // Completes the backend creation. Any blocked call will be notified via the
-  // provided callback.
-  void FinishCreation() {
-    block_ = false;
-    if (callback_) {
-      if (!fail_)
-        *backend_ = new MockDiskCache();
-      net::OldCompletionCallback* cb = callback_;
-      callback_ = NULL;
-      cb->Run(Result());  // This object can be deleted here.
-    }
-  }
-
-  disk_cache::Backend** backend() { return backend_; }
-  void set_fail(bool fail) { fail_ = fail; }
-
-  net::OldCompletionCallback* callback() { return callback_; }
-
- private:
-  int Result() { return fail_ ? net::ERR_FAILED : net::OK; }
-
-  disk_cache::Backend** backend_;
-  net::OldCompletionCallback* callback_;
-  bool block_;
-  bool fail_;
-};
-
 class DeleteCacheOldCompletionCallback : public TestOldCompletionCallback {
  public:
   explicit DeleteCacheOldCompletionCallback(MockHttpCache* cache)
       : cache_(cache) {}
 
   virtual void RunWithParams(const Tuple1<int>& params) {
     delete cache_;
     TestOldCompletionCallback::RunWithParams(params);
   }
 
@@ skipping 328 matching lines @@
 
   int result;
   TestOldCompletionCallback callback;
   scoped_ptr<net::HttpTransaction> trans;
 };
 
 }  // namespace
 
 
 //-----------------------------------------------------------------------------
-// HttpCache tests
+// Tests.
 
 TEST(HttpCache, CreateThenDestroy) {
   MockHttpCache cache;
 
   scoped_ptr<net::HttpTransaction> trans;
   int rv = cache.http_cache()->CreateTransaction(&trans);
   EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 }
 
@@ skipping 3279 matching lines @@
   rv = c->trans->Read(buf, buf->size(), &c->callback);
   if (rv == net::ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
   EXPECT_EQ(buf->size(), rv);
 
   // We want to cancel the request when the transaction is busy.
   rv = c->trans->Read(buf, buf->size(), &c->callback);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
   EXPECT_FALSE(c->callback.have_result());
 
-  g_test_mode = TEST_MODE_SYNC_ALL;
+  MockHttpCache::SetTestMode(TEST_MODE_SYNC_ALL);
 
   // Destroy the transaction.
   c->trans.reset();
-  g_test_mode = 0;
+  MockHttpCache::SetTestMode(0);
 
   // Make sure that we don't invoke the callback. We may have an issue if the
   // UrlRequestJob is killed directly (without cancelling the UrlRequest) so we
   // could end up with the transaction being deleted twice if we send any
   // notification from the transaction destructor (see http://crbug.com/31723).
   EXPECT_FALSE(c->callback.have_result());
 
   // Verify that the entry is marked as incomplete.
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache.OpenBackendEntry(kSimpleGET_Transaction.url, &entry));
@@ skipping 817 matching lines @@
 
   // Verify that the entry is marked as incomplete.
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache.OpenBackendEntry(kSimpleGET_Transaction.url, &entry));
   net::HttpResponseInfo response;
   bool truncated = false;
   EXPECT_TRUE(MockHttpCache::ReadResponseInfo(entry, &response, &truncated));
   EXPECT_TRUE(truncated);
   entry->Close();
 }
-
-//-----------------------------------------------------------------------------
-// DiskCacheBasedSSLHostInfo tests
-
-class DeleteSSLHostInfoOldCompletionCallback : public TestOldCompletionCallback {
- public:
-  explicit DeleteSSLHostInfoOldCompletionCallback(net::SSLHostInfo* ssl_host_info)
-      : ssl_host_info_(ssl_host_info) {}
-
-  virtual void RunWithParams(const Tuple1<int>& params) {
-    delete ssl_host_info_;
-    TestOldCompletionCallback::RunWithParams(params);
-  }
-
- private:
-  net::SSLHostInfo* ssl_host_info_;
-};
-
-// Tests that we can delete a DiskCacheBasedSSLHostInfo object in a
-// completion callback for DiskCacheBasedSSLHostInfo::WaitForDataReady.
-TEST(DiskCacheBasedSSLHostInfo, DeleteInCallback) {
-  net::CertVerifier cert_verifier;
-  // Use the blocking mock backend factory to force asynchronous completion
-  // of ssl_host_info->WaitForDataReady(), so that the callback will run.
-  MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
-  MockHttpCache cache(factory);
-  net::SSLConfig ssl_config;
-  net::SSLHostInfo* ssl_host_info =
-      new net::DiskCacheBasedSSLHostInfo("https://www.verisign.com", ssl_config,
-                                         &cert_verifier, cache.http_cache());
-  ssl_host_info->Start();
-  DeleteSSLHostInfoOldCompletionCallback callback(ssl_host_info);
-  int rv = ssl_host_info->WaitForDataReady(&callback);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
-  // Now complete the backend creation and let the callback run.
-  factory->FinishCreation();
-  EXPECT_EQ(net::OK, callback.GetResult(rv));
-}