Fix Firebase Storage C++ SDK desktop build issues

Resolved several issues preventing the Firebase Storage C++ SDK from building on desktop platforms (Linux):

1.  Corrected leveldb patching mechanism to avoid applying Windows-specific patches on Linux.
2.  Ensured BoringSSL is compiled with Position Independent Code (PIC) by adding -DCMAKE_POSITION_INDEPENDENT_CODE=ON to the main CMake configuration, resolving linker errors with libcurl.
3.  Created missing header files:
    *   `storage/src/common/storage_reference_internal.h` (defines base class for internal StorageReference implementations).
    *   `storage/src/include/firebase/storage/future_details.h` (placeholder, appears to be currently unused but was included).
4.  Refactored the Pimpl hierarchy for `StorageReference`:
    *   Renamed desktop-specific `StorageReferenceInternal` to `StorageReferenceInternalDesktop`.
    *   Made `StorageReferenceInternalDesktop` inherit from the common `StorageReferenceInternal` base class.
    *   Updated method overrides and return types in `StorageReferenceInternalDesktop` and its corresponding .cc file.
    *   Modified `StorageReference` (public class), `ControllerInternal` (desktop), and `MetadataInternal` (desktop) to correctly use `Clone()` for copying internal Pimpl objects and to instantiate the concrete `StorageReferenceInternalDesktop` where appropriate.
5.  Added the missing `kErrorUnimplemented` enum value to `firebase::storage::Error` in `firebase/storage/common.h`.
6.  Added `ClearInternalForCleanup` method declaration to `ListResult` class in its public header.
7.  Corrected various private access errors by adding necessary friend class declarations.
8.  Fixed incorrect `static` linkage for `GlobalCleanupListResult` function.

These changes allow `firebase_storage` to compile successfully on a Linux desktop environment. A C++17 `if constexpr` warning remains in `storage_reference_desktop.cc` but does not prevent the build.

Author: google-labs-jules[bot]

cmake/external/leveldb.cmake

@@ -18,16 +18,22 @@ if(TARGET leveldb)
   return()
 endif()
 
+set(current_patch_file "") # Explicitly initialize for this scope
 if (DESKTOP AND MSVC)
-set(patch_file 
-  ${CMAKE_CURRENT_LIST_DIR}/../../scripts/git/patches/leveldb/0001-leveldb-1.23-windows-paths.patch)
+  set(current_patch_file
+    ${CMAKE_CURRENT_LIST_DIR}/../../scripts/git/patches/leveldb/0001-leveldb-1.23-windows-paths.patch)
 endif()
 
 # This version must be kept in sync with the version in firestore.patch.txt.
 # If this version ever changes then make sure to update the version in
 # firestore.patch.txt accordingly.
 set(version 1.23)
 
