[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 {
+ 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 StorageMonitor::Initialize.
+  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