[Media Galleries] Lazily initialize the storage monitor.

chrome/browser/extensions/api/media_galleries_private/gallery_watch_state_tracker.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.
 
 // GalleryWatchStateTracker implementation.
 
 #include "chrome/browser/extensions/api/media_galleries_private/gallery_watch_state_tracker.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 54 matching lines @@
 
 // Looks up an extension by ID. Does not include disabled extensions.
 const Extension* GetExtensionById(Profile* profile,
                                   const std::string& extension_id) {
   ExtensionService* service = profile->GetExtensionService();
   if (!service)
     return NULL;
   return service->GetExtensionById(extension_id, false);
 }
 
-// Returns the initialized media galleries preferences for the specified
-// |profile|.
-chrome::MediaGalleriesPreferences* GetMediaGalleryPreferences(
-    Profile* profile) {
-  return g_browser_process->media_file_system_registry()->GetPreferences(
-      profile);
-}
-
 }  // namespace
 
 GalleryWatchStateTracker::GalleryWatchStateTracker(Profile* profile)
-    : profile_(profile) {
+    : profile_(profile),
+      preferences_(NULL) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(profile_);
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(profile_));
 }
 
 GalleryWatchStateTracker::~GalleryWatchStateTracker() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
@@ skipping 56 matching lines @@
   if (extension_id_iter == watched_extensions_map_.end())
     return;
   const WatchedGalleriesMap& galleries = extension_id_iter->second;
   for (WatchedGalleriesMap::const_iterator gallery_id_iter = galleries.begin();
        gallery_id_iter != galleries.end(); ++gallery_id_iter)
     RemoveGalleryWatch(extension_id, gallery_id_iter->second);
   watched_extensions_map_.erase(extension_id_iter);
   WriteToStorage(extension_id);
 }
 
+void GalleryWatchStateTracker::SetPreferences(
+    chrome::MediaGalleriesPreferences* preferences) {
+  if (preferences_ != NULL) {
+    DCHECK_EQ(preferences_, preferences);
+    return;
+  }
+  preferences_ = preferences;
+}
+
 void GalleryWatchStateTracker::OnGalleryWatchAdded(
     const std::string& extension_id,
     chrome::MediaGalleryPrefId gallery_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   bool update_storage =
       AddWatchedGalleryIdInfoForExtension(extension_id, gallery_id);
   if (update_storage)
     WriteToStorage(extension_id);
 }
 
@@ skipping 66 matching lines @@
       WatchedGalleryIdsToValue(gallery_ids).PassAs<base::Value>());
 }
 
 void GalleryWatchStateTracker::ReadFromStorage(const std::string& extension_id,
                                                scoped_ptr<base::Value> value) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   base::ListValue* list = NULL;
   if (!value.get() || !value->GetAsList(&list))
     return;
   chrome::MediaGalleryPrefIdSet gallery_ids = WatchedGalleryIdsFromValue(list);
+  if (!gallery_ids.empty()) {
+    g_browser_process->media_file_system_registry()->GetPreferencesAsync(
+        profile_,
+        base::Bind(&GalleryWatchStateTracker::ReadFromStorageWithPreferences,
+                   AsWeakPtr(), extension_id, gallery_ids));
+  }
+}
+
+void GalleryWatchStateTracker::ReadFromStorageWithPreferences(
+    const std::string& extension_id,
+    chrome::MediaGalleryPrefIdSet gallery_ids,
+    chrome::MediaGalleriesPreferences* preferences) {
+  SetPreferences(preferences);
+
   for (chrome::MediaGalleryPrefIdSet::const_iterator id_iter =
            gallery_ids.begin();
        id_iter != gallery_ids.end(); ++id_iter) {
     watched_extensions_map_[extension_id][*id_iter] = false;
     SetupGalleryWatch(extension_id, *id_iter);
   }
 }
 
 void GalleryWatchStateTracker::SetupGalleryWatch(
     const std::string& extension_id,
     chrome::MediaGalleryPrefId gallery_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   const Extension* extension = GetExtensionById(profile_, extension_id);
   DCHECK(extension);
-  base::FilePath gallery_file_path(
-      GetMediaGalleryPreferences(profile_)->LookUpGalleryPathForExtension(
-          gallery_id, extension, false));
+  DCHECK(preferences_);
+  base::FilePath gallery_file_path(preferences_->LookUpGalleryPathForExtension(

[vandebo (ex-Chrome), 2013/05/16 18:56:27]

Why are we sure preferences will be set by this point?

[Lei Zhang, 2013/05/16 21:09:12]

I looked at the caller chain and someone must have called SetPreferences()
before getting here. Let me look that up...

[Lei Zhang, 2013/05/16 22:17:52]

Oh, SetupGalleryWatch() has two callers:
1) ReadFromStorageWithPreferences() above which calls SetPreferences().

2) OnGalleryPermissionChanged(), and MediaGalleriesPreferences calls
OnGalleryPermissionChanged(). For this to happen, the extension must exist, and
if the extension exists, then (1) already occurred.

[Greg Billock, 2013/05/16 23:27:55]

One call is from ReadFromStorageWithPreferences above, the other is from
OnGalleryPermissionChanged, which is called from the permissions object itself.
We may need to pass the prefs through that call to make sure it gets set, I'm
not sure yet. Lei, do you know?

[Greg Billock, 2013/05/16 23:27:55]

Is there a race where the prefs can get initialized and call this before the
callback will run SetPreferences? If so, we can pass (this) through that
OnGalleryPermissionChanged call. That's easy enough and makes the point clear.

+      gallery_id, extension, false));
   if (gallery_file_path.empty())
     return;
   MediaGalleriesPrivateEventRouter* router =
       MediaGalleriesPrivateAPI::Get(profile_)->GetEventRouter();
   DCHECK(router);
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&GalleryWatchManager::SetupGalleryWatch,
                  profile_,
                  gallery_id,
                  gallery_file_path,
                  extension_id,
                  router->AsWeakPtr()),
       base::Bind(&GalleryWatchStateTracker::HandleSetupGalleryWatchResponse,
                  AsWeakPtr(),
                  extension_id,
                  gallery_id));
 }
 
 void GalleryWatchStateTracker::RemoveGalleryWatch(
     const std::string& extension_id,
     chrome::MediaGalleryPrefId gallery_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   const Extension* extension = GetExtensionById(profile_, extension_id);
   DCHECK(extension);
-  base::FilePath gallery_file_path(
-      GetMediaGalleryPreferences(profile_)->LookUpGalleryPathForExtension(
-          gallery_id, extension, true));
+  DCHECK(preferences_);
+  base::FilePath gallery_file_path(preferences_->LookUpGalleryPathForExtension(

[vandebo (ex-Chrome), 2013/05/16 18:56:27]

ditto

[Greg Billock, 2013/05/16 23:27:55]

Call situation here is only from OnGalleryPermissionChanged. So we may need to
push the prefs pointer through that call.

+      gallery_id, extension, true));
   if (gallery_file_path.empty())
     return;
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&GalleryWatchManager::RemoveGalleryWatch,
                  profile_,
                  gallery_file_path,
                  extension_id));
   watched_extensions_map_[extension_id][gallery_id] = false;
 }
@@ skipping 23 matching lines @@
     const std::string& extension_id,
     chrome::MediaGalleryPrefId gallery_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (HasGalleryWatchInfo(extension_id, gallery_id, true))
     return false;
   watched_extensions_map_[extension_id][gallery_id] = true;
   return true;
 }
 
 }  // namespace extensions