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)
+      : DeviceEventRouter(base::TimeDelta::FromSeconds(0)), profile_(profile) {}

[mtomasz, 2014/08/25 04:37:37]

Shall 0 be passed here?

[hirono, 2014/08/25 06:40:57]

No, it's a bug. Thank you for catching.

+
+  // Overrides

[mtomasz, 2014/08/25 04:37:37]

nit: ... -> DeviceEventRouter overrides. for consistency?

[hirono, 2014/08/25 06:40:57]

Done.

+  virtual void OnDeviceEvent(file_browser_private::DeviceEventType type,
+                             const std::string& device_path) OVERRIDE {
+    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));
+  }
+
+  // Overrides
+  virtual bool IsExternalStorageDisabled() OVERRIDE {
+    return profile_->GetPrefs()->GetBoolean(prefs::kExternalStorageDisabled);
+  }
+
+ private:
+  Profile* const profile_;

[mtomasz, 2014/08/25 04:37:36]

How about: DISALLOW_COPY_AND_ASSIGN?

[hirono, 2014/08/25 06:40:57]

Done.

+};
+
 }  // 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);

[mtomasz, 2014/08/25 04:37:36]

Does EventRouter need to observe VolumeManager? Most (or all) observer's methods
seem to be empty. WDYT?

[hirono, 2014/08/25 06:40:57]

EventRouter needs to observe VolumeManager to catch mount events. Thus the mount
events are dispatched for other than devices (e.g. drive, zip), I'd like to keep
the handler in EventRouter, not in DeviceEventRouter.

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

SGTM.

+    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