refactor: ScopedDeleter doesn't require metadata (#3380)

Before the change, `ScopedDeleter` kept `ObjectMetadata` of all object
to delete. This was unnecessary - object names and generation numbers
are enough, so this change stores them instead of the metadata. This is
useful when the caller has the information but doesn't have the full
metadata.

Author: dopiera

ci/test-abi/bigtable_client.expected.abi.dump.gz

@@ -344,17 +344,23 @@ std::string CreateRandomPrefixName(std::string const& prefix) {
 
 namespace internal {
 
-ScopedDeleter::ScopedDeleter(std::function<Status(ObjectMetadata)> delete_fun)
+ScopedDeleter::ScopedDeleter(
+    std::function<Status(std::string, std::int64_t)> delete_fun)
     : delete_fun_(std::move(delete_fun)) {}
 
 ScopedDeleter::~ScopedDeleter() { ExecuteDelete(); }
 
 void ScopedDeleter::Add(ObjectMetadata object) {
-  object_list_.emplace_back(std::move(object));
+  auto generation = object.generation();
+  Add(std::move(object).name(), generation);
+}
+
+void ScopedDeleter::Add(std::string object_name, std::int64_t generation) {
+  object_list_.emplace_back(std::move(object_name), generation);
 }
 
 Status ScopedDeleter::ExecuteDelete() {
-  std::vector<ObjectMetadata> object_list;
+  std::vector<std::pair<std::string, std::int64_t>> object_list;
   // make sure the dtor will not do this again
   object_list.swap(object_list_);
 
@@ -363,7 +369,7 @@ Status ScopedDeleter::ExecuteDelete() {
   // last.
   for (auto object_it = object_list.rbegin(); object_it != object_list.rend();
        ++object_it) {
-    Status status = delete_fun_(std::move(*object_it));
+    Status status = delete_fun_(std::move(object_it->first), object_it->second);
     // Fail on first error. If the service is unavailable, every deletion
     // would potentially keep retrying until the timeout passes - this would
     // take way too much time and would be pointless.

ci/test-abi/storage_client.expected.abi.dump.gz

@@ -3197,20 +3197,23 @@ class ScopedDeleter {
  public:
   // The actual deletion depends on local's types in a very non-trivial way,
   // so we abstract this away by providing the function to delete one object.
-  ScopedDeleter(std::function<Status(ObjectMetadata)> delete_fun);
+  ScopedDeleter(std::function<Status(std::string, std::int64_t)> delete_fun);
   ScopedDeleter(ScopedDeleter const&) = delete;
   ScopedDeleter& operator=(ScopedDeleter const&) = delete;
   ~ScopedDeleter();
 
   /// Defer object's deletion to this objects destruction (or ExecuteDelete())
   void Add(ObjectMetadata object);
 
+  /// Defer object's deletion to this objects destruction (or ExecuteDelete())
+  void Add(std::string object_name, std::int64_t generation);
+
   /// Execute all the deferred deletions now.
   Status ExecuteDelete();
 
  private:
-  std::function<Status(ObjectMetadata)> delete_fun_;
-  std::vector<ObjectMetadata> object_list_;
+  std::function<Status(std::string, std::int64_t)> delete_fun_;
+  std::vector<std::pair<std::string, std::int64_t>> object_list_;
 };
 
 }  // namespace internal
@@ -3288,14 +3291,15 @@ StatusOr<ObjectMetadata> ComposeMany(
       "EncryptionKey, IfGenerationMatch, IfMetagenerationMatch, KmsKeyName, "
       "QuotaUser, UserIp, UserProject or WithObjectMetadata.");
 
-  internal::ScopedDeleter deleter([&](ObjectMetadata const& object) {
-    return google::cloud::internal::apply(
-        internal::DeleteApplyHelper{client, bucket_name, object.name()},
-        std::tuple_cat(
-            std::make_tuple(IfGenerationMatch(object.generation())),
-            StaticTupleFilter<Among<QuotaUser, UserProject, UserIp>::TPred>(
-                all_options)));
-  });
+  internal::ScopedDeleter deleter(
+      [&](std::string const& object_name, std::int64_t generation) {
+        return google::cloud::internal::apply(
+            internal::DeleteApplyHelper{client, bucket_name, object_name},
+            std::tuple_cat(
+                std::make_tuple(IfGenerationMatch(generation)),
+                StaticTupleFilter<Among<QuotaUser, UserProject, UserIp>::TPred>(
+                    all_options)));
+      });
 
   auto lock = internal::LockPrefix(client, bucket_name, prefix, "",
                                    std::make_tuple(options...));

google/cloud/storage/client.cc

@@ -276,13 +276,12 @@ NonResumableParallelUploadState::Create(Client client,
       StaticTupleFilter<Among<QuotaUser, UserProject, UserIp>::TPred>(
           all_options);
   auto deleter = google::cloud::internal::make_unique<ScopedDeleter>(
-      [client, bucket_name,
-       delete_options](ObjectMetadata const& object) mutable {
+      [client, bucket_name, delete_options](std::string const& object_name,
+                                            std::int64_t generation) mutable {
         return google::cloud::internal::apply(
-            DeleteApplyHelper{client, std::move(bucket_name), object.name()},
-            std::tuple_cat(
-                std::make_tuple(IfGenerationMatch(object.generation())),
-                std::move(delete_options)));
+            DeleteApplyHelper{client, std::move(bucket_name), object_name},
+            std::tuple_cat(std::make_tuple(IfGenerationMatch(generation)),
+                           std::move(delete_options)));
       });
 
   auto compose_options = StaticTupleFilter<