Rename fileBrowserPrivate to fileManagerPrivate

chrome/browser/chromeos/extensions/file_manager/event_router.cc

 // Copyright 2014 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/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_change_registrar.h"
@@ skipping 38 matching lines @@
 #include "storage/common/fileapi/file_system_util.h"
 
 using chromeos::disks::DiskMountManager;
 using chromeos::NetworkHandler;
 using content::BrowserThread;
 using drive::DriveIntegrationService;
 using drive::DriveIntegrationServiceFactory;
 using file_manager::util::EntryDefinition;
 using file_manager::util::FileDefinition;
 
-namespace file_browser_private = extensions::api::file_browser_private;
+namespace file_manager_private = extensions::api::file_manager_private;
 
 namespace file_manager {
 namespace {
 // Constants for the "transferState" field of onFileTransferUpdated event.
 const char kFileTransferStateAdded[] = "added";
 const char kFileTransferStateStarted[] = "started";
 const char kFileTransferStateInProgress[] = "in_progress";
 const char kFileTransferStateCompleted[] = "completed";
 const char kFileTransferStateFailed[] = "failed";
 
@@ skipping 23 matching lines @@
   }
   return num_active_file_transfer_job_info;
 }
 
 // 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) {
+    file_manager_private::FileTransferStatus* status) {
   DCHECK(IsActiveFileTransferJobInfo(job_info));
 
   scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue);
   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_state = file_manager_private::ParseTransferState(job_status);
   status->transfer_type =
       IsUploadJob(job_info.job_type) ?
-      file_browser_private::TRANSFER_TYPE_UPLOAD :
-      file_browser_private::TRANSFER_TYPE_DOWNLOAD;
+      file_manager_private::TRANSFER_TYPE_UPLOAD :
+      file_manager_private::TRANSFER_TYPE_DOWNLOAD;
   DriveIntegrationService* const integration_service =
       DriveIntegrationServiceFactory::FindForProfile(profile);
   status->num_total_jobs = CountActiveFileTransferJobInfo(
       integration_service->job_list()->GetJobInfoList());
   // 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(
       new double(static_cast<double>(job_info.num_completed_bytes)));
   status->total.reset(
@@ skipping 23 matching lines @@
 }
 
 // Sends an event named |event_name| with arguments |event_args| to extensions.
 void BroadcastEvent(Profile* profile,
                     const std::string& event_name,
                     scoped_ptr<base::ListValue> event_args) {
   extensions::EventRouter::Get(profile)->BroadcastEvent(
       make_scoped_ptr(new extensions::Event(event_name, event_args.Pass())));
 }
 
