MediaFileSystemRegistry unit tests.

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 88 matching lines @@
     dict_value.SetWithoutPathExpansion("deviceId",
                                        Value::CreateStringValue(device_id));
   }
 
   std::string json_string;
   base::JSONWriter::Write(&dict_value, &json_string);
   return json_string;
 }
 
 std::string GetTransientIdForRemovableDeviceId(const std::string& device_id) {
+#if defined(OS_ANDROID)
+  return std::string();
+#else
   using extensions::MediaGalleriesPrivateEventRouter;
 
   if (!MediaStorageUtil::IsRemovableDevice(device_id))
     return std::string();
   return MediaGalleriesPrivateEventRouter::GetTransientIdForDeviceId(device_id);
+#endif  // OS_ANDROID
 }
 
 }  // namespace
 
 MediaFileSystemInfo::MediaFileSystemInfo(const std::string& fs_name,
                                          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> {
- 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) {
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        Bind(&MTPDeviceMapService::AddDelegate,
-             base::Unretained(MTPDeviceMapService::GetInstance()),
-             device_location_,
-             make_scoped_refptr(new MTPDeviceDelegateImpl(device_location))));
-  }
 
- private:
-  // Friend declaration for ref counted implementation.
-  friend class base::RefCounted<ScopedMTPDeviceMapEntry>;
+ScopedMTPDeviceMapEntry::ScopedMTPDeviceMapEntry(
+    const FilePath::StringType& device_location,
+    const base::Closure& no_references_callback)
+    : device_location_(device_location),
+      delegate_(new MTPDeviceDelegateImpl(device_location)),
+      no_references_callback_(no_references_callback) {
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      Bind(&MTPDeviceMapService::AddDelegate,
+           base::Unretained(MTPDeviceMapService::GetInstance()),
+           device_location_, make_scoped_refptr(delegate_)));
+}
 
-  // Private because this class is ref-counted.
-  ~ScopedMTPDeviceMapEntry() {
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        Bind(&MTPDeviceMapService::RemoveDelegate,
-             base::Unretained(MTPDeviceMapService::GetInstance()),
-             device_location_));
-    no_references_callback_.Run();
-  }
+ScopedMTPDeviceMapEntry::~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.
-  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
+#endif  // defined(SUPPORT_MTP_DEVICE_FILESYSTEM)
 
 // 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 {
  public:
   // |no_references_callback| is called when the last RenderViewHost reference
   // goes away. RenderViewHost references are added through ReferenceFromRVH().
@@ skipping 54 matching lines @@
 
     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);
 #endif
+
+    if (pref_id_map_.empty()) {
+      rph_refs_.clear();
+      CleanUp();
+    }
   }
 
   // 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))) {
       return;
     }
     registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                    content::Source<WebContents>(contents));
     registrar_.Add(
         this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
         content::Source<NavigationController>(&contents->GetController()));
 
     RenderProcessHost* rph = contents->GetRenderProcessHost();
     rph_refs_[rph].insert(contents);
     if (rph_refs_[rph].size() == 1) {
-      registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
+      registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                      content::Source<RenderProcessHost>(rph));
     }
   }
 
  private:
   typedef std::map<MediaGalleryPrefId, MediaFileSystemInfo>
       PrefIdFsInfoMap;
 #if defined(SUPPORT_MTP_DEVICE_FILESYSTEM)
   typedef std::map<MediaGalleryPrefId,
                    scoped_refptr<ScopedMTPDeviceMapEntry> >
@@ skipping 12 matching lines @@
 #if defined(SUPPORT_MTP_DEVICE_FILESYSTEM)
     DCHECK(media_device_map_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(
+      case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED: {
+        OnRendererProcessTerminated(
             content::Source<RenderProcessHost>(source).ptr());
         break;
       }
       case content::NOTIFICATION_WEB_CONTENTS_DESTROYED: {
         OnWebContentsDestroyedOrNavigated(
             content::Source<WebContents>(source).ptr());
         break;
       }
       case content::NOTIFICATION_NAV_ENTRY_COMMITTED: {
         NavigationController* controller =
@@ skipping 61 matching lines @@
           MakeJSONFileSystemName(gallery_info.display_name,
                                  pref_id,
                                  GetTransientIdForRemovableDeviceId(device_id)),
           path,
           fsid);
       result.push_back(new_entry);
       new_galleries.insert(pref_id);
       pref_id_map_[pref_id] = new_entry;
     }
 
-    RevokeOldGalleries(new_galleries);
+    if (result.size() == 0) {
+      rph_refs_.clear();
+      CleanUp();
+    } else {
+      RevokeOldGalleries(new_galleries);
+    }
 
     callback.Run(result);
   }
 
-  void OnRendererProcessClosed(const RenderProcessHost* rph) {
+  void OnRendererProcessTerminated(const RenderProcessHost* rph) {
     RenderProcessHostRefCount::const_iterator rph_info = rph_refs_.find(rph);
     DCHECK(rph_info != rph_refs_.end());
     // We're going to remove everything from the set, so we make a copy
     // before operating on it.
     std::set<const WebContents*> closed_web_contents = rph_info->second;
     DCHECK(!closed_web_contents.empty());
 
     for (std::set<const WebContents*>::const_iterator it =
              closed_web_contents.begin();
          it != closed_web_contents.end();
          ++it) {
       OnWebContentsDestroyedOrNavigated(*it);
     }
   }
 
   void OnWebContentsDestroyedOrNavigated(const WebContents* contents) {
     registrar_.Remove(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                       content::Source<WebContents>(contents));
     registrar_.Remove(
         this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
         content::Source<NavigationController>(&contents->GetController()));
 
     RenderProcessHost* rph = contents->GetRenderProcessHost();
     RenderProcessHostRefCount::iterator process_refs = rph_refs_.find(rph);
     DCHECK(process_refs != rph_refs_.end());
     process_refs->second.erase(contents);
     if (process_refs->second.empty()) {
-      registrar_.Remove(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
+      registrar_.Remove(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                         content::Source<RenderProcessHost>(rph));
       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 (rph_refs_.empty())
+      CleanUp();
+  }
+
+  void CleanUp() {
+    DCHECK(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();
+    media_device_map_references_.clear();
 #endif
 
-      no_references_callback_.Run();
-    }
+    registrar_.RemoveAll();
+
+    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.
@@ skipping 101 matching lines @@
 
   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*/);
   }
 }
 
+size_t MediaFileSystemRegistry::GetExtensionHostCountForTests() const {
+  return extension_hosts_map_.size();
+}
+
 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;
@@ skipping 186 matching lines @@
 
     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