Created a blocking copy to temporary file function.

mojo/data_pipe_utils/data_pipe_file_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/data_pipe_utils/data_pipe_utils.h"
 
 #include <stdio.h>
 
 #include <limits>
 
@@ skipping 311 matching lines @@
   base::ScopedFILE fp(base::OpenFile(destination, "wb"));
   if (!fp) {
     LOG(ERROR) << "OpenFile('" << destination.value()
                << "'failed in BlockingCopyToFile";
     return false;
   }
   return BlockingCopyHelper(source.Pass(),
                             base::Bind(&CopyToFileHelper, fp.get()));
 }
 
+bool BlockingCopyToTempFile(ScopedDataPipeConsumerHandle source,
+                            FILE** fpp) {

[viettrungluu, 2015/09/01 23:36:25]

Possibly this should be a base::ScopedFILE*.

Or you could return a base::ScopedFILE, with it being null on failure.

[Sean Klein, 2015/09/01 23:57:52]

Out of curiosity, what is the difference between a ScopedFILE and a FILE? I see
the documentation in base which says "Automatically closes |FILE*|s", but it is
not clear to me when this ScopedFILE is actually closed. Would it be when no one
holds a reference to the FILE * anymore?

[jamesr, 2015/09/02 00:06:39]

base::ScopedFILE's destructor calls fclose()

+  base::FilePath path;
+  *fpp = (base::CreateAndOpenTemporaryFile(&path));
+  if (!*fpp) {
+    LOG(ERROR) << "CreateAndOpenTemporaryFile failed in"
+               << "BlockingCopyToTempFile";
+    return false;
+  }
+  if (unlink(path.value().c_str())) {
+    LOG(ERROR) << "Failed to unlink temporary file\n";

[viettrungluu, 2015/09/01 23:36:25]

Also: no \n needed here.
More importantly, it's perhaps a bit unexpected that *fpp gets set even on
failure here.

[Sean Klein, 2015/09/01 23:57:52]

Done.

+    return false;
+  }
+  return BlockingCopyHelper(source.Pass(),
+                            base::Bind(&CopyToFileHelper, *fpp));
+}
+
 void CopyToFile(ScopedDataPipeConsumerHandle source,
                 const base::FilePath& destination,
                 base::TaskRunner* task_runner,
                 const base::Callback<void(bool)>& callback) {
   new CopyToFileHandler(source.Pass(), destination, task_runner, callback);
 }
 
 void CopyFromFile(const base::FilePath& source,
                   ScopedDataPipeProducerHandle destination,
                   uint32_t skip,
                   base::TaskRunner* task_runner,
                   const base::Callback<void(bool)>& callback) {
   new CopyFromFileHandler(source, destination.Pass(), skip, task_runner,
                           callback);
 }
 
 }  // namespace common
 }  // namespace mojo