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"
@@ skipping 40 matching lines @@
 size_t CopyToStringHelper(
     std::string* result, const void* buffer, uint32_t num_bytes) {
   result->append(static_cast<const char*>(buffer), num_bytes);
   return num_bytes;
 }
 
 size_t CopyToFileHelper(FILE* fp, const void* buffer, uint32_t num_bytes) {
   return fwrite(buffer, 1, num_bytes, fp);
 }
 
+bool BlockingCopyFromFile(const base::FilePath& source,
+                          ScopedDataPipeProducerHandle destination) {
+  base::File file(source, base::File::FLAG_OPEN | base::File::FLAG_READ);
+  if (!file.IsValid())
+    return false;
+  for (;;) {
+    void* buffer;

[Aaron Boodman, 2014/11/03 19:20:15]

= nullptr; I know the code above does not do it. That code is wrong :).

[qsr, 2014/11/04 11:58:34]

Done. But I do not understand why you say this code is wrong. The data is
initialized (through BeginWriteDataRaw) before being used. So, yes the buffer is
not initialized until then, but why would the code be wrong?

[Aaron Boodman, 2014/11/04 18:05:00]

Sorry, I was exaggerating for comedic effect. As if to say that failing to
initializing a local if morally, or ethically wrong.

In truth, it is wrong, at least in the stylistic sense:
http://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Local_Variables

+    uint32_t buffer_num_bytes;

[Aaron Boodman, 2014/11/03 19:20:14]

= 0;

[qsr, 2014/11/04 11:58:33]

Done.

+    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 consumder handle was closed, then treat as EOF.

[Aaron Boodman, 2014/11/03 19:20:14]

typo: consumer

[qsr, 2014/11/04 11:58:34]

Done.

+        return result == MOJO_RESULT_FAILED_PRECONDITION;
+      }
+    } else {
+      // If the consumder handle was closed, then treat as EOF.
+      return result == MOJO_RESULT_FAILED_PRECONDITION;
+    }
+  }
+  NOTREACHED();
+  return false;
+}
+
 } // namespace
 
 
 // TODO(hansmuller): Add a max_size parameter.
 bool BlockingCopyToString(ScopedDataPipeConsumerHandle source,
                           std::string* result) {
   CHECK(result);
   result->clear();
   return BlockingCopyHelper(
       source.Pass(), base::Bind(&CopyToStringHelper, result));
@@ skipping 12 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,

[Aaron Boodman, 2014/11/03 19:20:15]

Can you add a unit test for this?

[qsr, 2014/11/04 11:58:34]

Done.

+                  ScopedDataPipeProducerHandle destination,
+                  base::TaskRunner* task_runner,
+                  const base::Callback<void(bool)>& callback) {
+  base::PostTaskAndReplyWithResult(
+      task_runner,
+      FROM_HERE,
+      base::Bind(&BlockingCopyFromFile, source, base::Passed(&destination)),
+      callback);
+}
+
 }  // namespace common
 }  // namespace mojo