Files.app: Start to use DeviceEventRouter.

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"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
 #include "chrome/browser/chromeos/drive/file_change.h"
 #include "chrome/browser/chromeos/drive/file_system_interface.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
+#include "chrome/browser/chromeos/extensions/file_manager/device_event_router.h"
 #include "chrome/browser/chromeos/extensions/file_manager/private_api_util.h"
 #include "chrome/browser/chromeos/file_manager/app_id.h"
 #include "chrome/browser/chromeos/file_manager/fileapi_util.h"
 #include "chrome/browser/chromeos/file_manager/open_util.h"
 #include "chrome/browser/chromeos/file_manager/volume_manager.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
 #include "chrome/browser/drive/drive_service_interface.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_prefs.h"
@@ skipping 233 matching lines @@
     return false;
   } else {
     *last_time = now;
     return true;
   }
 }
 
 // Obtains whether the Files.app should handle the volume or not.
 bool ShouldShowNotificationForVolume(
     Profile* profile,
-    file_browser_private::MountCompletedEventType event_type,
-    chromeos::MountError error,
-    const VolumeInfo& volume_info,
-    bool is_remounting) {
-  if (event_type != file_browser_private::MOUNT_COMPLETED_EVENT_TYPE_MOUNT)
-    return false;
-
+    const DeviceEventRouter& device_event_router,
+    const VolumeInfo& volume_info) {
   if (volume_info.type != VOLUME_TYPE_MTP &&
       volume_info.type != VOLUME_TYPE_REMOVABLE_DISK_PARTITION) {
     return false;
   }
 
-  if (error != chromeos::MOUNT_ERROR_NONE)
-    return false;
-
-  if (is_remounting)
+  if (device_event_router.is_resuming() || device_event_router.is_starting_up())
     return false;
 
   // Do not attempt to open File Manager while the login is in progress or
   // the screen is locked or running in kiosk app mode and make sure the file
   // manager is opened only for the active user.
   if (chromeos::LoginDisplayHostImpl::default_host() ||
       chromeos::ScreenLocker::default_screen_locker() ||
       chrome::IsRunningInForcedAppMode() ||
       profile != ProfileManager::GetActiveUserProfile()) {
     return false;
   }
 
   // Do not pop-up the File Manager, if the recovery tool is running.
   if (IsRecoveryToolRunning(profile))
     return false;
 
   // If the disable-default-apps flag is on, Files.app is not opened
   // automatically on device mount not to obstruct the manual test.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableDefaultApps)) {
     return false;
   }
 
   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,
+                             const std::string& device_path) OVERRIDE {
+    file_browser_private::DeviceEvent event;

[mtomasz, 2014/08/25 07:48:23]

nit: How about adding a DCHECK if we are on the UI thread?

[hirono, 2014/08/26 01:06:45]

Done.

+    event.type = type;
+    event.device_path = device_path;
+
+    BroadcastEvent(profile_,
+                   file_browser_private::OnDeviceChanged::kEventName,
+                   file_browser_private::OnDeviceChanged::Create(event));
+  }
+
+  // DeviceEventRouter overrides.
+  virtual bool IsExternalStorageDisabled() OVERRIDE {
+    return profile_->GetPrefs()->GetBoolean(prefs::kExternalStorageDisabled);

[mtomasz, 2014/08/25 07:48:23]

nit: ditto

[hirono, 2014/08/26 01:06:45]

Done.

+  }
+
+ private:
+  Profile* const profile_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeviceEventRouterImpl);
+};
+
 }  // namespace
 
 // Pass dummy value to JobInfo's constructor for make it default constructible.
 EventRouter::DriveJobInfoWithStatus::DriveJobInfoWithStatus()
     : job_info(drive::TYPE_DOWNLOAD_FILE) {
 }
 
 EventRouter::DriveJobInfoWithStatus::DriveJobInfoWithStatus(
     const drive::JobInfo& info, const std::string& status)
     : job_info(info), status(status) {
 }
 
 EventRouter::EventRouter(Profile* profile)
     : pref_change_registrar_(new PrefChangeRegistrar),
       profile_(profile),
       multi_user_window_manager_observer_registered_(false),
