chromeos: Move chrome/browser/chromeos/extensions/file_browser* to chrome/browser/chromeos/file_man…

chrome/browser/chromeos/extensions/file_manager/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_browser_event_router.h"
+#include "chrome/browser/chromeos/extensions/file_manager/file_manager_event_router.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/drive/drive_cache.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_interface.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_util.h"
 #include "chrome/browser/chromeos/drive/drive_system_service.h"
-#include "chrome/browser/chromeos/extensions/file_browser_notifications.h"
+#include "chrome/browser/chromeos/extensions/file_manager/file_manager_notifications.h"
 #include "chrome/browser/chromeos/extensions/file_manager/file_manager_util.h"
 #include "chrome/browser/chromeos/login/base_login_display_host.h"
 #include "chrome/browser/chromeos/login/screen_locker.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/net/connectivity_state_helper.h"
 #include "chrome/browser/extensions/event_names.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/google_apis/drive_service_interface.h"
@@ skipping 99 matching lines @@
 // resumes. After the system resumes it will stay in "is_resuming" state for 5
 // seconds. This is to give DiskManager time to process device removed/added
 // events (events for the devices that were present before suspend should not
 // trigger any new notifications or file manager windows).
 // The delegate will go into the same state after screen is unlocked. Cros-disks
 // will not send events while the screen is locked. The events will be postponed
 // until the screen is unlocked. These have to be handled too.
 class SuspendStateDelegateImpl
     : public chromeos::PowerManagerClient::Observer,
       public chromeos::SessionManagerClient::Observer,
-      public FileBrowserEventRouter::SuspendStateDelegate {
+      public FileManagerEventRouter::SuspendStateDelegate {
  public:
   SuspendStateDelegateImpl()
       : is_resuming_(false),
         weak_factory_(this) {
     DBusThreadManager::Get()->GetPowerManagerClient()->AddObserver(this);
     DBusThreadManager::Get()->GetSessionManagerClient()->AddObserver(this);
   }
 
   virtual ~SuspendStateDelegateImpl() {
     DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(this);
@@ skipping 23 matching lines @@
     is_resuming_ = true;
     // Undo any previous resets.
     weak_factory_.InvalidateWeakPtrs();
     base::MessageLoopProxy::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&SuspendStateDelegateImpl::Reset,
                    weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromSeconds(5));
   }
 
-  // FileBrowserEventRouter::SuspendStateDelegate implementation.
+  // FileManagerEventRouter::SuspendStateDelegate implementation.
   virtual bool SystemIsResuming() const OVERRIDE {
     return is_resuming_;
   }
 
-  // FileBrowserEventRouter::SuspendStateDelegate implementation.
+  // FileManagerEventRouter::SuspendStateDelegate implementation.
   virtual bool DiskWasPresentBeforeSuspend(
       const DiskMountManager::Disk& disk) const OVERRIDE {
     // TODO(tbarzic): Implement this. Blocked on http://crbug.com/153338.
     return false;
   }
 
  private:
   void Reset() {
     is_resuming_ = false;
   }
@@ skipping 41 matching lines @@
   if (!watcher->Watch(watch_path, false /* recursive */, callback)) {
     delete watcher;
     return NULL;
   }
 
   return watcher;
 }
 
 }  // namespace
 
