Redesigned and refactored ScopedMTPDeviceMapEntry, MTPDeviceMapService & MTPDeviceDelegate classes.

chrome/browser/media_gallery/media_file_system_registry.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.
 
 // MediaFileSystemRegistry implementation.
 
 #include "chrome/browser/media_gallery/media_file_system_registry.h"
 
 #include <set>
 #include <vector>
@@ skipping 108 matching lines @@
                                          const FilePath& fs_path,
                                          const std::string& filesystem_id)
     : name(fs_name),
       path(fs_path),
       fsid(filesystem_id) {
 }
 
 MediaFileSystemInfo::MediaFileSystemInfo() {}
 
 #if defined(SUPPORT_MTP_DEVICE_FILESYSTEM)
-// Class to manage MTPDeviceDelegateImpl object for the attached MTP device.
-// Refcounted to reuse the same MTP device delegate entry across extensions.
-// This class supports WeakPtr (extends SupportsWeakPtr) to expose itself as
-// a weak pointer to MediaFileSystemRegistry.
-class ScopedMTPDeviceMapEntry
-    : public base::RefCounted<ScopedMTPDeviceMapEntry>,
-      public base::SupportsWeakPtr<ScopedMTPDeviceMapEntry> {
+// Class to manage the lifetime of MTPDeviceDelegateImpl object for the
+// attached media transfer protocol (MTP) device. This object is constructed for
+// each MTP device.
+class ScopedMTPDeviceMapEntry {
  public:
-  // |no_references_callback| is called when the last ScopedMTPDeviceMapEntry
-  // reference goes away.
-  ScopedMTPDeviceMapEntry(const FilePath::StringType& device_location,
-                          const base::Closure& no_references_callback)
-      : device_location_(device_location),
-        no_references_callback_(no_references_callback) {
+  explicit ScopedMTPDeviceMapEntry(const FilePath::StringType& device_location)
+      : device_location_(device_location) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         Bind(&MTPDeviceMapService::AddDelegate,
              base::Unretained(MTPDeviceMapService::GetInstance()),
              device_location_,
-             make_scoped_refptr(new MTPDeviceDelegateImpl(device_location))));
+             new MTPDeviceDelegateImpl(device_location)));
   }
 
- private:
-  // Friend declaration for ref counted implementation.
-  friend class base::RefCounted<ScopedMTPDeviceMapEntry>;
-
-  // Private because this class is ref-counted.
+  // Destructed when the last user of this MTP device is destroyed or when the
+  // MTP device is detached from the system or when the browser is in shutdown
+  // mode or when the extension revokes the MTP device gallery permissions.
   ~ScopedMTPDeviceMapEntry() {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         Bind(&MTPDeviceMapService::RemoveDelegate,
              base::Unretained(MTPDeviceMapService::GetInstance()),
              device_location_));
-    no_references_callback_.Run();
   }
 
-  // Store the MTP or PTP device location.
+ private:
+  // The MTP or PTP device location.
   const FilePath::StringType device_location_;
 
