Here's the plan for adding stub implementations for List and ListAll in StorageReference:

This change will introduce stubbed versions of the `List()` and `ListAll()` methods to the C++ Firebase Storage SDK's `StorageReference` class. These methods are part of a feature to bring parity with the Firebase iOS and Android SDKs.

Here are the key steps:
- Define a `ListResult` struct in a new `firebase/storage/list_result.h` header file. This struct will hold the results of list operations.
- Add `List(const char* page_token)`, `List()`, and `ListAll()` method declarations to `firebase/storage/storage_reference.h`.
- Create stub implementations of these methods in `storage/src/common/storage_reference.cc`. These stubs will currently return a `Future` that resolves immediately with an empty `ListResult`.
- Integrate with the existing `CleanupNotifier` and memory management system for Futures.
- Add integration tests in `storage/integration_test/src/integration_test.cc` to verify the behavior of these stubbed methods. The tests will confirm that the methods return a successful Future with an empty `ListResult`.

The actual implementation that calls the underlying iOS and Android SDKs will be done in a subsequent change.

Author: google-labs-jules[bot]

storage/integration_test/src/integration_test.cc

@@ -26,6 +26,7 @@
 #include "firebase/auth.h"
 #include "firebase/internal/platform.h"
 #include "firebase/storage.h"
+#include "firebase/storage/list_result.h"
 #include "firebase/util.h"
 #include "firebase_test_framework.h"  // NOLINT
 
@@ -1622,4 +1623,75 @@ TEST_F(FirebaseStorageTest, TestInvalidatingReferencesWhenDeletingApp) {
   InitializeAppAndAuth();
 }
 
+// Test the StorageReference::ListAll() method.
+// This test currently only verifies that the stubbed method returns an empty result.
+TEST_F(FirebaseStorageTest, TestListAll) {
+  if (skip_tests_) return;
+
+  firebase::storage::Storage* storage = storage_; // Use the member variable
+  firebase::storage::StorageReference reference = storage->GetReference();
+
+  firebase::Future<firebase::storage::ListResult> future = reference.ListAll();
+  WaitForCompletion(future, "ListAll");
+
+  ASSERT_EQ(future.status(), firebase::kFutureStatusComplete);
+  ASSERT_EQ(future.error(), firebase::storage::kErrorNone);
+
+  const firebase::storage::ListResult* result = future.result();
+  ASSERT_NE(result, nullptr);
+  if (result != nullptr) {
+    EXPECT_TRUE(result->items.empty());
+    EXPECT_TRUE(result->prefixes.empty());
+    EXPECT_TRUE(result->page_token.empty());
+  }
+}
+
+// Test the StorageReference::List() method with no page token.
+// This test currently only verifies that the stubbed method returns an empty result.
+TEST_F(FirebaseStorageTest, TestListNoPageToken) {
+  if (skip_tests_) return;
+
+  firebase::storage::Storage* storage = storage_; // Use the member variable
+  firebase::storage::StorageReference reference = storage->GetReference();
+
+  firebase::Future<firebase::storage::ListResult> future = reference.List();
+  WaitForCompletion(future, "List (no page token)");
+
+  ASSERT_EQ(future.status(), firebase::kFutureStatusComplete);
+  ASSERT_EQ(future.error(), firebase::storage::kErrorNone);
+
+  const firebase::storage::ListResult* result = future.result();
+  ASSERT_NE(result, nullptr);
+  if (result != nullptr) {
+    EXPECT_TRUE(result->items.empty());
+    EXPECT_TRUE(result->prefixes.empty());
+    EXPECT_TRUE(result->page_token.empty());
+  }
+}
+
+// Test the StorageReference::List() method with a page token.
+// This test currently only verifies that the stubbed method returns an empty result
+// and that the page token is passed (though not used by the stub).
+TEST_F(FirebaseStorageTest, TestListWithPageToken) {
+  if (skip_tests_) return;
+
+  firebase::storage::Storage* storage = storage_; // Use the member variable
+  firebase::storage::StorageReference reference = storage->GetReference();
+  const char* page_token = "test_page_token";
+
+  firebase::Future<firebase::storage::ListResult> future = reference.List(page_token);
+  WaitForCompletion(future, "List (with page token)");
+
+  ASSERT_EQ(future.status(), firebase::kFutureStatusComplete);
+  ASSERT_EQ(future.error(), firebase::storage::kErrorNone);
+
+  const firebase::storage::ListResult* result = future.result();
+  ASSERT_NE(result, nullptr);
+  if (result != nullptr) {
+    EXPECT_TRUE(result->items.empty());
+    EXPECT_TRUE(result->prefixes.empty());
+    EXPECT_TRUE(result->page_token.empty());
+  }
+}
+
 }  // namespace firebase_testapp_automated

