content/browser/indexed_db/mock_browsertest_indexed_db_class_factory.cc

   1 // Copyright 2014 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 <string>
   6
   7 #include "base/logging.h"
   8 #include "content/browser/indexed_db/leveldb/leveldb_iterator_impl.h"
   9 #include "content/browser/indexed_db/leveldb/leveldb_transaction.h"
  10 #include "content/browser/indexed_db/mock_browsertest_indexed_db_class_factory.h"
  11 #include "third_party/leveldatabase/env_chromium.h"
  12 #include "third_party/leveldatabase/src/include/leveldb/status.h"
  13
  14 namespace {
  15
  16 class FunctionTracer {
  17  public:
  18   FunctionTracer(const std::string& class_name,
  19                  const std::string& method_name,
  20                  int instance_num)
  21       : class_name_(class_name),
  22         method_name_(method_name),
  23         instance_count_(instance_num),
  24         current_call_num_(0) {}
  25
  26   void log_call() {
  27     current_call_num_++;
  28     VLOG(0) << class_name_ << '[' << instance_count_ << "]::" << method_name_
  29             << "()[" << current_call_num_ << ']';
  30   }
  31
  32  private:
  33   std::string class_name_;
  34   std::string method_name_;
  35   int instance_count_;
  36   int current_call_num_;
  37 };
  38
  39 }  // namespace
  40
  41 namespace content {
  42
  43 class LevelDBTestTransaction : public LevelDBTransaction {
  44  public:
  45   LevelDBTestTransaction(LevelDBDatabase* db,
  46                         FailMethod fail_method,
  47                         int fail_on_call_num)
  48       : LevelDBTransaction(db),
  49         fail_method_(fail_method),
  50         fail_on_call_num_(fail_on_call_num),
  51         current_call_num_(0) {
  52     DCHECK(fail_method != FAIL_METHOD_NOTHING);
  53     DCHECK_GT(fail_on_call_num, 0);
  54   }
  55
  56   leveldb::Status Get(const base::StringPiece& key,
  57                       std::string* value,
  58                       bool* found) override {
  59     if (fail_method_ != FAIL_METHOD_GET ||
  60         ++current_call_num_ != fail_on_call_num_)
  61       return LevelDBTransaction::Get(key, value, found);
  62
  63     *found = false;
  64     return leveldb::Status::Corruption("Corrupted for the test");
  65   }
  66
  67   leveldb::Status Commit() override {
  68     if ((fail_method_ != FAIL_METHOD_COMMIT &&
  69          fail_method_ != FAIL_METHOD_COMMIT_DISK_FULL) ||
  70         ++current_call_num_ != fail_on_call_num_)
  71       return LevelDBTransaction::Commit();
  72
  73     // TODO(jsbell): Consider parameterizing the failure mode.
  74     if (fail_method_ == FAIL_METHOD_COMMIT_DISK_FULL) {
  75       return leveldb_env::MakeIOError("dummy filename", "Disk Full",
  76                                       leveldb_env::kWritableFileAppend,
  77                                       base::File::FILE_ERROR_NO_SPACE);
  78     }
  79
  80     return leveldb::Status::Corruption("Corrupted for the test");
  81   }
  82
  83  private:
  84   ~LevelDBTestTransaction() override {}
  85
  86   FailMethod fail_method_;
  87   int fail_on_call_num_;
  88   int current_call_num_;
  89 };
  90
  91 class LevelDBTraceTransaction : public LevelDBTransaction {
  92  public:
  93   LevelDBTraceTransaction(LevelDBDatabase* db, int tx_num)
  94       : LevelDBTransaction(db),
  95         commit_tracer_(s_class_name, "Commit", tx_num),
  96         get_tracer_(s_class_name, "Get", tx_num) {}
  97
  98   leveldb::Status Get(const base::StringPiece& key,
  99                       std::string* value,
 100                       bool* found) override {
 101     get_tracer_.log_call();
 102     return LevelDBTransaction::Get(key, value, found);
 103   }
 104
 105   leveldb::Status Commit() override {
 106     commit_tracer_.log_call();
 107     return LevelDBTransaction::Commit();
 108   }
 109
 110  private:
 111   static const std::string s_class_name;
 112
 113   ~LevelDBTraceTransaction() override {}
 114
 115   FunctionTracer commit_tracer_;
 116   FunctionTracer get_tracer_;
 117 };
 118
 119 const std::string LevelDBTraceTransaction::s_class_name = "LevelDBTransaction";
 120
 121 class LevelDBTraceIteratorImpl : public LevelDBIteratorImpl {
 122  public:
 123   LevelDBTraceIteratorImpl(scoped_ptr<leveldb::Iterator> iterator, int inst_num)
 124       : LevelDBIteratorImpl(iterator.Pass()),
 125         is_valid_tracer_(s_class_name, "IsValid", inst_num),
 126         seek_to_last_tracer_(s_class_name, "SeekToLast", inst_num),
 127         seek_tracer_(s_class_name, "Seek", inst_num),
 128         next_tracer_(s_class_name, "Next", inst_num),
 129         prev_tracer_(s_class_name, "Prev", inst_num),
 130         key_tracer_(s_class_name, "Key", inst_num),
 131         value_tracer_(s_class_name, "Value", inst_num) {}
 132   ~LevelDBTraceIteratorImpl() override {}
 133
 134  private:
 135   static const std::string s_class_name;
 136
 137   bool IsValid() const override {
 138     is_valid_tracer_.log_call();
 139     return LevelDBIteratorImpl::IsValid();
 140   }
 141   leveldb::Status SeekToLast() override {
 142     seek_to_last_tracer_.log_call();
 143     return LevelDBIteratorImpl::SeekToLast();
 144   }
 145   leveldb::Status Seek(const base::StringPiece& target) override {
 146     seek_tracer_.log_call();
 147     return LevelDBIteratorImpl::Seek(target);
 148   }
 149   leveldb::Status Next() override {
 150     next_tracer_.log_call();
 151     return LevelDBIteratorImpl::Next();
 152   }
 153   leveldb::Status Prev() override {
 154     prev_tracer_.log_call();
 155     return LevelDBIteratorImpl::Prev();
 156   }
 157   base::StringPiece Key() const override {
 158     key_tracer_.log_call();
 159     return LevelDBIteratorImpl::Key();
 160   }
 161   base::StringPiece Value() const override {
 162     value_tracer_.log_call();
 163     return LevelDBIteratorImpl::Value();
 164   }
 165
 166   mutable FunctionTracer is_valid_tracer_;
 167   mutable FunctionTracer seek_to_last_tracer_;
 168   mutable FunctionTracer seek_tracer_;
 169   mutable FunctionTracer next_tracer_;
 170   mutable FunctionTracer prev_tracer_;
 171   mutable FunctionTracer key_tracer_;
 172   mutable FunctionTracer value_tracer_;
 173 };
 174
 175 const std::string LevelDBTraceIteratorImpl::s_class_name = "LevelDBIterator";
 176
 177 class LevelDBTestIteratorImpl : public content::LevelDBIteratorImpl {
 178  public:
 179   LevelDBTestIteratorImpl(scoped_ptr<leveldb::Iterator> iterator,
 180                           FailMethod fail_method,
 181                           int fail_on_call_num)
 182       : LevelDBIteratorImpl(iterator.Pass()),
 183         fail_method_(fail_method),
 184         fail_on_call_num_(fail_on_call_num),
 185         current_call_num_(0) {}
 186   ~LevelDBTestIteratorImpl() override {}
 187
 188  private:
 189   leveldb::Status Seek(const base::StringPiece& target) override {
 190     if (fail_method_ != FAIL_METHOD_SEEK ||
 191         ++current_call_num_ != fail_on_call_num_)
 192       return LevelDBIteratorImpl::Seek(target);
 193     return leveldb::Status::Corruption("Corrupted for test");
 194   }
 195
 196   FailMethod fail_method_;
 197   int fail_on_call_num_;
 198   int current_call_num_;
 199 };
 200
 201 MockBrowserTestIndexedDBClassFactory::MockBrowserTestIndexedDBClassFactory()
 202     : failure_class_(FAIL_CLASS_NOTHING),
 203       failure_method_(FAIL_METHOD_NOTHING),
 204       only_trace_calls_(false) {
 205 }
 206
 207 MockBrowserTestIndexedDBClassFactory::~MockBrowserTestIndexedDBClassFactory() {
 208 }
 209
 210 LevelDBTransaction*
 211 MockBrowserTestIndexedDBClassFactory::CreateLevelDBTransaction(
 212     LevelDBDatabase* db) {
 213   instance_count_[FAIL_CLASS_LEVELDB_TRANSACTION] =
 214       instance_count_[FAIL_CLASS_LEVELDB_TRANSACTION] + 1;
 215   if (only_trace_calls_) {
 216     return new LevelDBTraceTransaction(
 217         db, instance_count_[FAIL_CLASS_LEVELDB_TRANSACTION]);
 218   } else {
 219     if (failure_class_ == FAIL_CLASS_LEVELDB_TRANSACTION &&
 220         instance_count_[FAIL_CLASS_LEVELDB_TRANSACTION] ==
 221             fail_on_instance_num_[FAIL_CLASS_LEVELDB_TRANSACTION]) {
 222       return new LevelDBTestTransaction(
 223           db,
 224           failure_method_,
 225           fail_on_call_num_[FAIL_CLASS_LEVELDB_TRANSACTION]);
 226     } else {
 227       return IndexedDBClassFactory::CreateLevelDBTransaction(db);
 228     }
 229   }
 230 }
 231
 232 LevelDBIteratorImpl* MockBrowserTestIndexedDBClassFactory::CreateIteratorImpl(
 233     scoped_ptr<leveldb::Iterator> iterator) {
 234   instance_count_[FAIL_CLASS_LEVELDB_ITERATOR] =
 235       instance_count_[FAIL_CLASS_LEVELDB_ITERATOR] + 1;
 236   if (only_trace_calls_) {
 237     return new LevelDBTraceIteratorImpl(
 238         iterator.Pass(), instance_count_[FAIL_CLASS_LEVELDB_ITERATOR]);
 239   } else {
 240     if (failure_class_ == FAIL_CLASS_LEVELDB_ITERATOR &&
 241         instance_count_[FAIL_CLASS_LEVELDB_ITERATOR] ==
 242             fail_on_instance_num_[FAIL_CLASS_LEVELDB_ITERATOR]) {
 243       return new LevelDBTestIteratorImpl(
 244           iterator.Pass(),
 245           failure_method_,
 246           fail_on_call_num_[FAIL_CLASS_LEVELDB_ITERATOR]);
 247     } else {
 248       return new LevelDBIteratorImpl(iterator.Pass());
 249     }
 250   }
 251 }
 252
 253 void MockBrowserTestIndexedDBClassFactory::FailOperation(
 254     FailClass failure_class,
 255     FailMethod failure_method,
 256     int fail_on_instance_num,
 257     int fail_on_call_num) {
 258   VLOG(0) << "FailOperation: class=" << failure_class
 259           << ", method=" << failure_method
 260           << ", instanceNum=" << fail_on_instance_num
 261           << ", callNum=" << fail_on_call_num;
 262   DCHECK(failure_class != FAIL_CLASS_NOTHING);
 263   DCHECK(failure_method != FAIL_METHOD_NOTHING);
 264   failure_class_ = failure_class;
 265   failure_method_ = failure_method;
 266   fail_on_instance_num_[failure_class_] = fail_on_instance_num;
 267   fail_on_call_num_[failure_class_] = fail_on_call_num;
 268   instance_count_.clear();
 269 }
 270
 271 void MockBrowserTestIndexedDBClassFactory::Reset() {
 272   failure_class_ = FAIL_CLASS_NOTHING;
 273   failure_method_ = FAIL_METHOD_NOTHING;
 274   instance_count_.clear();
 275   fail_on_instance_num_.clear();
 276   fail_on_call_num_.clear();
 277 }
 278
 279 }  // namespace content