-FileBrowserEventRouter::FileBrowserEventRouter(
+FileManagerEventRouter::FileManagerEventRouter(
     Profile* profile)
     : weak_factory_(this),
-      notifications_(new FileBrowserNotifications(profile)),
+      notifications_(new FileManagerNotifications(profile)),
       pref_change_registrar_(new PrefChangeRegistrar),
       profile_(profile),
       num_remote_update_requests_(0),
       shift_pressed_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   file_watcher_callback_ =
-      base::Bind(&FileBrowserEventRouter::HandleFileWatchNotification,
+      base::Bind(&FileManagerEventRouter::HandleFileWatchNotification,
                  weak_factory_.GetWeakPtr());
 
   // Listen for the Shift modifier's state changes.
   chromeos::SystemKeyEventListener* key_event_listener =
       chromeos::SystemKeyEventListener::GetInstance();
   if (key_event_listener)
     key_event_listener->AddModifiersObserver(this);
 }
 
-FileBrowserEventRouter::~FileBrowserEventRouter() {
+FileManagerEventRouter::~FileManagerEventRouter() {
 }
 
-void FileBrowserEventRouter::Shutdown() {
+void FileManagerEventRouter::Shutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DLOG_IF(WARNING, !file_watchers_.empty()) << "Not all file watchers are "
       << "removed. This can happen when Files.app is open during shutdown.";
   STLDeleteValues(&file_watchers_);
   if (!profile_) {
     NOTREACHED();
     return;
   }
 
@@ skipping 13 matching lines @@
     system_service->drive_service()->RemoveObserver(this);
   }
 
   if (chromeos::ConnectivityStateHelper::IsInitialized()) {
     chromeos::ConnectivityStateHelper::Get()->
         RemoveNetworkManagerObserver(this);
   }
   profile_ = NULL;
 }
 
-void FileBrowserEventRouter::ObserveFileSystemEvents() {
+void FileManagerEventRouter::ObserveFileSystemEvents() {
   if (!profile_) {
     NOTREACHED();
     return;
   }
   if (!chromeos::UserManager::Get()->IsUserLoggedIn())
     return;
 
   DiskMountManager* disk_mount_manager = DiskMountManager::GetInstance();
   if (disk_mount_manager) {
     disk_mount_manager->RemoveObserver(this);
@@ skipping 11 matching lines @@
   if (chromeos::ConnectivityStateHelper::IsInitialized()) {
     chromeos::ConnectivityStateHelper::Get()->
         AddNetworkManagerObserver(this);
   }
   suspend_state_delegate_.reset(new SuspendStateDelegateImpl());
 
   pref_change_registrar_->Init(profile_->GetPrefs());
 
   pref_change_registrar_->Add(
       prefs::kExternalStorageDisabled,
-      base::Bind(&FileBrowserEventRouter::OnExternalStorageDisabledChanged,
+      base::Bind(&FileManagerEventRouter::OnExternalStorageDisabledChanged,
                  weak_factory_.GetWeakPtr()));
 
   base::Closure callback =
-      base::Bind(&FileBrowserEventRouter::OnFileBrowserPrefsChanged,
+      base::Bind(&FileManagerEventRouter::OnFileManagerPrefsChanged,
                  weak_factory_.GetWeakPtr());
   pref_change_registrar_->Add(prefs::kDisableDriveOverCellular, callback);
   pref_change_registrar_->Add(prefs::kDisableDriveHostedFiles, callback);
   pref_change_registrar_->Add(prefs::kDisableDrive, callback);
   pref_change_registrar_->Add(prefs::kUse24HourClock, callback);
 }
 
 // File watch setup routines.
-void FileBrowserEventRouter::AddFileWatch(
+void FileManagerEventRouter::AddFileWatch(
     const base::FilePath& local_path,
     const base::FilePath& virtual_path,
     const std::string& extension_id,
     const BoolCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::FilePath watch_path = local_path;
   bool is_remote_watch = false;
   // Tweak watch path for remote sources - we need to drop leading /special
@@ skipping 15 matching lines @@
                  file_watcher_callback_,
                  callback);
     file_watchers_[watch_path] = watch.release();
   } else {
     iter->second->AddExtension(extension_id);
     base::MessageLoopProxy::current()->PostTask(FROM_HERE,
                                                 base::Bind(callback, true));
   }
 }
 
-void FileBrowserEventRouter::RemoveFileWatch(
+void FileManagerEventRouter::RemoveFileWatch(
     const base::FilePath& local_path,
     const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::FilePath watch_path = local_path;
   // Tweak watch path for remote sources - we need to drop leading /special
   // directory from there in order to be able to pair these events with
   // their change notifications.
   if (drive::util::GetSpecialRemoteRootPath().IsParent(watch_path)) {
     watch_path = drive::util::ExtractDrivePath(watch_path);
     HandleRemoteUpdateRequestOnUIThread(false /* start */);
   }
   WatcherMap::iterator iter = file_watchers_.find(watch_path);
   if (iter == file_watchers_.end())
     return;
   // Remove the renderer process for this watch.
   iter->second->RemoveExtension(extension_id);
   if (iter->second->GetRefCount() == 0) {
     delete iter->second;
     file_watchers_.erase(iter);
   }
 }
 
-void FileBrowserEventRouter::MountDrive(
+void FileManagerEventRouter::MountDrive(
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Pass back the gdata mount point path as source path.
   const std::string& gdata_path = drive::util::GetDriveMountPointPathAsString();
   DiskMountManager::MountPointInfo mount_info(
       gdata_path,
       gdata_path,
       chromeos::MOUNT_TYPE_GOOGLE_DRIVE,
       chromeos::disks::MOUNT_CONDITION_NONE);
 
   // Raise mount event.
   // We can pass chromeos::MOUNT_ERROR_NONE even when authentication is failed
   // or network is unreachable. These two errors will be handled later.
   OnMountEvent(DiskMountManager::MOUNTING,
                chromeos::MOUNT_ERROR_NONE,
                mount_info);
 
   if (!callback.is_null())
     callback.Run();
 }
 
-void FileBrowserEventRouter::HandleRemoteUpdateRequestOnUIThread(bool start) {
+void FileManagerEventRouter::HandleRemoteUpdateRequestOnUIThread(bool start) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   drive::DriveFileSystemInterface* file_system = GetRemoteFileSystem();
   // |file_system| is NULL if Drive is disabled.
   if (!file_system)
     return;
 
   if (start) {
     file_system->CheckForUpdates();
     if (num_remote_update_requests_ == 0)
       file_system->StartPolling();
     ++num_remote_update_requests_;
   } else {
     DCHECK_LE(1, num_remote_update_requests_);
     --num_remote_update_requests_;
     if (num_remote_update_requests_ == 0)
       file_system->StopPolling();
   }
 }
 
-void FileBrowserEventRouter::OnDiskEvent(
+void FileManagerEventRouter::OnDiskEvent(
     DiskMountManager::DiskEvent event,
     const DiskMountManager::Disk* disk) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Disregard hidden devices.
   if (disk->is_hidden())
     return;
   if (event == DiskMountManager::DISK_ADDED) {
     OnDiskAdded(disk);
   } else if (event == DiskMountManager::DISK_REMOVED) {
     OnDiskRemoved(disk);
   }
 }
 
-void FileBrowserEventRouter::OnDeviceEvent(
+void FileManagerEventRouter::OnDeviceEvent(
     DiskMountManager::DeviceEvent event,
     const std::string& device_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (event == DiskMountManager::DEVICE_ADDED) {
     OnDeviceAdded(device_path);
   } else if (event == DiskMountManager::DEVICE_REMOVED) {
     OnDeviceRemoved(device_path);
   } else if (event == DiskMountManager::DEVICE_SCANNED) {
     OnDeviceScanned(device_path);
   }
 }
 
-void FileBrowserEventRouter::OnMountEvent(
+void FileManagerEventRouter::OnMountEvent(
     DiskMountManager::MountEvent event,
     chromeos::MountError error_code,
     const DiskMountManager::MountPointInfo& mount_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // profile_ is NULL if ShutdownOnUIThread() is called earlier. This can
   // happen at shutdown.
   if (!profile_)
     return;
 
   DCHECK(mount_info.mount_type != chromeos::MOUNT_TYPE_INVALID);
@@ skipping 30 matching lines @@
       DriveSystemService* system_service =
           DriveSystemServiceFactory::GetForProfile(profile_);
       drive::DriveCache* cache =
           system_service ? system_service->cache() : NULL;
       if (cache && cache->IsUnderDriveCacheDirectory(source_path))
         cache->MarkAsUnmounted(source_path, base::Bind(&OnMarkAsUnmounted));
     }
   }
 }
 
-void FileBrowserEventRouter::OnFormatEvent(
+void FileManagerEventRouter::OnFormatEvent(
       DiskMountManager::FormatEvent event,
       chromeos::FormatError error_code,
       const std::string& device_path) {
   if (event == DiskMountManager::FORMAT_STARTED) {
     OnFormatStarted(device_path, error_code == chromeos::FORMAT_ERROR_NONE);
   } else if (event == DiskMountManager::FORMAT_COMPLETED) {
     OnFormatCompleted(device_path, error_code == chromeos::FORMAT_ERROR_NONE);
   }
 }
 
-void FileBrowserEventRouter::NetworkManagerChanged() {
+void FileManagerEventRouter::NetworkManagerChanged() {
   if (!profile_ ||
       !extensions::ExtensionSystem::Get(profile_)->event_router()) {
     NOTREACHED();
     return;
   }
   scoped_ptr<extensions::Event> event(new extensions::Event(
       extensions::event_names::kOnFileBrowserDriveConnectionStatusChanged,
       scoped_ptr<ListValue>(new ListValue())));
   extensions::ExtensionSystem::Get(profile_)->event_router()->
       BroadcastEvent(event.Pass());
 }
 
-void FileBrowserEventRouter::OnExternalStorageDisabledChanged() {
+void FileManagerEventRouter::OnExternalStorageDisabledChanged() {
   // If the policy just got disabled we have to unmount every device currently
   // mounted. The opposite is fine - we can let the user re-plug her device to
   // make it available.
   if (profile_->GetPrefs()->GetBoolean(prefs::kExternalStorageDisabled)) {
     DiskMountManager* manager = DiskMountManager::GetInstance();
     DiskMountManager::MountPointMap mounts(manager->mount_points());
     for (DiskMountManager::MountPointMap::const_iterator it = mounts.begin();
          it != mounts.end(); ++it) {
       LOG(INFO) << "Unmounting " << it->second.mount_path
                 << " because of policy.";
       manager->UnmountPath(it->second.mount_path,
                            chromeos::UNMOUNT_OPTIONS_NONE,
                            DiskMountManager::UnmountPathCallback());
     }
   }
 }
 
-void FileBrowserEventRouter::OnFileBrowserPrefsChanged() {
+void FileManagerEventRouter::OnFileManagerPrefsChanged() {
   if (!profile_ ||
       !extensions::ExtensionSystem::Get(profile_)->event_router()) {
     NOTREACHED();
     return;
   }
 
   scoped_ptr<extensions::Event> event(new extensions::Event(
       extensions::event_names::kOnFileBrowserPreferencesChanged,
       scoped_ptr<ListValue>(new ListValue())));
   extensions::ExtensionSystem::Get(profile_)->event_router()->
       BroadcastEvent(event.Pass());
 }
 
-void FileBrowserEventRouter::OnProgressUpdate(
+void FileManagerEventRouter::OnProgressUpdate(
     const google_apis::OperationProgressStatusList& list) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   scoped_ptr<ListValue> event_list(
       file_manager_util::ProgressStatusVectorToListValue(
           profile_, kFileBrowserDomain, list));
 
   scoped_ptr<ListValue> args(new ListValue());
   args->Append(event_list.release());
   scoped_ptr<extensions::Event> event(new extensions::Event(
       extensions::event_names::kOnFileTransfersUpdated, args.Pass()));
   extensions::ExtensionSystem::Get(profile_)->event_router()->
       DispatchEventToExtension(kFileBrowserDomain, event.Pass());
 }
 
-void FileBrowserEventRouter::OnDirectoryChanged(
+void FileManagerEventRouter::OnDirectoryChanged(
     const base::FilePath& directory_path) {
   HandleFileWatchNotification(directory_path, false);
 }
 
-void FileBrowserEventRouter::OnFileSystemMounted() {
+void FileManagerEventRouter::OnFileSystemMounted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   MountDrive(base::Bind(&base::DoNothing));  // Callback does nothing.
 }
 
-void FileBrowserEventRouter::OnModifiersChange(int pressed_modifiers) {
+void FileManagerEventRouter::OnModifiersChange(int pressed_modifiers) {
   shift_pressed_ = (pressed_modifiers & SHIFT_PRESSED);
 }
 
-void FileBrowserEventRouter::OnFileSystemBeingUnmounted() {
+void FileManagerEventRouter::OnFileSystemBeingUnmounted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Raise a mount event to notify the File Manager.
   const std::string& gdata_path = drive::util::GetDriveMountPointPathAsString();
   DiskMountManager::MountPointInfo mount_info(
       gdata_path,
       gdata_path,
       chromeos::MOUNT_TYPE_GOOGLE_DRIVE,
       chromeos::disks::MOUNT_CONDITION_NONE);
   OnMountEvent(DiskMountManager::UNMOUNTING, chromeos::MOUNT_ERROR_NONE,
                mount_info);
 }
 
-void FileBrowserEventRouter::OnRefreshTokenInvalid() {
+void FileManagerEventRouter::OnRefreshTokenInvalid() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Raise a DriveConnectionStatusChanged event to notify the status offline.
   scoped_ptr<extensions::Event> event(new extensions::Event(
       extensions::event_names::kOnFileBrowserDriveConnectionStatusChanged,
       scoped_ptr<ListValue>(new ListValue())));
   extensions::ExtensionSystem::Get(profile_)->event_router()->
       BroadcastEvent(event.Pass());
 }
 
-void FileBrowserEventRouter::HandleFileWatchNotification(
+void FileManagerEventRouter::HandleFileWatchNotification(
     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;
   }
   DispatchDirectoryChangeEvent(iter->second->GetVirtualPath(), got_error,
                                iter->second->GetExtensions());
 }
 
-void FileBrowserEventRouter::DispatchDirectoryChangeEvent(
+void FileManagerEventRouter::DispatchDirectoryChangeEvent(
     const base::FilePath& virtual_path,
     bool got_error,
-    const FileBrowserEventRouter::ExtensionUsageRegistry& extensions) {
+    const FileManagerEventRouter::ExtensionUsageRegistry& extensions) {
   if (!profile_) {
     NOTREACHED();
     return;
   }
 
   for (ExtensionUsageRegistry::const_iterator iter = extensions.begin();
        iter != extensions.end(); ++iter) {
     GURL target_origin_url(extensions::Extension::GetBaseURLFromExtensionId(
         iter->first));
     GURL base_url = fileapi::GetFileSystemRootURI(target_origin_url,
@@ skipping 10 matching lines @@
     ListValue* watch_info_entries = new ListValue();
     watch_info->Set("changedEntries", watch_info_entries);
 
     scoped_ptr<extensions::Event> event(new extensions::Event(
         extensions::event_names::kOnDirectoryChanged, args.Pass()));
     extensions::ExtensionSystem::Get(profile_)->event_router()->
         DispatchEventToExtension(iter->first, event.Pass());
   }
 }
 
-void FileBrowserEventRouter::DispatchMountEvent(
+void FileManagerEventRouter::DispatchMountEvent(
     DiskMountManager::MountEvent event,
     chromeos::MountError error_code,
     const DiskMountManager::MountPointInfo& mount_info) {
   scoped_ptr<ListValue> args(new ListValue());
   DictionaryValue* mount_info_value = new DictionaryValue();
   args->Append(mount_info_value);
   mount_info_value->SetString("eventType",
       event == DiskMountManager::MOUNTING ? "mount" : "unmount");
   mount_info_value->SetString("status", MountErrorToString(error_code));
   mount_info_value->SetString(
@@ skipping 24 matching lines @@
           MountErrorToString(chromeos::MOUNT_ERROR_PATH_UNMOUNTED));
     }
   }
 
   scoped_ptr<extensions::Event> extension_event(new extensions::Event(
       extensions::event_names::kOnFileBrowserMountCompleted, args.Pass()));
   extensions::ExtensionSystem::Get(profile_)->event_router()->
       BroadcastEvent(extension_event.Pass());
 }
 
-void FileBrowserEventRouter::ShowRemovableDeviceInFileManager(
+void FileManagerEventRouter::ShowRemovableDeviceInFileManager(
     const DiskMountManager::Disk& disk, const base::FilePath& mount_path) {
   // Do not attempt to open File Manager while the login is in progress or
   // the screen is locked.
   if (chromeos::BaseLoginDisplayHost::default_host() ||
       chromeos::ScreenLocker::default_screen_locker())
     return;
 
   // According to DCF (Design rule of Camera File system) by JEITA / CP-3461
   // cameras should have pictures located in the DCIM root directory.
   const base::FilePath dcim_path = mount_path.Append(
@@ skipping 15 matching lines @@
   // If there is no DCIM folder or an external photo importer is not available,
   // then launch Files.app.
   DirectoryExistsOnUIThread(
       dcim_path,
       external_photo_importer_available ?
         base::Bind(&base::DoNothing) :
         base::Bind(&file_manager_util::ViewRemovableDrive, mount_path),
       base::Bind(&file_manager_util::ViewRemovableDrive, mount_path));
 }
 
-void FileBrowserEventRouter::OnDiskAdded(
+void FileManagerEventRouter::OnDiskAdded(
     const DiskMountManager::Disk* disk) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   VLOG(1) << "Disk added: " << disk->device_path();
   if (disk->device_path().empty()) {
     VLOG(1) << "Empty system path for " << disk->device_path();
     return;
   }
 
   // If disk is not mounted yet and it has media and there is no policy
   // forbidding external storage, give it a try.
   if (disk->mount_path().empty() && disk->has_media() &&
       !profile_->GetPrefs()->GetBoolean(prefs::kExternalStorageDisabled)) {
     // Initiate disk mount operation. MountPath auto-detects the filesystem
     // format if the second argument is empty. The third argument (mount label)
     // is not used in a disk mount operation.
     DiskMountManager::GetInstance()->MountPath(
         disk->device_path(), std::string(), std::string(),
         chromeos::MOUNT_TYPE_DEVICE);
   } else {
     // Either the disk was mounted or it has no media. In both cases we don't
     // want the Scanning notification to persist.
-    notifications_->HideNotification(FileBrowserNotifications::DEVICE,
+    notifications_->HideNotification(FileManagerNotifications::DEVICE,
                                      disk->system_path_prefix());
   }
 }
 
-void FileBrowserEventRouter::OnDiskRemoved(
+void FileManagerEventRouter::OnDiskRemoved(
     const DiskMountManager::Disk* disk) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   VLOG(1) << "Disk removed: " << disk->device_path();
 
   if (!disk->mount_path().empty()) {
     DiskMountManager::GetInstance()->UnmountPath(
         disk->mount_path(),
         chromeos::UNMOUNT_OPTIONS_LAZY,
         DiskMountManager::UnmountPathCallback());
   }
 }
 
-void FileBrowserEventRouter::OnDeviceAdded(
+void FileManagerEventRouter::OnDeviceAdded(
     const std::string& device_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   VLOG(1) << "Device added : " << device_path;
 
   // If the policy is set instead of showing the new device notification we show
   // a notification that the operation is not permitted.
   if (profile_->GetPrefs()->GetBoolean(prefs::kExternalStorageDisabled)) {
     notifications_->ShowNotification(
-        FileBrowserNotifications::DEVICE_EXTERNAL_STORAGE_DISABLED,
+        FileManagerNotifications::DEVICE_EXTERNAL_STORAGE_DISABLED,
         device_path);
     return;
   }
 
   notifications_->RegisterDevice(device_path);
-  notifications_->ShowNotificationDelayed(FileBrowserNotifications::DEVICE,
+  notifications_->ShowNotificationDelayed(FileManagerNotifications::DEVICE,
                                           device_path,
                                           base::TimeDelta::FromSeconds(5));
 }
 
-void FileBrowserEventRouter::OnDeviceRemoved(
+void FileManagerEventRouter::OnDeviceRemoved(
     const std::string& device_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   VLOG(1) << "Device removed : " << device_path;
-  notifications_->HideNotification(FileBrowserNotifications::DEVICE,
+  notifications_->HideNotification(FileManagerNotifications::DEVICE,
                                    device_path);
-  notifications_->HideNotification(FileBrowserNotifications::DEVICE_FAIL,
+  notifications_->HideNotification(FileManagerNotifications::DEVICE_FAIL,
                                    device_path);
   notifications_->UnregisterDevice(device_path);
 }
 
-void FileBrowserEventRouter::OnDeviceScanned(
+void FileManagerEventRouter::OnDeviceScanned(
     const std::string& device_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(1) << "Device scanned : " << device_path;
 }
 
-void FileBrowserEventRouter::OnFormatStarted(
+void FileManagerEventRouter::OnFormatStarted(
     const std::string& device_path, bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (success) {
-    notifications_->ShowNotification(FileBrowserNotifications::FORMAT_START,
+    notifications_->ShowNotification(FileManagerNotifications::FORMAT_START,
                                      device_path);
   } else {
     notifications_->ShowNotification(
-        FileBrowserNotifications::FORMAT_START_FAIL, device_path);
+        FileManagerNotifications::FORMAT_START_FAIL, device_path);
   }
 }
 
-void FileBrowserEventRouter::OnFormatCompleted(
+void FileManagerEventRouter::OnFormatCompleted(
     const std::string& device_path, bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (success) {
-    notifications_->HideNotification(FileBrowserNotifications::FORMAT_START,
+    notifications_->HideNotification(FileManagerNotifications::FORMAT_START,
                                      device_path);
-    notifications_->ShowNotification(FileBrowserNotifications::FORMAT_SUCCESS,
+    notifications_->ShowNotification(FileManagerNotifications::FORMAT_SUCCESS,
                                      device_path);
     // Hide it after a couple of seconds.
     notifications_->HideNotificationDelayed(
-        FileBrowserNotifications::FORMAT_SUCCESS,
+        FileManagerNotifications::FORMAT_SUCCESS,
         device_path,
         base::TimeDelta::FromSeconds(4));
     // MountPath auto-detects filesystem format if second argument is empty.
     // The third argument (mount label) is not used in a disk mount operation.
     DiskMountManager::GetInstance()->MountPath(device_path, std::string(),
                                                std::string(),
                                                chromeos::MOUNT_TYPE_DEVICE);
   } else {
-    notifications_->HideNotification(FileBrowserNotifications::FORMAT_START,
+    notifications_->HideNotification(FileManagerNotifications::FORMAT_START,
                                      device_path);
-    notifications_->ShowNotification(FileBrowserNotifications::FORMAT_FAIL,
+    notifications_->ShowNotification(FileManagerNotifications::FORMAT_FAIL,
                                      device_path);
   }
 }
 
-FileBrowserEventRouter::FileWatcherExtensions::FileWatcherExtensions(
+FileManagerEventRouter::FileWatcherExtensions::FileWatcherExtensions(
     const base::FilePath& virtual_path,
     const std::string& extension_id,
     bool is_remote_file_system)
     : file_watcher_(NULL),
       virtual_path_(virtual_path),
       ref_count_(0),
       is_remote_file_system_(is_remote_file_system),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   AddExtension(extension_id);
 }
 
-FileBrowserEventRouter::FileWatcherExtensions::~FileWatcherExtensions() {
+FileManagerEventRouter::FileWatcherExtensions::~FileWatcherExtensions() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   BrowserThread::DeleteSoon(BrowserThread::FILE, FROM_HERE, file_watcher_);
 }
 
-void FileBrowserEventRouter::FileWatcherExtensions::AddExtension(
+void FileManagerEventRouter::FileWatcherExtensions::AddExtension(
     const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ExtensionUsageRegistry::iterator it = extensions_.find(extension_id);
   if (it != extensions_.end()) {
     it->second++;
   } else {
     extensions_.insert(ExtensionUsageRegistry::value_type(extension_id, 1));
   }
 
   ref_count_++;
 }
 
-void FileBrowserEventRouter::FileWatcherExtensions::RemoveExtension(
+void FileManagerEventRouter::FileWatcherExtensions::RemoveExtension(
     const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ExtensionUsageRegistry::iterator it = extensions_.find(extension_id);
 
   if (it != extensions_.end()) {
     // If entry found - decrease it's count and remove if necessary
     if (0 == it->second--) {
       extensions_.erase(it);
     }
 
     ref_count_--;
   } else {
     // Might be reference counting problem - e.g. if some component of
     // extension subscribes/unsubscribes correctly, but other component
     // only unsubscribes, developer of first one might receive this message
     LOG(FATAL) << " Extension [" << extension_id
         << "] tries to unsubscribe from folder [" << local_path_.value()
         << "] it isn't subscribed";
   }
 }
 
-const FileBrowserEventRouter::ExtensionUsageRegistry&
-FileBrowserEventRouter::FileWatcherExtensions::GetExtensions() const {
+const FileManagerEventRouter::ExtensionUsageRegistry&
+FileManagerEventRouter::FileWatcherExtensions::GetExtensions() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return extensions_;
 }
 
 unsigned int
-FileBrowserEventRouter::FileWatcherExtensions::GetRefCount() const {
+FileManagerEventRouter::FileWatcherExtensions::GetRefCount() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return ref_count_;
 }
 
 const base::FilePath&
-FileBrowserEventRouter::FileWatcherExtensions::GetVirtualPath() const {
+FileManagerEventRouter::FileWatcherExtensions::GetVirtualPath() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return virtual_path_;
 }
 
 drive::DriveFileSystemInterface*
-FileBrowserEventRouter::GetRemoteFileSystem() const {
+FileManagerEventRouter::GetRemoteFileSystem() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DriveSystemService* system_service =
       DriveSystemServiceFactory::GetForProfile(profile_);
   return (system_service ? system_service->file_system() : NULL);
 }
 
-void FileBrowserEventRouter::FileWatcherExtensions::Watch(
+void FileManagerEventRouter::FileWatcherExtensions::Watch(
     const base::FilePath& local_path,
     const base::FilePathWatcher::Callback& file_watcher_callback,
     const BoolCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(!file_watcher_);
 
   local_path_ = local_path;  // For error message in RemoveExtension().
 
   if (is_remote_file_system_) {
     base::MessageLoopProxy::current()->PostTask(FROM_HERE,
                                                 base::Bind(callback, true));
     return;
   }
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&CreateAndStartFilePathWatcher,
                  local_path,
                  base::Bind(&RelayFileWatcherCallbackToUIThread,
                             file_watcher_callback)),
       base::Bind(
-          &FileBrowserEventRouter::FileWatcherExtensions::OnWatcherStarted,
+          &FileManagerEventRouter::FileWatcherExtensions::OnWatcherStarted,
           weak_ptr_factory_.GetWeakPtr(),
           callback));
 }
 
-void FileBrowserEventRouter::FileWatcherExtensions::OnWatcherStarted(
+void FileManagerEventRouter::FileWatcherExtensions::OnWatcherStarted(
     const BoolCallback& callback,
     base::FilePathWatcher* file_watcher) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (file_watcher) {
     file_watcher_ = file_watcher;
     callback.Run(true);
   } else {
     callback.Run(false);
   }
 }