Return number of values deleted by IDBObjectStore.delete(range)

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 <utility>
 
 #include "base/files/file_path.h"
@@ skipping 1345 matching lines @@
       DatabaseMetaDataKey::Encode(row_id, DatabaseMetaDataKey::USER_VERSION),
       version);
   return true;
 }
 
 // If you're deleting a range that contains user keys that have blob info, this
 // won't clean up the blobs.
 static leveldb::Status DeleteRangeBasic(LevelDBTransaction* transaction,
                                         const std::string& begin,
                                         const std::string& end,
-                                        bool upper_open) {
+                                        bool upper_open,
+                                        size_t* delete_count) {
+  DCHECK(delete_count);
   std::unique_ptr<LevelDBIterator> it = transaction->CreateIterator();
   leveldb::Status s;
+  *delete_count = 0;
   for (s = it->Seek(begin); s.ok() && it->IsValid() &&
-                                (upper_open ? CompareKeys(it->Key(), end) < 0
-                                            : CompareKeys(it->Key(), end) <= 0);
-       s = it->Next())
-    transaction->Remove(it->Key());
+                            (upper_open ? CompareKeys(it->Key(), end) < 0
+                                        : CompareKeys(it->Key(), end) <= 0);
+       s = it->Next()) {
+    if (transaction->Remove(it->Key()))
+      (*delete_count)++;
+  }
   return s;
 }
 
 static leveldb::Status DeleteBlobsInRange(
     IndexedDBBackingStore::Transaction* transaction,
     int64_t database_id,
     int64_t object_store_id,
     const std::string& start_key,
     const std::string& end_key,
     bool upper_open) {
@@ skipping 376 matching lines @@
 leveldb::Status IndexedDBBackingStore::DeleteObjectStore(
     IndexedDBBackingStore::Transaction* transaction,
     int64_t database_id,
     int64_t object_store_id) {
   IDB_TRACE("IndexedDBBackingStore::DeleteObjectStore");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return InvalidDBKeyStatus();
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
 
   base::string16 object_store_name;
+  size_t delete_count = 0;
   bool found = false;
   leveldb::Status s =
       GetString(leveldb_transaction,
                 ObjectStoreMetaDataKey::Encode(
                     database_id, object_store_id, ObjectStoreMetaDataKey::NAME),
                 &object_store_name,
                 &found);
   if (!s.ok()) {
     INTERNAL_READ_ERROR_UNTESTED(DELETE_OBJECT_STORE);
     return s;
   }
   if (!found) {
     INTERNAL_CONSISTENCY_ERROR_UNTESTED(DELETE_OBJECT_STORE);
     return InternalInconsistencyStatus();
   }
 
   s = DeleteBlobsInObjectStore(transaction, database_id, object_store_id);
   if (!s.ok()) {
     INTERNAL_CONSISTENCY_ERROR_UNTESTED(DELETE_OBJECT_STORE);
     return s;
   }
 
   s = DeleteRangeBasic(
       leveldb_transaction,
       ObjectStoreMetaDataKey::Encode(database_id, object_store_id, 0),
-      ObjectStoreMetaDataKey::EncodeMaxKey(database_id, object_store_id),
-      true);
+      ObjectStoreMetaDataKey::EncodeMaxKey(database_id, object_store_id), true,
+      &delete_count);
 
   if (s.ok()) {
     leveldb_transaction->Remove(
         ObjectStoreNamesKey::Encode(database_id, object_store_name));
 
     s = DeleteRangeBasic(
         leveldb_transaction,
         IndexFreeListKey::Encode(database_id, object_store_id, 0),
-        IndexFreeListKey::EncodeMaxKey(database_id, object_store_id),
-        true);
+        IndexFreeListKey::EncodeMaxKey(database_id, object_store_id), true,
+        &delete_count);
   }
 
   if (s.ok()) {
     s = DeleteRangeBasic(
         leveldb_transaction,
         IndexMetaDataKey::Encode(database_id, object_store_id, 0, 0),
-        IndexMetaDataKey::EncodeMaxKey(database_id, object_store_id),
-        true);
+        IndexMetaDataKey::EncodeMaxKey(database_id, object_store_id), true,
+        &delete_count);
   }
 
   if (!s.ok()) {
     INTERNAL_WRITE_ERROR_UNTESTED(DELETE_OBJECT_STORE);
     return s;
   }
 
   return ClearObjectStore(transaction, database_id, object_store_id);
 }
 
