[Media Galleries] Lazily initialize the storage monitor.

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 88 matching lines @@
 }
 
 }  // namespace
 
 
 ///////////////////////////////////////////////////////////////////////////////
 //                      MediaGalleriesPrivateAPI                             //
 ///////////////////////////////////////////////////////////////////////////////
 
 MediaGalleriesPrivateAPI::MediaGalleriesPrivateAPI(Profile* profile)
-    : profile_(profile) {
+    : profile_(profile),
+      weak_ptr_factory_(this) {
   DCHECK(profile_);
   (new MediaGalleriesHandlerParser)->Register();
   ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
       this, event_names::kOnAttachEventName);
   ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
       this, event_names::kOnDetachEventName);
   ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
       this, event_names::kOnGalleryChangedEventName);
 }
 
 MediaGalleriesPrivateAPI::~MediaGalleriesPrivateAPI() {
 }
 
 void MediaGalleriesPrivateAPI::Shutdown() {
   ExtensionSystem::Get(profile_)->event_router()->UnregisterObserver(this);
+  weak_ptr_factory_.InvalidateWeakPtrs();
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&HandleProfileShutdownOnFileThread, profile_));
 }
 
 static base::LazyInstance<ProfileKeyedAPIFactory<MediaGalleriesPrivateAPI> >
 g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 ProfileKeyedAPIFactory<MediaGalleriesPrivateAPI>*