-  // A callback to call when the last reference of this object goes away.
-  base::Closure no_references_callback_;
-
   DISALLOW_COPY_AND_ASSIGN(ScopedMTPDeviceMapEntry);
 };
 #endif
 
 // The main owner of this class is
 // |MediaFileSystemRegistry::extension_hosts_map_|, but a callback may
 // temporarily hold a reference.
 class ExtensionGalleriesHost
     : public base::RefCountedThreadSafe<ExtensionGalleriesHost>,
       public content::NotificationObserver {
@@ skipping 52 matching lines @@
   // Revoke the file system for |id| if this extension has created one for |id|.
   void RevokeGalleryByPrefId(MediaGalleryPrefId id) {
     PrefIdFsInfoMap::iterator gallery = pref_id_map_.find(id);
     if (gallery == pref_id_map_.end())
       return;
 
     file_system_context_->RevokeFileSystem(gallery->second.fsid);
     pref_id_map_.erase(gallery);
 
 #if defined(SUPPORT_MTP_DEVICE_FILESYSTEM)
-    MediaDeviceEntryReferencesMap::iterator mtp_device_host =
-        media_device_map_references_.find(id);
-    if (mtp_device_host != media_device_map_references_.end())
-      media_device_map_references_.erase(mtp_device_host);
+    for (MTPDeviceGalleryReferencesMap::iterator it =
+             mtp_device_gallery_references_.begin();
+         it != mtp_device_gallery_references_.end(); ++it) {
+      MediaGalleryPrefIdSet::iterator found = it->second.find(id);
+      if (found == it->second.end())
+        continue;
+      it->second.erase(id);
+      if (it->second.empty()) {
+        file_system_context_->RemoveMTPDeviceReferenceForHost(it->first, this);
+        mtp_device_gallery_references_.erase(it);
+      }
+      break;
+    }
 #endif
   }
 
   // Indicate that the passed |rvh| will reference the file system ids created
   // by this class.  It is safe to call this multiple times with the same RVH.
   void ReferenceFromRVH(const content::RenderViewHost* rvh) {
     WebContents* contents = WebContents::FromRenderViewHost(rvh);
     if (registrar_.IsRegistered(this,
                                 content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                                 content::Source<WebContents>(contents))) {
@@ skipping 10 matching lines @@
     if (rph_refs_[rph].size() == 1) {
       registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                      content::Source<RenderProcessHost>(rph));
     }
   }
 
  private:
   typedef std::map<MediaGalleryPrefId, MediaFileSystemInfo>
       PrefIdFsInfoMap;
 #if defined(SUPPORT_MTP_DEVICE_FILESYSTEM)
-  typedef std::map<MediaGalleryPrefId,
-                   scoped_refptr<ScopedMTPDeviceMapEntry> >
-      MediaDeviceEntryReferencesMap;
+  typedef std::map<const FilePath::StringType, MediaGalleryPrefIdSet>
+      MTPDeviceGalleryReferencesMap;
 #endif
   typedef std::map<const RenderProcessHost*, std::set<const WebContents*> >
       RenderProcessHostRefCount;
 
   // Private destructor and friend declaration for ref counted implementation.
   friend class base::RefCountedThreadSafe<ExtensionGalleriesHost>;
 
   virtual ~ExtensionGalleriesHost() {
     DCHECK(rph_refs_.empty());
     DCHECK(pref_id_map_.empty());
 
 #if defined(SUPPORT_MTP_DEVICE_FILESYSTEM)
-    DCHECK(media_device_map_references_.empty());
+    DCHECK(mtp_device_gallery_references_.empty());
 #endif
   }
 
   // NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE {
     switch (type) {
       case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
         OnRendererProcessClosed(
@@ skipping 48 matching lines @@
       FilePath path = gallery_info.AbsolutePath();
       if (!path.IsAbsolute())
         continue;
 
       std::string fsid;
       if (MediaStorageUtil::IsMassStorageDevice(device_id)) {
         fsid = file_system_context_->RegisterFileSystemForMassStorage(
             device_id, path);
       } else {
 #if defined(SUPPORT_MTP_DEVICE_FILESYSTEM)
-        scoped_refptr<ScopedMTPDeviceMapEntry> mtp_device_host;
         fsid = file_system_context_->RegisterFileSystemForMTPDevice(
-            device_id, path, &mtp_device_host);
-        DCHECK(mtp_device_host.get());
-        media_device_map_references_[pref_id] = mtp_device_host;
+            device_id, path, this);
+        mtp_device_gallery_references_[path.value()].insert(pref_id);
 #else
         NOTIMPLEMENTED();
         continue;
 #endif
       }
       DCHECK(!fsid.empty());
 
       MediaFileSystemInfo new_entry(
           MakeJSONFileSystemName(gallery_info.display_name,
                                  pref_id,
@@ skipping 43 matching lines @@
       rph_refs_.erase(process_refs);
     }
 
     if (rph_refs_.empty()) {
       for (PrefIdFsInfoMap::const_iterator it = pref_id_map_.begin();
            it != pref_id_map_.end();
            ++it) {
         file_system_context_->RevokeFileSystem(it->second.fsid);
       }
       pref_id_map_.clear();
-
 #if defined(SUPPORT_MTP_DEVICE_FILESYSTEM)
-      media_device_map_references_.clear();
+      for (MTPDeviceGalleryReferencesMap::iterator it =
+               mtp_device_gallery_references_.begin();
+           it != mtp_device_gallery_references_.end(); ++it) {
+        file_system_context_->RemoveMTPDeviceReferenceForHost(it->first, this);
+      }
+      mtp_device_gallery_references_.clear();
 #endif
-
       no_references_callback_.Run();
     }
   }
 
   // MediaFileSystemRegistry owns |this| and |file_system_context_|, so it's
   // safe to store a raw pointer.
   MediaFileSystemContext* file_system_context_;
 
   // A callback to call when the last RVH reference goes away.
   base::Closure no_references_callback_;
 
   // A map from the gallery preferences id to the file system information.
   PrefIdFsInfoMap pref_id_map_;
 
 #if defined(SUPPORT_MTP_DEVICE_FILESYSTEM)
-  // A map from the gallery preferences id to the corresponding media device
-  // host object.
-  MediaDeviceEntryReferencesMap media_device_map_references_;
+  // A map from the MTP device id to a set of media galleries that references to
+  // that device.
+  MTPDeviceGalleryReferencesMap mtp_device_gallery_references_;
 #endif
 
   // The set of render processes and web contents that may have references to
   // the file system ids this instance manages.
   RenderProcessHostRefCount rph_refs_;
 
   // A registrar for listening notifications.
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionGalleriesHost);
@@ skipping 67 matching lines @@
                             existing_devices[i].name, FilePath(),
                             false /*not user added*/);
   }
   return preferences;
 }
 
 void MediaFileSystemRegistry::OnRemovableStorageAttached(
     const std::string& id, const string16& name,
     const FilePath::StringType& location) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
   if (!MediaStorageUtil::IsMediaDevice(id))
     return;
 
   for (ExtensionGalleriesHostMap::iterator profile_it =
            extension_hosts_map_.begin();
        profile_it != extension_hosts_map_.end();
        ++profile_it) {
     MediaGalleriesPreferences* preferences = GetPreferences(profile_it->first);
     preferences->AddGallery(id, name, FilePath(), false /*not user added*/);
   }
 }
 
 void MediaFileSystemRegistry::OnRemovableStorageDetached(
     const std::string& id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
   // Since revoking a gallery in the ExtensionGalleriesHost may cause it
   // to be removed from the map and therefore invalidate any iterator pointing
   // to it, this code first copies all the invalid gallery ids and the
   // extension hosts in which they may appear (per profile) and revoked it in
   // a second step.
   std::vector<InvalidatedGalleriesInfo> invalid_galleries_info;
 
   for (ExtensionGalleriesHostMap::iterator profile_it =
            extension_hosts_map_.begin();
        profile_it != extension_hosts_map_.end();
@@ skipping 56 matching lines @@
     const std::string fsid =
         IsolatedContext::GetInstance()->RegisterFileSystemForPath(
             fileapi::kFileSystemTypeNativeMedia, path, &fs_name);
     CHECK(!fsid.empty());
     return fsid;
   }
 
 #if defined(SUPPORT_MTP_DEVICE_FILESYSTEM)
   virtual std::string RegisterFileSystemForMTPDevice(
       const std::string& device_id, const FilePath& path,
-      scoped_refptr<ScopedMTPDeviceMapEntry>* entry) {
+      const ExtensionGalleriesHost* galleries_host) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     DCHECK(!MediaStorageUtil::IsMassStorageDevice(device_id));
 
     // Sanity checks for |path|.
     CHECK(path.IsAbsolute());
     CHECK(!path.ReferencesParent());
     std::string fs_name(extension_misc::kMediaFileSystemPathPart);
     const std::string fsid =
         IsolatedContext::GetInstance()->RegisterFileSystemForPath(
             fileapi::kFileSystemTypeDeviceMedia, path, &fs_name);
     CHECK(!fsid.empty());
-    DCHECK(entry);
-    *entry = registry_->GetOrCreateScopedMTPDeviceMapEntry(path.value());
+    registry_->AddGalleriesHostReferenceForMTPDevice(path.value(),
+                                                     galleries_host);
     return fsid;
   }