-file_browser_private::MountCompletedStatus
+file_manager_private::MountCompletedStatus
 MountErrorToMountCompletedStatus(chromeos::MountError error) {
   switch (error) {
     case chromeos::MOUNT_ERROR_NONE:
-      return file_browser_private::MOUNT_COMPLETED_STATUS_SUCCESS;
+      return file_manager_private::MOUNT_COMPLETED_STATUS_SUCCESS;
     case chromeos::MOUNT_ERROR_UNKNOWN:
-      return file_browser_private::MOUNT_COMPLETED_STATUS_ERROR_UNKNOWN;
+      return file_manager_private::MOUNT_COMPLETED_STATUS_ERROR_UNKNOWN;
     case chromeos::MOUNT_ERROR_INTERNAL:
-      return file_browser_private::MOUNT_COMPLETED_STATUS_ERROR_INTERNAL;
+      return file_manager_private::MOUNT_COMPLETED_STATUS_ERROR_INTERNAL;
     case chromeos::MOUNT_ERROR_INVALID_ARGUMENT:
-      return file_browser_private::
+      return file_manager_private::
           MOUNT_COMPLETED_STATUS_ERROR_INVALID_ARGUMENT;
     case chromeos::MOUNT_ERROR_INVALID_PATH:
-      return file_browser_private::MOUNT_COMPLETED_STATUS_ERROR_INVALID_PATH;
+      return file_manager_private::MOUNT_COMPLETED_STATUS_ERROR_INVALID_PATH;
     case chromeos::MOUNT_ERROR_PATH_ALREADY_MOUNTED:
-      return file_browser_private::
+      return file_manager_private::
           MOUNT_COMPLETED_STATUS_ERROR_PATH_ALREADY_MOUNTED;
     case chromeos::MOUNT_ERROR_PATH_NOT_MOUNTED:
-      return file_browser_private::
+      return file_manager_private::
           MOUNT_COMPLETED_STATUS_ERROR_PATH_NOT_MOUNTED;
     case chromeos::MOUNT_ERROR_DIRECTORY_CREATION_FAILED:
-      return file_browser_private
+      return file_manager_private
           ::MOUNT_COMPLETED_STATUS_ERROR_DIRECTORY_CREATION_FAILED;
     case chromeos::MOUNT_ERROR_INVALID_MOUNT_OPTIONS:
-      return file_browser_private
+      return file_manager_private
           ::MOUNT_COMPLETED_STATUS_ERROR_INVALID_MOUNT_OPTIONS;
     case chromeos::MOUNT_ERROR_INVALID_UNMOUNT_OPTIONS:
-      return file_browser_private::
+      return file_manager_private::
           MOUNT_COMPLETED_STATUS_ERROR_INVALID_UNMOUNT_OPTIONS;
     case chromeos::MOUNT_ERROR_INSUFFICIENT_PERMISSIONS:
-      return file_browser_private::
+      return file_manager_private::
           MOUNT_COMPLETED_STATUS_ERROR_INSUFFICIENT_PERMISSIONS;
     case chromeos::MOUNT_ERROR_MOUNT_PROGRAM_NOT_FOUND:
-      return file_browser_private::
+      return file_manager_private::
           MOUNT_COMPLETED_STATUS_ERROR_MOUNT_PROGRAM_NOT_FOUND;
     case chromeos::MOUNT_ERROR_MOUNT_PROGRAM_FAILED:
-      return file_browser_private::
+      return file_manager_private::
           MOUNT_COMPLETED_STATUS_ERROR_MOUNT_PROGRAM_FAILED;
     case chromeos::MOUNT_ERROR_INVALID_DEVICE_PATH:
-      return file_browser_private::
+      return file_manager_private::
           MOUNT_COMPLETED_STATUS_ERROR_INVALID_DEVICE_PATH;
     case chromeos::MOUNT_ERROR_UNKNOWN_FILESYSTEM:
-      return file_browser_private::
+      return file_manager_private::
           MOUNT_COMPLETED_STATUS_ERROR_UNKNOWN_FILESYSTEM;
     case chromeos::MOUNT_ERROR_UNSUPPORTED_FILESYSTEM:
-      return file_browser_private::
+      return file_manager_private::
           MOUNT_COMPLETED_STATUS_ERROR_UNSUPPORTED_FILESYSTEM;
     case chromeos::MOUNT_ERROR_INVALID_ARCHIVE:
-      return file_browser_private::MOUNT_COMPLETED_STATUS_ERROR_INVALID_ARCHIVE;
+      return file_manager_private::MOUNT_COMPLETED_STATUS_ERROR_INVALID_ARCHIVE;
     case chromeos::MOUNT_ERROR_NOT_AUTHENTICATED:
-      return file_browser_private::MOUNT_COMPLETED_STATUS_ERROR_AUTHENTICATION;
+      return file_manager_private::MOUNT_COMPLETED_STATUS_ERROR_AUTHENTICATION;
     case chromeos::MOUNT_ERROR_PATH_UNMOUNTED:
-      return file_browser_private::MOUNT_COMPLETED_STATUS_ERROR_PATH_UNMOUNTED;
+      return file_manager_private::MOUNT_COMPLETED_STATUS_ERROR_PATH_UNMOUNTED;
   }
   NOTREACHED();
-  return file_browser_private::MOUNT_COMPLETED_STATUS_NONE;
+  return file_manager_private::MOUNT_COMPLETED_STATUS_NONE;
 }
 
