chromeos: Replace resource ID in drive URL with path

chrome/browser/chromeos/drive/drive_file_system_util.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/drive/drive_file_system_util.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 97 matching lines @@
     browser->OpenURL(content::OpenURLParams(edit_url, content::Referrer(),
         CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
   }
 }
 
 // Invoked upon completion of GetEntryInfoByResourceId initiated by
 // ModifyDriveFileResourceUrl.
 void OnGetEntryInfoByResourceId(Profile* profile,
                                 const std::string& resource_id,
                                 DriveFileError error,
-                                const base::FilePath& /* drive_file_path */,
+                                const base::FilePath& drive_file_path,
                                 scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != DRIVE_FILE_OK)
     return;
 
-  DCHECK(entry_proto.get());
-  const std::string& base_name = entry_proto->base_name();
-  const GURL edit_url = GetFileResourceUrl(resource_id, base_name);
+  const GURL edit_url = FilePathToDriveURL(drive_file_path);
   OpenEditURLUIThread(profile, edit_url);
-  DVLOG(1) << "OnFindEntryByResourceId " << edit_url;
+  DVLOG(1) << "OnGetEntryInfoByResourceId " << edit_url;
 }
 
 }  // namespace
 
 
 const base::FilePath& GetDriveGrandRootPath() {
   CR_DEFINE_STATIC_LOCAL(base::FilePath, grand_root_path,
       (base::FilePath::FromUTF8Unsafe(util::kDriveGrandRootDirName)));
   return grand_root_path;
 }
@@ skipping 32 matching lines @@
       (base::FilePath::FromUTF8Unsafe(kDriveSpecialRootPath)));
   return drive_mount_path;
 }
 
 const base::FilePath& GetDriveMyDriveMountPointPath() {
   CR_DEFINE_STATIC_LOCAL(base::FilePath, drive_mydrive_mount_path,
       (base::FilePath::FromUTF8Unsafe(kDriveMyDriveMountPointPath)));
   return drive_mydrive_mount_path;
 }
 
-GURL GetFileResourceUrl(const std::string& resource_id,
-                        const std::string& file_name) {
-  std::string url(base::StringPrintf(
-      "%s:%s",
-      chrome::kDriveScheme,
-      net::EscapePath(resource_id).c_str()));
+GURL FilePathToDriveURL(const base::FilePath& path) {
+  std::string url(base::StringPrintf("%s:%s",
+                                     chrome::kDriveScheme,
+                                     path.AsUTF8Unsafe().c_str()));
   return GURL(url);
 }
 
+base::FilePath DriveURLToFilePath(const GURL& url) {
+  if (!url.is_valid() || url.scheme() != chrome::kDriveScheme)
+    return base::FilePath();
+  std::string path_string = net::UnescapeURLComponent(
+      url.path(), net::UnescapeRule::NORMAL);
+  return base::FilePath::FromUTF8Unsafe(path_string);
+}
+
 void ModifyDriveFileResourceUrl(Profile* profile,
                                 const base::FilePath& drive_cache_path,
                                 GURL* url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DriveFileSystemInterface* file_system = GetDriveFileSystem(profile);
   if (!file_system)
     return;
   DriveCache* cache = GetDriveCache(profile);
   if (!cache)
@@ skipping 229 matching lines @@
   proto->set_last_modified(file_info.last_modified.ToInternalValue());
   proto->set_last_accessed(file_info.last_accessed.ToInternalValue());
   proto->set_creation_time(file_info.creation_time.ToInternalValue());
 }
 
 void EmptyFileOperationCallback(DriveFileError error) {
 }
 
 }  // namespace util
 }  // namespace drive