Expose gallery watching functionality to the public mediaGalleries API.

chrome/browser/extensions/api/media_galleries/media_galleries_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.
 
 // Implements the Chrome Extensions Media Galleries API.
 
 #include "chrome/browser/extensions/api/media_galleries/media_galleries_api.h"
 
 #include <set>
 #include <string>
@@ skipping 50 matching lines @@
 using storage_monitor::MediaStorageUtil;
 using storage_monitor::StorageInfo;
 using web_modal::WebContentsModalDialogManager;
 
 namespace extensions {
 
 namespace MediaGalleries = api::media_galleries;
 namespace DropPermissionForMediaFileSystem =
     MediaGalleries::DropPermissionForMediaFileSystem;
 namespace GetMediaFileSystems = MediaGalleries::GetMediaFileSystems;
+namespace AddGalleryWatch = MediaGalleries::AddGalleryWatch;
+namespace RemoveGalleryWatch = MediaGalleries::RemoveGalleryWatch;
+namespace GetAllGalleryWatch = MediaGalleries::GetAllGalleryWatch;
 
 namespace {
 
 const char kDisallowedByPolicy[] =
     "Media Galleries API is disallowed by policy: ";
 const char kFailedToSetGalleryPermission[] =
     "Failed to set gallery permission.";
-const char kInvalidGalleryId[] = "Invalid gallery id.";
+const char kInvalidGalleryIdMsg[] = "Invalid gallery id.";
 const char kMissingEventListener[] = "Missing event listener registration.";
 const char kNonExistentGalleryId[] = "Non-existent gallery id.";
 const char kNoScanPermission[] = "No permission to scan.";
 
 const char kDeviceIdKey[] = "deviceId";
 const char kGalleryIdKey[] = "galleryId";
 const char kIsAvailableKey[] = "isAvailable";
 const char kIsMediaDeviceKey[] = "isMediaDevice";
 const char kIsRemovableKey[] = "isRemovable";
 const char kNameKey[] = "name";
 
 const char kMetadataKey[] = "metadata";
 const char kAttachedImagesBlobInfoKey[] = "attachedImagesBlobInfo";
 const char kBlobUUIDKey[] = "blobUUID";
 const char kTypeKey[] = "type";
 const char kSizeKey[] = "size";
 
+const char kInvalidGalleryId[] = "-1";
+
 MediaFileSystemRegistry* media_file_system_registry() {
   return g_browser_process->media_file_system_registry();
 }
 
 GalleryWatchManager* gallery_watch_manager() {
   return media_file_system_registry()->gallery_watch_manager();
 }
 
 MediaScanManager* media_scan_manager() {
   return media_file_system_registry()->media_scan_manager();
 }
 
 // Checks whether the MediaGalleries API is currently accessible (it may be
 // disallowed even if an extension has the requisite permission). Then
 // initializes the MediaGalleriesPreferences
 bool Setup(Profile* profile, std::string* error, base::Closure callback) {
   if (!ChromeSelectFilePolicy::FileSelectDialogsAllowed()) {
     *error = std::string(kDisallowedByPolicy) +
         prefs::kAllowFileSelectionDialogs;
     return false;
   }
 
   MediaGalleriesPreferences* preferences =
       media_file_system_registry()->GetPreferences(profile);
   preferences->EnsureInitialized(callback);
   return true;
 }
 
+// Returns true and sets |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;
+  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;
+}
+
 WebContents* GetWebContents(content::RenderViewHost* rvh,
                             Profile* profile,
                             const std::string& app_id) {
   WebContents* contents = WebContents::FromRenderViewHost(rvh);
   WebContentsModalDialogManager* web_contents_modal_dialog_manager =
       WebContentsModalDialogManager::FromWebContents(contents);
   if (!web_contents_modal_dialog_manager) {
     // If there is no WebContentsModalDialogManager, then this contents is
     // probably the background page for an app. Try to find a app window to
     // host the dialog.
@@ skipping 258 matching lines @@
 
   scoped_ptr<extensions::Event> event(
       new extensions::Event(event_name, event_args.Pass()));
   router->DispatchEventToExtension(extension_id, event.Pass());
 }
 
 void MediaGalleriesEventRouter::OnGalleryChanged(
     const std::string& extension_id, MediaGalleryPrefId gallery_id) {
   MediaGalleries::GalleryChangeDetails details;
   details.type = MediaGalleries::GALLERY_CHANGE_TYPE_CONTENTS_CHANGED;
-  details.gallery_id = gallery_id;
+  details.gallery_id = base::Uint64ToString(gallery_id);
   DispatchEventToExtension(
       extension_id,
       MediaGalleries::OnGalleryChanged::kEventName,
       MediaGalleries::OnGalleryChanged::Create(details).Pass());
 }
 
 void MediaGalleriesEventRouter::OnGalleryWatchDropped(
     const std::string& extension_id, MediaGalleryPrefId gallery_id) {
   MediaGalleries::GalleryChangeDetails details;
   details.type = MediaGalleries::GALLERY_CHANGE_TYPE_WATCH_DROPPED;
   details.gallery_id = gallery_id;
   DispatchEventToExtension(
       extension_id,
       MediaGalleries::OnGalleryChanged::kEventName,
       MediaGalleries::OnGalleryChanged::Create(details).Pass());
 }
 
 void MediaGalleriesEventRouter::OnListenerRemoved(
     const EventListenerInfo& details) {
   if (details.event_name == MediaGalleries::OnGalleryChanged::kEventName &&
       !ExtensionHasGalleryChangeListener(details.extension_id)) {
     gallery_watch_manager()->RemoveAllWatches(profile_, details.extension_id);
   }
 }
 
+///////////////////////////////////////////////////////////////////////////////
+//               MediaGalleriesGetMediaFileSystemsFunction                   //
+///////////////////////////////////////////////////////////////////////////////
 MediaGalleriesGetMediaFileSystemsFunction::
     ~MediaGalleriesGetMediaFileSystemsFunction() {}
 
 bool MediaGalleriesGetMediaFileSystemsFunction::RunAsync() {
   media_galleries::UsageCount(media_galleries::GET_MEDIA_FILE_SYSTEMS);
   scoped_ptr<GetMediaFileSystems::Params> params(
       GetMediaFileSystems::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   MediaGalleries::GetMediaFileSystemsInteractivity interactive =
       MediaGalleries::GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_NO;
@@ skipping 87 matching lines @@
   if (!render_view_host()) {
     cb.Run(std::vector<MediaFileSystemInfo>());
     return;
   }
   MediaFileSystemRegistry* registry = media_file_system_registry();
   DCHECK(registry->GetPreferences(GetProfile())->IsInitialized());
   registry->GetMediaFileSystemsForExtension(
       render_view_host(), extension(), cb);
 }
 
+
+///////////////////////////////////////////////////////////////////////////////
+//          MediaGalleriesGetAllMediaFileSystemMetadataFunction              //
+///////////////////////////////////////////////////////////////////////////////
 MediaGalleriesGetAllMediaFileSystemMetadataFunction::
     ~MediaGalleriesGetAllMediaFileSystemMetadataFunction() {}
 
 bool MediaGalleriesGetAllMediaFileSystemMetadataFunction::RunAsync() {
   media_galleries::UsageCount(
       media_galleries::GET_ALL_MEDIA_FILE_SYSTEM_METADATA);
   return Setup(GetProfile(), &error_, base::Bind(
       &MediaGalleriesGetAllMediaFileSystemMetadataFunction::OnPreferencesInit,
       this));
 }
@@ skipping 42 matching lines @@
     metadata.is_removable = StorageInfo::IsRemovableDevice(gallery.device_id);
     metadata.is_media_device = StorageInfo::IsMediaDevice(gallery.device_id);
     metadata.is_available = ContainsKey(*available_devices, gallery.device_id);
     list->Append(metadata.ToValue().release());
   }
 
   SetResult(list);
   SendResponse(true);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+//               MediaGalleriesAddUserSelectedFolderFunction                 //
+///////////////////////////////////////////////////////////////////////////////
 MediaGalleriesAddUserSelectedFolderFunction::
     ~MediaGalleriesAddUserSelectedFolderFunction() {}
 
 bool MediaGalleriesAddUserSelectedFolderFunction::RunAsync() {
   media_galleries::UsageCount(media_galleries::ADD_USER_SELECTED_FOLDER);
   return Setup(GetProfile(), &error_, base::Bind(
       &MediaGalleriesAddUserSelectedFolderFunction::OnPreferencesInit, this));
 }
 
 void MediaGalleriesAddUserSelectedFolderFunction::OnPreferencesInit() {
@@ skipping 89 matching lines @@
   if (!render_view_host()) {
     cb.Run(std::vector<MediaFileSystemInfo>());
     return;
   }
   MediaFileSystemRegistry* registry = media_file_system_registry();
   DCHECK(registry->GetPreferences(GetProfile())->IsInitialized());
   registry->GetMediaFileSystemsForExtension(
       render_view_host(), extension(), cb);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+//         MediaGalleriesDropPermissionForMediaFileSystemFunction            //
+///////////////////////////////////////////////////////////////////////////////
 MediaGalleriesDropPermissionForMediaFileSystemFunction::
     ~MediaGalleriesDropPermissionForMediaFileSystemFunction() {}
 
 bool MediaGalleriesDropPermissionForMediaFileSystemFunction::RunAsync() {
   media_galleries::UsageCount(
       media_galleries::DROP_PERMISSION_FOR_MEDIA_FILE_SYSTEM);
 
   scoped_ptr<DropPermissionForMediaFileSystem::Params> params(
       DropPermissionForMediaFileSystem::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   MediaGalleryPrefId pref_id;
   if (!base::StringToUint64(params->gallery_id, &pref_id)) {
-    error_ = kInvalidGalleryId;
+    error_ = kInvalidGalleryIdMsg;
     return false;
   }
 
   base::Closure callback = base::Bind(
       &MediaGalleriesDropPermissionForMediaFileSystemFunction::
           OnPreferencesInit,
       this,
       pref_id);
   return Setup(GetProfile(), &error_, callback);
 }
@@ skipping 10 matching lines @@
 
   bool dropped = preferences->SetGalleryPermissionForExtension(
       *extension(), pref_id, false);
   if (dropped)
     SetResult(new base::StringValue(base::Uint64ToString(pref_id)));
   else
     error_ = kFailedToSetGalleryPermission;
   SendResponse(dropped);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+//                 MediaGalleriesStartMediaScanFunction                      //
+///////////////////////////////////////////////////////////////////////////////
 MediaGalleriesStartMediaScanFunction::~MediaGalleriesStartMediaScanFunction() {}
 
 bool MediaGalleriesStartMediaScanFunction::RunAsync() {
   media_galleries::UsageCount(media_galleries::START_MEDIA_SCAN);
   if (!CheckScanPermission(extension(), &error_)) {
     MediaGalleriesEventRouter::Get(GetProfile())
         ->OnScanError(extension()->id());
     return false;
   }
   return Setup(GetProfile(), &error_, base::Bind(
       &MediaGalleriesStartMediaScanFunction::OnPreferencesInit, this));
 }
 
 void MediaGalleriesStartMediaScanFunction::OnPreferencesInit() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   MediaGalleriesEventRouter* api = MediaGalleriesEventRouter::Get(GetProfile());
   if (!api->ExtensionHasScanProgressListener(extension()->id())) {
     error_ = kMissingEventListener;
     SendResponse(false);
     return;
   }
 
   media_scan_manager()->StartScan(GetProfile(), extension(), user_gesture());
   SendResponse(true);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+//                MediaGalleriesCancelMediaScanFunction                      //
+///////////////////////////////////////////////////////////////////////////////
 MediaGalleriesCancelMediaScanFunction::
     ~MediaGalleriesCancelMediaScanFunction() {
 }
 
 bool MediaGalleriesCancelMediaScanFunction::RunAsync() {
   media_galleries::UsageCount(media_galleries::CANCEL_MEDIA_SCAN);
   if (!CheckScanPermission(extension(), &error_)) {
     MediaGalleriesEventRouter::Get(GetProfile())
         ->OnScanError(extension()->id());
     return false;
   }
   return Setup(GetProfile(), &error_, base::Bind(
       &MediaGalleriesCancelMediaScanFunction::OnPreferencesInit, this));
 }
 
 void MediaGalleriesCancelMediaScanFunction::OnPreferencesInit() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   media_scan_manager()->CancelScan(GetProfile(), extension());
   SendResponse(true);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+//                MediaGalleriesAddScanResultsFunction                       //
+///////////////////////////////////////////////////////////////////////////////
 MediaGalleriesAddScanResultsFunction::~MediaGalleriesAddScanResultsFunction() {}
 
 bool MediaGalleriesAddScanResultsFunction::RunAsync() {
   media_galleries::UsageCount(media_galleries::ADD_SCAN_RESULTS);
   if (!CheckScanPermission(extension(), &error_)) {
     // We don't fire a scan progress error here, as it would be unintuitive.
     return false;
   }
   if (!user_gesture())
     return false;
@@ skipping 54 matching lines @@
   if (!list.get()) {
     SendResponse(false);
     return;
   }
 
   // The custom JS binding will use this list to create DOMFileSystem objects.
   SetResult(list.release());
   SendResponse(true);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+//                 MediaGalleriesGetMetadataFunction                         //
+///////////////////////////////////////////////////////////////////////////////
 MediaGalleriesGetMetadataFunction::~MediaGalleriesGetMetadataFunction() {}
 
 bool MediaGalleriesGetMetadataFunction::RunAsync() {
   std::string blob_uuid;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &blob_uuid));
 
   const base::Value* options_value = NULL;
   if (!args_->Get(1, &options_value))
     return false;
   scoped_ptr<MediaGalleries::MediaMetadataOptions> options =
@@ skipping 147 matching lines @@
                    base::Passed(&attached_images), base::Passed(&blob_uuids)));
     return;
   }
 
   // All Blobs have been constructed. The renderer will take ownership.
   SetResult(result_dictionary.release());
   SetTransferredBlobUUIDs(*blob_uuids);
   SendResponse(true);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+//              MediaGalleriesAddGalleryWatchFunction                        //
+///////////////////////////////////////////////////////////////////////////////
+MediaGalleriesAddGalleryWatchFunction::
+    ~MediaGalleriesAddGalleryWatchFunction() {
+}
+
+bool MediaGalleriesAddGalleryWatchFunction::RunAsync() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(GetProfile());
+  if (!render_view_host() || !render_view_host()->GetProcess())
+    return false;
+
+  scoped_ptr<AddGalleryWatch::Params> params(
+      AddGalleryWatch::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  MediaGalleriesPreferences* preferences =
+      g_browser_process->media_file_system_registry()->GetPreferences(
+          GetProfile());
+  preferences->EnsureInitialized(
+      base::Bind(&MediaGalleriesAddGalleryWatchFunction::OnPreferencesInit,
+                 this,
+                 params->gallery_id));
+
+  return true;
+}
+
+void MediaGalleriesAddGalleryWatchFunction::OnPreferencesInit(
+    const std::string& pref_id) {
+  base::FilePath gallery_file_path;
+  MediaGalleryPrefId gallery_pref_id = kInvalidMediaGalleryPrefId;
+  if (!GetGalleryFilePathAndId(pref_id,
+                               GetProfile(),
+                               extension(),
+                               &gallery_file_path,
+                               &gallery_pref_id)) {
+    api::media_galleries::AddGalleryWatchResult result;
+    error_ = kInvalidGalleryIdMsg;
+    result.gallery_id = kInvalidGalleryId;
+    result.success = false;
+    SetResult(result.ToValue().release());
+    SendResponse(false);
+    return;
+  }
+
+  gallery_watch_manager()->AddWatch(
+      GetProfile(),
+      extension(),
+      gallery_pref_id,
+      base::Bind(&MediaGalleriesAddGalleryWatchFunction::HandleResponse,
+                 this,
+                 gallery_pref_id));
+}
+
+void MediaGalleriesAddGalleryWatchFunction::HandleResponse(
+    MediaGalleryPrefId gallery_id,
+    const std::string& error) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  // If an app added a file watch without any event listeners on the
+  // onGalleryChanged event, that's an error.
+  MediaGalleriesEventRouter* api = MediaGalleriesEventRouter::Get(GetProfile());
+  api::media_galleries::AddGalleryWatchResult result;
+  result.gallery_id = base::Uint64ToString(gallery_id);
+
+  if (!api->ExtensionHasGalleryChangeListener(extension()->id())) {
+    result.success = false;
+    SetResult(result.ToValue().release());
+    error_ = kMissingEventListener;
+    SendResponse(false);
+    return;
+  }
+
+  result.success = error.empty();
+  SetResult(result.ToValue().release());
+  if (error.empty()) {
+    SendResponse(true);
+  } else {
+    error_ = error.c_str();
+    SendResponse(false);
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//              MediaGalleriesRemoveGalleryWatchFunction                     //
+///////////////////////////////////////////////////////////////////////////////
+
+MediaGalleriesRemoveGalleryWatchFunction::
+    ~MediaGalleriesRemoveGalleryWatchFunction() {
+}
+
+bool MediaGalleriesRemoveGalleryWatchFunction::RunAsync() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (!render_view_host() || !render_view_host()->GetProcess())
+    return false;
+
+  scoped_ptr<RemoveGalleryWatch::Params> params(
+      RemoveGalleryWatch::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  MediaGalleriesPreferences* preferences =
+      g_browser_process->media_file_system_registry()->GetPreferences(
+          GetProfile());
+  preferences->EnsureInitialized(
+      base::Bind(&MediaGalleriesRemoveGalleryWatchFunction::OnPreferencesInit,
+                 this,
+                 params->gallery_id));
+  return true;
+}
+
+void MediaGalleriesRemoveGalleryWatchFunction::OnPreferencesInit(
+    const std::string& pref_id) {
+  base::FilePath gallery_file_path;
+  MediaGalleryPrefId gallery_pref_id = 0;
+  if (!GetGalleryFilePathAndId(pref_id,
+                               GetProfile(),
+                               extension(),
+                               &gallery_file_path,
+                               &gallery_pref_id)) {
+    error_ = kInvalidGalleryIdMsg;
+    SendResponse(false);
+    return;
+  }
+
+  gallery_watch_manager()->RemoveWatch(
+      GetProfile(), extension_id(), gallery_pref_id);
+  SendResponse(true);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//              MediaGalleriesGetAllGalleryWatchFunction                     //
+///////////////////////////////////////////////////////////////////////////////
+
+MediaGalleriesGetAllGalleryWatchFunction::
+    ~MediaGalleriesGetAllGalleryWatchFunction() {
+}
+
+bool MediaGalleriesGetAllGalleryWatchFunction::RunAsync() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (!render_view_host() || !render_view_host()->GetProcess())
+    return false;
+
+  MediaGalleriesPreferences* preferences =
+      g_browser_process->media_file_system_registry()->GetPreferences(
+          GetProfile());
+  preferences->EnsureInitialized(base::Bind(
+      &MediaGalleriesGetAllGalleryWatchFunction::OnPreferencesInit, this));
+  return true;
+}
+
+void MediaGalleriesGetAllGalleryWatchFunction::OnPreferencesInit() {
+  std::vector<std::string> result;
+  MediaGalleryPrefIdSet gallery_ids =
+      gallery_watch_manager()->GetWatchSet(GetProfile(), extension_id());
+  for (MediaGalleryPrefIdSet::const_iterator iter = gallery_ids.begin();
+       iter != gallery_ids.end();
+       ++iter) {
+    result.push_back(base::Uint64ToString(*iter));
+  }
+  results_ = GetAllGalleryWatch::Results::Create(result);
+  SendResponse(true);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//              MediaGalleriesRemoveAllGalleryWatchFunction                  //
+///////////////////////////////////////////////////////////////////////////////
+
+MediaGalleriesRemoveAllGalleryWatchFunction::
+    ~MediaGalleriesRemoveAllGalleryWatchFunction() {
+}
+
+bool MediaGalleriesRemoveAllGalleryWatchFunction::RunAsync() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (!render_view_host() || !render_view_host()->GetProcess())
+    return false;
+
+  MediaGalleriesPreferences* preferences =
+      g_browser_process->media_file_system_registry()->GetPreferences(
+          GetProfile());
+  preferences->EnsureInitialized(base::Bind(
+      &MediaGalleriesRemoveAllGalleryWatchFunction::OnPreferencesInit, this));
+  return true;
+}
+
+void MediaGalleriesRemoveAllGalleryWatchFunction::OnPreferencesInit() {
+  gallery_watch_manager()->RemoveAllWatches(GetProfile(), extension_id());
+  SendResponse(true);
+}
+
 }  // namespace extensions