-file_browser_private::CopyProgressStatusType
+file_manager_private::CopyProgressStatusType
 CopyProgressTypeToCopyProgressStatusType(
     storage::FileSystemOperation::CopyProgressType type) {
   switch (type) {
     case storage::FileSystemOperation::BEGIN_COPY_ENTRY:
-      return file_browser_private::COPY_PROGRESS_STATUS_TYPE_BEGIN_COPY_ENTRY;
+      return file_manager_private::COPY_PROGRESS_STATUS_TYPE_BEGIN_COPY_ENTRY;
     case storage::FileSystemOperation::END_COPY_ENTRY:
-      return file_browser_private::COPY_PROGRESS_STATUS_TYPE_END_COPY_ENTRY;
+      return file_manager_private::COPY_PROGRESS_STATUS_TYPE_END_COPY_ENTRY;
     case storage::FileSystemOperation::PROGRESS:
-      return file_browser_private::COPY_PROGRESS_STATUS_TYPE_PROGRESS;
+      return file_manager_private::COPY_PROGRESS_STATUS_TYPE_PROGRESS;
   }
   NOTREACHED();
-  return file_browser_private::COPY_PROGRESS_STATUS_TYPE_NONE;
+  return file_manager_private::COPY_PROGRESS_STATUS_TYPE_NONE;
 }
 
-file_browser_private::ChangeType ConvertChangeTypeFromDriveToApi(
+file_manager_private::ChangeType ConvertChangeTypeFromDriveToApi(
     drive::FileChange::ChangeType type) {
   switch (type) {
     case drive::FileChange::ADD_OR_UPDATE:
-      return file_browser_private::CHANGE_TYPE_ADD_OR_UPDATE;
+      return file_manager_private::CHANGE_TYPE_ADD_OR_UPDATE;
     case drive::FileChange::DELETE:
-      return file_browser_private::CHANGE_TYPE_DELETE;
+      return file_manager_private::CHANGE_TYPE_DELETE;
   }
   NOTREACHED();
-  return file_browser_private::CHANGE_TYPE_ADD_OR_UPDATE;
+  return file_manager_private::CHANGE_TYPE_ADD_OR_UPDATE;
 }
 
 std::string FileErrorToErrorName(base::File::Error error_code) {
-  namespace js = extensions::api::file_browser_private;
+  namespace js = extensions::api::file_manager_private;
   switch (error_code) {
     case base::File::FILE_ERROR_NOT_FOUND:
       return "NotFoundError";
     case base::File::FILE_ERROR_INVALID_OPERATION:
     case base::File::FILE_ERROR_EXISTS:
     case base::File::FILE_ERROR_NOT_EMPTY:
       return "InvalidModificationError";
     case base::File::FILE_ERROR_NOT_A_DIRECTORY:
     case base::File::FILE_ERROR_NOT_A_FILE:
       return "TypeMismatchError";
@@ skipping 67 matching lines @@
 
   return true;
 }
 
 // Sub-part of the event router for handling device events.
 class DeviceEventRouterImpl : public DeviceEventRouter {
  public:
   explicit DeviceEventRouterImpl(Profile* profile) : profile_(profile) {}
 
   // DeviceEventRouter overrides.
-  virtual void OnDeviceEvent(file_browser_private::DeviceEventType type,
+  virtual void OnDeviceEvent(file_manager_private::DeviceEventType type,
                              const std::string& device_path) OVERRIDE {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-    file_browser_private::DeviceEvent event;
+    file_manager_private::DeviceEvent event;
     event.type = type;
     event.device_path = device_path;
 
     BroadcastEvent(profile_,
-                   file_browser_private::OnDeviceChanged::kEventName,
-                   file_browser_private::OnDeviceChanged::Create(event));
+                   file_manager_private::OnDeviceChanged::kEventName,
+                   file_manager_private::OnDeviceChanged::Create(event));
   }
 
   // DeviceEventRouter overrides.
   virtual bool IsExternalStorageDisabled() OVERRIDE {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     return profile_->GetPrefs()->GetBoolean(prefs::kExternalStorageDisabled);
   }
 
  private:
   Profile* const profile_;
@@ skipping 177 matching lines @@
     file_watchers_.erase(iter);
   }
 }
 
 void EventRouter::OnCopyCompleted(int copy_id,
                                   const GURL& source_url,
                                   const GURL& destination_url,
                                   base::File::Error error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  file_browser_private::CopyProgressStatus status;
+  file_manager_private::CopyProgressStatus status;
   if (error == base::File::FILE_OK) {
     // Send success event.
-    status.type = file_browser_private::COPY_PROGRESS_STATUS_TYPE_SUCCESS;
+    status.type = file_manager_private::COPY_PROGRESS_STATUS_TYPE_SUCCESS;
     status.source_url.reset(new std::string(source_url.spec()));
     status.destination_url.reset(new std::string(destination_url.spec()));
   } else {
     // Send error event.
-    status.type = file_browser_private::COPY_PROGRESS_STATUS_TYPE_ERROR;
+    status.type = file_manager_private::COPY_PROGRESS_STATUS_TYPE_ERROR;
     status.error.reset(new std::string(FileErrorToErrorName(error)));
   }
 
   BroadcastEvent(
       profile_,
-      file_browser_private::OnCopyProgress::kEventName,
-      file_browser_private::OnCopyProgress::Create(copy_id, status));
+      file_manager_private::OnCopyProgress::kEventName,
+      file_manager_private::OnCopyProgress::Create(copy_id, status));
 }
 
 void EventRouter::OnCopyProgress(
     int copy_id,
     storage::FileSystemOperation::CopyProgressType type,
     const GURL& source_url,
     const GURL& destination_url,
     int64 size) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  file_browser_private::CopyProgressStatus status;
