Clarify and separate the concept of "Drive path" and "Filesystem relative path".

chrome/browser/chromeos/extensions/file_manager/event_router.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_manager/event_router.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_change_registrar.h"
@@ skipping 74 matching lines @@
 const int64 kFileTransferEventFrequencyInMilliseconds = 1000;
 
 // Utility function to check if |job_info| is a file uploading job.
 bool IsUploadJob(drive::JobType type) {
   return (type == drive::TYPE_UPLOAD_NEW_FILE ||
           type == drive::TYPE_UPLOAD_EXISTING_FILE);
 }
 
 // Converts the job info to a IDL generated type.
 void JobInfoToTransferStatus(
+    Profile* profile,
     const std::string& extension_id,
     const std::string& job_status,
     const drive::JobInfo& job_info,
     file_browser_private::FileTransferStatus* status) {
   DCHECK(IsActiveFileTransferJobInfo(job_info));
 
   scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue);
-  GURL url = util::ConvertRelativeFilePathToFileSystemUrl(
-      job_info.file_path, extension_id);
+  GURL url = util::ConvertDrivePathToFileSystemUrl(
+      profile, job_info.file_path, extension_id);
   status->file_url = url.spec();
   status->transfer_state = file_browser_private::ParseTransferState(job_status);
   status->transfer_type =
       IsUploadJob(job_info.job_type) ?
       file_browser_private::TRANSFER_TYPE_UPLOAD :
       file_browser_private::TRANSFER_TYPE_DOWNLOAD;
   // JavaScript does not have 64-bit integers. Instead we use double, which
   // is in IEEE 754 formant and accurate up to 52-bits in JS, and in practice
   // in C++. Larger values are rounded.
   status->processed.reset(
@@ skipping 426 matching lines @@
       return;
   }
 
   // Convert the current |drive_jobs_| to IDL type.
   std::vector<linked_ptr<file_browser_private::FileTransferStatus> >
       status_list;
   for (std::map<drive::JobID, DriveJobInfoWithStatus>::iterator
            iter = drive_jobs_.begin(); iter != drive_jobs_.end(); ++iter) {
     linked_ptr<file_browser_private::FileTransferStatus> status(
         new file_browser_private::FileTransferStatus());
-    JobInfoToTransferStatus(kFileManagerAppId,
+    JobInfoToTransferStatus(profile_,
+                            kFileManagerAppId,
                             iter->second.status,
                             iter->second.job_info,
                             status.get());
     status_list.push_back(status);
   }
   BroadcastEvent(
       profile_,
       file_browser_private::OnFileTransfersUpdated::kEventName,
       file_browser_private::OnFileTransfersUpdated::Create(status_list));
   last_file_transfer_event_ = now;
 }
 
-void EventRouter::OnDirectoryChanged(const base::FilePath& directory_path) {
-  HandleFileWatchNotification(directory_path, false);
+void EventRouter::OnDirectoryChanged(const base::FilePath& drive_path) {
+  HandleFileWatchNotification(drive_path, false);
 }
 
-void EventRouter::OnDriveSyncError(
-    drive::file_system::DriveSyncErrorType type,
-    const base::FilePath& file_path) {
+void EventRouter::OnDriveSyncError(drive::file_system::DriveSyncErrorType type,
+                                   const base::FilePath& drive_path) {
   file_browser_private::DriveSyncErrorEvent event;
   switch (type) {
     case drive::file_system::DRIVE_SYNC_ERROR_DELETE_WITHOUT_PERMISSION:
       event.type =
           file_browser_private::DRIVE_SYNC_ERROR_TYPE_DELETE_WITHOUT_PERMISSION;
       break;
     case drive::file_system::DRIVE_SYNC_ERROR_SERVICE_UNAVAILABLE:
       event.type =
           file_browser_private::DRIVE_SYNC_ERROR_TYPE_SERVICE_UNAVAILABLE;
       break;
     case drive::file_system::DRIVE_SYNC_ERROR_MISC:
       event.type =
           file_browser_private::DRIVE_SYNC_ERROR_TYPE_MISC;
       break;
   }
-  event.file_url = util::ConvertRelativeFilePathToFileSystemUrl(
-      file_path, kFileManagerAppId).spec();
+  event.file_url = util::ConvertDrivePathToFileSystemUrl(
+      profile_, drive_path, kFileManagerAppId).spec();
   BroadcastEvent(
       profile_,
       file_browser_private::OnDriveSyncError::kEventName,
       file_browser_private::OnDriveSyncError::Create(event));
 }
 
 void EventRouter::OnRefreshTokenInvalid() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Raise a DriveConnectionStatusChanged event to notify the status offline.
@@ skipping 184 matching lines @@
 void EventRouter::OnFormatCompleted(const std::string& device_path,
                                     bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DispatchDeviceEvent(success ?
                       file_browser_private::DEVICE_EVENT_TYPE_FORMAT_SUCCESS :
                       file_browser_private::DEVICE_EVENT_TYPE_FORMAT_FAIL,
                       device_path);
 }
 
 }  // namespace file_manager