+set(final_patch_command "")
+if(current_patch_file)
+  set(final_patch_command git apply ${current_patch_file} && git gc --aggressive)
+endif()
+
 ExternalProject_Add(
   leveldb
 
@@ -42,5 +48,5 @@ ExternalProject_Add(
   INSTALL_COMMAND   ""
   TEST_COMMAND      ""
   HTTP_HEADER "${EXTERNAL_PROJECT_HTTP_HEADER}"
-  PATCH_COMMAND git apply ${patch_file} && git gc --aggressive
+  PATCH_COMMAND ${final_patch_command}
 )

storage/src/common/list_result.cc

@@ -42,7 +42,7 @@ using internal::ListResultInternal;
 // Global function to be called by CleanupNotifier
 // This function is responsible for cleaning up the internal state of a
 // ListResult object when the App is being shut down.
-static void GlobalCleanupListResult(void* list_result_void) {
+void GlobalCleanupListResult(void* list_result_void) {
   if (list_result_void) {
     ListResult* list_result = static_cast<ListResult*>(list_result_void);
     // This method will delete internal_ and set it to nullptr.

storage/src/common/storage_reference.cc

@@ -87,15 +87,14 @@ StorageReference::StorageReference(StorageReferenceInternal* internal)
 }
 
 StorageReference::StorageReference(const StorageReference& other)
-    : internal_(other.internal_ ? new StorageReferenceInternal(*other.internal_)
-                                : nullptr) {
+    : internal_(other.internal_ ? other.internal_->Clone() : nullptr) {
   StorageReferenceInternalCommon::RegisterForCleanup(this, internal_);
 }
 
 StorageReference& StorageReference::operator=(const StorageReference& other) {
+  if (this == &other) return *this;
   StorageReferenceInternalCommon::DeleteInternal(this);
-  internal_ = other.internal_ ? new StorageReferenceInternal(*other.internal_)
-                              : nullptr;
+  internal_ = other.internal_ ? other.internal_->Clone() : nullptr;
   StorageReferenceInternalCommon::RegisterForCleanup(this, internal_);
   return *this;
 }
@@ -269,9 +268,7 @@ Future<ListResult> StorageReference::ListAll() {
 }
 
 Future<ListResult> StorageReference::ListLastResult() {
-  if (!internal_) return Future<ListResult>();
-  return static_cast<const Future<ListResult>&>(
-      internal_->future()->LastResult(kStorageReferenceFnList));
+  return internal_ ? internal_->ListLastResult() : Future<ListResult>();
 }
 
 }  // namespace storage

storage/src/common/storage_reference_internal.h

@@ -0,0 +1,104 @@
+#ifndef FIREBASE_STORAGE_SRC_COMMON_STORAGE_REFERENCE_INTERNAL_H_
+#define FIREBASE_STORAGE_SRC_COMMON_STORAGE_REFERENCE_INTERNAL_H_
+
+#include <string>
+#include <vector>
+
+#include "firebase/future.h"
+#include "firebase/storage/metadata.h"
+// Listener and Controller are used in method signatures, need full declaration or forward
+#include "firebase/storage/listener.h"
+#include "firebase/storage/controller.h"
+
+namespace firebase {
+namespace storage {
+
+// Forward declarations from public API
+class Storage;
+class ListResult;
+class StorageReference;
+
+
+namespace internal {
+
+class StorageInternal; // Platform-specific internal helper for Storage.
+
+// Defines the common internal interface for StorageReference.
+// Platform-specific implementations (Desktop, Android, iOS) will derive from this.
+class StorageReferenceInternal {
+ public:
+  virtual ~StorageReferenceInternal() = default;
+
+  // Interface methods mirroring the public StorageReference API
+  virtual Storage* storage() const = 0;
+  virtual StorageReferenceInternal* Child(const char* path) const = 0;
+  virtual std::string bucket() const = 0;
+  virtual std::string full_path() const = 0;
+  virtual std::string name() = 0; // Desktop implementation is not const
+  virtual StorageReferenceInternal* GetParent() = 0; // Desktop implementation is not const
+
+  virtual Future<void> Delete() = 0;
+  virtual Future<void> DeleteLastResult() = 0;
+
+  virtual Future<size_t> GetFile(const char* path, Listener* listener,
+                                 Controller* controller_out) = 0;
+  virtual Future<size_t> GetFileLastResult() = 0;
+
+  virtual Future<size_t> GetBytes(void* buffer, size_t buffer_size,
+                                  Listener* listener,
+                                  Controller* controller_out) = 0;
+  virtual Future<size_t> GetBytesLastResult() = 0;
+
+  virtual Future<std::string> GetDownloadUrl() = 0;
+  virtual Future<std::string> GetDownloadUrlLastResult() = 0;
+
+  virtual Future<Metadata> GetMetadata() = 0;
+  virtual Future<Metadata> GetMetadataLastResult() = 0;
+
+  virtual Future<Metadata> UpdateMetadata(const Metadata* metadata) = 0;
+  virtual Future<Metadata> UpdateMetadataLastResult() = 0;
+
+  virtual Future<Metadata> PutBytes(const void* buffer, size_t buffer_size,
+                                    Listener* listener,
+                                    Controller* controller_out) = 0;
+  virtual Future<Metadata> PutBytes(const void* buffer, size_t buffer_size,
+                                    const Metadata* metadata, Listener* listener,
+                                    Controller* controller_out) = 0;
+  virtual Future<Metadata> PutBytesLastResult() = 0;
+
+  virtual Future<Metadata> PutFile(const char* path, Listener* listener,
+                                   Controller* controller_out) = 0;
+  virtual Future<Metadata> PutFile(const char* path, const Metadata* metadata,
+                                   Listener* listener,
+                                   Controller* controller_out) = 0;
+  virtual Future<Metadata> PutFileLastResult() = 0;
+
+  virtual Future<ListResult> List(int32_t max_results) = 0;
+  virtual Future<ListResult> List(int32_t max_results,
+                                  const char* page_token) = 0;
+  virtual Future<ListResult> ListAll() = 0;
+  virtual Future<ListResult> ListLastResult() = 0;
+
+  // Common utility methods needed by StorageReference and platform implementations
+  virtual StorageInternal* storage_internal() const = 0;
+  virtual StorageReferenceInternal* Clone() const = 0;
+
+ protected:
+  StorageReferenceInternal() = default;
+
+ private:
+  // Public class is a friend to access constructor & internal_
+  friend class firebase::storage::StorageReference;
+
+  // Disallow copy/move of the base class directly; cloning is explicit.
+  StorageReferenceInternal(const StorageReferenceInternal&) = delete;
+  StorageReferenceInternal& operator=(const StorageReferenceInternal&) = delete;
+  StorageReferenceInternal(StorageReferenceInternal&&) = delete;
+  StorageReferenceInternal& operator=(StorageReferenceInternal&&) = delete;
+};
+
+}  // namespace internal
+}  // namespace storage
+}  // namespace firebase
+
+#endif  // FIREBASE_STORAGE_SRC_COMMON_STORAGE_REFERENCE_INTERNAL_H_

storage/src/desktop/controller_desktop.cc

@@ -82,8 +82,8 @@ int64_t ControllerInternal::total_byte_count() {
 // Returns the StorageReference associated with this Controller.
 StorageReferenceInternal* ControllerInternal::GetReference() const {
   MutexLock lock(mutex_);
-  return reference_.is_valid()
-             ? new StorageReferenceInternal(*reference_.internal_)
+  return reference_.is_valid() && reference_.internal_ != nullptr
+             ? reference_.internal_->Clone()
              : nullptr;
 }
 

storage/src/desktop/metadata_desktop.cc

@@ -144,7 +144,9 @@ void MetadataInternal::UpdateStorageInternal() {
 }
 
 StorageReferenceInternal* MetadataInternal::GetReference() const {
-  return new StorageReferenceInternal(*storage_reference_.internal_);
+  return storage_reference_.is_valid() && storage_reference_.internal_ != nullptr
+             ? storage_reference_.internal_->Clone()
+             : nullptr;
 }
 
 std::string MetadataInternal::LookUpString(Variant* root, const char* key,

storage/src/desktop/storage_desktop.cc

@@ -77,20 +77,20 @@ StorageInternal::~StorageInternal() {
 
 // Get a StorageReference to the root of the database.
 StorageReferenceInternal* StorageInternal::GetReference() const {
-  return new StorageReferenceInternal(url_, const_cast<StorageInternal*>(this));
+  return new StorageReferenceInternalDesktop(url_, const_cast<StorageInternal*>(this));
 }
 
 // Get a StorageReference for the specified path.
 StorageReferenceInternal* StorageInternal::GetReference(
     const char* path) const {
-  return new StorageReferenceInternal(root_.GetChild(path),
+  return new StorageReferenceInternalDesktop(root_.GetChild(path),
                                       const_cast<StorageInternal*>(this));
 }
 
 // Get a StorageReference for the provided URL.
 StorageReferenceInternal* StorageInternal::GetReferenceFromUrl(
     const char* url) const {
-  return new StorageReferenceInternal(url, const_cast<StorageInternal*>(this));
+  return new StorageReferenceInternalDesktop(url, const_cast<StorageInternal*>(this));
 }
 
 // Returns the auth token for the current user, if there is a current user,

storage/src/desktop/storage_desktop.h

@@ -82,6 +82,9 @@ class StorageInternal {
   // Whether this object was successfully initialized by the constructor.
   bool initialized() const { return app_ != nullptr; }
 
+  // Conforms to common interface, equivalent to initialized() for desktop.
+  bool app_valid() const { return initialized(); }
+
   // When this is deleted, it will clean up all StorageReferences and other
   // objects.
   FutureManager& future_manager() { return future_manager_; }