Media Galleries API: Fix MediaGalleriesPreferences finders race.

chrome/browser/extensions/api/media_galleries_private/media_galleries_private_api.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.
 
 #include "chrome/browser/extensions/api/media_galleries_private/media_galleries_private_api.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
@@ skipping 45 matching lines @@
 // by the |gallery_id|. Returns true and set |gallery_file_path| and
 // |gallery_pref_id| if the |gallery_id| is valid and returns false otherwise.
 bool GetGalleryFilePathAndId(const std::string& gallery_id,
                              Profile* profile,
                              const Extension* extension,
                              base::FilePath* gallery_file_path,
                              MediaGalleryPrefId* gallery_pref_id) {
   MediaGalleryPrefId pref_id;
   if (!base::StringToUint64(gallery_id, &pref_id))
     return false;
-  MediaFileSystemRegistry* registry =
-      g_browser_process->media_file_system_registry();
-   base::FilePath file_path(
-      registry->GetPreferences(profile)->LookUpGalleryPathForExtension(
-          pref_id, extension, false));
+  MediaGalleriesPreferences* preferences =
+      g_browser_process->media_file_system_registry()->GetPreferences(profile);
+  base::FilePath file_path(
+      preferences->LookUpGalleryPathForExtension(pref_id, extension, false));
   if (file_path.empty())
     return false;
   *gallery_pref_id = pref_id;
   *gallery_file_path = file_path;
   return true;
 }
 
 }  // namespace
 
 
