No dbus::FileDescriptor in DebugDaemonClient

chrome/browser/chromeos/system_logs/debug_log_writer.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 "chrome/browser/chromeos/system_logs/debug_log_writer.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 44 matching lines @@
         base::Bind(callback, file_path, false));
     DCHECK(posted);
     return;
   }
   if (!callback.is_null())
     callback.Run(file_path, true);
 }
 
 // Stores into |file_path| debug logs in the .tgz format. Calls
 // |callback| upon completion.
-void WriteDebugLogToFile(base::File* file,
+void WriteDebugLogToFile(std::unique_ptr<base::File> file,
                          const std::string& sequence_token_name,
                          const base::FilePath& file_path,
                          bool should_compress,
                          const DebugLogWriter::StoreLogsCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!file->IsValid()) {
     LOG(ERROR) << "Can't create debug log file: " << file_path.AsUTF8Unsafe()
                << ", "
                << "error: " << file->error_details();
     return;
   }
-  scoped_refptr<base::TaskRunner> task_runner =
-      GetSequencedTaskRunner(sequence_token_name);
   chromeos::DBusThreadManager::Get()->GetDebugDaemonClient()->DumpDebugLogs(
-      should_compress, std::move(*file), task_runner,
+      should_compress, file->GetPlatformFile(),
       base::Bind(&WriteDebugLogToFileCompleted, file_path, sequence_token_name,
                  callback));
+
+  // Close the file on an IO-allowed thread.
+  GetSequencedTaskRunner(sequence_token_name)
+      ->PostTask(FROM_HERE,
+                 base::Bind(&base::DeletePointer<base::File>, file.release()));
 }
 
 // Runs command with its parameters as defined in |argv|.
 // Upon completion, it will report command run outcome via |callback| on the
 // same thread from where it was initially called from.
 void RunCommand(const std::vector<std::string>& argv,
                 const CommandCompletionCallback& callback) {
   base::Process process = base::LaunchProcess(argv, base::LaunchOptions());
   if (!process.IsValid()) {
     LOG(ERROR) << "Failed to execute command " << argv[0];
@@ skipping 100 matching lines @@
 
   content::BrowserThread::PostBlockingPoolTask(
       FROM_HERE,
       base::Bind(&AddUserLogsToArchive,
                  user_log_dir,
                  tar_file_path,
                  compressed_output_path,
                  callback));
 }
 
-void IntializeLogFile(base::File* file,
-                      const base::FilePath& file_path,
-                      uint32_t flags) {
+void InitializeLogFile(base::File* file,
+                       const base::FilePath& file_path,
+                       uint32_t flags) {
   base::FilePath dir = file_path.DirName();
   if (!base::DirectoryExists(dir)) {
     if (!base::CreateDirectory(dir)) {
       LOG(ERROR) << "Can not create " << dir.value();
       return;
     }
   }
 
   file->Initialize(file_path, flags);
 }
 
 // Starts logs retrieval process. The output will be stored in file with name
 // derived from |file_name_template|.
 void StartLogRetrieval(const base::FilePath& file_name_template,
                        bool should_compress,
                        const std::string& sequence_token_name,
                        const DebugLogWriter::StoreLogsCallback& callback) {
   base::FilePath file_path =
       logging::GenerateTimestampedName(file_name_template, base::Time::Now());
 
   int flags = base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE;
-  base::File* file = new base::File;
-  GetSequencedTaskRunner(sequence_token_name)->PostTaskAndReply(
-      FROM_HERE,
-      base::Bind(&IntializeLogFile, base::Unretained(file), file_path, flags),
-      base::Bind(&WriteDebugLogToFile,
-                 base::Owned(file),
-                 sequence_token_name,
-                 file_path,
-                 should_compress,
-                 callback));
+  std::unique_ptr<base::File> file(new base::File);
+  base::File* file_ptr = file.get();
+  GetSequencedTaskRunner(sequence_token_name)
+      ->PostTaskAndReply(
+          FROM_HERE, base::Bind(&InitializeLogFile, base::Unretained(file_ptr),
+                                file_path, flags),
+          base::Bind(&WriteDebugLogToFile, base::Passed(&file),
+                     sequence_token_name, file_path, should_compress,
+                     callback));
 }
 
 const char kDefaultSequenceName[] = "DebugLogWriter";
 
 }  // namespace
 
 // static.
 void DebugLogWriter::StoreLogs(const base::FilePath& fileshelf,
                                bool should_compress,
                                const StoreLogsCallback& callback) {
@@ skipping 18 matching lines @@
       fileshelf.Append(FILE_PATH_LITERAL("combined-logs.tar"));
 
   // Get system logs from /var/log first, then add user-specific stuff.
   StartLogRetrieval(file_path,
                     false,
                     sequence_token_name,
                     base::Bind(&OnSystemLogsAdded, callback));
 }
 
 }  // namespace chromeos