Expose lower-level zip source types from BuildApi and remote_zip.h

Creating the low-level types and wrapping them before returning it gets
in the way of expressing the correct ordering of IO wrappers.

The new function `OpenZip(BuildApi&, Build, std::string)` now expresses
the intended layering of Buffer(Cache(Remote)).

Bug: b/439624498

Author: Databean

base/cvd/cuttlefish/host/libs/web/BUILD.bazel

@@ -37,7 +37,6 @@ cf_cc_library(
         "//cuttlefish/host/libs/web/http_client:http_json",
         "//cuttlefish/host/libs/zip:remote_zip",
         "//cuttlefish/host/libs/zip:zip_cc",
-        "//cuttlefish/host/libs/zip:zip_file",
         "//libbase",
         "@jsoncpp",
     ],
@@ -90,6 +89,19 @@ cf_cc_library(
     ],
 )
 
+cf_cc_library(
+    name = "build_api_zip",
+    srcs = ["build_api_zip.cc"],
+    hdrs = ["build_api_zip.h"],
+    deps = [
+        "//cuttlefish/common/libs/utils:result",
+        "//cuttlefish/host/libs/web:android_build",
+        "//cuttlefish/host/libs/web:build_api",
+        "//cuttlefish/host/libs/zip:buffered_zip_source",
+        "//cuttlefish/host/libs/zip:zip_cc",
+    ],
+)
+
 cf_cc_library(
     name = "build_zip_name",
     srcs = ["build_zip_name.cc"],
@@ -113,8 +125,8 @@ cf_cc_library(
         "//cuttlefish/host/libs/web:credential_source",
         "//cuttlefish/host/libs/web/cas:cas_downloader",
         "//cuttlefish/host/libs/web/http_client",
+        "//cuttlefish/host/libs/zip:cached_zip_source",
         "//cuttlefish/host/libs/zip:zip_cc",
-        "//cuttlefish/host/libs/zip:zip_file",
         "//libbase",
         "@fmt",
     ],

base/cvd/cuttlefish/host/libs/web/android_build_api.cpp

@@ -52,7 +52,6 @@
 #include "cuttlefish/host/libs/web/http_client/http_json.h"
 #include "cuttlefish/host/libs/zip/remote_zip.h"
 #include "cuttlefish/host/libs/zip/zip_cc.h"
-#include "cuttlefish/host/libs/zip/zip_file.h"
 
 namespace cuttlefish {
 namespace {
@@ -193,31 +192,31 @@ Result<std::string> AndroidBuildApi::DownloadFileWithBackup(
   return DownloadTargetFile(build, target_directory, selected_artifact);
 }
 
-Result<ReadableZip> AndroidBuildApi::OpenZipArchive(
-    const Build& build, const std::string& archive_name) {
-  Result<ReadableZip> res =
-      std::visit([this, &archive_name](
-                     auto&& arg) { return OpenZipArchive(arg, archive_name); },
+Result<SeekableZipSource> AndroidBuildApi::FileReader(
+    const Build& build, const std::string& artifact_name) {
+  Result<SeekableZipSource> res =
+      std::visit([this, &artifact_name](
+                     auto&& arg) { return FileReader(arg, artifact_name); },
                  build);
   return CF_EXPECT(std::move(res));
 }
 
-Result<ReadableZip> AndroidBuildApi::OpenZipArchive(
-    const DeviceBuild& build, const std::string& archive_name) {
-  std::string url = CF_EXPECT(GetArtifactDownloadUrl(build, archive_name));
+Result<SeekableZipSource> AndroidBuildApi::FileReader(
+    const DeviceBuild& build, const std::string& artifact_name) {
+  std::string url = CF_EXPECT(GetArtifactDownloadUrl(build, artifact_name));
   std::vector<std::string> headers = CF_EXPECT(Headers());
-  return CF_EXPECT(ZipFromUrl(http_client, url, headers));
+  return CF_EXPECT(ZipSourceFromUrl(http_client, url, headers));
 }
 
-Result<ReadableZip> AndroidBuildApi::OpenZipArchive(
-    const DirectoryBuild& build, const std::string& archive_name) {
+Result<SeekableZipSource> AndroidBuildApi::FileReader(
+    const DirectoryBuild& build, const std::string& artifact_name) {
   for (const std::string& path : build.paths) {
-    std::string zip_path_attempt = path + "/" + archive_name;
+    std::string zip_path_attempt = path + "/" + artifact_name;
     if (FileExists(zip_path_attempt)) {
-      return CF_EXPECT(ZipOpenRead(zip_path_attempt));
+      return CF_EXPECT(WritableZipSource::FromFile(zip_path_attempt));
     }
   }
-  return CF_ERRF("Could not find '{}'", archive_name);
+  return CF_ERRF("Could not find '{}'", artifact_name);
 }
 
 Result<std::vector<std::string>> AndroidBuildApi::Headers() {

base/cvd/cuttlefish/host/libs/web/android_build_api.h

@@ -58,8 +58,8 @@ class AndroidBuildApi : public BuildApi {
       const std::string& artifact_name,
       const std::string& backup_artifact_name) override;
 
-  Result<ReadableZip> OpenZipArchive(const Build& build,
-                                     const std::string& archive_name) override;
+  Result<SeekableZipSource> FileReader(
+      const Build&, const std::string& artifact_name) override;
 
  private:
   Result<std::vector<std::string>> Headers();
@@ -105,10 +105,10 @@ class AndroidBuildApi : public BuildApi {
   Result<Build> GetBuild(const DeviceBuildString& build_string);
   Result<Build> GetBuild(const DirectoryBuildString& build_string);
 
-  Result<ReadableZip> OpenZipArchive(const DeviceBuild& build,
-                                     const std::string& archive_name);
-  Result<ReadableZip> OpenZipArchive(const DirectoryBuild& build,
-                                     const std::string& archive_name);
+  Result<SeekableZipSource> FileReader(const DeviceBuild&,
+                                       const std::string& artifact_name);
+  Result<SeekableZipSource> FileReader(const DirectoryBuild&,
+                                       const std::string& artifact_name);
 
   HttpClient& http_client;
   CredentialSource* credential_source;

base/cvd/cuttlefish/host/libs/web/build_api.h

@@ -38,8 +38,8 @@ class BuildApi {
       const std::string& artifact_name,
       const std::string& backup_artifact_name) = 0;
 
-  virtual Result<ReadableZip> OpenZipArchive(const Build& build,
-                                             const std::string& artifact_name) = 0;
+  virtual Result<SeekableZipSource> FileReader(
+      const Build&, const std::string& artifact_name) = 0;
 };
 
 }  // namespace cuttlefish

base/cvd/cuttlefish/host/libs/web/build_api_zip.cc

@@ -0,0 +1,39 @@
+//
+// Copyright (C) 2025 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "cuttlefish/host/libs/web/build_api_zip.h"
+
+#include <string>
+#include <utility>
+
+#include "cuttlefish/common/libs/utils/result.h"
+#include "cuttlefish/host/libs/web/android_build.h"
+#include "cuttlefish/host/libs/web/build_api.h"
+#include "cuttlefish/host/libs/zip/buffered_zip_source.h"
+#include "cuttlefish/host/libs/zip/zip_cc.h"
+
+namespace cuttlefish {
+
+Result<ReadableZip> OpenZip(BuildApi& build_api, const Build& build,
+                            const std::string& name) {
+  SeekableZipSource source = CF_EXPECT(build_api.FileReader(build, name));
+
+  SeekableZipSource buffered =
+      CF_EXPECT(BufferZipSource(std::move(source), 1 << 16));
+
+  return CF_EXPECT(ReadableZip::FromSource(std::move(buffered)));
+}
+
+}  // namespace cuttlefish

base/cvd/cuttlefish/host/libs/web/build_api_zip.h

@@ -0,0 +1,29 @@
+//
+// Copyright (C) 2025 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <string>
+
+#include "cuttlefish/common/libs/utils/result.h"
+#include "cuttlefish/host/libs/web/android_build.h"
+#include "cuttlefish/host/libs/web/build_api.h"
+#include "cuttlefish/host/libs/zip/zip_cc.h"
+
+namespace cuttlefish {
+
+Result<ReadableZip> OpenZip(BuildApi&, const Build&, const std::string& name);
+
+}  // namespace cuttlefish

base/cvd/cuttlefish/host/libs/web/caching_build_api.cpp

@@ -28,8 +28,8 @@
 #include "cuttlefish/host/libs/web/android_build_api.h"
 #include "cuttlefish/host/libs/web/android_build_string.h"
 #include "cuttlefish/host/libs/web/build_api.h"
+#include "cuttlefish/host/libs/zip/cached_zip_source.h"
 #include "cuttlefish/host/libs/zip/zip_cc.h"
-#include "cuttlefish/host/libs/zip/zip_file.h"
 
 namespace cuttlefish {
 namespace {
@@ -144,11 +144,11 @@ Result<std::string> CachingBuildApi::DownloadFileWithBackup(
                                   paths.target_backup_artifact));
 }
 
-Result<ReadableZip> CachingBuildApi::OpenZipArchive(
-    const Build& build, const std::string& zip_name) {
-  // TODO: schuffelen - cache only needed zip file parts
-  CF_EXPECT(build_api_.DownloadFile(build, cache_base_path_, zip_name));
-  return ZipOpenRead(cache_base_path_ + "/" + zip_name);
+Result<SeekableZipSource> CachingBuildApi::FileReader(
+    const Build& build, const std::string& artifact) {
+  SeekableZipSource source = CF_EXPECT(build_api_.FileReader(build, artifact));
+  std::string cache_path = fmt::format("{}/{}", cache_base_path_, artifact);
+  return CF_EXPECT(CacheZipSource(std::move(source), cache_path));
 }
 
 }  // namespace cuttlefish

base/cvd/cuttlefish/host/libs/web/caching_build_api.h

@@ -39,8 +39,8 @@ class CachingBuildApi : public BuildApi {
       const std::string& artifact_name,
       const std::string& backup_artifact_name) override;
 
-  Result<ReadableZip> OpenZipArchive(const Build& build,
-                                     const std::string& zip_name) override;
+  Result<SeekableZipSource> FileReader(const Build&,
+                                       const std::string& artifact) override;
 
  private:
   Result<bool> CanCache(const std::string& target_directory);

base/cvd/cuttlefish/host/libs/zip/BUILD.bazel

@@ -106,7 +106,6 @@ cf_cc_library(
     deps = [
         "//cuttlefish/common/libs/utils:result",
         "//cuttlefish/host/libs/web/http_client",
-        "//cuttlefish/host/libs/zip:buffered_zip_source",
         "//cuttlefish/host/libs/zip:zip_cc",
         "@abseil-cpp//absl/strings",
         "@fmt",

base/cvd/cuttlefish/host/libs/zip/remote_zip.cc

@@ -30,7 +30,6 @@
 
 #include "cuttlefish/common/libs/utils/result.h"
 #include "cuttlefish/host/libs/web/http_client/http_client.h"
-#include "cuttlefish/host/libs/zip/buffered_zip_source.h"
 #include "cuttlefish/host/libs/zip/zip_cc.h"
 
 namespace cuttlefish {
@@ -124,22 +123,17 @@ Result<uint64_t> GetSizeIfSupportsRangeRequests(
 
 }  // namespace
 
-Result<ReadableZip> ZipFromUrl(HttpClient& http_client, const std::string& url,
-                               std::vector<std::string> headers) {
+Result<SeekableZipSource> ZipSourceFromUrl(HttpClient& http_client,
+                                           const std::string& url,
+                                           std::vector<std::string> headers) {
   uint64_t size =
       CF_EXPECT(GetSizeIfSupportsRangeRequests(http_client, url, headers));
 
   std::unique_ptr<RemoteZip> callbacks =
       std::make_unique<RemoteZip>(http_client, url, size, std::move(headers));
   CF_EXPECT(callbacks.get());
 
-  SeekableZipSource source =
-      CF_EXPECT(SeekableZipSource::FromCallbacks(std::move(callbacks)));
-
-  SeekableZipSource buffered =
-      CF_EXPECT(BufferZipSource(std::move(source), 1 << 16));
-
-  return CF_EXPECT(ReadableZip::FromSource(std::move(buffered)));
+  return CF_EXPECT(SeekableZipSource::FromCallbacks(std::move(callbacks)));
 }
 
 }  // namespace cuttlefish