Small refactoring in DiskMountManager (event reporting; format method).

chrome/browser/chromeos/extensions/file_browser_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 "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
 #include "base/prefs/public/pref_change_registrar.h"
@@ skipping 18 matching lines @@
 #include "chrome/browser/profiles/profile_dependency_manager.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_source.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 
 using chromeos::disks::DiskMountManager;
-using chromeos::disks::DiskMountManagerEventType;
 using content::BrowserThread;
 using drive::DriveSystemService;
 using drive::DriveSystemServiceFactory;
 
 namespace {
   const char kDiskAddedEventType[] = "added";
   const char kDiskRemovedEventType[] = "removed";
 
   const char kPathChanged[] = "changed";
   const char kPathWatchError[] = "error";
@@ skipping 208 matching lines @@
 
   // 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_GDATA,
       chromeos::disks::MOUNT_CONDITION_NONE);
 
   // Raise mount event.
-  MountCompleted(DiskMountManager::MOUNTING, error_code, mount_info);
+  OnMountEvent(DiskMountManager::MOUNTING, error_code, mount_info);
 
   if (!callback.is_null())
     callback.Run();
 }
 
 void FileBrowserEventRouter::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::DiskChanged(
-    DiskMountManagerEventType event,
+void FileBrowserEventRouter::OnDiskEvent(
+    DiskMountManager::DiskEvent event,
     const DiskMountManager::Disk* disk) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Disregard hidden devices.
   if (disk->is_hidden())
     return;
-  if (event == chromeos::disks::MOUNT_DISK_ADDED) {
+  if (event == DiskMountManager::DISK_ADDED) {
     OnDiskAdded(disk);
-  } else if (event == chromeos::disks::MOUNT_DISK_REMOVED) {
+  } else if (event == DiskMountManager::DISK_REMOVED) {
     OnDiskRemoved(disk);
   }
 }
 
-void FileBrowserEventRouter::DeviceChanged(
-    DiskMountManagerEventType event,
+void FileBrowserEventRouter::OnDeviceEvent(
+    DiskMountManager::DeviceEvent event,
     const std::string& device_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (event == chromeos::disks::MOUNT_DEVICE_ADDED) {
+  if (event == DiskMountManager::DEVICE_ADDED) {
     OnDeviceAdded(device_path);
-  } else if (event == chromeos::disks::MOUNT_DEVICE_REMOVED) {
+  } else if (event == DiskMountManager::DEVICE_REMOVED) {
     OnDeviceRemoved(device_path);
-  } else if (event == chromeos::disks::MOUNT_DEVICE_SCANNED) {
+  } else if (event == DiskMountManager::DEVICE_SCANNED) {
     OnDeviceScanned(device_path);
-  } else if (event == chromeos::disks::MOUNT_FORMATTING_STARTED) {
-  // TODO(tbarzic): get rid of '!'.
-    if (device_path[0] == '!') {
-      OnFormattingStarted(device_path.substr(1), false);
-    } else {
-      OnFormattingStarted(device_path, true);
-    }
-  } else if (event == chromeos::disks::MOUNT_FORMATTING_FINISHED) {
-    if (device_path[0] == '!') {
-      OnFormattingFinished(device_path.substr(1), false);
-    } else {
-      OnFormattingFinished(device_path, true);
-    }
   }
 }
 
-void FileBrowserEventRouter::MountCompleted(
-    DiskMountManager::MountEvent event_type,
+void FileBrowserEventRouter::OnMountEvent(
+    DiskMountManager::MountEvent event,
     chromeos::MountError error_code,
     const DiskMountManager::MountPointInfo& mount_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  DispatchMountCompletedEvent(event_type, error_code, mount_info);
+  DispatchMountEvent(event, error_code, mount_info);
 
   if (mount_info.mount_type == chromeos::MOUNT_TYPE_DEVICE &&
-      event_type == DiskMountManager::MOUNTING) {
+      event == DiskMountManager::MOUNTING) {
     DiskMountManager* disk_mount_manager = DiskMountManager::GetInstance();
     const DiskMountManager::Disk* disk =
         disk_mount_manager->FindDiskBySourcePath(mount_info.source_path);
     if (!disk)
       return;
 
     notifications_->ManageNotificationsOnMountCompleted(
         disk->system_path_prefix(), disk->drive_label(), disk->is_parent(),
         error_code == chromeos::MOUNT_ERROR_NONE,
         error_code == chromeos::MOUNT_ERROR_UNSUPPORTED_FILESYSTEM);
   } else if (mount_info.mount_type == chromeos::MOUNT_TYPE_ARCHIVE) {
     // Clear the "mounted" state for archive files in gdata cache
     // when mounting failed or unmounting succeeded.
-    if ((event_type == DiskMountManager::MOUNTING) !=
+    if ((event == DiskMountManager::MOUNTING) !=
         (error_code == chromeos::MOUNT_ERROR_NONE)) {
       FilePath source_path(mount_info.source_path);
       DriveSystemService* system_service =
           DriveSystemServiceFactory::GetForProfile(profile_);
       drive::DriveCache* cache =
           system_service ? system_service->cache() : NULL;
       if (cache) {
         cache->SetMountedState(
             source_path, false, drive::GetFileFromCacheCallback());
       }
     }
   }
 }
 
+void FileBrowserEventRouter::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::OnNetworkManagerChanged(
     chromeos::NetworkLibrary* network_library) {
   if (!profile_ ||
       !extensions::ExtensionSystem::Get(profile_)->event_router()) {
     NOTREACHED();
     return;
   }
   extensions::ExtensionSystem::Get(profile_)->event_router()->
       DispatchEventToRenderers(
           extensions::event_names::kOnFileBrowserNetworkConnectionChanged,
@@ skipping 76 matching lines @@
 
 void FileBrowserEventRouter::OnFileSystemMounted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   MountDrive(base::Bind(&base::DoNothing));  // Callback does nothing.
 }
 
 void FileBrowserEventRouter::OnFileSystemBeingUnmounted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  // Raise a MountCompleted event to notify the File Manager.
+  // 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_GDATA,
       chromeos::disks::MOUNT_CONDITION_NONE);
-  MountCompleted(DiskMountManager::UNMOUNTING, chromeos::MOUNT_ERROR_NONE,
-                 mount_info);
+  OnMountEvent(DiskMountManager::UNMOUNTING, chromeos::MOUNT_ERROR_NONE,
+               mount_info);
 }
 
 void FileBrowserEventRouter::OnAuthenticationFailed(
     google_apis::GDataErrorCode error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error == google_apis::GDATA_NO_CONNECTION)
     return;
 
-  // Raise a MountCompleted event to notify the File Manager.
+  // 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_GDATA,
       chromeos::disks::MOUNT_CONDITION_NONE);
-  MountCompleted(DiskMountManager::UNMOUNTING, chromeos::MOUNT_ERROR_NONE,
-                 mount_info);
+  OnMountEvent(DiskMountManager::UNMOUNTING, chromeos::MOUNT_ERROR_NONE,
+               mount_info);
 }
 
 void FileBrowserEventRouter::HandleFileWatchNotification(
     const FilePath& local_path, bool got_error) {
   base::AutoLock lock(lock_);
   WatcherMap::const_iterator iter = file_watchers_.find(local_path);
   if (iter == file_watchers_.end()) {
     return;
   }
   DispatchDirectoryChangeEvent(iter->second->GetVirtualPath(), got_error,
@@ skipping 52 matching lines @@
                         added ? kDiskAddedEventType : kDiskRemovedEventType);
   DictionaryValue* disk_info = DiskToDictionaryValue(disk);
   mount_info->Set("volumeInfo", disk_info);
 
   extensions::ExtensionSystem::Get(profile_)->event_router()->
       DispatchEventToRenderers(
           extensions::event_names::kOnFileBrowserDiskChanged, args.Pass(), NULL,
           GURL());
 }
 
-void FileBrowserEventRouter::DispatchMountCompletedEvent(
+void FileBrowserEventRouter::DispatchMountEvent(
     DiskMountManager::MountEvent event,
     chromeos::MountError error_code,
     const DiskMountManager::MountPointInfo& mount_info) {
   // profile_ is NULL if ShutdownOnUIThread() is called earlier. This can
   // happen at shutdown.
   if (!profile_)
     return;
 
   if (mount_info.mount_type == chromeos::MOUNT_TYPE_INVALID) {
     NOTREACHED();
@@ skipping 132 matching lines @@
                                    device_path);
   notifications_->UnregisterDevice(device_path);
 }
 
 void FileBrowserEventRouter::OnDeviceScanned(
     const std::string& device_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(1) << "Device scanned : " << device_path;
 }
 
-void FileBrowserEventRouter::OnFormattingStarted(
+void FileBrowserEventRouter::OnFormatStarted(
     const std::string& device_path, bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (success) {
     notifications_->ShowNotification(FileBrowserNotifications::FORMAT_START,
                                      device_path);
   } else {
     notifications_->ShowNotification(
         FileBrowserNotifications::FORMAT_START_FAIL, device_path);
   }
 }
 
-void FileBrowserEventRouter::OnFormattingFinished(
+void FileBrowserEventRouter::OnFormatCompleted(
     const std::string& device_path, bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (success) {
     notifications_->HideNotification(FileBrowserNotifications::FORMAT_START,
                                      device_path);
     notifications_->ShowNotification(FileBrowserNotifications::FORMAT_SUCCESS,
                                      device_path);
     // Hide it after a couple of seconds.
     notifications_->HideNotificationDelayed(
@@ skipping 147 matching lines @@
   return scoped_refptr<RefcountedProfileKeyedService>(
       new FileBrowserEventRouter(profile));
 }
 
 bool FileBrowserEventRouterFactory::ServiceHasOwnInstanceInIncognito() const {
   // Explicitly and always allow this router in guest login mode.   see
   // chrome/browser/profiles/profile_keyed_base_factory.h comment
   // for the details.
   return true;
 }