net/disk_cache/disk_cache_test_util.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/disk_cache/disk_cache_test_util.h"
   6
   7 #include "base/logging.h"
   8 #include "base/file_util.h"
   9 #include "base/message_loop_proxy.h"
  10 #include "base/path_service.h"
  11 #include "net/base/net_errors.h"
  12 #include "net/disk_cache/backend_impl.h"
  13 #include "net/disk_cache/cache_util.h"
  14 #include "net/disk_cache/file.h"
  15
  16 using base::Time;
  17 using base::TimeDelta;
  18
  19 std::string GenerateKey(bool same_length) {
  20   char key[200];
  21   CacheTestFillBuffer(key, sizeof(key), same_length);
  22
  23   key[199] = '\0';
  24   return std::string(key);
  25 }
  26
  27 void CacheTestFillBuffer(char* buffer, size_t len, bool no_nulls) {
  28   static bool called = false;
  29   if (!called) {
  30     called = true;
  31     int seed = static_cast<int>(Time::Now().ToInternalValue());
  32     srand(seed);
  33   }
  34
  35   for (size_t i = 0; i < len; i++) {
  36     buffer[i] = static_cast<char>(rand());
  37     if (!buffer[i] && no_nulls)
  38       buffer[i] = 'g';
  39   }
  40   if (len && !buffer[0])
  41     buffer[0] = 'g';
  42 }
  43
  44 bool CreateCacheTestFile(const base::FilePath& name) {
  45   int flags = base::PLATFORM_FILE_CREATE_ALWAYS |
  46               base::PLATFORM_FILE_READ |
  47               base::PLATFORM_FILE_WRITE;
  48
  49   scoped_refptr<disk_cache::File> file(new disk_cache::File(
  50       base::CreatePlatformFile(name, flags, NULL, NULL)));
  51   if (!file->IsValid())
  52     return false;
  53
  54   file->SetLength(4 * 1024 * 1024);
  55   return true;
  56 }
  57
  58 bool DeleteCache(const base::FilePath& path) {
  59   disk_cache::DeleteCache(path, false);
  60   return true;
  61 }
  62
  63 bool CheckCacheIntegrity(const base::FilePath& path, bool new_eviction,
  64                          uint32 mask) {
  65   scoped_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
  66       path, mask, base::MessageLoopProxy::current(), NULL));
  67   if (!cache.get())
  68     return false;
  69   if (new_eviction)
  70     cache->SetNewEviction();
  71   cache->SetFlags(disk_cache::kNoRandom);
  72   if (cache->SyncInit() != net::OK)
  73     return false;
  74   return cache->SelfCheck() >= 0;
  75 }
  76
  77 // -----------------------------------------------------------------------
  78
  79 MessageLoopHelper::MessageLoopHelper()
  80     : num_callbacks_(0),
  81       num_iterations_(0),
  82       last_(0),
  83       completed_(false),
  84       callback_reused_error_(false),
  85       callbacks_called_(0) {
  86 }
  87
  88 MessageLoopHelper::~MessageLoopHelper() {
  89 }
  90
  91 bool MessageLoopHelper::WaitUntilCacheIoFinished(int num_callbacks) {
  92   if (num_callbacks == callbacks_called_)
  93     return true;
  94
  95   ExpectCallbacks(num_callbacks);
  96   // Create a recurrent timer of 50 mS.
  97   if (!timer_.IsRunning())
  98     timer_.Start(FROM_HERE, TimeDelta::FromMilliseconds(50), this,
  99                  &MessageLoopHelper::TimerExpired);
 100   MessageLoop::current()->Run();
 101   return completed_;
 102 }
 103
 104 // Quits the message loop when all callbacks are called or we've been waiting
 105 // too long for them (2 secs without a callback).
 106 void MessageLoopHelper::TimerExpired() {
 107   CHECK_LE(callbacks_called_, num_callbacks_);
 108   if (callbacks_called_ == num_callbacks_) {
 109     completed_ = true;
 110     MessageLoop::current()->Quit();
 111   } else {
 112     // Not finished yet. See if we have to abort.
 113     if (last_ == callbacks_called_)
 114       num_iterations_++;
 115     else
 116       last_ = callbacks_called_;
 117     if (40 == num_iterations_)
 118       MessageLoop::current()->Quit();
 119   }
 120 }
 121
 122 // -----------------------------------------------------------------------
 123
 124 CallbackTest::CallbackTest(MessageLoopHelper* helper,
 125                            bool reuse)
 126     : helper_(helper),
 127       reuse_(reuse ? 0 : 1) {
 128 }
 129
 130 CallbackTest::~CallbackTest() {
 131 }
 132
 133 // On the actual callback, increase the number of tests received and check for
 134 // errors (an unexpected test received)
 135 void CallbackTest::Run(int params) {
 136   if (reuse_) {
 137     DCHECK_EQ(1, reuse_);
 138     if (2 == reuse_)
 139       helper_->set_callback_reused_error(true);
 140     reuse_++;
 141   }
 142
 143   helper_->CallbackWasCalled();
 144 }