@@ skipping 123 matching lines @@
     IndexedDBBackingStore::Transaction* transaction,
     int64_t database_id,
     int64_t object_store_id) {
   IDB_TRACE("IndexedDBBackingStore::ClearObjectStore");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return InvalidDBKeyStatus();
   const std::string start_key =
       KeyPrefix(database_id, object_store_id).Encode();
   const std::string stop_key =
       KeyPrefix(database_id, object_store_id + 1).Encode();
-
-  leveldb::Status s =
-      DeleteRangeBasic(transaction->transaction(), start_key, stop_key, true);
+  size_t delete_count = 0;
+  leveldb::Status s = DeleteRangeBasic(transaction->transaction(), start_key,
+                                       stop_key, true, &delete_count);
   if (!s.ok()) {
     INTERNAL_WRITE_ERROR(CLEAR_OBJECT_STORE);
     return s;
   }
   return DeleteBlobsInObjectStore(transaction, database_id, object_store_id);
 }
 
 leveldb::Status IndexedDBBackingStore::DeleteRecord(
     IndexedDBBackingStore::Transaction* transaction,
     int64_t database_id,
@@ skipping 15 matching lines @@
   const std::string exists_entry_key = ExistsEntryKey::Encode(
       database_id, object_store_id, record_identifier.primary_key());
   leveldb_transaction->Remove(exists_entry_key);
   return leveldb::Status::OK();
 }
 
 leveldb::Status IndexedDBBackingStore::DeleteRange(
     IndexedDBBackingStore::Transaction* transaction,
     int64_t database_id,
     int64_t object_store_id,
-    const IndexedDBKeyRange& key_range) {
+    const IndexedDBKeyRange& key_range,
+    size_t* exists_delete_count) {
+  DCHECK(exists_delete_count);
   leveldb::Status s;
+  *exists_delete_count = 0;
   std::unique_ptr<IndexedDBBackingStore::Cursor> start_cursor =
       OpenObjectStoreCursor(transaction, database_id, object_store_id,
                             key_range, blink::WebIDBCursorDirectionNext, &s);
   if (!s.ok())
     return s;
   if (!start_cursor)
     return leveldb::Status::OK();  // Empty range == delete success.
-
   std::unique_ptr<IndexedDBBackingStore::Cursor> end_cursor =
       OpenObjectStoreCursor(transaction, database_id, object_store_id,
                             key_range, blink::WebIDBCursorDirectionPrev, &s);
 
   if (!s.ok())
     return s;
   if (!end_cursor)
     return leveldb::Status::OK();  // Empty range == delete success.
 
   BlobEntryKey start_blob_key, end_blob_key;
-
   std::string start_key = ObjectStoreDataKey::Encode(
       database_id, object_store_id, start_cursor->key());
   base::StringPiece start_key_piece(start_key);
   if (!BlobEntryKey::FromObjectStoreDataKey(&start_key_piece, &start_blob_key))
     return InternalInconsistencyStatus();
   std::string stop_key = ObjectStoreDataKey::Encode(
       database_id, object_store_id, end_cursor->key());
   base::StringPiece stop_key_piece(stop_key);
   if (!BlobEntryKey::FromObjectStoreDataKey(&stop_key_piece, &end_blob_key))
     return InternalInconsistencyStatus();
 
   s = DeleteBlobsInRange(transaction,
                          database_id,
                          object_store_id,
                          start_blob_key.Encode(),
                          end_blob_key.Encode(),
                          false);
   if (!s.ok())
     return s;
-  s = DeleteRangeBasic(transaction->transaction(), start_key, stop_key, false);
+  size_t data_delete_count = 0;
+  s = DeleteRangeBasic(transaction->transaction(), start_key, stop_key, false,
+                       &data_delete_count);
   if (!s.ok())
     return s;
   start_key =
       ExistsEntryKey::Encode(database_id, object_store_id, start_cursor->key());
   stop_key =
       ExistsEntryKey::Encode(database_id, object_store_id, end_cursor->key());
-  return DeleteRangeBasic(
-      transaction->transaction(), start_key, stop_key, false);
+
+  s = DeleteRangeBasic(transaction->transaction(), start_key, stop_key, false,
+                       exists_delete_count);
+  DCHECK_EQ(data_delete_count, *exists_delete_count);
+  return s;
 }
 
 leveldb::Status IndexedDBBackingStore::GetKeyGeneratorCurrentNumber(
     IndexedDBBackingStore::Transaction* transaction,
     int64_t database_id,
     int64_t object_store_id,
     int64_t* key_generator_current_number) {
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return InvalidDBKeyStatus();
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
@@ skipping 773 matching lines @@
 leveldb::Status IndexedDBBackingStore::DeleteIndex(
     IndexedDBBackingStore::Transaction* transaction,
     int64_t database_id,
     int64_t object_store_id,
     int64_t index_id) {
   IDB_TRACE("IndexedDBBackingStore::DeleteIndex");
   if (!KeyPrefix::ValidIds(database_id, object_store_id, index_id))
     return InvalidDBKeyStatus();
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
 
+  size_t delete_count = 0;
   const std::string index_meta_data_start =
       IndexMetaDataKey::Encode(database_id, object_store_id, index_id, 0);
   const std::string index_meta_data_end =
       IndexMetaDataKey::EncodeMaxKey(database_id, object_store_id, index_id);
-  leveldb::Status s = DeleteRangeBasic(
-      leveldb_transaction, index_meta_data_start, index_meta_data_end, true);
+  leveldb::Status s =
+      DeleteRangeBasic(leveldb_transaction, index_meta_data_start,
+                       index_meta_data_end, true, &delete_count);
 
   if (s.ok()) {
     const std::string index_data_start =
         IndexDataKey::EncodeMinKey(database_id, object_store_id, index_id);
     const std::string index_data_end =
         IndexDataKey::EncodeMaxKey(database_id, object_store_id, index_id);
-    s = DeleteRangeBasic(
-        leveldb_transaction, index_data_start, index_data_end, true);
+    s = DeleteRangeBasic(leveldb_transaction, index_data_start, index_data_end,
+                         true, &delete_count);
   }
 
   if (!s.ok())
     INTERNAL_WRITE_ERROR_UNTESTED(DELETE_INDEX);
 
   return s;
 }
 
 leveldb::Status IndexedDBBackingStore::PutIndexDataForRecord(
     IndexedDBBackingStore::Transaction* transaction,
@@ skipping 1597 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