[Media Galleries] Lazily initialize the storage monitor.

chrome/browser/media_galleries/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_galleries/media_file_system_registry.h"
 
 #include <set>
 #include <vector>
@@ skipping 19 matching lines @@
 #include "chrome/common/extensions/extension_set.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_view_host_observer.h"
 #include "content/public/browser/web_contents.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/isolated_context.h"
 
 using content::BrowserThread;
 using content::NavigationController;
 using content::RenderProcessHost;
 using content::WebContents;
 using fileapi::IsolatedContext;
 
@@ skipping 352 matching lines @@
   // host object.
   MediaDeviceEntryReferencesMap media_device_map_references_;
 
   // The set of render processes and web contents that may have references to
   // the file system ids this instance manages.
   RPHReferenceManager rph_refs_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionGalleriesHost);
 };
 
+// This self-deleting transaction object contains the state needed to
+// asynchronously initialize the storage monitor if needed when an
+// extension calles |GetMediaFileSystemsForExtension|. Specifically,
+// it tracks if the RenderViewHost with which it was initialized was
+// destroyed, and if so, it never calls the callback.
+// When it receives the OnStorageMonitorInitialized callback, it deletes itself.
+class GetPreferencesTransaction : public content::RenderViewHostObserver {

[vandebo (ex-Chrome), 2013/05/22 21:40:34]

You probably don't need this.  But if you do the StorageMonitor init at the API
level, it'll be clear that you don't need it.

[Greg Billock, 2013/05/23 00:55:59]

We need it since the RVH can disappear while we're initializing the storage
monitor. GetMediaFileSystemsForExtension is the entry point of the API, so
that's our trigger to initialize. Doing that async means the RVH could be
closed.

[vandebo (ex-Chrome), 2013/05/23 15:04:17]

We talked about the extension system probably having a rvh listener, did you
check for that?

[Greg Billock, 2013/05/30 22:17:47]

This is moved to the API now. You'll see a couple classes needed weak ptrs,
which I've added.

+ public:
+  GetPreferencesTransaction(
+      content::RenderViewHost* rvh,
+      base::Closure callback)
+    : content::RenderViewHostObserver(rvh),
+      callback_(callback) {}
+  virtual ~GetPreferencesTransaction() {}
+
+  virtual void RenderViewHostDestroyed(content::RenderViewHost* rvh) OVERRIDE {
+    callback_.Reset();
+  }
+
+  void OnStorageMonitorInitialized() {
+    if (!callback_.is_null())
+      callback_.Run();
+
+    delete this;
+  }
+
+ private:
+  base::Closure callback_;
+};
+
 /******************
  * Public methods
  ******************/
 
 void MediaFileSystemRegistry::GetMediaFileSystemsForExtension(
-    const content::RenderViewHost* rvh,
+    content::RenderViewHost* rvh,
     const extensions::Extension* extension,
     const MediaFileSystemsCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  Profile* profile =
-      Profile::FromBrowserContext(rvh->GetProcess()->GetBrowserContext());
+  // This object is self-deleting when it receives the callback
+  // from GetPreferencesAsync.
+  GetPreferencesTransaction* transaction = new GetPreferencesTransaction(
+      rvh,
+      base::Bind(
+          &MediaFileSystemRegistry::GetMediaFileSystemsPostInit,
+          weak_ptr_factory_.GetWeakPtr(),
+          rvh, extension, callback));
+  StorageMonitor* monitor = StorageMonitor::GetInstance();
+  if (monitor) {
+    monitor->Initialize(base::Bind(
+        &GetPreferencesTransaction::OnStorageMonitorInitialized,
+        base::Unretained(transaction)));
+  }
+}
+
+void MediaFileSystemRegistry::GetMediaFileSystemsPostInit(
+    const content::RenderViewHost* rvh,
+    const extensions::Extension* extension,
+    const MediaFileSystemsCallback& callback) {
+  Profile* profile = Profile::FromBrowserContext(
+      rvh->GetProcess()->GetBrowserContext());
   MediaGalleriesPreferences* preferences = GetPreferences(profile);
   MediaGalleryPrefIdSet galleries =
       preferences->GalleriesForExtension(*extension);
 
   if (galleries.empty()) {
     callback.Run(std::vector<MediaFileSystemInfo>());
     return;
   }
 
   if (!ContainsKey(pref_change_registrar_map_, profile)) {
@@ skipping 26 matching lines @@
     Profile* profile) {
   MediaGalleriesPreferences* preferences =
       MediaGalleriesPreferencesFactory::GetForProfile(profile);
   if (ContainsKey(extension_hosts_map_, profile))
     return preferences;
 
   // Create an empty entry so the initialization code below only gets called
   // once per profile.
   extension_hosts_map_[profile] = ExtensionHostMap();
 
-  // TODO(gbillock): Move this stanza to MediaGalleriesPreferences init code.
   // StorageMonitor may be NULL in unit tests.
+  // TODO(gbillock): Make sure all tests have a storage monitor and remove this.
   StorageMonitor* monitor = StorageMonitor::GetInstance();
   if (!monitor)
     return preferences;
+  DCHECK(monitor->IsInitialized());
   std::vector<StorageInfo> existing_devices = monitor->GetAttachedStorage();
   for (size_t i = 0; i < existing_devices.size(); i++) {
     if (!StorageInfo::IsMediaDevice(existing_devices[i].device_id))
       continue;
     if (!existing_devices[i].name.empty()) {
       preferences->AddGalleryWithName(existing_devices[i].device_id,
                                       existing_devices[i].name,
                                       base::FilePath(),
                                       false /*not user added*/);
     } else {
@@ skipping 124 matching lines @@
     return registry_;
   }
 
  private:
   MediaFileSystemRegistry* registry_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaFileSystemContextImpl);
 };
 
 MediaFileSystemRegistry::MediaFileSystemRegistry()
-    : file_system_context_(new MediaFileSystemContextImpl(this)) {
+    : file_system_context_(new MediaFileSystemContextImpl(this)),
+      weak_ptr_factory_(this) {
   // StorageMonitor may be NULL in unit tests.
   StorageMonitor* monitor = StorageMonitor::GetInstance();
   if (monitor)
     monitor->AddObserver(this);
 }
 
 MediaFileSystemRegistry::~MediaFileSystemRegistry() {
   // StorageMonitor may be NULL in unit tests.
   StorageMonitor* monitor = StorageMonitor::GetInstance();
   if (monitor)
@@ skipping 90 matching lines @@
     // previously used.
     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