+
+  virtual void RemoveMTPDeviceReferenceForHost(
+      const FilePath::StringType& device_location,
+      const ExtensionGalleriesHost* galleries_host) {
+    registry_->RemoveGalleriesHostReferenceForMTPDevice(device_location,
+                                                        galleries_host);
+  }
 #endif
 
   virtual void RevokeFileSystem(const std::string& fsid) {
     IsolatedContext::GetInstance()->RevokeFileSystem(fsid);
   }
 
  private:
   MediaFileSystemRegistry* registry_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaFileSystemContextImpl);
 };
 
 MediaFileSystemRegistry::MediaFileSystemRegistry()
     : file_system_context_(new MediaFileSystemContextImpl(this)) {
   // SystemMonitor may be NULL in unit tests.
   SystemMonitor* system_monitor = SystemMonitor::Get();
   if (system_monitor)
     system_monitor->AddDevicesChangedObserver(this);
 }
 
 MediaFileSystemRegistry::~MediaFileSystemRegistry() {
   // SystemMonitor may be NULL in unit tests.
   SystemMonitor* system_monitor = SystemMonitor::Get();
   if (system_monitor)
     system_monitor->RemoveDevicesChangedObserver(this);
+  DCHECK(mtp_device_delegate_map_.empty());
+  DCHECK(mtp_device_references_map_.empty());
 }
 
 void MediaFileSystemRegistry::OnPreferenceChanged(
     PrefServiceBase* prefs,
     const std::string& pref_name) {
   DCHECK_EQ(std::string(prefs::kMediaGalleriesRememberedGalleries), pref_name);
 
   // Find the Profile that contains the source PrefService.
   PrefChangeRegistrarMap::iterator pref_change_it =
       pref_change_registrar_map_.begin();
@@ skipping 22 matching lines @@
        gallery_host_it != extension_host_map.end();
        ++gallery_host_it) {
     const extensions::Extension* extension =
         extensions_set->GetByID(gallery_host_it->first);
     gallery_host_it->second->RevokeOldGalleries(
         preferences->GalleriesForExtension(*extension));
   }
 }
 
 #if defined(SUPPORT_MTP_DEVICE_FILESYSTEM)
