[IndexedDB] Adding traces, perf tests

content/browser/indexed_db/indexed_db_backing_store.cc

 // Copyright (c) 2013 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 "content/browser/indexed_db/indexed_db_backing_store.h"
 
 #include <algorithm>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 547 matching lines @@
 // though that may be costly. Still, database/directory deletion should always
 // clean things up, and we can write an fsck that will do a full correction if
 // need be.
 
 // Read and decode the specified blob journal via the supplied transaction.
 // The key must be either the primary journal key or live journal key.
 template <typename TransactionType>
 static leveldb::Status GetBlobJournal(const StringPiece& key,
                                       TransactionType* transaction,
                                       BlobJournalType* journal) {
+  IDB_TRACE("IndexedDBBackingStore::GetBlobJournal");
   std::string data;
   bool found = false;
   leveldb::Status s = transaction->Get(key, &data, &found);
   if (!s.ok()) {
     INTERNAL_READ_ERROR(READ_BLOB_JOURNAL);
     return s;
   }
   journal->clear();
   if (!found || data.empty())
     return leveldb::Status::OK();
@@ skipping 81 matching lines @@
   return AppendBlobsToBlobJournal(transaction, LiveBlobJournalKey::Encode(),
                                   journal);
 }
 
 // Append a database to the specified blob journal via the supplied transaction.
 // The key must be either the primary journal key or live journal key.
 static leveldb::Status MergeDatabaseIntoBlobJournal(
     LevelDBDirectTransaction* transaction,
     const std::string& key,
     int64 database_id) {
+  IDB_TRACE("IndexedDBBackingStore::MergeDatabaseIntoBlobJournal");
   BlobJournalType journal;
   leveldb::Status s = GetBlobJournal(key, transaction, &journal);
   if (!s.ok())
     return s;
   journal.push_back(
       std::make_pair(database_id, DatabaseMetaDataKey::kAllBlobsKey));
   UpdateBlobJournal(transaction, key, journal);
   return leveldb::Status::OK();
 }
 
@@ skipping 788 matching lines @@
   s = GetIDBDatabaseMetaData(name, &metadata, &success);
   if (!s.ok())
     return s;
   if (!success)
     return leveldb::Status::OK();
 
   const std::string start_key = DatabaseMetaDataKey::Encode(
       metadata.id, DatabaseMetaDataKey::ORIGIN_NAME);
   const std::string stop_key = DatabaseMetaDataKey::Encode(
       metadata.id + 1, DatabaseMetaDataKey::ORIGIN_NAME);
