Add tests for chrome.fileSystem app API.

chrome/browser/extensions/api/file_system/file_system_api.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 "chrome/browser/extensions/api/file_system/file_system_api.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "chrome/browser/extensions/shell_window_registry.h"
@@ skipping 14 matching lines @@
 const char kUserCancelled[] = "User cancelled";
 const char kWritableFileError[] = "Invalid file for writing";
 
 const char kSaveFileOption[] = "saveFile";
 
 namespace file_system = extensions::api::file_system;
 namespace ChooseFile = file_system::ChooseFile;
 
 namespace {
 
+bool g_skip_picker = false;
+FilePath* g_path_to_be_picked;
+
 bool GetFilePathOfFileEntry(const std::string& filesystem_name,
                             const std::string& filesystem_path,
                             const content::RenderViewHost* render_view_host,
                             FilePath* file_path,
                             std::string* error) {
   std::string filesystem_id;
   if (!fileapi::CrackIsolatedFileSystemName(filesystem_name, &filesystem_id)) {
     *error = kInvalidParameters;
     return false;
   }
@@ skipping 74 matching lines @@
     FilePath::StringType extension = suggested_path.Extension();
     if (!extension.empty()) {
       extension.erase(extension.begin());  // drop the .
       file_type_info.extensions.resize(1);
       file_type_info.extensions[0].push_back(extension);
     }
     file_type_info.include_all_files = true;
     gfx::NativeWindow owning_window = web_contents ?
         platform_util::GetTopLevel(web_contents->GetNativeView()) : NULL;
 
+    if (g_skip_picker) {
+      if (g_path_to_be_picked) {
+        content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
+            base::Bind(&FileSystemPickerFunction::FilePicker::FileSelected,
+                base::Unretained(this), *g_path_to_be_picked, 1,
+                static_cast<void*>(NULL)));
+      } else {
+        content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
+            base::Bind(
+                &FileSystemPickerFunction::FilePicker::FileSelectionCanceled,
+                base::Unretained(this), static_cast<void*>(NULL)));
+      }
+      return;
+    }
+
     select_file_dialog_->SelectFile(for_save ?
                                         SelectFileDialog::SELECT_SAVEAS_FILE :
                                         SelectFileDialog::SELECT_OPEN_FILE,
                                     string16(),
                                     suggested_path,
                                     &file_type_info, 0, FILE_PATH_LITERAL(""),
                                     web_contents, owning_window, NULL);
   }
 
   virtual ~FilePicker() {}
@@ skipping 37 matching lines @@
   }
 
   // The file picker will hold a reference to this function instance, preventing
   // its destruction (and subsequent sending of the function response) until the
   // user has selected a file or cancelled the picker. At that point, the picker
   // will delete itself, which will also free the function instance.
   new FilePicker(this, shell_window->web_contents(), suggested_path, for_save);
   return true;
 }
 
+// static
+void FileSystemPickerFunction::SkipPickerAndAlwaysSelectPath(FilePath* path) {
+  g_skip_picker = true;
+  g_path_to_be_picked = path;
+}
+
+// static
+void FileSystemPickerFunction::SkipPickerAndAlwaysCancel() {
+  g_skip_picker = true;
+  g_path_to_be_picked = NULL;
+}
+
+// static
+void FileSystemPickerFunction::StopSkippingPicker() {
+  g_skip_picker = false;
+}
+
 void FileSystemPickerFunction::FileSelected(const FilePath& path,
                                             bool for_save) {
   if (for_save) {
     content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
         base::Bind(&FileSystemPickerFunction::CheckWritableFile, this, path));
     return;
   }
 
   // Don't need to check the file, it's for reading.
   RegisterFileSystemAndSendResponse(path, false);
@@ skipping 79 matching lines @@
   file_system::ChooseFileOptions* options = params->options.get();
   if (options) {
     if (options->type.get() &&  *options->type == kSaveFileOption)
       for_save = true;
   }
 
   return ShowPicker(FilePath(), for_save);
 }
 
 }  // namespace extensions