cleanup(GCS+gRPC): remove redundant overload (#13985)

Author: coryan

google/cloud/storage/async/client.cc

@@ -69,21 +69,11 @@ std::pair<AsyncRewriter, AsyncToken> AsyncClient::StartRewrite(
     BucketName const& source_bucket, std::string source_object_name,
     BucketName const& destination_bucket, std::string destination_object_name,
     Options opts) {
-  return StartRewrite(source_bucket, std::move(source_object_name),
-                      destination_bucket, std::move(destination_object_name),
-                      google::storage::v2::RewriteObjectRequest{},
-                      std::move(opts));
-}
-
-std::pair<AsyncRewriter, AsyncToken> AsyncClient::StartRewrite(
-    BucketName const& source_bucket, std::string source_object_name,
-    BucketName const& destination_bucket, std::string destination_object_name,
-    google::storage::v2::RewriteObjectRequest request, Options opts) {
+  auto request = google::storage::v2::RewriteObjectRequest{};
   request.set_destination_name(std::move(destination_object_name));
   request.set_destination_bucket(destination_bucket.FullName());
   request.set_source_object(std::move(source_object_name));
   request.set_source_bucket(source_bucket.FullName());
-  request.mutable_rewrite_token()->clear();
   return ResumeRewrite(std::move(request), std::move(opts));
 }
 
@@ -93,15 +83,6 @@ std::pair<AsyncRewriter, AsyncToken> AsyncClient::StartRewrite(
   return ResumeRewrite(std::move(request), std::move(opts));
 }
 
-std::pair<AsyncRewriter, AsyncToken> AsyncClient::ResumeRewrite(
-    google::storage::v2::RewriteObjectRequest request, Options opts) {
-  auto c = connection_->RewriteObject(
-      {std::move(request),
-       internal::MergeOptions(std::move(opts), connection_->options())});
-  auto token = storage_internal::MakeAsyncToken(c.get());
-  return std::make_pair(AsyncRewriter(std::move(c)), std::move(token));
-}
-
 std::pair<AsyncRewriter, AsyncToken> AsyncClient::ResumeRewrite(
     BucketName const& source_bucket, std::string source_object_name,
     BucketName const& destination_bucket, std::string destination_object_name,
@@ -115,6 +96,15 @@ std::pair<AsyncRewriter, AsyncToken> AsyncClient::ResumeRewrite(
   return ResumeRewrite(std::move(request), std::move(opts));
 }
 
+std::pair<AsyncRewriter, AsyncToken> AsyncClient::ResumeRewrite(
+    google::storage::v2::RewriteObjectRequest request, Options opts) {
+  auto c = connection_->RewriteObject(
+      {std::move(request),
+       internal::MergeOptions(std::move(opts), connection_->options())});
+  auto token = storage_internal::MakeAsyncToken(c.get());
+  return std::make_pair(AsyncRewriter(std::move(c)), std::move(token));
+}
+
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
 }  // namespace storage_experimental
 }  // namespace cloud

google/cloud/storage/async/client.h

@@ -632,25 +632,6 @@ class AsyncClient {
       BucketName const& destination_bucket, std::string destination_object_name,
       Options opts = {});
 