@@ skipping 123 matching lines @@
     if (!Extension::IdIsValid(iter.key())) {
       NOTREACHED();
       continue;
     }
     UnsetMediaGalleryPermission(prefs, iter.key(), gallery_id);
   }
 }
 
 void MediaGalleriesPrivateAPI::OnListenerAdded(
     const EventListenerInfo& details) {
-  // Try to initialize the event router for the listener. If
-  // MediaGalleriesPrivateAPI::GetEventRouter() was called before adding
-  // the listener, router would be initialized.
-  MaybeInitializeEventRouterAndTracker();
+  // Start the StorageMonitor if it is not already 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.
+
+  chrome::StorageMonitor::GetInstance()->Initialize(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(chrome::StorageMonitor::GetInstance()->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());
 
+  chrome::StorageMonitor::GetInstance()->Initialize(base::Bind(
+      &MediaGalleriesPrivateAddGalleryWatchFunction::OnStorageMonitorInit,
+      this,
+      params->gallery_id));
+
+  return true;
+}
+
+void MediaGalleriesPrivateAddGalleryWatchFunction::OnStorageMonitorInit(
+    const std::string& pref_id) {
+  DCHECK(chrome::StorageMonitor::GetInstance()->IsInitialized());
   base::FilePath gallery_file_path;
   chrome::MediaGalleryPrefId gallery_pref_id = 0;
-  if (!GetGalleryFilePathAndId(params->gallery_id, profile_, GetExtension(),
+  if (!GetGalleryFilePathAndId(pref_id, profile_, GetExtension(),
                                &gallery_file_path, &gallery_pref_id)) {
     error_ = kInvalidGalleryIDError;
-    return false;
+    HandleResponse(gallery_pref_id, false);
+    return;
   }
 
 #if defined(OS_WIN)
   MediaGalleriesPrivateEventRouter* router =
       MediaGalleriesPrivateAPI::Get(profile_)->GetEventRouter();
   DCHECK(router);
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&GalleryWatchManager::SetupGalleryWatch,
                  profile_,
                  gallery_pref_id,
                  gallery_file_path,
                  extension_id(),
                  router->AsWeakPtr()),
       base::Bind(&MediaGalleriesPrivateAddGalleryWatchFunction::HandleResponse,
                  this,
                  gallery_pref_id));
 #else
   // Recursive gallery watch operation is not currently supported on
   // non-windows platforms. Please refer to crbug.com/144491 for more details.
   HandleResponse(gallery_pref_id, false);
 #endif
-  return true;
 }
 
 void MediaGalleriesPrivateAddGalleryWatchFunction::HandleResponse(
     chrome::MediaGalleryPrefId gallery_id,
     bool success) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   extensions::api::media_galleries_private::AddGalleryWatchResult result;
   result.gallery_id = base::Uint64ToString(gallery_id);
   result.success = success;
   SetResult(result.ToValue().release());
   if (success) {
+    DCHECK(chrome::StorageMonitor::GetInstance()->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 defined(OS_WIN)
   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());
 
+  chrome::StorageMonitor::GetInstance()->Initialize(base::Bind(
+      &MediaGalleriesPrivateRemoveGalleryWatchFunction::OnStorageMonitorInit,
+      this,
+      params->gallery_id));
+  return true;
+}
+
+void MediaGalleriesPrivateRemoveGalleryWatchFunction::OnStorageMonitorInit(
+    const std::string& pref_id) {
+  DCHECK(chrome::StorageMonitor::GetInstance()->IsInitialized());
+#if defined(OS_WIN)
   base::FilePath gallery_file_path;
   chrome::MediaGalleryPrefId gallery_pref_id = 0;
-  if (!GetGalleryFilePathAndId(params->gallery_id, profile_, GetExtension(),
+  if (!GetGalleryFilePathAndId(pref_id, profile_, GetExtension(),
                                &gallery_file_path, &gallery_pref_id)) {
     error_ = kInvalidGalleryIDError;
-    return false;
+    SendResponse(false);
+    return;
   }
 
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&GalleryWatchManager::RemoveGalleryWatch,
                  profile_,
                  gallery_file_path,
                  extension_id()));
 
   GalleryWatchStateTracker* state_tracker =
       MediaGalleriesPrivateAPI::Get(profile_)->GetGalleryWatchStateTracker();
   state_tracker->OnGalleryWatchRemoved(extension_id(), gallery_pref_id);
 #endif
-  return true;
+  SendResponse(true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //              MediaGalleriesPrivateGetAllGalleryWatchFunction              //
 ///////////////////////////////////////////////////////////////////////////////
 
 MediaGalleriesPrivateGetAllGalleryWatchFunction::
 ~MediaGalleriesPrivateGetAllGalleryWatchFunction() {
 }
 
 bool MediaGalleriesPrivateGetAllGalleryWatchFunction::RunImpl() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (!render_view_host() || !render_view_host()->GetProcess())
     return false;
 
+  chrome::StorageMonitor::GetInstance()->Initialize(base::Bind(
+      &MediaGalleriesPrivateGetAllGalleryWatchFunction::OnStorageMonitorInit,
+      this));
+  return true;
+}
+
+void MediaGalleriesPrivateGetAllGalleryWatchFunction::OnStorageMonitorInit() {
   std::vector<std::string> result;
 #if defined(OS_WIN)
+  DCHECK(chrome::StorageMonitor::GetInstance()->IsInitialized());
   GalleryWatchStateTracker* state_tracker =
       MediaGalleriesPrivateAPI::Get(profile_)->GetGalleryWatchStateTracker();
   chrome::MediaGalleryPrefIdSet gallery_ids =
       state_tracker->GetAllWatchedGalleryIDsForExtension(extension_id());
   for (chrome::MediaGalleryPrefIdSet::const_iterator iter =
            gallery_ids.begin();
        iter != gallery_ids.end(); ++iter) {
     result.push_back(base::Uint64ToString(*iter));
   }
 #endif
   results_ = GetAllGalleryWatch::Results::Create(result);
-  return true;
+  SendResponse(true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //              MediaGalleriesPrivateRemoveAllGalleryWatchFunction           //
 ///////////////////////////////////////////////////////////////////////////////
 
 MediaGalleriesPrivateRemoveAllGalleryWatchFunction::
 ~MediaGalleriesPrivateRemoveAllGalleryWatchFunction() {
 }
 
 bool MediaGalleriesPrivateRemoveAllGalleryWatchFunction::RunImpl() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-#if defined(OS_WIN)
   if (!render_view_host() || !render_view_host()->GetProcess())
     return false;
 
+  chrome::StorageMonitor::GetInstance()->Initialize(base::Bind(
+      &MediaGalleriesPrivateRemoveAllGalleryWatchFunction::OnStorageMonitorInit,
+      this));
+  return true;
+}
+
+void
+MediaGalleriesPrivateRemoveAllGalleryWatchFunction::OnStorageMonitorInit() {
+#if defined(OS_WIN)
+  DCHECK(chrome::StorageMonitor::GetInstance()->IsInitialized());
   chrome::MediaFileSystemRegistry* registry =
       g_browser_process->media_file_system_registry();
   chrome::MediaGalleriesPreferences* preferences =
       registry->GetPreferences(profile_);
   GalleryWatchStateTracker* state_tracker =
       MediaGalleriesPrivateAPI::Get(profile_)->GetGalleryWatchStateTracker();
   state_tracker->RemoveAllGalleryWatchersForExtension(
       extension_id(), preferences);
 #endif
-  return true;
+  SendResponse(true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //              MediaGalleriesPrivateEjectDeviceFunction                     //
 ///////////////////////////////////////////////////////////////////////////////
 
 MediaGalleriesPrivateEjectDeviceFunction::
 ~MediaGalleriesPrivateEjectDeviceFunction() {
 }
 
 bool MediaGalleriesPrivateEjectDeviceFunction::RunImpl() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   scoped_ptr<EjectDevice::Params> params(EjectDevice::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
+  chrome::StorageMonitor::GetInstance()->Initialize(base::Bind(
+      &MediaGalleriesPrivateEjectDeviceFunction::OnStorageMonitorInit,
+      this,
+      params->device_id));
+  return true;
+}
+
+void MediaGalleriesPrivateEjectDeviceFunction::OnStorageMonitorInit(
+    const std::string& transient_device_id) {
+  DCHECK(chrome::StorageMonitor::GetInstance()->IsInitialized());
   chrome::StorageMonitor* monitor = chrome::StorageMonitor::GetInstance();
   std::string device_id_str =
-      monitor->GetDeviceIdForTransientId(params->device_id);
+      monitor->GetDeviceIdForTransientId(transient_device_id);
   if (device_id_str == "") {
     HandleResponse(chrome::StorageMonitor::EJECT_NO_SUCH_DEVICE);
-    return true;
+    return;
   }
 
   monitor->EjectDevice(
       device_id_str,
       base::Bind(&MediaGalleriesPrivateEjectDeviceFunction::HandleResponse,
                  this));
-
-  return true;
 }
 
 void MediaGalleriesPrivateEjectDeviceFunction::HandleResponse(
     chrome::StorageMonitor::EjectStatus status) {
   using extensions::api::media_galleries_private::
       EJECT_DEVICE_RESULT_CODE_FAILURE;
   using extensions::api::media_galleries_private::
       EJECT_DEVICE_RESULT_CODE_IN_USE;
   using extensions::api::media_galleries_private::
       EJECT_DEVICE_RESULT_CODE_NO_SUCH_DEVICE;
@@ skipping 58 matching lines @@
     }
   }
 
   SetResult(result_list);
   SendResponse(true);
 
   return true;
 }
 
 }  // namespace extensions