+      device_event_router_(new DeviceEventRouterImpl(profile)),
       weak_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 EventRouter::~EventRouter() {
 }
 
 void EventRouter::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;
   }
 
   pref_change_registrar_->RemoveAll();
 
   if (NetworkHandler::IsInitialized()) {
     NetworkHandler::Get()->network_state_handler()->RemoveObserver(this,
                                                                    FROM_HERE);
   }
 
-  DriveIntegrationService* integration_service =
+  DriveIntegrationService* const integration_service =
       DriveIntegrationServiceFactory::FindForProfile(profile_);
   if (integration_service) {
     integration_service->file_system()->RemoveObserver(this);
     integration_service->drive_service()->RemoveObserver(this);
     integration_service->job_list()->RemoveObserver(this);
   }
 
-  VolumeManager* volume_manager = VolumeManager::Get(profile_);
-  if (volume_manager)
+  VolumeManager* const volume_manager = VolumeManager::Get(profile_);
+  if (volume_manager) {
     volume_manager->RemoveObserver(this);
+    volume_manager->RemoveObserver(device_event_router_.get());
+  }
+
+  chromeos::PowerManagerClient* const power_manager_client =
+      chromeos::DBusThreadManager::Get()->GetPowerManagerClient();
+  power_manager_client->RemoveObserver(device_event_router_.get());
 
   chrome::MultiUserWindowManager* const multi_user_window_manager =
       chrome::MultiUserWindowManager::GetInstance();
   if (multi_user_window_manager &&
       multi_user_window_manager_observer_registered_) {
     multi_user_window_manager_observer_registered_ = false;
     multi_user_window_manager->RemoveObserver(this);
   }
 
   profile_ = NULL;
 }
 
 void EventRouter::ObserveEvents() {
   if (!profile_) {
     NOTREACHED();
     return;
   }
   if (!chromeos::LoginState::IsInitialized() ||
       !chromeos::LoginState::Get()->IsUserLoggedIn()) {
     return;
   }
 
+  // Ignore device events for the first few seconds.
+  device_event_router_->Startup();
+
   // VolumeManager's construction triggers DriveIntegrationService's
   // construction, so it is necessary to call VolumeManager's Get before
   // accessing DriveIntegrationService.
-  VolumeManager* volume_manager = VolumeManager::Get(profile_);
-  if (volume_manager)
+  VolumeManager* const volume_manager = VolumeManager::Get(profile_);
+  if (volume_manager) {
     volume_manager->AddObserver(this);
+    volume_manager->AddObserver(device_event_router_.get());
+  }
 
-  DriveIntegrationService* integration_service =
+  chromeos::PowerManagerClient* const power_manager_client =
+      chromeos::DBusThreadManager::Get()->GetPowerManagerClient();
+  power_manager_client->AddObserver(device_event_router_.get());
+
+  DriveIntegrationService* const integration_service =
       DriveIntegrationServiceFactory::FindForProfile(profile_);
   if (integration_service) {
     integration_service->drive_service()->AddObserver(this);
     integration_service->file_system()->AddObserver(this);
     integration_service->job_list()->AddObserver(this);
   }
 
   if (NetworkHandler::IsInitialized()) {
     NetworkHandler::Get()->network_state_handler()->AddObserver(this,
                                                                 FROM_HERE);
@@ skipping 394 matching lines @@
   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));
 }
 