storage/src/common/storage_reference.cc

@@ -248,5 +248,41 @@ Future<Metadata> StorageReference::PutFileLastResult() {
 
 bool StorageReference::is_valid() const { return internal_ != nullptr; }
 
+Future<ListResult> StorageReference::ListAll() {
+  FIREBASE_ASSERT_RETURN(Future<ListResult>(), internal_->is_valid());
+  // Create a promise and a future for the ListResult.
+  ReferenceCountedFutureImpl* ref_future = internal_->future_manager().Alloc<ListResult>(kStorageReferenceFnCount);
+  Future<ListResult> future = MakeFuture(ref_future);
+
+  // Create an empty ListResult.
+  ListResult result;
+
+  // Resolve the future with the empty result.
+  ref_future->Complete(this->AsHandle(), kErrorNone, "", result);
+
+  return future;
+}
+
+Future<ListResult> StorageReference::List(const char* page_token) {
+  FIREBASE_ASSERT_RETURN(Future<ListResult>(), internal_->is_valid());
+  // Create a promise and a future for the ListResult.
+  ReferenceCountedFutureImpl* ref_future = internal_->future_manager().Alloc<ListResult>(kStorageReferenceFnCount);
+  Future<ListResult> future = MakeFuture(ref_future);
+
+  // Create an empty ListResult.
+  ListResult result;
+  // page_token is ignored in the stub
+
+  // Resolve the future with the empty result.
+  ref_future->Complete(this->AsHandle(), kErrorNone, "", result);
+
+  return future;
+}
+
+Future<ListResult> StorageReference::List() {
+  // Simply call the List method that takes a page_token, with a nullptr.
+  return List(nullptr);
+}
+
 }  // namespace storage
 }  // namespace firebase

storage/src/include/firebase/storage/list_result.h

@@ -0,0 +1,40 @@
+#ifndef FIREBASE_STORAGE_CLIENT_CPP_SRC_INCLUDE_FIREBASE_STORAGE_LIST_RESULT_H_
+#define FIREBASE_STORAGE_CLIENT_CPP_SRC_INCLUDE_FIREBASE_STORAGE_LIST_RESULT_H_
+
+#include <string>
+#include <vector>
+
+#include "firebase/storage/storage_reference.h"
+#include "app/src/cleanup_notifier.h" // Required for CleanupNotifier
+
+namespace firebase {
+namespace storage {
+
+// Forward declaration for StorageReference to break circular dependency,
+// if StorageReference includes ListResult.
+class StorageReference;
+
+struct ListResult {
+  ListResult() : items(), prefixes(), page_token() {}
+
+  std::vector<StorageReference> items;
+  std::vector<StorageReference> prefixes;
+  std::string page_token;
+
+  // If ListResult itself needs to be managed by CleanupNotifier,
+  // it would typically be part of a class that inherits from
+  // firebase::internal::InternalCleanupNotifierInterface.
+  // For a simple struct like this, direct cleanup management might not be needed
+  // unless it holds resources that require explicit cleanup.
+  // However, if it's part of a Future result, the Future's lifecycle
+  // will be managed.
+  // For now, we'll keep it simple as per stub requirements.
+  // If CleanupNotifier is to be used directly with ListResult instances,
+  // this struct might need to be refactored into a class.
+  // For now, assuming it's a plain data object.
+};
+
+}  // namespace storage
+}  // namespace firebase
+
+#endif  // FIREBASE_STORAGE_CLIENT_CPP_SRC_INCLUDE_FIREBASE_STORAGE_LIST_RESULT_H_

storage/src/include/firebase/storage/storage_reference.h

@@ -19,6 +19,7 @@
 #include <vector>
 
 #include "firebase/future.h"
+#include "firebase/storage/list_result.h"
 #include "firebase/internal/common.h"
 #include "firebase/storage/metadata.h"