@@ skipping 34 matching lines @@
 }
 
 // static
 MediaGalleriesPrivateAPI* MediaGalleriesPrivateAPI::Get(Profile* profile) {
   return
       ProfileKeyedAPIFactory<MediaGalleriesPrivateAPI>::GetForProfile(profile);
 }
 
 void MediaGalleriesPrivateAPI::OnListenerAdded(
     const EventListenerInfo& details) {
-  // Start the StorageMonitor if it is not already initialized. After that,
+  // Make sure MediaGalleriesPreferences is initialized. After that,
   // try to initialize the event router for the listener.
   // This method is called synchronously with the message handler for the
   // JS invocation.
 
-  StorageMonitor::GetInstance()->EnsureInitialized(base::Bind(
+  MediaGalleriesPreferences* preferences =
+      g_browser_process->media_file_system_registry()->GetPreferences(profile_);
+  preferences->EnsureInitialized(base::Bind(
       &MediaGalleriesPrivateAPI::MaybeInitializeEventRouterAndTracker,
       weak_ptr_factory_.GetWeakPtr()));
 }
 
 MediaGalleriesPrivateEventRouter* MediaGalleriesPrivateAPI::GetEventRouter() {
   MaybeInitializeEventRouterAndTracker();
   return media_galleries_private_event_router_.get();
 }
 
 GalleryWatchStateTracker*
 MediaGalleriesPrivateAPI::GetGalleryWatchStateTracker() {
   MaybeInitializeEventRouterAndTracker();
   return tracker_.get();
 }
 
 void MediaGalleriesPrivateAPI::MaybeInitializeEventRouterAndTracker() {
   if (media_galleries_private_event_router_.get())
     return;
   media_galleries_private_event_router_.reset(
       new MediaGalleriesPrivateEventRouter(profile_));
-  DCHECK(StorageMonitor::GetInstance()->IsInitialized());
+  DCHECK(g_browser_process->media_file_system_registry()->
+             GetPreferences(profile_)->IsInitialized());
   tracker_.reset(
       new GalleryWatchStateTracker(profile_));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //              MediaGalleriesPrivateAddGalleryWatchFunction                 //
 ///////////////////////////////////////////////////////////////////////////////
 MediaGalleriesPrivateAddGalleryWatchFunction::
 ~MediaGalleriesPrivateAddGalleryWatchFunction() {
 }
 
 bool MediaGalleriesPrivateAddGalleryWatchFunction::RunImpl() {
   DCHECK(profile_);
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (!render_view_host() || !render_view_host()->GetProcess())
     return false;
 
   scoped_ptr<AddGalleryWatch::Params> params(
       AddGalleryWatch::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  StorageMonitor::GetInstance()->EnsureInitialized(base::Bind(
-      &MediaGalleriesPrivateAddGalleryWatchFunction::OnStorageMonitorInit,
+  MediaGalleriesPreferences* preferences =
+      g_browser_process->media_file_system_registry()->GetPreferences(profile_);
+  preferences->EnsureInitialized(base::Bind(
+      &MediaGalleriesPrivateAddGalleryWatchFunction::OnPreferencesInit,
       this,
       params->gallery_id));
 
   return true;
 }
 
-void MediaGalleriesPrivateAddGalleryWatchFunction::OnStorageMonitorInit(
+void MediaGalleriesPrivateAddGalleryWatchFunction::OnPreferencesInit(
     const std::string& pref_id) {
-  DCHECK(StorageMonitor::GetInstance()->IsInitialized());
   base::FilePath gallery_file_path;
   MediaGalleryPrefId gallery_pref_id = 0;
   if (!GetGalleryFilePathAndId(pref_id, profile_, GetExtension(),
                                &gallery_file_path, &gallery_pref_id)) {
     error_ = kInvalidGalleryIDError;
     HandleResponse(gallery_pref_id, false);
     return;
   }
 
 #if defined(OS_WIN)
@@ skipping 21 matching lines @@
 
 void MediaGalleriesPrivateAddGalleryWatchFunction::HandleResponse(
     MediaGalleryPrefId gallery_id,
     bool success) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   media_galleries_private::AddGalleryWatchResult result;
   result.gallery_id = base::Uint64ToString(gallery_id);
   result.success = success;
   SetResult(result.ToValue().release());
   if (success) {
-    DCHECK(StorageMonitor::GetInstance()->IsInitialized());
+    DCHECK(g_browser_process->media_file_system_registry()->
+               GetPreferences(profile_)->IsInitialized());
     GalleryWatchStateTracker* state_tracker =
         MediaGalleriesPrivateAPI::Get(profile_)->GetGalleryWatchStateTracker();
     state_tracker->OnGalleryWatchAdded(extension_id(), gallery_id);
   }
   SendResponse(true);
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 //              MediaGalleriesPrivateRemoveGalleryWatchFunction              //
 ///////////////////////////////////////////////////////////////////////////////
 
 MediaGalleriesPrivateRemoveGalleryWatchFunction::
 ~MediaGalleriesPrivateRemoveGalleryWatchFunction() {
 }
 
 bool MediaGalleriesPrivateRemoveGalleryWatchFunction::RunImpl() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (!render_view_host() || !render_view_host()->GetProcess())
     return false;
 
   // Remove gallery watch operation is currently supported on windows platforms.
   // Please refer to crbug.com/144491 for more details.
   scoped_ptr<RemoveGalleryWatch::Params> params(
       RemoveGalleryWatch::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  StorageMonitor::GetInstance()->EnsureInitialized(base::Bind(
-      &MediaGalleriesPrivateRemoveGalleryWatchFunction::OnStorageMonitorInit,
+  MediaGalleriesPreferences* preferences =
+      g_browser_process->media_file_system_registry()->GetPreferences(profile_);
+  preferences->EnsureInitialized(base::Bind(
+      &MediaGalleriesPrivateRemoveGalleryWatchFunction::OnPreferencesInit,
       this,
       params->gallery_id));
   return true;
 }
 
-void MediaGalleriesPrivateRemoveGalleryWatchFunction::OnStorageMonitorInit(
+void MediaGalleriesPrivateRemoveGalleryWatchFunction::OnPreferencesInit(
     const std::string& pref_id) {
-  DCHECK(StorageMonitor::GetInstance()->IsInitialized());
 #if defined(OS_WIN)
   base::FilePath gallery_file_path;
   MediaGalleryPrefId gallery_pref_id = 0;
   if (!GetGalleryFilePathAndId(pref_id, profile_, GetExtension(),
                                &gallery_file_path, &gallery_pref_id)) {
     error_ = kInvalidGalleryIDError;
     SendResponse(false);
     return;
   }
 
@@ skipping 17 matching lines @@
 
 MediaGalleriesPrivateGetAllGalleryWatchFunction::
 ~MediaGalleriesPrivateGetAllGalleryWatchFunction() {
 }
 
 bool MediaGalleriesPrivateGetAllGalleryWatchFunction::RunImpl() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (!render_view_host() || !render_view_host()->GetProcess())
     return false;
 
-  StorageMonitor::GetInstance()->EnsureInitialized(base::Bind(
-      &MediaGalleriesPrivateGetAllGalleryWatchFunction::OnStorageMonitorInit,
+  MediaGalleriesPreferences* preferences =
+      g_browser_process->media_file_system_registry()->GetPreferences(profile_);
+  preferences->EnsureInitialized(base::Bind(
+      &MediaGalleriesPrivateGetAllGalleryWatchFunction::OnPreferencesInit,
       this));
   return true;
 }
 
-void MediaGalleriesPrivateGetAllGalleryWatchFunction::OnStorageMonitorInit() {
+void MediaGalleriesPrivateGetAllGalleryWatchFunction::OnPreferencesInit() {
   std::vector<std::string> result;
 #if defined(OS_WIN)
-  DCHECK(StorageMonitor::GetInstance()->IsInitialized());
   GalleryWatchStateTracker* state_tracker =
       MediaGalleriesPrivateAPI::Get(profile_)->GetGalleryWatchStateTracker();
   MediaGalleryPrefIdSet gallery_ids =
       state_tracker->GetAllWatchedGalleryIDsForExtension(extension_id());
   for (MediaGalleryPrefIdSet::const_iterator iter = gallery_ids.begin();
        iter != gallery_ids.end(); ++iter) {
     result.push_back(base::Uint64ToString(*iter));
   }
 #endif
   results_ = GetAllGalleryWatch::Results::Create(result);
   SendResponse(true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //              MediaGalleriesPrivateRemoveAllGalleryWatchFunction           //
 ///////////////////////////////////////////////////////////////////////////////
 
 MediaGalleriesPrivateRemoveAllGalleryWatchFunction::
 ~MediaGalleriesPrivateRemoveAllGalleryWatchFunction() {
 }
 
 bool MediaGalleriesPrivateRemoveAllGalleryWatchFunction::RunImpl() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (!render_view_host() || !render_view_host()->GetProcess())
     return false;
 
-  StorageMonitor::GetInstance()->EnsureInitialized(base::Bind(
-      &MediaGalleriesPrivateRemoveAllGalleryWatchFunction::OnStorageMonitorInit,
+  MediaGalleriesPreferences* preferences =
+      g_browser_process->media_file_system_registry()->GetPreferences(profile_);
+  preferences->EnsureInitialized(base::Bind(
+      &MediaGalleriesPrivateRemoveAllGalleryWatchFunction::OnPreferencesInit,
       this));
   return true;
 }
 
-void
-MediaGalleriesPrivateRemoveAllGalleryWatchFunction::OnStorageMonitorInit() {
+void MediaGalleriesPrivateRemoveAllGalleryWatchFunction::OnPreferencesInit() {
 #if defined(OS_WIN)
-  DCHECK(StorageMonitor::GetInstance()->IsInitialized());
-  MediaFileSystemRegistry* registry =
-      g_browser_process->media_file_system_registry();
-  MediaGalleriesPreferences* preferences = registry->GetPreferences(profile_);
+  MediaGalleriesPreferences* preferences =
+      g_browser_process->media_file_system_registry()->GetPreferences(profile_);
   GalleryWatchStateTracker* state_tracker =
       MediaGalleriesPrivateAPI::Get(profile_)->GetGalleryWatchStateTracker();
   state_tracker->RemoveAllGalleryWatchersForExtension(
       extension_id(), preferences);
 #endif
   SendResponse(true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //              MediaGalleriesPrivateGetHandlersFunction                     //
@@ skipping 39 matching lines @@
     }
   }
 
   SetResult(result_list);
   SendResponse(true);
 
   return true;
 }
 
 }  // namespace extensions