The tracing service sometimes creates corrupt data

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 112 matching lines @@
 
 // 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));
 }
 
+bool MOJO_COMMON_EXPORT BlockingCopyFromString(
+    const std::string& source,
+    const ScopedDataPipeProducerHandle& destination) {
+  auto it = source.begin();
+  for (;;) {
+    void* buffer = nullptr;
+    uint32_t buffer_num_bytes = 0;
+    MojoResult result =
+        BeginWriteDataRaw(destination.get(), &buffer, &buffer_num_bytes,
+                          MOJO_WRITE_DATA_FLAG_NONE);
+    if (result == MOJO_RESULT_OK) {
+      char* char_buffer = static_cast<char*>(buffer);
+      uint32_t byte_index = 0;
+      while (it != source.end() && byte_index < buffer_num_bytes) {
+        char_buffer[byte_index++] = *it++;
+      }
+      EndWriteDataRaw(destination.get(), byte_index);
+    } else if (result == MOJO_RESULT_SHOULD_WAIT) {
+      result = Wait(destination.get(), MOJO_HANDLE_SIGNAL_WRITABLE,
+                    MOJO_DEADLINE_INDEFINITE, nullptr);
+      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;
+    }
+  }
+}
+
 bool BlockingCopyToFile(ScopedDataPipeConsumerHandle source,
                         const base::FilePath& destination) {
   base::ScopedFILE fp(base::OpenFile(destination, "wb"));
   if (!fp) {
     LOG(ERROR) << "OpenFile('" << destination.value()
                << "'failed in BlockingCopyToFile" << std::endl;
     return false;
   }
   return BlockingCopyHelper(
       source.Pass(), base::Bind(&CopyToFileHelper, fp.get()));
@@ skipping 16 matching lines @@
                   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