Add recursive flag to file_util_proxy::CreateDirectory

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 302 matching lines @@
  private:
   FilePath src_file_path_;
   FilePath dest_file_path_;
 };
 
 class RelayCreateDirectory : public RelayWithStatusCallback {
  public:
   RelayCreateDirectory(
       const FilePath& file_path,
       bool exclusive,
+      bool recursive,
       base::FileUtilProxy::StatusCallback* callback)
       : RelayWithStatusCallback(callback),
         file_path_(file_path),
-        exclusive_(exclusive) {
+        exclusive_(exclusive),
+        recursive_(recursive) {
   }
 
  protected:
   virtual void RunWork() {
     bool path_exists = file_util::PathExists(file_path_);
     // If parent dir of file doesn't exist.
-    if (!file_util::PathExists(file_path_.DirName())) {
+    if (!recursive_ && !file_util::PathExists(file_path_.DirName())) {
       set_error_code(base::PLATFORM_FILE_ERROR_NOT_FOUND);
       return;
     }
     if (exclusive_ && path_exists) {
       set_error_code(base::PLATFORM_FILE_ERROR_EXISTS);
       return;
     }
     // If file exists at the path.
     if (path_exists && !file_util::DirectoryExists(file_path_)) {
       set_error_code(base::PLATFORM_FILE_ERROR_EXISTS);
       return;
     }
     if (!file_util::CreateDirectory(file_path_))
       set_error_code(base::PLATFORM_FILE_ERROR_FAILED);
   }
 
  private:
   FilePath file_path_;
   bool exclusive_;
+  bool recursive_;
 };
 
 class RelayReadDirectory : public MessageLoopRelay {
  public:
   RelayReadDirectory(const FilePath& file_path,
       base::FileUtilProxy::ReadDirectoryCallback* callback)
       : callback_(callback), file_path_(file_path) {
     DCHECK(callback);
   }
 
@@ skipping 88 matching lines @@
     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,
     const FilePath& file_path,
     bool exclusive,
+    bool recursive,
     StatusCallback* callback) {
   return Start(FROM_HERE, message_loop_proxy, new RelayCreateDirectory(
-      file_path, exclusive, callback));
+      file_path, exclusive, recursive, callback));
 }
 
 // static
 bool FileUtilProxy::Close(scoped_refptr<MessageLoopProxy> message_loop_proxy,
                           base::PlatformFile file_handle,
                           StatusCallback* callback) {
   return Start(FROM_HERE, message_loop_proxy,
                new RelayClose(file_handle, callback));
 }
 
@@ skipping 45 matching lines @@
 // static
 bool FileUtilProxy::RecursiveDelete(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const FilePath& file_path,
     StatusCallback* callback) {
   return Start(FROM_HERE, message_loop_proxy,
                new RelayDelete(file_path, true, callback));
 }
 
 }  // namespace base