Allow local file to run though content handler.

mojo/common/data_pipe_utils.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "mojo/common/data_pipe_utils.h"
 
 #include <stdio.h>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/message_loop/message_loop.h"
 #include "base/task_runner_util.h"
 #include "base/threading/platform_thread.h"
 
 namespace mojo {
 namespace common {
 namespace {
 
 bool BlockingCopyHelper(ScopedDataPipeConsumerHandle source,
     const base::Callback<size_t(const void*, uint32_t)>& write_bytes) {
   for (;;) {
-    const void* buffer;
-    uint32_t num_bytes;
+    const void* buffer = nullptr;
+    uint32_t num_bytes = 0;
     MojoResult result = BeginReadDataRaw(
         source.get(), &buffer, &num_bytes, MOJO_READ_DATA_FLAG_NONE);
     if (result == MOJO_RESULT_OK) {
       size_t bytes_written = write_bytes.Run(buffer, num_bytes);
       result = EndReadDataRaw(source.get(), num_bytes);
       if (bytes_written < num_bytes || result != MOJO_RESULT_OK)
         return false;
     } else if (result == MOJO_RESULT_SHOULD_WAIT) {
       result = Wait(source.get(),
                     MOJO_HANDLE_SIGNAL_READABLE,
@@ skipping 131 matching lines @@
                       uint32 buffer_num_bytes,
                       std::string* bytes) {
   if (buffer_num_bytes >= bytes_length) {
     const char* p = static_cast<const char*>(buffer);
     *bytes = std::string(p, bytes_length);
     return PeekStatus::kSuccess;
   }
   return PeekStatus::kKeepReading;
 }
 
+bool BlockingCopyFromFile(const base::FilePath& source,
+                          ScopedDataPipeProducerHandle destination,
+                          uint32_t skip) {
+  base::File file(source, base::File::FLAG_OPEN | base::File::FLAG_READ);
+  if (!file.IsValid())
+    return false;
+  if (file.Seek(base::File::FROM_BEGIN, skip) != skip) {
+    return false;
+  }
+  for (;;) {
+    void* buffer;
+    uint32_t buffer_num_bytes;
+    MojoResult result = BeginWriteDataRaw(destination.get(),
+                                          &buffer,
+                                          &buffer_num_bytes,
+                                          MOJO_WRITE_DATA_FLAG_NONE);
+    if (result == MOJO_RESULT_OK) {
+      int bytes_read =
+          file.ReadAtCurrentPos(static_cast<char*>(buffer), buffer_num_bytes);
+      if (bytes_read >= 0) {
+        EndWriteDataRaw(destination.get(), bytes_read);
+        if (bytes_read == 0) {
+          // eof
+          return true;
+        }
+      } else {
+        // error
+        EndWriteDataRaw(destination.get(), 0);
+        return false;
+      }
+    } else if (result == MOJO_RESULT_SHOULD_WAIT) {
+      result = Wait(destination.get(),
+                    MOJO_HANDLE_SIGNAL_WRITABLE,
+                    MOJO_DEADLINE_INDEFINITE);
+      if (result != MOJO_RESULT_OK) {
+        // If the consumer handle was closed, then treat as EOF.
+        return result == MOJO_RESULT_FAILED_PRECONDITION;
+      }
+    } else {
+      // If the consumer handle was closed, then treat as EOF.
+      return result == MOJO_RESULT_FAILED_PRECONDITION;
+    }
+  }
+  NOTREACHED();
+  return false;
+}
+
 } // namespace
 
 bool BlockingPeekNBytes(DataPipeConsumerHandle source,
                         std::string* bytes,
                         size_t bytes_length,
                         MojoDeadline timeout) {
   PeekFunc peek_nbytes = base::Bind(PeekNBytes, bytes_length);
   return BlockingPeekHelper(source, bytes, timeout, peek_nbytes);
 }
 
@@ skipping 27 matching lines @@
                 const base::FilePath& destination,
                 base::TaskRunner* task_runner,
                 const base::Callback<void(bool)>& callback) {
   base::PostTaskAndReplyWithResult(
       task_runner,
       FROM_HERE,
       base::Bind(&BlockingCopyToFile, base::Passed(&source), destination),
       callback);
 }
 
+void CopyFromFile(const base::FilePath& source,
+                  ScopedDataPipeProducerHandle destination,
+                  uint32_t skip,
+                  base::TaskRunner* task_runner,
+                  const base::Callback<void(bool)>& callback) {
+  base::PostTaskAndReplyWithResult(
+      task_runner,
+      FROM_HERE,
+      base::Bind(
+          &BlockingCopyFromFile, source, base::Passed(&destination), skip),
+      callback);
+}
+
 }  // namespace common
 }  // namespace mojo