Cleanup: Remove chrome namespace for storage monitor and media galleries.

chrome/browser/extensions/api/media_galleries_private/gallery_watch_manager.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.
 //
 // GalleryWatchManager implementation.
 
 #include "chrome/browser/extensions/api/media_galleries_private/gallery_watch_manager.h"
 
 #include <list>
 #include <set>
@@ skipping 18 matching lines @@
 // Map to keep track of profile specific GalleryWatchManager objects.
 // Key: Profile identifier.
 // Value: GalleryWatchManager*.
 // This map owns the GalleryWatchManager object.
 typedef std::map<void*, extensions::GalleryWatchManager*> WatchManagerMap;
 WatchManagerMap* g_gallery_watch_managers = NULL;
 
 // Dispatches the gallery changed event on the UI thread.
 void SendGalleryChangedEventOnUIThread(
     base::WeakPtr<MediaGalleriesPrivateEventRouter> event_router,
-    chrome::MediaGalleryPrefId gallery_id,
+    MediaGalleryPrefId gallery_id,
     const std::set<std::string>& extension_ids) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (event_router.get())
     event_router->OnGalleryChanged(gallery_id, extension_ids);
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 //            GalleryWatchManager::GalleryFilePathWatcher                    //
 ///////////////////////////////////////////////////////////////////////////////
 
 // This class does a recursive watch on the gallery file path and holds a list
 // of extensions that are watching the gallery. When there is a file system
 // activity within the gallery, GalleryFilePathWatcher notifies the interested
 // extensions. This class lives on the file thread.
 class GalleryWatchManager::GalleryFilePathWatcher
     : public base::RefCounted<GalleryFilePathWatcher> {
  public:
   // |on_destroyed_callback| is called when the last GalleryFilePathWatcher
   // reference goes away.
   GalleryFilePathWatcher(
       base::WeakPtr<MediaGalleriesPrivateEventRouter> event_router,
-      chrome::MediaGalleryPrefId gallery_id,
+      MediaGalleryPrefId gallery_id,
       const base::FilePath& path,
       const std::string& extension_id,
       const base::Closure& on_destroyed_callback);
 
   // Adds the extension reference to the watched gallery.
   void AddExtension(const std::string& extension_id);
 
   // Removes the extension reference to the watched gallery.
   void RemoveExtension(const std::string& extension_id);
 
@@ skipping 23 matching lines @@
   void OnFilePathChanged(const base::FilePath& path, bool error);
 
   // Remove the watch references for the extension specified by the
   // |extension_id|.
   void RemoveExtensionReferences(const std::string& extension_id);
 
   // Used to notify the interested extensions about the gallery changed event.
   base::WeakPtr<MediaGalleriesPrivateEventRouter> event_router_;
 
   // The gallery identifier, e.g "1".
-  chrome::MediaGalleryPrefId gallery_id_;
+  MediaGalleryPrefId gallery_id_;
 
   // The gallery file path watcher.
   base::FilePathWatcher file_watcher_;
 
   // The gallery file path, e.g "C:\My Pictures".
   base::FilePath gallery_path_;
 
   // A callback to call when |this| object is destroyed.
   base::Closure on_destroyed_callback_;
 
   // Map to keep track of the extension and its corresponding watch count.
   ExtensionWatchInfoMap extension_watch_info_map_;
 
   // Used to provide a weak pointer to FilePathWatcher callback.
   base::WeakPtrFactory<GalleryFilePathWatcher> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GalleryFilePathWatcher);
 };
 
 GalleryWatchManager::GalleryFilePathWatcher::GalleryFilePathWatcher(
     base::WeakPtr<MediaGalleriesPrivateEventRouter> event_router,
-    chrome::MediaGalleryPrefId gallery_id,
+    MediaGalleryPrefId gallery_id,
     const base::FilePath& path,
     const std::string& extension_id,
     const base::Closure& on_destroyed_callback)
     : event_router_(event_router),
       gallery_id_(gallery_id),
       on_destroyed_callback_(on_destroyed_callback),
       weak_ptr_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   gallery_path_ = path;
   AddExtension(extension_id);
@@ skipping 129 matching lines @@
     return;
   delete it->second;
   g_gallery_watch_managers->erase(it);
   if (g_gallery_watch_managers->empty())
     delete g_gallery_watch_managers;
 }
 
 // static
 bool GalleryWatchManager::SetupGalleryWatch(
     void* profile_id,
-    chrome::MediaGalleryPrefId gallery_id,
+    MediaGalleryPrefId gallery_id,
     const base::FilePath& watch_path,
     const std::string& extension_id,
     base::WeakPtr<MediaGalleriesPrivateEventRouter> event_router) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   return GalleryWatchManager::GetForProfile(profile_id)->StartGalleryWatch(
       gallery_id, watch_path, extension_id, event_router);
 }
 
 // static
 void GalleryWatchManager::RemoveGalleryWatch(void* profile_id,
@@ skipping 18 matching lines @@
 GalleryWatchManager::GalleryWatchManager() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
 GalleryWatchManager::~GalleryWatchManager() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DeleteAllWatchers();
 }
 
 bool GalleryWatchManager::StartGalleryWatch(
-    chrome::MediaGalleryPrefId gallery_id,
+    MediaGalleryPrefId gallery_id,
     const base::FilePath& watch_path,
     const std::string& extension_id,
     base::WeakPtr<MediaGalleriesPrivateEventRouter> event_router) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   WatcherMap::const_iterator iter = gallery_watchers_.find(watch_path);
   if (iter != gallery_watchers_.end()) {
     // Already watched.
     iter->second->AddExtension(extension_id);
     return true;
   }
@@ skipping 55 matching lines @@
     iter->second->RemoveAllWatchReferences();
 }
 
 void GalleryWatchManager::RemoveGalleryFilePathWatcherEntry(
     const base::FilePath& watch_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   gallery_watchers_.erase(watch_path);
 }
 
 }  // namespace extensions