Use base::PostTaskAndReplyWithResults() in more places.

components/nacl/browser/nacl_process_host.cc

 // Copyright (c) 2012 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 "components/nacl/browser/nacl_process_host.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 254 matching lines @@
 
 NaClProcessHost::~NaClProcessHost() {
   // Report exit status only if the process was successfully started.
   if (process_->GetData().handle != base::kNullProcessHandle) {
     int exit_code = 0;
     process_->GetTerminationStatus(false /* known_dead */, &exit_code);
     std::string message =
         base::StringPrintf("NaCl process exited with status %i (0x%x)",
                            exit_code, exit_code);
     if (exit_code == 0) {
-      LOG(INFO) << message;
+      VLOG(1) << message;
     } else {
       LOG(ERROR) << message;
     }
   }
 
   if (internal_->socket_for_renderer != NACL_INVALID_HANDLE) {
     if (NaClClose(internal_->socket_for_renderer) != 0) {
       NOTREACHED() << "NaClClose() failed";
     }
   }
@@ skipping 582 matching lines @@
   NaClBrowser* nacl_browser = NaClBrowser::GetInstance();
   *result = nacl_browser->QueryKnownToValidate(signature, off_the_record_);
 }
 
 void NaClProcessHost::OnSetKnownToValidate(const std::string& signature) {
   NaClBrowser::GetInstance()->SetKnownToValidate(
       signature, off_the_record_);
 }
 
 void NaClProcessHost::FileResolved(
-    base::PlatformFile* file,
     const base::FilePath& file_path,
-    IPC::Message* reply_msg) {
-  if (*file != base::kInvalidPlatformFileValue) {
+    IPC::Message* reply_msg,
+    const base::PlatformFile& file) {
+  if (file != base::kInvalidPlatformFileValue) {
     IPC::PlatformFileForTransit handle = IPC::GetFileHandleForProcess(
-        *file,
+        file,
         process_->GetData().handle,
         true /* close_source */);
     NaClProcessMsg_ResolveFileToken::WriteReplyParams(
         reply_msg,
         handle,
         file_path);
   } else {
     NaClProcessMsg_ResolveFileToken::WriteReplyParams(
         reply_msg,
         IPC::InvalidPlatformFileForTransit(),
-        base::FilePath(FILE_PATH_LITERAL("")));
+        base::FilePath());
   }
   Send(reply_msg);
 }
 
 void NaClProcessHost::OnResolveFileToken(uint64 file_token_lo,
                                          uint64 file_token_hi,
                                          IPC::Message* reply_msg) {
   // Was the file registered?
   //
   // Note that the file path cache is of bounded size, and old entries can get
@@ skipping 16 matching lines @@
   // while the load is in flight.
   //
   // TODO(ncbray): track behavior with UMA. If entries are getting evicted or
   // bogus keys are getting queried, this would be good to know.
   base::FilePath file_path;
   if (!NaClBrowser::GetInstance()->GetFilePath(
         file_token_lo, file_token_hi, &file_path)) {
     NaClProcessMsg_ResolveFileToken::WriteReplyParams(
         reply_msg,
         IPC::InvalidPlatformFileForTransit(),
-        base::FilePath(FILE_PATH_LITERAL("")));
+        base::FilePath());
     Send(reply_msg);
     return;
   }
 
-  // Scratch space to share between the callbacks.
-  base::PlatformFile* data = new base::PlatformFile();
-
   // Open the file.
-  if (!content::BrowserThread::PostBlockingPoolTaskAndReply(
+  if (!base::PostTaskAndReplyWithResult(
+          content::BrowserThread::GetBlockingPool(),
           FROM_HERE,
-          base::Bind(OpenNaClExecutableImpl,
-                     file_path, data),
+          base::Bind(OpenNaClExecutableImpl, file_path),
           base::Bind(&NaClProcessHost::FileResolved,
                      weak_factory_.GetWeakPtr(),
-                     base::Owned(data),
                      file_path,
                      reply_msg))) {
      NaClProcessMsg_ResolveFileToken::WriteReplyParams(
          reply_msg,
          IPC::InvalidPlatformFileForTransit(),
-         base::FilePath(FILE_PATH_LITERAL("")));
+         base::FilePath());
      Send(reply_msg);
   }
 }
 
 #if defined(OS_WIN)
 void NaClProcessHost::OnAttachDebugExceptionHandler(const std::string& info,
                                                     IPC::Message* reply_msg) {
   if (!AttachDebugExceptionHandler(info, reply_msg)) {
     // Send failure message.
     NaClProcessMsg_AttachDebugExceptionHandler::WriteReplyParams(reply_msg,
@@ skipping 54 matching lines @@
         process_handle.Take(), info,
         base::MessageLoopProxy::current(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif
 
 }  // namespace nacl