[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 413 matching lines @@
 };
 
 /******************
  * Public methods
  ******************/
 
 void MediaFileSystemRegistry::GetMediaFileSystemsForExtension(
     const content::RenderViewHost* rvh,
     const extensions::Extension* extension,
     const MediaFileSystemsCallback& callback) {
+LOG(INFO) << "GetFSForExt";
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   Profile* profile =
       Profile::FromBrowserContext(rvh->GetProcess()->GetBrowserContext());
-  MediaGalleriesPreferences* preferences = GetPreferences(profile);
+  GetPreferencesAsync(
+      profile, base::Bind(
+          &MediaFileSystemRegistry::GetMediaFileSystemsPostStorageMonitorInit,
+          base::Unretained(this),
+          rvh, extension, callback));
+}
+
+void MediaFileSystemRegistry::GetMediaFileSystemsPostStorageMonitorInit(
+    const content::RenderViewHost* rvh,
+    const extensions::Extension* extension,
+    const MediaFileSystemsCallback& callback,
+    MediaGalleriesPreferences* preferences) {
+LOG(INFO) << "GetFSForExtPostInit";
   MediaGalleryPrefIdSet galleries =
       preferences->GalleriesForExtension(*extension);
 
   if (galleries.empty()) {
     callback.Run(std::vector<MediaFileSystemInfo>());
     return;
   }
 
+  Profile* profile =
+      Profile::FromBrowserContext(rvh->GetProcess()->GetBrowserContext());
   if (!ContainsKey(pref_change_registrar_map_, profile)) {
     PrefChangeRegistrar* pref_registrar = new PrefChangeRegistrar;
     pref_registrar->Init(profile->GetPrefs());
     pref_registrar->Add(
         prefs::kMediaGalleriesRememberedGalleries,
         base::Bind(&MediaFileSystemRegistry::OnRememberedGalleriesChanged,
                    base::Unretained(this),
                    pref_registrar->prefs()));
     pref_change_registrar_map_[profile] = pref_registrar;
   }
 
   ExtensionGalleriesHost* extension_host =
       extension_hosts_map_[profile][extension->id()].get();
   if (!extension_host) {
     extension_host = new ExtensionGalleriesHost(
         file_system_context_.get(),
         base::Bind(&MediaFileSystemRegistry::OnExtensionGalleriesHostEmpty,
                    base::Unretained(this), profile, extension->id()));
     extension_hosts_map_[profile][extension->id()] = extension_host;
   }
   extension_host->ReferenceFromRVH(rvh);
 
   extension_host->GetMediaFileSystems(galleries, preferences->known_galleries(),
                                       callback);
 }
 
+void MediaFileSystemRegistry::GetPreferencesAsync(
+    Profile* profile,
+    base::Callback<void(MediaGalleriesPreferences*)> callback) {
+LOG(INFO) << "GetPreferencesAsync";
+  StorageMonitor* monitor = StorageMonitor::GetInstance();
+  if (!monitor) {

[Lei Zhang, 2013/05/10 05:24:43]

Do we want to just make tests that use MediaFSRegistry have a storage monitor,
instead of writing handlers for things that should never happen in production?

[Greg Billock, 2013/05/10 16:20:27]

Yes, I think that'd be better. I kind of suspect this may even be obsolete, and
all our tests really do have a storage monitor already. :-/ Let's do that
separately though.

[Lei Zhang, 2013/05/11 02:12:22]

Can you add a TODO so we don't forget?

[Greg Billock, 2013/05/13 21:20:38]

Done.

+    callback.Run(MediaGalleriesPreferencesFactory::GetForProfile(profile));
+    return;
+  }
+
+  if (monitor->IsInitialized()) {
+    callback.Run(GetPreferences(profile));
+    return;
+  }
+
+  monitor->Initialize(
+      base::Bind(&MediaFileSystemRegistry::OnStorageMonitorInitialized,
+                 base::Unretained(this),
+                 profile, callback));
+
+  // TODO(gbillock): set a timeout here to bail out of init?
+}
+
+void MediaFileSystemRegistry::OnStorageMonitorInitialized(
+    Profile* profile,
+    base::Callback<void(MediaGalleriesPreferences*)> callback) {
+LOG(INFO) << "StorageMonitor inialized...";
+  callback.Run(GetPreferences(profile));
+}
+
 MediaGalleriesPreferences* MediaFileSystemRegistry::GetPreferences(
     Profile* profile) {
+LOG(INFO) << "MFSR::GetPreferences";
   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();
 
   // StorageMonitor may be NULL in unit tests.
   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 (!MediaStorageUtil::IsMediaDevice(existing_devices[i].device_id))
       continue;
     preferences->AddGalleryWithName(existing_devices[i].device_id,
                                     existing_devices[i].name,
                                     base::FilePath(),
                                     false /*not user added*/);
   }
   return preferences;
@@ skipping 230 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