[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"
 #include "base/location.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/media_galleries_private/gallery_watch_manager.h"
 #include "chrome/browser/extensions/api/media_galleries_private/media_galleries_private_api.h"
 #include "chrome/browser/extensions/api/media_galleries_private/media_galleries_private_event_router.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/state_store.h"
 #include "chrome/browser/media_galleries/media_file_system_registry.h"
 #include "chrome/browser/media_galleries/media_galleries_preferences.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/storage_monitor/storage_monitor.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 
 namespace extensions {
 
 namespace {
 
@@ skipping 30 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) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(profile_);
+  chrome::StorageMonitor::GetInstance()->Initialize(
+      base::Bind(&GalleryWatchStateTracker::OnStorageMonitorInitialized,
+                 AsWeakPtr()));
+}
+
+void GalleryWatchStateTracker::OnStorageMonitorInitialized() {
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,

[vandebo (ex-Chrome), 2013/05/22 16:27:52]

Why do we need to wait for storage monitor to be initialized before doing these
registrations?  Is it correct for GalleryWatchStateTracker to exist in a half
initialized state?

[Greg Billock, 2013/05/22 18:42:52]

Observe() calls ReadFromStorage(), which requires initialization.

I wondered about the half-initialized state, and investigated that. The only
other calls into the class carry the initialized permissions, so we're OK.

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

I dug into this a bit and I think it can be untangled.  Registration for the
events that Observe() receives is done in the GalleryWatchStateTracker
constructor. But the tracker doesn't care about the events until someone calls
the API, so we could delay creating the state tracker until it's needed.  In
fact, it seems that's what's done with MediaGalleriesPrivateEventRouter.
MediaGalleriesPrivateApi (which, by the way is a profile keyed service) owns
both MediaGalleriesPrivateEventRouter and GalleryWatchStateTracker.  If we just
move GalleryWatchStateTracker to be owned by MediaGalleriesPrivateEventRouter, I
think we can be assured that the StorageMonitor is initialized before any
notification arrives.

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

Shall I do that here? That's part of the refactor we talked about. I could split
it out separately, as well...

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

Seems like that too would benefit from its own CL.

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

It was in the other one

                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(profile_));
 }
 
 GalleryWatchStateTracker::~GalleryWatchStateTracker() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 }
 
 // static
 GalleryWatchStateTracker* GalleryWatchStateTracker::GetForProfile(
     Profile* profile) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 #if defined(OS_WIN)
   // Gallery watch operation is supported only on windows.
   // Please refer to crbug.com/144491 for more details.
   DCHECK(profile);
   MediaGalleriesPrivateAPI* private_api =
       MediaGalleriesPrivateAPI::Get(profile);
   if (!private_api)
     return NULL;  // In unit tests, we don't have a MediaGalleriesPrivateAPI.
   return private_api->GetGalleryWatchStateTracker();
 #endif
   return NULL;
 }
 
 void GalleryWatchStateTracker::OnGalleryPermissionChanged(
     const std::string& extension_id,
     chrome::MediaGalleryPrefId gallery_id,
-    bool has_permission) {
+    bool has_permission,
+    chrome::MediaGalleriesPreferences* preferences) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   // Granted gallery permission.
   if (has_permission && HasGalleryWatchInfo(extension_id, gallery_id, false)) {
-    SetupGalleryWatch(extension_id, gallery_id);
+    SetupGalleryWatch(extension_id, gallery_id, preferences);
     return;
   }
 
   // Revoked gallery permission.
   if (!has_permission && HasGalleryWatchInfo(extension_id, gallery_id, true))
-    RemoveGalleryWatch(extension_id, gallery_id);
+    RemoveGalleryWatch(extension_id, gallery_id, preferences);
 }
 
 chrome::MediaGalleryPrefIdSet
 GalleryWatchStateTracker::GetAllWatchedGalleryIDsForExtension(
     const std::string& extension_id) const {
   chrome::MediaGalleryPrefIdSet gallery_ids;
   WatchedExtensionsMap::const_iterator extension_id_iter =
       watched_extensions_map_.find(extension_id);
   if (extension_id_iter != watched_extensions_map_.end()) {
     for (WatchedGalleriesMap::const_iterator gallery_id_iter =
              extension_id_iter->second.begin();
          gallery_id_iter != extension_id_iter->second.end();
          ++gallery_id_iter) {
       gallery_ids.insert(gallery_id_iter->first);
     }
   }
   return gallery_ids;
 }
 
 void GalleryWatchStateTracker::RemoveAllGalleryWatchersForExtension(
-    const std::string& extension_id) {
+    const std::string& extension_id,
+    chrome::MediaGalleriesPreferences* preferences) {
   WatchedExtensionsMap::iterator extension_id_iter =
       watched_extensions_map_.find(extension_id);
   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);
+    RemoveGalleryWatch(extension_id, gallery_id_iter->second, preferences);
   watched_extensions_map_.erase(extension_id_iter);
   WriteToStorage(extension_id);
 }
 
 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);
@@ skipping 63 matching lines @@
   if (!storage)
     return;
   chrome::MediaGalleryPrefIdSet gallery_ids =
       GetAllWatchedGalleryIDsForExtension(extension_id);
   storage->SetExtensionValue(
       extension_id,
       kRegisteredGalleryWatchers,
       WatchedGalleryIdsToValue(gallery_ids).PassAs<base::Value>());
 }
 
-void GalleryWatchStateTracker::ReadFromStorage(const std::string& extension_id,
-                                               scoped_ptr<base::Value> value) {
+void GalleryWatchStateTracker::ReadFromStorage(
+    const std::string& extension_id,
+    scoped_ptr<base::Value> value) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  chrome::MediaGalleriesPreferences* preferences =

[vandebo (ex-Chrome), 2013/05/22 16:27:52]

DCHECK that StorageMonitor is initialized?

[Greg Billock, 2013/05/22 18:42:52]

This is done in GetPreferences().

+      g_browser_process->media_file_system_registry()->GetPreferences(profile_);
   base::ListValue* list = NULL;
   if (!value.get() || !value->GetAsList(&list))
     return;
   chrome::MediaGalleryPrefIdSet gallery_ids = WatchedGalleryIdsFromValue(list);
+  if (gallery_ids.empty())
+    return;
+
   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);
+    SetupGalleryWatch(extension_id, *id_iter, preferences);
   }
 }
 
 void GalleryWatchStateTracker::SetupGalleryWatch(
     const std::string& extension_id,
-    chrome::MediaGalleryPrefId gallery_id) {
+    chrome::MediaGalleryPrefId gallery_id,
+    chrome::MediaGalleriesPreferences* preferences) {
   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));
+  base::FilePath gallery_file_path(preferences->LookUpGalleryPathForExtension(
+      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) {
+    chrome::MediaGalleryPrefId gallery_id,
+    chrome::MediaGalleriesPreferences* preferences) {
   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));
+  base::FilePath gallery_file_path(preferences->LookUpGalleryPathForExtension(
+      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