-void EventRouter::DispatchDeviceEvent(
-    file_browser_private::DeviceEventType type,
-    const std::string& device_path) {
-  file_browser_private::DeviceEvent event;
-
-  event.type = type;
-  event.device_path = device_path;
-  BroadcastEvent(profile_,
-                 file_browser_private::OnDeviceChanged::kEventName,
-                 file_browser_private::OnDeviceChanged::Create(event));
-}
-
 void EventRouter::OnDiskAdded(
     const DiskMountManager::Disk& disk, bool mounting) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (!mounting) {
-    // If the disk is not being mounted, we don't want the Scanning
-    // notification to persist.
-    DispatchDeviceEvent(
-        file_browser_private::DEVICE_EVENT_TYPE_SCAN_CANCELED,
-        disk.system_path_prefix());
-  }
+  // Do nothing.
 }
 
 void EventRouter::OnDiskRemoved(const DiskMountManager::Disk& disk) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Do nothing.
 }
 
 void EventRouter::OnDeviceAdded(const std::string& device_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  // 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)) {
-    DispatchDeviceEvent(
-        file_browser_private::DEVICE_EVENT_TYPE_DISABLED,
-        device_path);
-    return;
-  }
-
-  DispatchDeviceEvent(
-      file_browser_private::DEVICE_EVENT_TYPE_ADDED,
-      device_path);
+  // Do nothing.
 }
 
 void EventRouter::OnDeviceRemoved(const std::string& device_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DispatchDeviceEvent(
-      file_browser_private::DEVICE_EVENT_TYPE_REMOVED,
-      device_path);
+  // Do nothing.
 }
 
 void EventRouter::OnVolumeMounted(chromeos::MountError error_code,
                                   const VolumeInfo& volume_info,
                                   bool is_remounting) {
   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,
       error_code,
-      volume_info,
-      is_remounting);
+      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,
       error_code,
-      volume_info,
-      false);
-}
-
-void EventRouter::OnHardUnplugged(const std::string& device_path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DispatchDeviceEvent(file_browser_private::DEVICE_EVENT_TYPE_HARD_UNPLUGGED,
-                      device_path);
+      volume_info);
 }
 
 void EventRouter::DispatchMountCompletedEvent(
     file_browser_private::MountCompletedEventType event_type,
     chromeos::MountError error,
-    const VolumeInfo& volume_info,
-    bool is_remounting) {
+    const VolumeInfo& volume_info) {
   // Build an event object.
   file_browser_private::MountCompletedEvent event;
   event.event_type = event_type;
   event.status = MountErrorToMountCompletedStatus(error);
   util::VolumeInfoToVolumeMetadata(
       profile_, volume_info, &event.volume_metadata);
-  event.is_remounting = is_remounting;
   event.should_notify = ShouldShowNotificationForVolume(
-      profile_, event_type, error, volume_info, is_remounting);
+      profile_, *device_event_router_, volume_info);
   BroadcastEvent(profile_,
                  file_browser_private::OnMountCompleted::kEventName,
                  file_browser_private::OnMountCompleted::Create(event));
 }
 
 void EventRouter::OnFormatStarted(const std::string& device_path,
                                   bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (success) {
-    DispatchDeviceEvent(file_browser_private::DEVICE_EVENT_TYPE_FORMAT_START,
-                        device_path);
-  } else {
-    DispatchDeviceEvent(file_browser_private::DEVICE_EVENT_TYPE_FORMAT_FAIL,
-                        device_path);
-  }
+  // Do nothing.
 }
 
 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);
+  // Do nothing.
 }
 
 void EventRouter::Observe(int type,
                           const content::NotificationSource& source,
                           const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_PROFILE_ADDED) {
     Profile* const added_profile = content::Source<Profile>(source).ptr();
     if (!added_profile->IsOffTheRecord())
       GrantAccessForAddedProfileToRunningInstance(added_profile, profile_);
 
@@ skipping 14 matching lines @@
   }
 }
 
 void EventRouter::OnOwnerEntryChanged(aura::Window* window) {
   BroadcastEvent(profile_,
                  file_browser_private::OnDesktopChanged::kEventName,
                  file_browser_private::OnDesktopChanged::Create());
 }
 
 }  // namespace file_manager