Replace LazilyLoadedFileReadCallback with ReaderSeeker

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

@@ -45,8 +45,8 @@ cf_cc_library(
         "//cuttlefish/host/libs/zip/libzip_cc:seekable_source",
         "//cuttlefish/host/libs/zip/libzip_cc:source_callback",
         "//cuttlefish/host/libs/zip/libzip_cc:stat",
+        "//cuttlefish/io",
         "//cuttlefish/result",
-        "//libbase",
         "@abseil-cpp//absl/log",
     ],
 )
@@ -105,8 +105,8 @@ cf_cc_library(
         "//cuttlefish/common/libs/utils:files",
         "//cuttlefish/host/libs/zip:disjoint_range_set",
         "//cuttlefish/host/libs/zip:serialize_disjoint_range_set",
+        "//cuttlefish/io",
         "//cuttlefish/result",
-        "//libbase",
         "@abseil-cpp//absl/log",
     ],
 )

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

@@ -28,6 +28,7 @@
 #include "cuttlefish/host/libs/zip/libzip_cc/seekable_source.h"
 #include "cuttlefish/host/libs/zip/libzip_cc/source_callback.h"
 #include "cuttlefish/host/libs/zip/libzip_cc/stat.h"
+#include "cuttlefish/io/io.h"
 #include "cuttlefish/result/result.h"
 
 namespace cuttlefish {
@@ -80,44 +81,18 @@ class CachedZipSourceCallbacks : public SeekableZipSourceCallback {
   const size_t size_;
 };
 
-class LazilyLoadedZipSourceFile : public LazilyLoadedFileReadCallback {
- public:
-  LazilyLoadedZipSourceFile(std::unique_ptr<SeekableZipSource> source,
-                            SeekingZipSourceReader reader)
-      : source_(std::move(source)), reader_(std::move(reader)) {}
-
-  Result<size_t> Seek(size_t offset) override {
-    CF_EXPECT(reader_.SeekSet(offset));
-    return offset;
-  }
-  Result<size_t> Read(char* data, size_t size) override {
-    return CF_EXPECT(reader_.Read(data, size));
-  }
-
- private:
-  std::unique_ptr<SeekableZipSource> source_;
-  SeekingZipSourceReader reader_;
-};
-
 }  // namespace
 
 Result<SeekableZipSource> CacheZipSource(SeekableZipSource inner,
                                          std::string file_path) {
   ZipStat zip_stat = CF_EXPECT(inner.Stat());
   size_t size = CF_EXPECT(std::move(zip_stat.size));
 
-  std::unique_ptr<SeekableZipSource> unique_inner =
-      std::make_unique<SeekableZipSource>(std::move(inner));
-  CF_EXPECT(unique_inner.get());
-
-  SeekingZipSourceReader reader = CF_EXPECT(unique_inner->Reader());
-
-  std::unique_ptr<LazilyLoadedFileReadCallback> file_callbacks =
-      std::make_unique<LazilyLoadedZipSourceFile>(std::move(unique_inner),
-                                                  std::move(reader));
+  std::unique_ptr<ReaderSeeker> reader =
+      CF_EXPECT(ZipSourceAsReaderSeeker(std::move(inner)));
 
-  LazilyLoadedFile file = CF_EXPECT(LazilyLoadedFile::Create(
-      std::move(file_path), size, std::move(file_callbacks)));
+  LazilyLoadedFile file = CF_EXPECT(
+      LazilyLoadedFile::Create(std::move(file_path), size, std::move(reader)));
 
   CachedZipSourceCallbacks callbacks(std::move(file), size);
 

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

@@ -35,14 +35,13 @@
 #include "cuttlefish/common/libs/utils/files.h"
 #include "cuttlefish/host/libs/zip/disjoint_range_set.h"
 #include "cuttlefish/host/libs/zip/serialize_disjoint_range_set.h"
+#include "cuttlefish/io/io.h"
 #include "cuttlefish/result/result.h"
 
 namespace cuttlefish {
 
 static constexpr size_t kMinReadSize = 1 << 26;
 
-LazilyLoadedFileReadCallback::~LazilyLoadedFileReadCallback() = default;
-
 struct LazilyLoadedFile::Impl {
   std::string MetadataFile() const;
   Result<void> ReadMetadata();
@@ -52,16 +51,15 @@ struct LazilyLoadedFile::Impl {
 
   std::string filename_;
   SharedFD contents_file_;
-  std::unique_ptr<LazilyLoadedFileReadCallback> callback_;
+  std::unique_ptr<ReaderSeeker> callback_;
   DisjointRangeSet already_downloaded_;
   size_t seek_pos_;
   size_t size_;
   std::vector<char> extended_read_buffer_;
 };
 
 Result<LazilyLoadedFile> LazilyLoadedFile::Create(
-    std::string filename, size_t size,
-    std::unique_ptr<LazilyLoadedFileReadCallback> callback) {
+    std::string filename, size_t size, std::unique_ptr<ReaderSeeker> callback) {
   std::unique_ptr<Impl> impl = std::make_unique<Impl>();
   CF_EXPECT(impl.get());
 
@@ -172,7 +170,7 @@ Result<size_t> LazilyLoadedFile::Impl::Read(char* data, size_t size) {
     seek_pos_ += data_read;
     return data_read;
   }
-  CF_EXPECT(callback_->Seek(seek_pos_));
+  CF_EXPECT(callback_->SeekSet(seek_pos_));
   if (size < kMinReadSize) {
     size_t extended_read_size = std::min(kMinReadSize, size_ - seek_pos_);
     VLOG(1) << "Extending read request from " << size << " to "

base/cvd/cuttlefish/host/libs/zip/lazily_loaded_file.h

@@ -19,23 +19,15 @@
 #include <memory>
 #include <string>
 
+#include "cuttlefish/io/io.h"
 #include "cuttlefish/result/result.h"
 
 namespace cuttlefish {
 
-class LazilyLoadedFileReadCallback {
- public:
-  virtual ~LazilyLoadedFileReadCallback();
-
-  virtual Result<size_t> Read(char* buf, size_t count) = 0;
-  virtual Result<size_t> Seek(size_t offset) = 0;
-};
-
 class LazilyLoadedFile {
  public:
-  static Result<LazilyLoadedFile> Create(
-      std::string filename, size_t size,
-      std::unique_ptr<LazilyLoadedFileReadCallback>);
+  static Result<LazilyLoadedFile> Create(std::string filename, size_t size,
+                                         std::unique_ptr<ReaderSeeker>);
 
   LazilyLoadedFile(LazilyLoadedFile&&);
   ~LazilyLoadedFile();

base/cvd/cuttlefish/host/libs/zip/libzip_cc/seekable_source.cc

@@ -26,11 +26,12 @@
 
 #include "zip.h"
 
-#include "cuttlefish/io/fake_pread_pwrite.h"
 #include "cuttlefish/host/libs/zip/libzip_cc/error.h"
 #include "cuttlefish/host/libs/zip/libzip_cc/managed.h"
 #include "cuttlefish/host/libs/zip/libzip_cc/readable_source.h"
 #include "cuttlefish/host/libs/zip/libzip_cc/source_callback.h"
+#include "cuttlefish/io/fake_pread_pwrite.h"
+#include "cuttlefish/io/io.h"
 #include "cuttlefish/result/result.h"
 
 namespace cuttlefish {
@@ -82,6 +83,38 @@ int64_t SeekableZipSourceCallbackFn(void* userdata, void* data, uint64_t len,
                         cmd);
 }
 
+class ZipSourceAsReaderSeekerImpl : public ReaderSeeker {
+ public:
+  ZipSourceAsReaderSeekerImpl(std::unique_ptr<SeekableZipSource> source,
+                              SeekingZipSourceReader reader)
+      : source_(std::move(source)), reader_(std::move(reader)) {}
+
+  Result<size_t> Read(void* buf, size_t size) override {
+    return CF_EXPECT(reader_.Read(buf, size));
+  }
+
+  Result<uint64_t> SeekSet(uint64_t offset) override {
+    return CF_EXPECT(reader_.SeekSet(offset));
+  }
+
+  Result<uint64_t> SeekCur(int64_t offset) override {
+    return CF_EXPECT(reader_.SeekCur(offset));
+  }
+
+  Result<uint64_t> SeekEnd(int64_t offset) override {
+    return CF_EXPECT(reader_.SeekEnd(offset));
+  }
+
+  Result<uint64_t> PRead(void* buf, uint64_t count,
+                         uint64_t offset) const override {
+    return CF_EXPECT(reader_.PRead(buf, count, offset));
+  }
+
+ private:
+  std::unique_ptr<SeekableZipSource> source_;
+  SeekingZipSourceReader reader_;
+};
+
 }  // namespace
 
 Result<SeekableZipSource> SeekableZipSource::FromCallbacks(
@@ -157,4 +190,16 @@ Result<uint64_t> SeekingZipSourceReader::PRead(void* buf, uint64_t count,
   return CF_EXPECT(FakePRead(non_const, buf, count, offset));
 }
 
+Result<std::unique_ptr<ReaderSeeker>> ZipSourceAsReaderSeeker(
+    SeekableZipSource inner) {
+  std::unique_ptr<SeekableZipSource> unique_inner =
+      std::make_unique<SeekableZipSource>(std::move(inner));
+  CF_EXPECT(unique_inner.get());
+
+  SeekingZipSourceReader reader = CF_EXPECT(unique_inner->Reader());
+
+  return std::make_unique<ZipSourceAsReaderSeekerImpl>(std::move(unique_inner),
+                                                       std::move(reader));
+}
+
 }  // namespace cuttlefish

base/cvd/cuttlefish/host/libs/zip/libzip_cc/seekable_source.h

@@ -70,4 +70,7 @@ class SeekingZipSourceReader : public ZipSourceReader, public ReaderSeeker {
   SeekingZipSourceReader(SeekableZipSource*);
 };
 
+Result<std::unique_ptr<ReaderSeeker>> ZipSourceAsReaderSeeker(
+    SeekableZipSource inner);
+
 }  // namespace cuttlefish