-  /**
-   * Creates an `AsyncRewriter` to copy the source object.
-   *
-   * @snippet{doc} async/client.h start-rewrite-common
-   *
-   * @param source_bucket the name of the bucket containing the source object.
-   * @param source_object_name the name of the source object.
-   * @param destination_bucket the name of the bucket for the new object.
-   * @param destination_object_name what to name the destination object.
-   * @param request any additional parameters modifying the request, such as
-   *   pre-conditions, and overrides for the destination object metadata.
-   * @param opts options controlling the behavior of this RPC, for example
-   *     the application may change the retry policy.
-   */
-  std::pair<AsyncRewriter, AsyncToken> StartRewrite(
-      BucketName const& source_bucket, std::string source_object_name,
-      BucketName const& destination_bucket, std::string destination_object_name,
-      google::storage::v2::RewriteObjectRequest request, Options opts = {});
-
   /**
    * Creates an `AsyncRewriter` to copy the source object.
    *

google/cloud/storage/async/client_test.cc

@@ -506,53 +506,6 @@ TEST(AsyncClient, StartRewrite2) {
       .WillRepeatedly(
           Return(Options{}.set<TestOption<0>>("O0").set<TestOption<1>>("O1")));
 
-  EXPECT_CALL(*mock, RewriteObject)
-      .WillOnce([](AsyncConnection::RewriteObjectParams const& p) {
-        EXPECT_THAT(p.options.get<TestOption<0>>(), "O0");
-        EXPECT_THAT(p.options.get<TestOption<1>>(), "O1-function");
-        EXPECT_THAT(p.options.get<TestOption<2>>(), "O2-function");
-        auto constexpr kExpected = R"pb(
-          source_bucket: "projects/_/buckets/src-bucket"
-          source_object: "src-object"
-          destination_bucket: "projects/_/buckets/dst-bucket"
-          destination_name: "dst-object"
-          if_generation_match: 42
-        )pb";
-        EXPECT_THAT(p.request, MatchRewriteRequest(kExpected));
-        auto rewriter = std::make_shared<MockAsyncRewriterConnection>();
-        EXPECT_CALL(*rewriter, Iterate).WillOnce([] {
-          RewriteResponse response;
-          response.set_total_bytes_rewritten(3000);
-          response.set_object_size(3000);
-          response.mutable_resource()->set_size(3000);
-          return make_ready_future(make_status_or(MakeRewriteResponse()));
-        });
-        return rewriter;
-      });
-
-  auto client = AsyncClient(mock);
-  AsyncRewriter rewriter;
-  AsyncToken token;
-  RewriteObjectRequest request;
-  request.set_if_generation_match(42);
-  std::tie(rewriter, token) =
-      client.StartRewrite(BucketName("src-bucket"), "src-object",
-                          BucketName("dst-bucket"), "dst-object", request,
-                          Options{}
-                              .set<TestOption<1>>("O1-function")
-                              .set<TestOption<2>>("O2-function"));
-  auto rt = rewriter.Iterate(std::move(token)).get();
-  ASSERT_STATUS_OK(rt);
-  EXPECT_FALSE(rt->second.valid());
-  EXPECT_THAT(rt->first, MatchRewriteResponse());
-}
-
-TEST(AsyncClient, StartRewrite3) {
-  auto mock = std::make_shared<MockAsyncConnection>();
-  EXPECT_CALL(*mock, options)
-      .WillRepeatedly(
-          Return(Options{}.set<TestOption<0>>("O0").set<TestOption<1>>("O1")));
-
   EXPECT_CALL(*mock, RewriteObject)
       .WillOnce([](AsyncConnection::RewriteObjectParams const& p) {
         EXPECT_THAT(p.options.get<TestOption<0>>(), "O0");

google/cloud/storage/examples/storage_async_samples.cc

@@ -371,11 +371,14 @@ void ResumeRewrite(google::cloud::storage_experimental::AsyncClient& client,
     // First start a rewrite. In this example we will limit the number of bytes
     // rewritten by each iteration, then capture the token, and then resume the
     // rewrite operation.
-    auto bucket = gcs_ex::BucketName(bucket_name);
-    auto request = google::storage::v2::RewriteObjectRequest();
+    auto bucket = gcs_ex::BucketName(std::move(bucket_name));
+    auto request = google::storage::v2::RewriteObjectRequest{};
+    request.set_destination_name(destination_name);
+    request.set_destination_bucket(bucket.FullName());
+    request.set_source_object(std::move(object_name));
+    request.set_source_bucket(bucket.FullName());
     request.set_max_bytes_rewritten_per_call(1024 * 1024);
-    auto [rewriter, token] = client.StartRewrite(
-        bucket, object_name, bucket, destination_name, std::move(request));
+    auto [rewriter, token] = client.StartRewrite(std::move(request));
     auto [progress, t] = (co_await rewriter.Iterate(std::move(token))).value();
     co_return progress.rewrite_token();
   };
@@ -385,12 +388,12 @@ void ResumeRewrite(google::cloud::storage_experimental::AsyncClient& client,
          std::string rewrite_token) -> g::future<google::storage::v2::Object> {
     // Continue rewriting, this could happen on a separate process, or even
     // after the application restarts.
-    auto bucket = gcs_ex::BucketName(bucket_name);
+    auto bucket = gcs_ex::BucketName(std::move(bucket_name));
     auto request = google::storage::v2::RewriteObjectRequest();
     request.set_destination_bucket(bucket.FullName());
-    request.set_destination_name(destination_name);
+    request.set_destination_name(std::move(destination_name));
     request.set_source_bucket(bucket.FullName());
-    request.set_source_object(object_name);
+    request.set_source_object(std::move(object_name));
     request.set_rewrite_token(std::move(rewrite_token));
     request.set_max_bytes_rewritten_per_call(1024 * 1024);
     auto [rewriter, token] = client.ResumeRewrite(std::move(request));

google/cloud/storage/tests/async_client_integration_test.cc

@@ -419,10 +419,12 @@ TEST_F(AsyncClientIntegrationTest, RewriteObject) {
   AsyncRewriter rewriter;
   AsyncToken token;
   google::storage::v2::RewriteObjectRequest request;
+  request.set_destination_name(o2);
+  request.set_destination_bucket(BucketName(bucket_name()).FullName());
+  request.set_source_object(o1);
+  request.set_source_bucket(BucketName(bucket_name()).FullName());
   request.set_max_bytes_rewritten_per_call(1024 * 1024);
-  std::tie(rewriter, token) =
-      async.StartRewrite(BucketName(bucket_name()), o1,
-                         BucketName(bucket_name()), o2, std::move(request));
+  std::tie(rewriter, token) = async.StartRewrite(std::move(request));
   while (token.valid()) {
     auto rt = rewriter.Iterate(std::move(token)).get();
     ASSERT_STATUS_OK(rt);
@@ -464,10 +466,12 @@ TEST_F(AsyncClientIntegrationTest, RewriteObjectResume) {
   AsyncToken token;
   auto const expected_name = MakeRandomObjectName();
   google::storage::v2::RewriteObjectRequest start_request;
+  start_request.set_destination_name(expected_name);
+  start_request.set_destination_bucket(BucketName(*destination).FullName());
+  start_request.set_source_object(source->name());
+  start_request.set_source_bucket(BucketName(bucket_name()).FullName());
   start_request.set_max_bytes_rewritten_per_call(1024 * 1024);
-  std::tie(rewriter, token) = async.StartRewrite(
-      BucketName(source->bucket()), source->name(), BucketName(*destination),
-      expected_name, start_request);
+  std::tie(rewriter, token) = async.StartRewrite(start_request);
 
   auto rt = rewriter.Iterate(std::move(token)).get();
   ASSERT_STATUS_OK(rt);