Change chrome.filesystem to handle the Chrome OS Drive file entries directly.

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_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 10 matching lines @@
 #include "chrome/common/extensions/permissions/api_permission.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "grit/generated_resources.h"
 #include "net/base/mime_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/shell_dialogs/select_file_dialog.h"
+#include "ui/shell_dialogs/selected_file_info.h"
+#include "webkit/fileapi/external_mount_points.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/isolated_context.h"
 
 #if defined(OS_MACOSX)
 #include <CoreFoundation/CoreFoundation.h>
 #include "base/mac/foundation_util.h"
 #endif
 
 using fileapi::IsolatedContext;
@@ skipping 341 matching lines @@
         entry_type_(entry_type),
         function_(function) {
     select_file_dialog_ = ui::SelectFileDialog::Create(
         this, new ChromeSelectFilePolicy(web_contents));
     gfx::NativeWindow owning_window = web_contents ?
         platform_util::GetTopLevel(web_contents->GetView()->GetNativeView()) :
         NULL;
 
     if (g_skip_picker_for_test) {
       if (g_path_to_be_picked_for_test) {
+        ui::SelectedFileInfo selected_path(*g_path_to_be_picked_for_test,
+                                           base::FilePath());
         content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
             base::Bind(
-                &FileSystemChooseEntryFunction::FilePicker::FileSelected,
-                base::Unretained(this), *g_path_to_be_picked_for_test, 1,
+                &FileSystemChooseEntryFunction::FilePicker::
+                    FileSelectedWithExtraInfo,
+                base::Unretained(this), selected_path, 1,
                 static_cast<void*>(NULL)));
       } else {
         content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
             base::Bind(
                 &FileSystemChooseEntryFunction::FilePicker::
                     FileSelectionCanceled,
                 base::Unretained(this), static_cast<void*>(NULL)));
       }
       return;
     }
 
     select_file_dialog_->SelectFile(picker_type,
                                     string16(),
                                     suggested_name,
                                     &file_type_info, 0, FILE_PATH_LITERAL(""),
                                     owning_window, NULL);
   }
 
   virtual ~FilePicker() {}
 
  private:
   // ui::SelectFileDialog::Listener implementation.
   virtual void FileSelected(const base::FilePath& path,
                             int index,
                             void* params) OVERRIDE {
-    function_->FileSelected(path, entry_type_);
+    // The version taking ui::SelectedFileInfo should be used.
+    NOTREACHED();
+  }
+
+  virtual void FileSelectedWithExtraInfo(const ui::SelectedFileInfo& file,
+                                         int index,
+                                         void* params) OVERRIDE {
+    // Normally, file.local_path is used because it is a native path to the
+    // local read-only cached file in the case of remote file system like
+    // Chrome OS's Google Drive integration. Here, however, |file.file_path| is
+    // necessary because we need to create a FileEntry denoting the remote file,
+    // not its cache. On other platforms than Chrome OS, they are the same.
+    //
+    // TODO(kinaba): remove this, once after the file picker implements proper
+    // switch of the path treatment depending on the |support_drive| flag.
+    function_->FileSelected(file.file_path, entry_type_);
     delete this;
   }
 
   virtual void FileSelectionCanceled(void* params) OVERRIDE {
     function_->FileSelectionCanceled();
     delete this;
   }
 
   base::FilePath suggested_name_;
 
@@ skipping 39 matching lines @@
 void FileSystemChooseEntryFunction::SkipPickerAndAlwaysCancelForTest() {
   g_skip_picker_for_test = true;
   g_path_to_be_picked_for_test = NULL;
 }
 
 // static
 void FileSystemChooseEntryFunction::StopSkippingPickerForTest() {
   g_skip_picker_for_test = false;
 }
 
+// static
+void FileSystemChooseEntryFunction::RegisterTempExternalFileSystemForTest(
+    const std::string& name, const base::FilePath& path) {
+  // For testing on Chrome OS, where to deal with remote and local paths
+  // smoothly, all accessed paths need to be registered in the list of
+  // external mount points.
+  fileapi::ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
+      name, fileapi::kFileSystemTypeNativeLocal, path);
+}
+
 void FileSystemChooseEntryFunction::FileSelected(const base::FilePath& path,
                                                 EntryType entry_type) {
   if (entry_type == WRITABLE) {
     content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
         base::Bind(&FileSystemChooseEntryFunction::CheckWritableFile,
             this, path));
     return;
   }
 
   // Don't need to check the file, it's for reading.
@@ skipping 95 matching lines @@
 
     BuildFileTypeInfo(&file_type_info, suggested_extension,
         options->accepts.get(), options->accepts_all_types.get());
   }
 
   if (entry_type == WRITABLE && !HasFileSystemWritePermission()) {
     error_ = kRequiresFileSystemWriteError;
     return false;
   }
 
+  if (entry_type != WRITABLE)
+    file_type_info.support_drive = true;
+
   return ShowPicker(suggested_name, file_type_info, picker_type, entry_type);
 }
 
 }  // namespace extensions