-ScopedMTPDeviceMapEntry*
-MediaFileSystemRegistry::GetOrCreateScopedMTPDeviceMapEntry(
-    const FilePath::StringType& device_location) {
+void MediaFileSystemRegistry::AddGalleriesHostReferenceForMTPDevice(
+    const FilePath::StringType& device_location,
+    const ExtensionGalleriesHost* galleries_host) {
   MTPDeviceDelegateMap::iterator delegate_it =
-      mtp_delegate_map_.find(device_location);
-  if (delegate_it != mtp_delegate_map_.end() && delegate_it->second.get())
-    return delegate_it->second;
-  ScopedMTPDeviceMapEntry* mtp_device_host = new ScopedMTPDeviceMapEntry(
-      device_location, base::Bind(
-          &MediaFileSystemRegistry::RemoveScopedMTPDeviceMapEntry,
-          base::Unretained(this), device_location));
-  mtp_delegate_map_[device_location] = mtp_device_host->AsWeakPtr();
-  return mtp_device_host;
+      mtp_device_delegate_map_.find(device_location);
+  if (delegate_it == mtp_device_delegate_map_.end()) {
+    mtp_device_delegate_map_[device_location] =
+        new ScopedMTPDeviceMapEntry(device_location);
+  }
+  mtp_device_references_map_[device_location].insert(galleries_host);
 }
 
-void MediaFileSystemRegistry::RemoveScopedMTPDeviceMapEntry(
-    const FilePath::StringType& device_location) {
-  MTPDeviceDelegateMap::iterator delegate_it =
-      mtp_delegate_map_.find(device_location);
-  DCHECK(delegate_it != mtp_delegate_map_.end());
-  mtp_delegate_map_.erase(delegate_it);
+void MediaFileSystemRegistry::RemoveGalleriesHostReferenceForMTPDevice(
+    const FilePath::StringType& device_location,
+    const ExtensionGalleriesHost* galleries_host) {
+  MTPDeviceReferencesMap::iterator hosts_it =
+      mtp_device_references_map_.find(device_location);
+  DCHECK(hosts_it != mtp_device_references_map_.end());
+  DCHECK(hosts_it->second.find(galleries_host) != hosts_it->second.end());
+  hosts_it->second.erase(galleries_host);
+  if (hosts_it->second.empty()) {
+    delete mtp_device_delegate_map_[device_location];
+    mtp_device_delegate_map_.erase(device_location);
+    mtp_device_references_map_.erase(hosts_it);
+  }
 }
 #endif
 
 void MediaFileSystemRegistry::OnExtensionGalleriesHostEmpty(
     Profile* profile, const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ExtensionGalleriesHostMap::iterator extension_hosts =
       extension_hosts_map_.find(profile);
   DCHECK(extension_hosts != extension_hosts_map_.end());
   ExtensionHostMap::size_type erase_count =
       extension_hosts->second.erase(extension_id);
   DCHECK_EQ(1U, erase_count);
   if (extension_hosts->second.empty()) {
     extension_hosts_map_.erase(extension_hosts);
 
     PrefChangeRegistrarMap::iterator pref_it =
         pref_change_registrar_map_.find(profile);
     DCHECK(pref_it != pref_change_registrar_map_.end());
     delete pref_it->second;
     pref_change_registrar_map_.erase(pref_it);
   }
 }
 
 }  // namespace chrome