Fix open dialog not remembering last opened folder on drive

chrome/browser/chromeos/extensions/file_browser_private_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/chromeos/extensions/file_browser_private_api.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 841 matching lines @@
     LOG(WARNING) << "External provider is not available";
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(callback, selected_files));
     return;
   }
 
   GURL origin_url = source_url().GetOrigin();
   size_t len = file_urls.size();
   selected_files.reserve(len);
   for (size_t i = 0; i < len; ++i) {
-    FilePath real_path;
+    FilePath local_path;
     const GURL& file_url = file_urls[i];
 
     // If "localPath" parameter is set, use it as the real path.
     // TODO(satorux): Eventually, we should be able to get the real path
     // from GDataFileSystem instead of passing through with filesystem
     // URLs. crosbug.com/27510.
     //
     // TODO(satorux): GURL::query() is not yet supported for filesystem:
     // URLs. For now, use GURL::spec() to get the query portion. Should
     // get rid of the hack once query() is supported: crbug.com/114484.
     const std::string::size_type query_start = file_url.spec().find('?');
     if (query_start != std::string::npos) {
       const std::string query = file_url.spec().substr(query_start + 1);
       std::vector<std::pair<std::string, std::string> > parameters;
       if (base::SplitStringIntoKeyValuePairs(
               query, '=', '&', &parameters)) {
         for (size_t i = 0; i < parameters.size(); ++i) {
           if (parameters[i].first == "localPath") {
             const std::string unescaped_value =
                 net::UnescapeURLComponent(parameters[i].second,
                                           kUnescapeRuleForQueryParameters);
-            real_path = FilePath::FromUTF8Unsafe(unescaped_value);
+            local_path = FilePath::FromUTF8Unsafe(unescaped_value);
             break;
           }
         }
       }
     }
 
     // Extract the path from |file_url|.
     GURL file_origin_url;
     FilePath virtual_path;
     fileapi::FileSystemType type;
 
     if (!CrackFileSystemURL(file_url, &file_origin_url, &type,
                             &virtual_path)) {
       continue;
     }
     if (type != fileapi::kFileSystemTypeExternal) {
       NOTREACHED();
       continue;
     }
 
-    FilePath::StringType display_name;
     FilePath root = provider->GetFileSystemRootPathOnFileThread(
         origin_url,
         fileapi::kFileSystemTypeExternal,
         FilePath(virtual_path),
         false);
+    FilePath file_path;
     if (!root.empty()) {
-      // If we haven't got the real path from "localPath", use it as the
-      // real path.  Otherwise, use it as the display name.
-      if (real_path.empty())
-        real_path = root.Append(virtual_path);
-      else
-        display_name = virtual_path.BaseName().value();
+      file_path = root.Append(virtual_path);
     } else {
       LOG(WARNING) << "GetLocalPathsOnFileThread failed "
                    << file_url.spec();
     }
 
-    if (!real_path.empty()) {
-      DVLOG(1) << "Selected: real path: " << real_path.value()
-               << " display name: " << display_name;
+    if (!file_path.empty()) {
+      DVLOG(1) << "Selected: file path: " << file_path.value()
+               << " local path: " << local_path.value();
       selected_files.push_back(
-          ui::SelectedFileInfo(real_path, display_name));
+          ui::SelectedFileInfo(file_path, local_path));
     }
   }
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(callback, selected_files));
 }
 
 bool SelectFileFunction::RunImpl() {
   if (args_->GetSize() != 2) {
     return false;
@@ skipping 61 matching lines @@
 
 void ViewFilesFunction::GetLocalPathsResponseOnUIThread(
     const std::string& internal_task_id,
     const SelectedFileInfoList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   bool success = true;
   for (SelectedFileInfoList::const_iterator iter = files.begin();
        iter != files.end();
        ++iter) {
     bool handled = file_manager_util::ExecuteBuiltinHandler(
-        GetCurrentBrowser(), iter->path, internal_task_id);
+        GetCurrentBrowser(), iter->file_path, internal_task_id);
     if (!handled && files.size() == 1)
       success = false;
   }
   SetResult(Value::CreateBooleanValue(success));
   SendResponse(true);
 }
 
 SelectFilesFunction::SelectFilesFunction() {
 }
 
@@ skipping 129 matching lines @@
 void AddMountFunction::GetLocalPathsResponseOnUIThread(
     const std::string& mount_type_str,
     const SelectedFileInfoList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!files.size()) {
     SendResponse(false);
     return;
   }
 
-  const FilePath& source_path = files[0].path;
-  const FilePath::StringType& display_name = files[0].display_name;
+  const FilePath& source_path = files[0].local_path;
+  const FilePath::StringType& display_name =
+      files[0].file_path.BaseName().value();
   // Check if the source path is under GData cache directory.
   gdata::GDataSystemService* system_service =
       gdata::GDataSystemServiceFactory::GetForProfile(profile_);
   gdata::GDataCache* cache = system_service ? system_service->cache() : NULL;
   if (cache && cache->IsUnderGDataCacheDirectory(source_path)) {
     cache->SetMountedStateOnUIThread(
         source_path,
         true,
         base::Bind(&AddMountFunction::OnMountedStateSet, this, mount_type_str,
                    display_name));
@@ skipping 44 matching lines @@
 }
 
 void RemoveMountFunction::GetLocalPathsResponseOnUIThread(
     const SelectedFileInfoList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (files.size() != 1) {
     SendResponse(false);
     return;
   }
-  DiskMountManager::GetInstance()->UnmountPath(files[0].path.value());
+  DiskMountManager::GetInstance()->UnmountPath(files[0].local_path.value());
   SendResponse(true);
 }
 
 GetMountPointsFunction::GetMountPointsFunction() {
 }
 
 GetMountPointsFunction::~GetMountPointsFunction() {
 }
 
 bool GetMountPointsFunction::RunImpl() {
@@ skipping 45 matching lines @@
 
 void GetSizeStatsFunction::GetLocalPathsResponseOnUIThread(
     const SelectedFileInfoList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (files.size() != 1) {
     SendResponse(false);
     return;
   }
 
-  if (files[0].path == gdata::util::GetGDataMountPointPath()) {
+  if (files[0].file_path == gdata::util::GetGDataMountPointPath()) {
     gdata::GDataSystemService* system_service =
         gdata::GDataSystemServiceFactory::GetForProfile(profile_);
 
     gdata::GDataFileSystemInterface* file_system =
         system_service->file_system();
 
     file_system->GetAvailableSpace(
         base::Bind(&GetSizeStatsFunction::GetGDataAvailableSpaceCallback,
                    this));
 
   } else {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(
             &GetSizeStatsFunction::CallGetSizeStatsOnFileThread,
             this,
-            files[0].path.value()));
+            files[0].file_path.value()));
   }
 }
 
 void GetSizeStatsFunction::GetGDataAvailableSpaceCallback(
     gdata::GDataFileError error,
     int64 bytes_total,
     int64 bytes_used) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error == gdata::GDATA_FILE_OK) {
@@ skipping 65 matching lines @@
 
 void FormatDeviceFunction::GetLocalPathsResponseOnUIThread(
     const SelectedFileInfoList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (files.size() != 1) {
     SendResponse(false);
     return;
   }
 
-  DiskMountManager::GetInstance()->FormatMountedDevice(files[0].path.value());
+  DiskMountManager::GetInstance()->FormatMountedDevice(
+      files[0].file_path.value());
   SendResponse(true);
 }
 
 GetVolumeMetadataFunction::GetVolumeMetadataFunction() {
 }
 
 GetVolumeMetadataFunction::~GetVolumeMetadataFunction() {
 }
 
 bool GetVolumeMetadataFunction::RunImpl() {
@@ skipping 25 matching lines @@
   // Should contain volume's mount path.
   if (files.size() != 1) {
     error_ = "Invalid mount path.";
     SendResponse(false);
     return;
   }
 
   results_.reset();
 
   const DiskMountManager::Disk* volume = GetVolumeAsDisk(
-      files[0].path.value());
+      files[0].file_path.value());
   if (volume) {
     DictionaryValue* volume_info =
         CreateValueFromDisk(profile_, volume);
     SetResult(volume_info);
   }
 
   SendResponse(true);
 }
 
 bool ToggleFullscreenFunction::RunImpl() {
@@ skipping 548 matching lines @@
                  this));
   return true;
 }
 
 void GetFileLocationsFunction::GetLocalPathsResponseOnUIThread(
     const SelectedFileInfoList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ListValue* locations = new ListValue;
   for (size_t i = 0; i < files.size(); ++i) {
-    if (gdata::util::IsUnderGDataMountPoint(files[i].path)) {
+    if (gdata::util::IsUnderGDataMountPoint(files[i].file_path)) {
       locations->Append(Value::CreateStringValue("drive"));
     } else {
       locations->Append(Value::CreateStringValue("local"));
     }
   }
 
   SetResult(locations);
   SendResponse(true);
 }
 
@@ skipping 23 matching lines @@
       base::Bind(&GetGDataFilesFunction::GetLocalPathsResponseOnUIThread,
                  this));
   return true;
 }
 
 void GetGDataFilesFunction::GetLocalPathsResponseOnUIThread(
     const SelectedFileInfoList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   for (size_t i = 0; i < files.size(); ++i) {
-    DCHECK(gdata::util::IsUnderGDataMountPoint(files[i].path));
-    FilePath gdata_path = gdata::util::ExtractGDataPath(files[i].path);
+    DCHECK(gdata::util::IsUnderGDataMountPoint(files[i].file_path));
+    FilePath gdata_path = gdata::util::ExtractGDataPath(files[i].file_path);
     remaining_gdata_paths_.push(gdata_path);
   }
 
   local_paths_ = new ListValue;
   GetFileOrSendResponse();
 }
 
 void GetGDataFilesFunction::GetFileOrSendResponse() {
   // Send the response if all files are obtained.
   if (remaining_gdata_paths_.empty()) {
@@ skipping 108 matching lines @@
   if (!system_service) {
     SendResponse(false);
     return;
   }
 
   gdata::GDataOperationRegistry* operation_registry =
       system_service->docs_service()->operation_registry();
 
   scoped_ptr<ListValue> responses(new ListValue());
   for (size_t i = 0; i < files.size(); ++i) {
-    DCHECK(gdata::util::IsUnderGDataMountPoint(files[i].path));
-    FilePath file_path = gdata::util::ExtractGDataPath(files[i].path);
+    DCHECK(gdata::util::IsUnderGDataMountPoint(files[i].file_path));
+    FilePath file_path = gdata::util::ExtractGDataPath(files[i].file_path);
     scoped_ptr<DictionaryValue> result(new DictionaryValue());
     result->SetBoolean(
         "canceled",
         operation_registry->CancelForFilePath(file_path));
     GURL file_url;
     if (file_manager_util::ConvertFileToFileSystemUrl(profile_,
             gdata::util::GetSpecialRemoteRootPath().Append(file_path),
             source_url_.GetOrigin(),
             &file_url)) {
       result->SetString("fileUrl", file_url.spec());
@@ skipping 36 matching lines @@
     return;
   }
 
   gdata::GDataSystemService* system_service =
       gdata::GDataSystemServiceFactory::GetForProfile(profile_);
   if (!system_service) {
     SendResponse(false);
     return;
   }
 
-  FilePath source_file = files[0].path;
-  FilePath destination_file = files[1].path;
+  FilePath source_file = files[0].file_path;
+  FilePath destination_file = files[1].file_path;
 
   bool source_file_under_gdata =
       gdata::util::IsUnderGDataMountPoint(source_file);
   bool destination_file_under_gdata =
       gdata::util::IsUnderGDataMountPoint(destination_file);
 
   if (source_file_under_gdata && !destination_file_under_gdata) {
     // Transfer a file from gdata to local file system.
     source_file = gdata::util::ExtractGDataPath(source_file);
     system_service->file_system()->TransferFileFromRemoteToLocal(
@@ skipping 164 matching lines @@
   gdata::GDataSystemService* system_service =
       gdata::GDataSystemServiceFactory::GetForProfile(profile_);
   if (!system_service || !system_service->file_system())
     return false;
 
   FilePath directory_path = GetVirtualPathFromURL(GURL(file_url_as_string));
   system_service->file_system()->RequestDirectoryRefresh(directory_path);
 
   return true;
 }