+  file_manager_private::CopyProgressStatus status;
   status.type = CopyProgressTypeToCopyProgressStatusType(type);
   status.source_url.reset(new std::string(source_url.spec()));
   if (type == storage::FileSystemOperation::END_COPY_ENTRY)
     status.destination_url.reset(new std::string(destination_url.spec()));
   if (type == storage::FileSystemOperation::PROGRESS)
     status.size.reset(new double(size));
 
   // Should not skip events other than TYPE_PROGRESS.
   const bool always =
-      status.type != file_browser_private::COPY_PROGRESS_STATUS_TYPE_PROGRESS;
+      status.type != file_manager_private::COPY_PROGRESS_STATUS_TYPE_PROGRESS;
   if (!ShouldSendProgressEvent(always, &last_copy_progress_event_))
     return;
 
   BroadcastEvent(
       profile_,
-      file_browser_private::OnCopyProgress::kEventName,
-      file_browser_private::OnCopyProgress::Create(copy_id, status));
+      file_manager_private::OnCopyProgress::kEventName,
+      file_manager_private::OnCopyProgress::Create(copy_id, status));
 }
 
 void EventRouter::DefaultNetworkChanged(const chromeos::NetworkState* network) {
   if (!profile_ || !extensions::EventRouter::Get(profile_)) {
     NOTREACHED();
     return;
   }
 
   BroadcastEvent(
       profile_,
-      file_browser_private::OnDriveConnectionStatusChanged::kEventName,
-      file_browser_private::OnDriveConnectionStatusChanged::Create());
+      file_manager_private::OnDriveConnectionStatusChanged::kEventName,
+      file_manager_private::OnDriveConnectionStatusChanged::Create());
 }
 
 void EventRouter::OnFileManagerPrefsChanged() {
   if (!profile_ || !extensions::EventRouter::Get(profile_)) {
     NOTREACHED();
     return;
   }
 
   BroadcastEvent(
       profile_,
-      file_browser_private::OnPreferencesChanged::kEventName,
-      file_browser_private::OnPreferencesChanged::Create());
+      file_manager_private::OnPreferencesChanged::kEventName,
+      file_manager_private::OnPreferencesChanged::Create());
 }
 
 void EventRouter::OnJobAdded(const drive::JobInfo& job_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!drive::IsActiveFileTransferJobInfo(job_info))
     return;
   ScheduleDriveFileTransferEvent(
       job_info, kFileTransferStateAdded, false /* immediate */);
 }
 
