Remove all notion of transport from the API - V2.

There is only a need to pass buffers in and out of the system.
All transport is external to the system.

BUG=skia:7515

Change-Id: Ie50cbc3fa1b9776e56dab8e49e91ce640e0b3954
Reviewed-on: https://skia-review.googlesource.com/119893
Reviewed-by: Herb Derby <herb@google.com>
Commit-Queue: Herb Derby <herb@google.com>

1 files changed, 68 insertions, 30 deletions

diff --git a/tools/remote_demo.cpp b/tools/remote_demo.cpp
index a5e0a367de..8fc96cadb8 100644
--- a/tools/remote_demo.cpp
+++ b/tools/remote_demo.cpp
@@ -25,35 +25,52 @@ static bool gUseGpu = true;
 static bool gPurgeFontCaches = true;
 static bool gUseProcess = true;
 
-class ReadWriteTransport : public SkRemoteStrikeTransport {
-public:
-    ReadWriteTransport(int readFd, int writeFd) : fReadFd{readFd}, fWriteFd{writeFd} {}
-    ~ReadWriteTransport() override {
-        close(fWriteFd);
-        close(fReadFd);
+static bool write_SkData(int fd, const SkData& data) {
+    size_t size = data.size();
+    ssize_t bytesWritten = ::write(fd, &size, sizeof(size));
+    if (bytesWritten < 0) {
+        err(1,"Failed write %zu", size);
+        return false;
     }
-    IOResult write(const void* buffer, size_t size) override {
-        ssize_t writeSize = ::write(fWriteFd, buffer, size);
-        if (writeSize < 0) {
-            err(1,"Failed write %zu", size);
-            return kFail;
-        }
-        return kSuccess;
+
+    bytesWritten = ::write(fd, data.data(), data.size());
+    if (bytesWritten < 0) {
+        err(1,"Failed write %zu", size);
+        return false;
     }
 
-    std::tuple<size_t, IOResult> read(void* buffer, size_t size) override {
-        ssize_t readSize = ::read(fReadFd, buffer, size);
+    return true;
+}
+
+static sk_sp<SkData> read_SkData(int fd) {
+
+    size_t size;
+    ssize_t readSize = ::read(fd, &size, sizeof(size));
+    if (readSize <= 0) {
         if (readSize < 0) {
-            err(1,"Failed read %zu", size);
-            return {size, kFail};
+            err(1, "Failed read %zu", size);
         }
-        return {readSize, kSuccess};
+        return nullptr;
     }
 
-private:
-    const int fReadFd,
-              fWriteFd;
-};
+    auto out = SkData::MakeUninitialized(size);
+    auto data = (uint8_t*)out->data();
+
+    size_t totalRead = 0;
+    while (totalRead < size) {
+        ssize_t sizeRead;
+        sizeRead = ::read(fd, &data[totalRead], size - totalRead);
+        if (sizeRead <= 0) {
+            if (readSize < 0) {
+                err(1, "Failed read %zu", size);
+            }
+            return nullptr;
+        }
+        totalRead += sizeRead;
+    }
+
+    return out;
+}
 
 class Timer {
 public:
@@ -133,14 +150,17 @@ static void final_draw(std::string outFilename,
 static void gpu(int readFd, int writeFd) {
 
     if (gUseGpu) {
-        ReadWriteTransport rwTransport{readFd, writeFd};
+        auto clientRPC = [readFd, writeFd](const SkData& inBuffer) {
+            write_SkData(writeFd, inBuffer);
+            return read_SkData(readFd);
+        };
 
-        auto picData = rwTransport.readSkData();
+        auto picData = read_SkData(readFd);
         if (picData == nullptr) {
             return;
         }
 
-        SkStrikeClient client{&rwTransport};
+        SkStrikeClient client{clientRPC};
 
         SkDeserialProcs procs;
         client.prepareDeserializeProcs(&procs);
@@ -148,14 +168,20 @@ static void gpu(int readFd, int writeFd) {
         final_draw("test.png", &procs, picData.get(), &client);
     }
 
+    ::close(writeFd);
+    ::close(readFd);
+
     printf("GPU is exiting\n");
 }
 
 static int renderer(
     const std::string& skpName, int readFd, int writeFd)
 {
-    ReadWriteTransport rwTransport{readFd, writeFd};
-    SkStrikeServer server{&rwTransport};
+    SkStrikeServer server{};
+    auto closeAll = [readFd, writeFd]() {
+        ::close(writeFd);
+        ::close(readFd);
+    };
 
     auto skpData = SkData::MakeFromFileName(skpName.c_str());
     std::cout << "skp stream is " << skpData->size() << " bytes long " << std::endl;
@@ -167,16 +193,28 @@ static int renderer(
         server.prepareSerializeProcs(&procs);
         stream = pic->serialize(&procs);
 
-        if (rwTransport.writeSkData(*stream) == SkRemoteStrikeTransport::kFail) {
+        if (!write_SkData(writeFd, *stream)) {
+            closeAll();
             return 1;
         }
 
-        std::cout << "Waiting for scaler context ops." << std::endl;
+        std::vector<uint8_t> tmpBuffer;
+        while (true) {
+            auto inBuffer = read_SkData(readFd);
+            if (inBuffer == nullptr) {
+                closeAll();
+                return 0;
+            }
 
-        return server.serve();
+            tmpBuffer.clear();
+            server.serve(*inBuffer, &tmpBuffer);
+            auto outBuffer = SkData::MakeWithoutCopy(tmpBuffer.data(), tmpBuffer.size());
+            write_SkData(writeFd, *outBuffer);
+        }
     } else {
         stream = skpData;
         final_draw("test-correct.png", nullptr, stream.get(), nullptr);
+        closeAll();
         return 0;
     }
 }