src/chrome/browser/extensions/api/media_galleries_private/gallery_watch_manager.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4 //
   5 // GalleryWatchManager implementation.
   6
   7 #include "chrome/browser/extensions/api/media_galleries_private/gallery_watch_manager.h"
   8
   9 #include <list>
  10 #include <set>
  11
  12 #include "base/bind.h"
  13 #include "base/callback.h"
  14 #include "base/compiler_specific.h"
  15 #include "base/files/file_path_watcher.h"
  16 #include "base/location.h"
  17 #include "base/memory/ref_counted.h"
  18 #include "base/stl_util.h"
  19 #include "base/time/time.h"
  20 #include "chrome/browser/extensions/api/media_galleries_private/media_galleries_private_event_router.h"
  21 #include "content/public/browser/browser_thread.h"
  22
  23 namespace extensions {
  24
  25 namespace {
  26
  27 using content::BrowserThread;
  28
  29 // Map to keep track of profile specific GalleryWatchManager objects.
  30 // Key: Profile identifier.
  31 // Value: GalleryWatchManager*.
  32 // This map owns the GalleryWatchManager object.
  33 typedef std::map<void*, extensions::GalleryWatchManager*> WatchManagerMap;
  34 WatchManagerMap* g_gallery_watch_managers = NULL;
  35
  36 // Dispatches the gallery changed event on the UI thread.
  37 void SendGalleryChangedEventOnUIThread(
  38     base::WeakPtr<MediaGalleriesPrivateEventRouter> event_router,
  39     MediaGalleryPrefId gallery_id,
  40     const std::set<std::string>& extension_ids) {
  41   DCHECK_CURRENTLY_ON(BrowserThread::UI);
  42   if (event_router.get())
  43     event_router->OnGalleryChanged(gallery_id, extension_ids);
  44 }
  45
  46 }  // namespace
  47
  48 ///////////////////////////////////////////////////////////////////////////////
  49 //            GalleryWatchManager::GalleryFilePathWatcher                    //
  50 ///////////////////////////////////////////////////////////////////////////////
  51
  52 // This class does a recursive watch on the gallery file path and holds a list
  53 // of extensions that are watching the gallery. When there is a file system
  54 // activity within the gallery, GalleryFilePathWatcher notifies the interested
  55 // extensions. This class lives on the file thread.
  56 class GalleryWatchManager::GalleryFilePathWatcher
  57     : public base::RefCounted<GalleryFilePathWatcher> {
  58  public:
  59   // |on_destroyed_callback| is called when the last GalleryFilePathWatcher
  60   // reference goes away.
  61   GalleryFilePathWatcher(
  62       base::WeakPtr<MediaGalleriesPrivateEventRouter> event_router,
  63       MediaGalleryPrefId gallery_id,
  64       const base::FilePath& path,
  65       const std::string& extension_id,
  66       const base::Closure& on_destroyed_callback);
  67
  68   // Adds the extension reference to the watched gallery.
  69   void AddExtension(const std::string& extension_id);
  70
  71   // Removes the extension reference to the watched gallery.
  72   void RemoveExtension(const std::string& extension_id);
  73
  74   // Handles the extension unloaded/uninstalled event.
  75   void OnExtensionUnloaded(const std::string& extension_id);
  76
  77   // Sets up the watch operation for the specified |gallery_path_|. On
  78   // success, returns true.
  79   bool SetupWatch();
  80
  81   // Removes all the extension references when the browser profile is in
  82   // shutdown mode.
  83   void RemoveAllWatchReferences();
  84
  85  private:
  86   friend class base::RefCounted<GalleryFilePathWatcher>;
  87
  88   // Key: Extension identifier, e.g "qoueruoweuroiwueroiwujkshdf".
  89   // Value: Time at which the last gallery changed event is dispatched.
  90   //        Initialized to null Time value.
  91   typedef std::map<std::string, base::Time> ExtensionWatchInfoMap;
  92
  93   // Private because GalleryFilePathWatcher is ref-counted.
  94   virtual ~GalleryFilePathWatcher();
  95
  96   // FilePathWatcher callback.
  97   void OnFilePathChanged(const base::FilePath& path, bool error);
  98
  99   // Remove the watch references for the extension specified by the
 100   // |extension_id|.
 101   void RemoveExtensionReferences(const std::string& extension_id);
 102
 103   // Used to notify the interested extensions about the gallery changed event.
 104   base::WeakPtr<MediaGalleriesPrivateEventRouter> event_router_;
 105
 106   // The gallery identifier, e.g "1".
 107   MediaGalleryPrefId gallery_id_;
 108
 109   // The gallery file path watcher.
 110   base::FilePathWatcher file_watcher_;
 111
 112   // The gallery file path, e.g "C:\My Pictures".
 113   base::FilePath gallery_path_;
 114
 115   // A callback to call when |this| object is destroyed.
 116   base::Closure on_destroyed_callback_;
 117
 118   // Map to keep track of the extension and its corresponding watch count.
 119   ExtensionWatchInfoMap extension_watch_info_map_;
 120
 121   // Used to provide a weak pointer to FilePathWatcher callback.
 122   base::WeakPtrFactory<GalleryFilePathWatcher> weak_ptr_factory_;
 123
 124   DISALLOW_COPY_AND_ASSIGN(GalleryFilePathWatcher);
 125 };
 126
 127 GalleryWatchManager::GalleryFilePathWatcher::GalleryFilePathWatcher(
 128     base::WeakPtr<MediaGalleriesPrivateEventRouter> event_router,
 129     MediaGalleryPrefId gallery_id,
 130     const base::FilePath& path,
 131     const std::string& extension_id,
 132     const base::Closure& on_destroyed_callback)
 133     : event_router_(event_router),
 134       gallery_id_(gallery_id),
 135       on_destroyed_callback_(on_destroyed_callback),
 136       weak_ptr_factory_(this) {
 137   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 138   gallery_path_ = path;
 139   AddExtension(extension_id);
 140 }
 141
 142 void GalleryWatchManager::GalleryFilePathWatcher::AddExtension(
 143     const std::string& extension_id) {
 144   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 145   if (ContainsKey(extension_watch_info_map_, extension_id))
 146     return;
 147   extension_watch_info_map_[extension_id] = base::Time();
 148   AddRef();
 149 }
 150
 151 void GalleryWatchManager::GalleryFilePathWatcher::RemoveExtension(
 152     const std::string& extension_id) {
 153   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 154   if (extension_watch_info_map_.erase(extension_id) == 1)
 155     Release();
 156 }
 157
 158 void GalleryWatchManager::GalleryFilePathWatcher::OnExtensionUnloaded(
 159     const std::string& extension_id) {
 160   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 161   RemoveExtensionReferences(extension_id);
 162 }
 163
 164 bool GalleryWatchManager::GalleryFilePathWatcher::SetupWatch() {
 165   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 166   return file_watcher_.Watch(
 167       gallery_path_, true,
 168       base::Bind(&GalleryFilePathWatcher::OnFilePathChanged,
 169                  weak_ptr_factory_.GetWeakPtr()));
 170 }
 171
 172 void GalleryWatchManager::GalleryFilePathWatcher::RemoveAllWatchReferences() {
 173   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 174   std::set<std::string> extension_ids;
 175   for (ExtensionWatchInfoMap::iterator iter = extension_watch_info_map_.begin();
 176        iter != extension_watch_info_map_.end(); ++iter)
 177     extension_ids.insert(iter->first);
 178
 179   for (std::set<std::string>::const_iterator it = extension_ids.begin();
 180        it != extension_ids.end(); ++it)
 181     RemoveExtensionReferences(*it);
 182 }
 183
 184 GalleryWatchManager::GalleryFilePathWatcher::~GalleryFilePathWatcher() {
 185   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 186   on_destroyed_callback_.Run();
 187 }
 188
 189 void GalleryWatchManager::GalleryFilePathWatcher::OnFilePathChanged(
 190     const base::FilePath& path,
 191     bool error) {
 192   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 193   if (error || (path != gallery_path_))
 194     return;
 195
 196   std::set<std::string> extension_ids;
 197   for (ExtensionWatchInfoMap::iterator iter = extension_watch_info_map_.begin();
 198        iter != extension_watch_info_map_.end(); ++iter) {
 199     if (!iter->second.is_null()) {
 200       // Ignore gallery change event if it is received too frequently.
 201       // For example, when an user copies/deletes 1000 media files from a
 202       // gallery, this callback is called 1000 times within a span of 10ms.
 203       // GalleryWatchManager should not send 1000 gallery changed events to
 204       // the watching extension.
 205       const int kMinSecondsToIgnoreGalleryChangedEvent = 3;
 206       base::TimeDelta diff = base::Time::Now() - iter->second;
 207       if (diff.InSeconds() < kMinSecondsToIgnoreGalleryChangedEvent)
 208         continue;
 209     }
 210     iter->second = base::Time::Now();
 211     extension_ids.insert(iter->first);
 212   }
 213   if (!extension_ids.empty()) {
 214     content::BrowserThread::PostTask(
 215         content::BrowserThread::UI, FROM_HERE,
 216         base::Bind(SendGalleryChangedEventOnUIThread, event_router_,
 217                    gallery_id_, extension_ids));
 218   }
 219 }
 220
 221 void GalleryWatchManager::GalleryFilePathWatcher::RemoveExtensionReferences(
 222     const std::string& extension_id) {
 223   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 224   ExtensionWatchInfoMap::iterator it =
 225       extension_watch_info_map_.find(extension_id);
 226   if (it == extension_watch_info_map_.end())
 227     return;
 228   extension_watch_info_map_.erase(it);
 229   Release();
 230 }
 231
 232 ///////////////////////////////////////////////////////////////////////////////
 233 //                       GalleryWatchManager                                 //
 234 ///////////////////////////////////////////////////////////////////////////////
 235
 236 // static
 237 GalleryWatchManager* GalleryWatchManager::GetForProfile(
 238     void* profile_id) {
 239   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 240   DCHECK(profile_id);
 241   bool has_watch_manager = (g_gallery_watch_managers &&
 242                             GalleryWatchManager::HasForProfile(profile_id));
 243   if (!g_gallery_watch_managers)
 244     g_gallery_watch_managers = new WatchManagerMap;
 245   if (!has_watch_manager)
 246     (*g_gallery_watch_managers)[profile_id] = new GalleryWatchManager;
 247   return (*g_gallery_watch_managers)[profile_id];
 248 }
 249
 250 // static
 251 bool GalleryWatchManager::HasForProfile(void* profile_id) {
 252   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 253   DCHECK(profile_id);
 254   if (!g_gallery_watch_managers)
 255     return false;
 256   WatchManagerMap::const_iterator it =
 257       g_gallery_watch_managers->find(profile_id);
 258   return (it != g_gallery_watch_managers->end());
 259 }
 260
 261 // static
 262 void GalleryWatchManager::OnProfileShutdown(void* profile_id) {
 263   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 264   DCHECK(profile_id);
 265   if (!g_gallery_watch_managers || g_gallery_watch_managers->empty())
 266     return;
 267   WatchManagerMap::iterator it = g_gallery_watch_managers->find(profile_id);
 268   if (it == g_gallery_watch_managers->end())
 269     return;
 270   delete it->second;
 271   g_gallery_watch_managers->erase(it);
 272   if (g_gallery_watch_managers->empty()) {
 273     delete g_gallery_watch_managers;
 274     g_gallery_watch_managers = NULL;
 275   }
 276 }
 277
 278 // static
 279 bool GalleryWatchManager::SetupGalleryWatch(
 280     void* profile_id,
 281     MediaGalleryPrefId gallery_id,
 282     const base::FilePath& watch_path,
 283     const std::string& extension_id,
 284     base::WeakPtr<MediaGalleriesPrivateEventRouter> event_router) {
 285   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 286   return GalleryWatchManager::GetForProfile(profile_id)->StartGalleryWatch(
 287       gallery_id, watch_path, extension_id, event_router);
 288 }
 289
 290 // static
 291 void GalleryWatchManager::RemoveGalleryWatch(void* profile_id,
 292                                              const base::FilePath& watch_path,
 293                                              const std::string& extension_id) {
 294   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 295   if (!GalleryWatchManager::HasForProfile(profile_id))
 296     return;
 297   GalleryWatchManager::GetForProfile(profile_id)->StopGalleryWatch(
 298       watch_path, extension_id);
 299 }
 300
 301 void GalleryWatchManager::OnExtensionUnloaded(void* profile_id,
 302                                               const std::string& extension_id) {
 303   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 304   if (!GalleryWatchManager::HasForProfile(profile_id))
 305     return;
 306   GalleryWatchManager::GetForProfile(profile_id)->HandleExtensionUnloadedEvent(
 307       extension_id);
 308 }
 309
 310 GalleryWatchManager::GalleryWatchManager() {
 311   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 312 }
 313
 314 GalleryWatchManager::~GalleryWatchManager() {
 315   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 316   DeleteAllWatchers();
 317 }
 318
 319 bool GalleryWatchManager::StartGalleryWatch(
 320     MediaGalleryPrefId gallery_id,
 321     const base::FilePath& watch_path,
 322     const std::string& extension_id,
 323     base::WeakPtr<MediaGalleriesPrivateEventRouter> event_router) {
 324   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 325   WatcherMap::const_iterator iter = gallery_watchers_.find(watch_path);
 326   if (iter != gallery_watchers_.end()) {
 327     // Already watched.
 328     iter->second->AddExtension(extension_id);
 329     return true;
 330   }
 331
 332   // Need to add a new watcher.
 333   scoped_refptr<GalleryFilePathWatcher> watch(
 334       new GalleryFilePathWatcher(
 335           event_router, gallery_id, watch_path, extension_id,
 336           base::Bind(&GalleryWatchManager::RemoveGalleryFilePathWatcherEntry,
 337                      base::Unretained(this),
 338                      watch_path)));
 339   if (!watch->SetupWatch())
 340     return false;
 341   gallery_watchers_[watch_path] = watch.get();
 342   return true;
 343 }
 344
 345 void GalleryWatchManager::StopGalleryWatch(
 346     const base::FilePath& watch_path,
 347     const std::string& extension_id) {
 348   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 349   WatcherMap::iterator iter = gallery_watchers_.find(watch_path);
 350   if (iter == gallery_watchers_.end())
 351     return;
 352   // Remove the renderer process for this watch.
 353   iter->second->RemoveExtension(extension_id);
 354 }
 355
 356 void GalleryWatchManager::HandleExtensionUnloadedEvent(
 357     const std::string& extension_id) {
 358   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 359   std::list<base::FilePath> watchers_to_notify;
 360   for (WatcherMap::iterator iter = gallery_watchers_.begin();
 361        iter != gallery_watchers_.end(); ++iter)
 362     watchers_to_notify.push_back(iter->first);
 363
 364   for (std::list<base::FilePath>::const_iterator path =
 365            watchers_to_notify.begin();
 366        path != watchers_to_notify.end(); ++path) {
 367      WatcherMap::iterator iter = gallery_watchers_.find(*path);
 368      if (iter == gallery_watchers_.end())
 369        continue;
 370      iter->second->OnExtensionUnloaded(extension_id);
 371   }
 372 }
 373
 374 void GalleryWatchManager::DeleteAllWatchers() {
 375   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 376   if (gallery_watchers_.empty())
 377     return;
 378
 379   // Create a copy of |gallery_watchers_| to delete because
 380   // GalleryFilePathWatcher::RemoveAllWatchReferences will
 381   // eventually call GalleryWatchManager::RemoveGalleryFilePathWatcherEntry()
 382   // and modify |gallery_watchers_|.
 383   WatcherMap watchers_to_delete(gallery_watchers_);
 384   for (WatcherMap::const_iterator iter = watchers_to_delete.begin();
 385        iter != watchers_to_delete.end(); ++iter)
 386     iter->second->RemoveAllWatchReferences();
 387 }
 388
 389 void GalleryWatchManager::RemoveGalleryFilePathWatcherEntry(
 390     const base::FilePath& watch_path) {
 391   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 392   gallery_watchers_.erase(watch_path);
 393 }
 394
 395 }  // namespace extensions