-  scoped_ptr<LevelDBIterator> it = db_->CreateIterator();
-  for (s = it->Seek(start_key);
-       s.ok() && it->IsValid() && CompareKeys(it->Key(), stop_key) < 0;
-       s = it->Next())
-    transaction->Remove(it->Key());
+  {
+    IDB_TRACE("IndexedDBBackingStore::DeleteDatabase.DeleteEntries");
+    scoped_ptr<LevelDBIterator> it = db_->CreateIterator();
+    for (s = it->Seek(start_key);
+         s.ok() && it->IsValid() && CompareKeys(it->Key(), stop_key) < 0;
+         s = it->Next())
+      transaction->Remove(it->Key());
+  }
   if (!s.ok()) {
     INTERNAL_WRITE_ERROR_UNTESTED(DELETE_DATABASE);
     return s;
   }
 
   const std::string key = DatabaseNameKey::Encode(origin_identifier_, name);
   transaction->Remove(key);
 
   bool need_cleanup = false;
   if (active_blob_registry()->MarkDeletedCheckIfUsed(
@@ skipping 1193 matching lines @@
   return base::DeleteFile(path, false);
 }
 
 bool IndexedDBBackingStore::RemoveBlobDirectory(int64 database_id) const {
   FilePath path = GetBlobDirectoryName(blob_path_, database_id);
   return base::DeleteFile(path, true);
 }
 
 leveldb::Status IndexedDBBackingStore::CleanUpBlobJournalEntries(
     const BlobJournalType& journal) const {
+  IDB_TRACE("IndexedDBBackingStore::CleanUpBlobJournalEntries");
   if (journal.empty())
     return leveldb::Status::OK();
   for (const auto& entry : journal) {
     int64 database_id = entry.first;
     int64 blob_key = entry.second;
     DCHECK(KeyPrefix::IsValidDatabaseId(database_id));
     if (blob_key == DatabaseMetaDataKey::kAllBlobsKey) {
       if (!RemoveBlobDirectory(database_id))
         return IOErrorStatus();
     } else {
       DCHECK(DatabaseMetaDataKey::IsValidBlobKey(blob_key));
       if (!RemoveBlobFile(database_id, blob_key))
         return IOErrorStatus();
     }
   }
   return leveldb::Status::OK();
 }
 
 leveldb::Status IndexedDBBackingStore::CleanUpBlobJournal(
     const std::string& level_db_key) const {
+  IDB_TRACE("IndexedDBBackingStore::CleanUpBlobJournal");
   DCHECK(!committing_transaction_count_);
   leveldb::Status s;
   scoped_refptr<LevelDBTransaction> journal_transaction =
       IndexedDBClassFactory::Get()->CreateLevelDBTransaction(db_.get());
   BlobJournalType journal;
 
   s = GetBlobJournal(level_db_key, journal_transaction.get(), &journal);
   if (!s.ok())
     return s;
   if (journal.empty())
@@ skipping 1491 matching lines @@
   leveldb::Status s;
 
   DCHECK(committing_);
   committing_ = false;
   DCHECK_GT(backing_store_->committing_transaction_count_, 0UL);
   --backing_store_->committing_transaction_count_;
 
   BlobJournalType primary_journal, live_journal, saved_primary_journal,
       dead_blobs;
   if (!blob_change_map_.empty()) {
+    IDB_TRACE("IndexedDBBackingStore::Transaction.BlobJournal");
     // Read the persisted states of the primary/live blob journals,
     // so that they can be updated correctly by the transaction.
     scoped_refptr<LevelDBTransaction> journal_transaction =
         IndexedDBClassFactory::Get()->CreateLevelDBTransaction(
             backing_store_->db_.get());
     s = GetPrimaryBlobJournal(journal_transaction.get(), &primary_journal);
     if (!s.ok())
       return s;
     s = GetLiveBlobJournal(journal_transaction.get(), &live_journal);
     if (!s.ok())
@@ skipping 74 matching lines @@
 }
 
 
 class IndexedDBBackingStore::Transaction::BlobWriteCallbackWrapper
     : public IndexedDBBackingStore::BlobWriteCallback {
  public:
   BlobWriteCallbackWrapper(IndexedDBBackingStore::Transaction* transaction,
                            scoped_refptr<BlobWriteCallback> callback)
       : transaction_(transaction), callback_(callback) {}
   void Run(bool succeeded) override {
+    IDB_ASYNC_TRACE_END("IndexedDBBackingStore::Transaction::WriteNewBlobs",
+                        transaction_);
     callback_->Run(succeeded);
     if (succeeded)  // Else it's already been deleted during rollback.
       transaction_->chained_blob_writer_ = NULL;
   }
 
  private:
   ~BlobWriteCallbackWrapper() override {}
   friend class base::RefCounted<IndexedDBBackingStore::BlobWriteCallback>;
 
   IndexedDBBackingStore::Transaction* transaction_;
   scoped_refptr<BlobWriteCallback> callback_;
 
   DISALLOW_COPY_AND_ASSIGN(BlobWriteCallbackWrapper);
 };
 
 void IndexedDBBackingStore::Transaction::WriteNewBlobs(
     BlobEntryKeyValuePairVec* new_blob_entries,
     WriteDescriptorVec* new_files_to_write,
     scoped_refptr<BlobWriteCallback> callback) {
+  IDB_ASYNC_TRACE_BEGIN("IndexedDBBackingStore::Transaction::WriteNewBlobs",
+                        this);
   DCHECK_GT(new_files_to_write->size(), 0UL);
   DCHECK_GT(database_id_, 0);
   for (auto& blob_entry_iter : *new_blob_entries) {
     // Add the new blob-table entry for each blob to the main transaction, or
     // remove any entry that may exist if there's no new one.
     if (blob_entry_iter.second.empty())
       transaction_->Remove(blob_entry_iter.first.Encode());
     else
       transaction_->Put(blob_entry_iter.first.Encode(),
                         &blob_entry_iter.second);
@@ skipping 144 matching lines @@
 
 IndexedDBBackingStore::Transaction::WriteDescriptor::WriteDescriptor(
     const WriteDescriptor& other) = default;
 IndexedDBBackingStore::Transaction::WriteDescriptor::~WriteDescriptor() =
     default;
 IndexedDBBackingStore::Transaction::WriteDescriptor&
     IndexedDBBackingStore::Transaction::WriteDescriptor::
     operator=(const WriteDescriptor& other) = default;
 
 }  // namespace content