Make sure we close the file_handle when we create (but not open) a new file

base/file_util_proxy.cc

 // Copyright (c) 2010 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 "base/file_util_proxy.h"
 
 #include "base/message_loop_proxy.h"
 
 // TODO(jianli): Move the code from anonymous namespace to base namespace so
 // that all of the base:: prefixes would be unnecessary.
@@ skipping 101 matching lines @@
   scoped_refptr<base::MessageLoopProxy> origin_message_loop_proxy_;
   base::PlatformFileError error_code_;
 };
 
 class RelayCreateOrOpen : public MessageLoopRelay {
  public:
   RelayCreateOrOpen(
       scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
       const FilePath& file_path,
       int file_flags,
+      bool return_no_handle,
       base::FileUtilProxy::CreateOrOpenCallback* callback)
       : message_loop_proxy_(message_loop_proxy),
         file_path_(file_path),
         file_flags_(file_flags),
         callback_(callback),
         file_handle_(base::kInvalidPlatformFileValue),
+        return_no_handle_(return_no_handle),
         created_(false) {
     DCHECK(callback);
   }
 
  protected:
   virtual ~RelayCreateOrOpen() {
     if (file_handle_ != base::kInvalidPlatformFileValue)
       base::FileUtilProxy::Close(message_loop_proxy_, file_handle_, NULL);
   }
 
   virtual void RunWork() {
     base::PlatformFileError error_code = base::PLATFORM_FILE_OK;
     file_handle_ = base::CreatePlatformFile(file_path_, file_flags_,
                                             &created_, &error_code);
+    // If the return_no_handle is true the caller is not interested
+    // in the file_handle_.  Close it right now.
+    if (return_no_handle_ && file_handle_ != base::kInvalidPlatformFileValue) {
+      // We don't check the return value here.
+      base::ClosePlatformFile(file_handle_);
+      file_handle_ = base::kInvalidPlatformFileValue;
+    }
     set_error_code(error_code);
   }
 
   virtual void RunCallback() {
     callback_->Run(error_code(), base::PassPlatformFile(&file_handle_),
                    created_);
     delete callback_;
   }
 
  private:
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
   FilePath file_path_;
   int file_flags_;
   base::FileUtilProxy::CreateOrOpenCallback* callback_;
   base::PlatformFile file_handle_;
+  bool return_no_handle_;
   bool created_;
 };
 
 class RelayCreateTemporary : public MessageLoopRelay {
  public:
   RelayCreateTemporary(
       scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
       base::FileUtilProxy::CreateTemporaryCallback* callback)
       : message_loop_proxy_(message_loop_proxy),
         callback_(callback),
@@ skipping 506 matching lines @@
 }  // namespace
 
 namespace base {
 
 // static
 bool FileUtilProxy::CreateOrOpen(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const FilePath& file_path, int file_flags,
     CreateOrOpenCallback* callback) {
   return Start(FROM_HERE, message_loop_proxy, new RelayCreateOrOpen(
-      message_loop_proxy, file_path, file_flags, callback));
+      message_loop_proxy, file_path, file_flags, false /* return_no_handle */,
+      callback));
 }
 
 // static
+bool FileUtilProxy::Create(
+    scoped_refptr<MessageLoopProxy> message_loop_proxy,
+    const FilePath& file_path, int file_flags,
+    CreateOrOpenCallback* callback) {
+  return Start(FROM_HERE, message_loop_proxy, new RelayCreateOrOpen(
+      message_loop_proxy, file_path, file_flags, true /* return_no_handle */,
+      callback));
+}
+
+// static
 bool FileUtilProxy::CreateTemporary(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     CreateTemporaryCallback* callback) {
   return Start(FROM_HERE, message_loop_proxy,
                new RelayCreateTemporary(message_loop_proxy, callback));
 }
 
 // static
 bool FileUtilProxy::CreateDirectory(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
@@ skipping 147 matching lines @@
 
 // static
 bool FileUtilProxy::Flush(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     PlatformFile file,
     StatusCallback* callback) {
   return Start(FROM_HERE, message_loop_proxy, new RelayFlush(file, callback));
 }
 
 }  // namespace base