@@ skipping 46 matching lines @@
         base::Bind(&EventRouter::SendDriveFileTransferEvent,
                    weak_factory_.GetWeakPtr()),
         delay);
   }
 }
 
 void EventRouter::SendDriveFileTransferEvent() {
   if (!drive_job_info_for_scheduled_event_)
     return;
 
-  file_browser_private::FileTransferStatus status;
+  file_manager_private::FileTransferStatus status;
   JobInfoToTransferStatus(profile_,
                           kFileManagerAppId,
                           drive_job_info_for_scheduled_event_->status,
                           drive_job_info_for_scheduled_event_->job_info,
                           &status);
 
   drive_job_info_for_scheduled_event_.reset();
 
   BroadcastEvent(profile_,
-                 file_browser_private::OnFileTransfersUpdated::kEventName,
-                 file_browser_private::OnFileTransfersUpdated::Create(status));
+                 file_manager_private::OnFileTransfersUpdated::kEventName,
+                 file_manager_private::OnFileTransfersUpdated::Create(status));
 }
 
 void EventRouter::OnDirectoryChanged(const base::FilePath& drive_path) {
   HandleFileWatchNotification(NULL, drive_path, false);
 }
 
 void EventRouter::OnFileChanged(const drive::FileChange& changed_files) {
   typedef std::map<base::FilePath, drive::FileChange> FileChangeMap;
 
   FileChangeMap map;
   const drive::FileChange::Map& changed_file_map = changed_files.map();
   for (drive::FileChange::Map::const_iterator it = changed_file_map.begin();
        it != changed_file_map.end();
        it++) {
     const base::FilePath& path = it->first;
     map[path.DirName()].Update(path, it->second);
   }
 
   for (FileChangeMap::const_iterator it = map.begin(); it != map.end(); it++) {
     HandleFileWatchNotification(&(it->second), it->first, false);
   }
 }
 
 void EventRouter::OnDriveSyncError(drive::file_system::DriveSyncErrorType type,
                                    const base::FilePath& drive_path) {
-  file_browser_private::DriveSyncErrorEvent event;
+  file_manager_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;
+          file_manager_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;
+          file_manager_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;
+          file_manager_private::DRIVE_SYNC_ERROR_TYPE_MISC;
       break;
   }
   event.file_url = util::ConvertDrivePathToFileSystemUrl(
       profile_, drive_path, kFileManagerAppId).spec();
   BroadcastEvent(
       profile_,
-      file_browser_private::OnDriveSyncError::kEventName,
-      file_browser_private::OnDriveSyncError::Create(event));
+      file_manager_private::OnDriveSyncError::kEventName,
+      file_manager_private::OnDriveSyncError::Create(event));
 }
 
 void EventRouter::OnRefreshTokenInvalid() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Raise a DriveConnectionStatusChanged event to notify the status offline.
   BroadcastEvent(
       profile_,
-      file_browser_private::OnDriveConnectionStatusChanged::kEventName,
-      file_browser_private::OnDriveConnectionStatusChanged::Create());
+      file_manager_private::OnDriveConnectionStatusChanged::kEventName,
+      file_manager_private::OnDriveConnectionStatusChanged::Create());
 }
 
 void EventRouter::HandleFileWatchNotification(const drive::FileChange* list,
                                               const base::FilePath& local_path,
                                               bool got_error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   WatcherMap::const_iterator iter = file_watchers_.find(local_path);
   if (iter == file_watchers_.end()) {
     return;
@@ skipping 53 matching lines @@
     const EntryDefinition& entry_definition) {
   typedef std::map<base::FilePath, drive::FileChange::ChangeList> ChangeListMap;
 
   if (entry_definition.error != base::File::FILE_OK ||
       !entry_definition.is_directory) {
     DVLOG(1) << "Unable to dispatch event because resolving the directory "
              << "entry definition failed.";
     return;
   }
 
-  file_browser_private::FileWatchEvent event;
+  file_manager_private::FileWatchEvent event;
   event.event_type = watcher_error
-      ? file_browser_private::FILE_WATCH_EVENT_TYPE_ERROR
-      : file_browser_private::FILE_WATCH_EVENT_TYPE_CHANGED;
+      ? file_manager_private::FILE_WATCH_EVENT_TYPE_ERROR
+      : file_manager_private::FILE_WATCH_EVENT_TYPE_CHANGED;
 
   // Detailed information is available.
   if (list.get()) {
     event.changed_files.reset(
-        new std::vector<linked_ptr<file_browser_private::FileChange> >);
+        new std::vector<linked_ptr<file_manager_private::FileChange> >);
 
     if (list->map().empty())
       return;
 
     for (drive::FileChange::Map::const_iterator it = list->map().begin();
          it != list->map().end();
          it++) {
-      linked_ptr<file_browser_private::FileChange> change_list(
-          new file_browser_private::FileChange);
+      linked_ptr<file_manager_private::FileChange> change_list(
+          new file_manager_private::FileChange);
 
       GURL url = util::ConvertDrivePathToFileSystemUrl(
           profile_, it->first, *extension_id);
       change_list->url = url.spec();
 
       for (drive::FileChange::ChangeList::List::const_iterator change =
                it->second.list().begin();
            change != it->second.list().end();
            change++) {
         change_list->changes.push_back(
             ConvertChangeTypeFromDriveToApi(change->change()));
       }
 
       event.changed_files->push_back(change_list);
     }
   }
 
   event.entry.additional_properties.SetString(
       "fileSystemName", entry_definition.file_system_name);
   event.entry.additional_properties.SetString(
       "fileSystemRoot", entry_definition.file_system_root_url);
   event.entry.additional_properties.SetString(
       "fileFullPath", "/" + entry_definition.full_path.value());
   event.entry.additional_properties.SetBoolean("fileIsDirectory",
                                                entry_definition.is_directory);
 
   BroadcastEvent(profile_,
-                 file_browser_private::OnDirectoryChanged::kEventName,
-                 file_browser_private::OnDirectoryChanged::Create(event));
+                 file_manager_private::OnDirectoryChanged::kEventName,
+                 file_manager_private::OnDirectoryChanged::Create(event));
 }
 
 void EventRouter::OnDiskAdded(
     const DiskMountManager::Disk& disk, bool mounting) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Do nothing.
 }
 
 void EventRouter::OnDiskRemoved(const DiskMountManager::Disk& disk) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 14 matching lines @@
                                   const VolumeInfo& volume_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // profile_ is NULL if ShutdownOnUIThread() is called earlier. This can
   // happen at shutdown. This should be removed after removing Drive mounting
   // code in addMount. (addMount -> OnFileSystemMounted -> OnVolumeMounted is
   // the only path to come here after Shutdown is called).
   if (!profile_)
     return;
 
   DispatchMountCompletedEvent(
-      file_browser_private::MOUNT_COMPLETED_EVENT_TYPE_MOUNT,
+      file_manager_private::MOUNT_COMPLETED_EVENT_TYPE_MOUNT,
       error_code,
       volume_info);
 }
 
 void EventRouter::OnVolumeUnmounted(chromeos::MountError error_code,
                                     const VolumeInfo& volume_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DispatchMountCompletedEvent(
-      file_browser_private::MOUNT_COMPLETED_EVENT_TYPE_UNMOUNT,
+      file_manager_private::MOUNT_COMPLETED_EVENT_TYPE_UNMOUNT,
       error_code,
       volume_info);
 }
 
 void EventRouter::DispatchMountCompletedEvent(
-    file_browser_private::MountCompletedEventType event_type,
+    file_manager_private::MountCompletedEventType event_type,
     chromeos::MountError error,
     const VolumeInfo& volume_info) {
   // Build an event object.
-  file_browser_private::MountCompletedEvent event;
+  file_manager_private::MountCompletedEvent event;
   event.event_type = event_type;
   event.status = MountErrorToMountCompletedStatus(error);
   util::VolumeInfoToVolumeMetadata(
       profile_, volume_info, &event.volume_metadata);
   event.should_notify = ShouldShowNotificationForVolume(
       profile_, *device_event_router_, volume_info);
   BroadcastEvent(profile_,
-                 file_browser_private::OnMountCompleted::kEventName,
-                 file_browser_private::OnMountCompleted::Create(event));
+                 file_manager_private::OnMountCompleted::kEventName,
+                 file_manager_private::OnMountCompleted::Create(event));
 }
 
 void EventRouter::OnFormatStarted(const std::string& device_path,
                                   bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Do nothing.
 }
 
 void EventRouter::OnFormatCompleted(const std::string& device_path,
                                     bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Do nothing.
 }
 
 }  // namespace file_manager