Home | History | Annotate | Download | only in disk_cache 
      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/files/file_path.h"
      8 #include "base/logging.h"
      9 #include "base/message_loop/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().get(), 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   base::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     base::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       base::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 result) {
    136   last_result_ = result;
    137 
    138   if (reuse_) {
    139     DCHECK_EQ(1, reuse_);
    140     if (2 == reuse_)
    141       helper_->set_callback_reused_error(true);
    142     reuse_++;
    143   }
    144 
    145   helper_->CallbackWasCalled();
    146 }
    147