IndexedDB: Added IDBIndex.getAll() implementation.

content/browser/indexed_db/indexed_db_database.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_database.h"
 
 #include <math.h>
 #include <limits>
 #include <set>
 
@@ skipping 517 matching lines @@
   IDB_TRACE1("IndexedDBDatabase::Abort(error)", "txn.id", transaction_id);
   // If the transaction is unknown, then it has already been aborted by the
   // backend before this call so it is safe to ignore it.
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (transaction)
     transaction->Abort(error);
 }
 
 void IndexedDBDatabase::GetAll(int64 transaction_id,
                                int64 object_store_id,
+                               int64 index_id,
                                scoped_ptr<IndexedDBKeyRange> key_range,
                                int64 max_count,
                                scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE1("IndexedDBDatabase::GetAll", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   transaction->ScheduleTask(
       base::Bind(&IndexedDBDatabase::GetAllOperation, this, object_store_id,
-                 Passed(&key_range), max_count, callbacks));
+                 index_id, Passed(&key_range), max_count, callbacks));
 }
 
 void IndexedDBDatabase::Get(int64 transaction_id,
                             int64 object_store_id,
                             int64 index_id,
                             scoped_ptr<IndexedDBKeyRange> key_range,
                             bool key_only,
                             scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE1("IndexedDBDatabase::Get", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
@@ skipping 170 matching lines @@
   if (object_store_metadata.auto_increment &&
       !object_store_metadata.key_path.IsNull()) {
     value.primary_key = *primary_key;
     value.key_path = object_store_metadata.key_path;
   }
   callbacks->OnSuccess(&value);
 }
 
 void IndexedDBDatabase::GetAllOperation(
     int64 object_store_id,
+    int64 index_id,
     scoped_ptr<IndexedDBKeyRange> key_range,
     int64 max_count,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::GetAllOperation", "txn.id", transaction->id());
 
   DCHECK_GE(max_count, 0);
   if (!max_count)
     max_count = std::numeric_limits<decltype(max_count)>::max();
 
   DCHECK(metadata_.object_stores.find(object_store_id) !=
          metadata_.object_stores.end());
   const IndexedDBObjectStoreMetadata& object_store_metadata =
       metadata_.object_stores[object_store_id];
 
   leveldb::Status s;
 
-  scoped_ptr<IndexedDBBackingStore::Cursor> cursor =
-      backing_store_->OpenObjectStoreCursor(
-          transaction->BackingStoreTransaction(), id(), object_store_id,
-          *key_range, blink::WebIDBCursorDirectionNext, &s);
+  scoped_ptr<IndexedDBBackingStore::Cursor> cursor;
+
+  if (index_id == IndexedDBIndexMetadata::kInvalidId) {
+    // ObjectStore
+    cursor = backing_store_->OpenObjectStoreCursor(
+        transaction->BackingStoreTransaction(), id(), object_store_id,
+        *key_range, blink::WebIDBCursorDirectionNext, &s);
+  } else {
+    // Index
+    cursor = backing_store_->OpenIndexCursor(
+        transaction->BackingStoreTransaction(), id(), object_store_id, index_id,
+        *key_range, blink::WebIDBCursorDirectionNext, &s);
+  }
 
   if (!s.ok()) {
     DLOG(ERROR) << "Unable to open cursor operation: " << s.ToString();
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error in GetAllOperation");
     callbacks->OnError(error);
     if (s.IsCorruption()) {
       factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
                                              error);
     }
@@ skipping 1152 matching lines @@
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE1("IndexedDBDatabase::VersionChangeAbortOperation",
              "txn.id",
              transaction->id());
   metadata_.version = previous_version;
   metadata_.int_version = previous_int_version;
 }
 
 }  // namespace content