src/chrome/browser/extensions/api/media_galleries/media_galleries_api.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Implements the Chrome Extensions Media Galleries API.
   6
   7 #include "chrome/browser/extensions/api/media_galleries/media_galleries_api.h"
   8
   9 #include <set>
  10 #include <string>
  11 #include <vector>
  12
  13 #include "base/callback.h"
  14 #include "base/lazy_instance.h"
  15 #include "base/numerics/safe_conversions.h"
  16 #include "base/stl_util.h"
  17 #include "base/strings/string_number_conversions.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "base/values.h"
  20 #include "chrome/browser/browser_process.h"
  21 #include "chrome/browser/extensions/api/file_system/file_system_api.h"
  22 #include "chrome/browser/extensions/blob_reader.h"
  23 #include "chrome/browser/extensions/extension_tab_util.h"
  24 #include "chrome/browser/media_galleries/fileapi/safe_media_metadata_parser.h"
  25 #include "chrome/browser/media_galleries/gallery_watch_manager.h"
  26 #include "chrome/browser/media_galleries/media_file_system_registry.h"
  27 #include "chrome/browser/media_galleries/media_galleries_histograms.h"
  28 #include "chrome/browser/media_galleries/media_galleries_permission_controller.h"
  29 #include "chrome/browser/media_galleries/media_galleries_preferences.h"
  30 #include "chrome/browser/media_galleries/media_galleries_scan_result_controller.h"
  31 #include "chrome/browser/media_galleries/media_scan_manager.h"
  32 #include "chrome/browser/platform_util.h"
  33 #include "chrome/browser/profiles/profile.h"
  34 #include "chrome/browser/ui/chrome_select_file_policy.h"
  35 #include "chrome/common/extensions/api/media_galleries.h"
  36 #include "chrome/common/pref_names.h"
  37 #include "chrome/grit/generated_resources.h"
  38 #include "components/storage_monitor/storage_info.h"
  39 #include "components/web_modal/web_contents_modal_dialog_manager.h"
  40 #include "content/public/browser/blob_handle.h"
  41 #include "content/public/browser/browser_context.h"
  42 #include "content/public/browser/browser_thread.h"
  43 #include "content/public/browser/child_process_security_policy.h"
  44 #include "content/public/browser/render_process_host.h"
  45 #include "content/public/browser/render_view_host.h"
  46 #include "content/public/browser/web_contents.h"
  47 #include "extensions/browser/app_window/app_window.h"
  48 #include "extensions/browser/app_window/app_window_registry.h"
  49 #include "extensions/browser/blob_holder.h"
  50 #include "extensions/browser/extension_prefs.h"
  51 #include "extensions/browser/extension_system.h"
  52 #include "extensions/common/extension.h"
  53 #include "extensions/common/permissions/api_permission.h"
  54 #include "extensions/common/permissions/media_galleries_permission.h"
  55 #include "extensions/common/permissions/permissions_data.h"
  56 #include "net/base/mime_sniffer.h"
  57 #include "storage/browser/blob/blob_data_handle.h"
  58 #include "ui/base/l10n/l10n_util.h"
  59
  60 using content::WebContents;
  61 using storage_monitor::MediaStorageUtil;
  62 using storage_monitor::StorageInfo;
  63 using web_modal::WebContentsModalDialogManager;
  64
  65 namespace extensions {
  66
  67 namespace MediaGalleries = api::media_galleries;
  68 namespace DropPermissionForMediaFileSystem =
  69     MediaGalleries::DropPermissionForMediaFileSystem;
  70 namespace GetMediaFileSystems = MediaGalleries::GetMediaFileSystems;
  71 namespace AddGalleryWatch = MediaGalleries::AddGalleryWatch;
  72 namespace RemoveGalleryWatch = MediaGalleries::RemoveGalleryWatch;
  73 namespace GetAllGalleryWatch = MediaGalleries::GetAllGalleryWatch;
  74
  75 namespace {
  76
  77 const char kDisallowedByPolicy[] =
  78     "Media Galleries API is disallowed by policy: ";
  79 const char kFailedToSetGalleryPermission[] =
  80     "Failed to set gallery permission.";
  81 const char kInvalidGalleryIdMsg[] = "Invalid gallery id.";
  82 const char kMissingEventListener[] = "Missing event listener registration.";
  83 const char kNonExistentGalleryId[] = "Non-existent gallery id.";
  84 const char kNoScanPermission[] = "No permission to scan.";
  85
  86 const char kDeviceIdKey[] = "deviceId";
  87 const char kGalleryIdKey[] = "galleryId";
  88 const char kIsAvailableKey[] = "isAvailable";
  89 const char kIsMediaDeviceKey[] = "isMediaDevice";
  90 const char kIsRemovableKey[] = "isRemovable";
  91 const char kNameKey[] = "name";
  92
  93 const char kMetadataKey[] = "metadata";
  94 const char kAttachedImagesBlobInfoKey[] = "attachedImagesBlobInfo";
  95 const char kBlobUUIDKey[] = "blobUUID";
  96 const char kTypeKey[] = "type";
  97 const char kSizeKey[] = "size";
  98
  99 const char kInvalidGalleryId[] = "-1";
 100
 101 MediaFileSystemRegistry* media_file_system_registry() {
 102   return g_browser_process->media_file_system_registry();
 103 }
 104
 105 GalleryWatchManager* gallery_watch_manager() {
 106   return media_file_system_registry()->gallery_watch_manager();
 107 }
 108
 109 MediaScanManager* media_scan_manager() {
 110   return media_file_system_registry()->media_scan_manager();
 111 }
 112
 113 // Checks whether the MediaGalleries API is currently accessible (it may be
 114 // disallowed even if an extension has the requisite permission). Then
 115 // initializes the MediaGalleriesPreferences
 116 bool Setup(Profile* profile, std::string* error, base::Closure callback) {
 117   if (!ChromeSelectFilePolicy::FileSelectDialogsAllowed()) {
 118     *error = std::string(kDisallowedByPolicy) +
 119         prefs::kAllowFileSelectionDialogs;
 120     return false;
 121   }
 122
 123   MediaGalleriesPreferences* preferences =
 124       media_file_system_registry()->GetPreferences(profile);
 125   preferences->EnsureInitialized(callback);
 126   return true;
 127 }
 128
 129 // Returns true and sets |gallery_file_path| and |gallery_pref_id| if the
 130 // |gallery_id| is valid and returns false otherwise.
 131 bool GetGalleryFilePathAndId(const std::string& gallery_id,
 132                              Profile* profile,
 133                              const Extension* extension,
 134                              base::FilePath* gallery_file_path,
 135                              MediaGalleryPrefId* gallery_pref_id) {
 136   MediaGalleryPrefId pref_id;
 137   if (!base::StringToUint64(gallery_id, &pref_id))
 138     return false;
 139   MediaGalleriesPreferences* preferences =
 140       g_browser_process->media_file_system_registry()->GetPreferences(profile);
 141   base::FilePath file_path(
 142       preferences->LookUpGalleryPathForExtension(pref_id, extension, false));
 143   if (file_path.empty())
 144     return false;
 145   *gallery_pref_id = pref_id;
 146   *gallery_file_path = file_path;
 147   return true;
 148 }
 149
 150 WebContents* GetWebContents(content::RenderViewHost* rvh,
 151                             Profile* profile,
 152                             const std::string& app_id) {
 153   WebContents* contents = WebContents::FromRenderViewHost(rvh);
 154   WebContentsModalDialogManager* web_contents_modal_dialog_manager =
 155       WebContentsModalDialogManager::FromWebContents(contents);
 156   if (!web_contents_modal_dialog_manager) {
 157     // If there is no WebContentsModalDialogManager, then this contents is
 158     // probably the background page for an app. Try to find a app window to
 159     // host the dialog.
 160     AppWindow* window = AppWindowRegistry::Get(profile)
 161                             ->GetCurrentAppWindowForApp(app_id);
 162     contents = window ? window->web_contents() : NULL;
 163   }
 164   return contents;
 165 }
 166
 167 base::ListValue* ConstructFileSystemList(
 168     content::RenderViewHost* rvh,
 169     const Extension* extension,
 170     const std::vector<MediaFileSystemInfo>& filesystems) {
 171   if (!rvh)
 172     return NULL;
 173
 174   MediaGalleriesPermission::CheckParam read_param(
 175       MediaGalleriesPermission::kReadPermission);
 176   const PermissionsData* permissions_data = extension->permissions_data();
 177   bool has_read_permission = permissions_data->CheckAPIPermissionWithParam(
 178       APIPermission::kMediaGalleries, &read_param);
 179   MediaGalleriesPermission::CheckParam copy_to_param(
 180       MediaGalleriesPermission::kCopyToPermission);
 181   bool has_copy_to_permission = permissions_data->CheckAPIPermissionWithParam(
 182       APIPermission::kMediaGalleries, &copy_to_param);
 183   MediaGalleriesPermission::CheckParam delete_param(
 184       MediaGalleriesPermission::kDeletePermission);
 185   bool has_delete_permission = permissions_data->CheckAPIPermissionWithParam(
 186       APIPermission::kMediaGalleries, &delete_param);
 187
 188   const int child_id = rvh->GetProcess()->GetID();
 189   scoped_ptr<base::ListValue> list(new base::ListValue());
 190   for (size_t i = 0; i < filesystems.size(); ++i) {
 191     scoped_ptr<base::DictionaryValue> file_system_dict_value(
 192         new base::DictionaryValue());
 193
 194     // Send the file system id so the renderer can create a valid FileSystem
 195     // object.
 196     file_system_dict_value->SetStringWithoutPathExpansion(
 197         "fsid", filesystems[i].fsid);
 198
 199     file_system_dict_value->SetStringWithoutPathExpansion(
 200         kNameKey, filesystems[i].name);
 201     file_system_dict_value->SetStringWithoutPathExpansion(
 202         kGalleryIdKey,
 203         base::Uint64ToString(filesystems[i].pref_id));
 204     if (!filesystems[i].transient_device_id.empty()) {
 205       file_system_dict_value->SetStringWithoutPathExpansion(
 206           kDeviceIdKey, filesystems[i].transient_device_id);
 207     }
 208     file_system_dict_value->SetBooleanWithoutPathExpansion(
 209         kIsRemovableKey, filesystems[i].removable);
 210     file_system_dict_value->SetBooleanWithoutPathExpansion(
 211         kIsMediaDeviceKey, filesystems[i].media_device);
 212     file_system_dict_value->SetBooleanWithoutPathExpansion(
 213         kIsAvailableKey, true);
 214
 215     list->Append(file_system_dict_value.release());
 216
 217     if (filesystems[i].path.empty())
 218       continue;
 219
 220     if (has_read_permission) {
 221       content::ChildProcessSecurityPolicy* policy =
 222           content::ChildProcessSecurityPolicy::GetInstance();
 223       policy->GrantReadFile(child_id, filesystems[i].path);
 224       if (has_delete_permission) {
 225         policy->GrantDeleteFrom(child_id, filesystems[i].path);
 226         if (has_copy_to_permission) {
 227           policy->GrantCopyInto(child_id, filesystems[i].path);
 228         }
 229       }
 230     }
 231   }
 232
 233   return list.release();
 234 }
 235
 236 bool CheckScanPermission(const extensions::Extension* extension,
 237                          std::string* error) {
 238   DCHECK(extension);
 239   DCHECK(error);
 240   MediaGalleriesPermission::CheckParam scan_param(
 241       MediaGalleriesPermission::kScanPermission);
 242   bool has_scan_permission =
 243       extension->permissions_data()->CheckAPIPermissionWithParam(
 244           APIPermission::kMediaGalleries, &scan_param);
 245   if (!has_scan_permission)
 246     *error = kNoScanPermission;
 247   return has_scan_permission;
 248 }
 249
 250 class SelectDirectoryDialog : public ui::SelectFileDialog::Listener,
 251                               public base::RefCounted<SelectDirectoryDialog> {
 252  public:
 253   // Selected file path, or an empty path if the user canceled.
 254   typedef base::Callback<void(const base::FilePath&)> Callback;
 255
 256   SelectDirectoryDialog(WebContents* web_contents, const Callback& callback)
 257       : web_contents_(web_contents),
 258         callback_(callback) {
 259     select_file_dialog_ = ui::SelectFileDialog::Create(
 260         this, new ChromeSelectFilePolicy(web_contents));
 261   }
 262
 263   void Show(const base::FilePath& default_path) {
 264     AddRef();  // Balanced in the two reachable listener outcomes.
 265     select_file_dialog_->SelectFile(
 266       ui::SelectFileDialog::SELECT_FOLDER,
 267       l10n_util::GetStringUTF16(IDS_MEDIA_GALLERIES_DIALOG_ADD_GALLERY_TITLE),
 268       default_path,
 269       NULL,
 270       0,
 271       base::FilePath::StringType(),
 272       platform_util::GetTopLevel(web_contents_->GetNativeView()),
 273       NULL);
 274   }
 275
 276   // ui::SelectFileDialog::Listener implementation.
 277   virtual void FileSelected(const base::FilePath& path,
 278                             int index,
 279                             void* params) OVERRIDE {
 280     callback_.Run(path);
 281     Release();  // Balanced in Show().
 282   }
 283
 284   virtual void MultiFilesSelected(const std::vector<base::FilePath>& files,
 285                                   void* params) OVERRIDE {
 286     NOTREACHED() << "Should not be able to select multiple files";
 287   }
 288
 289   virtual void FileSelectionCanceled(void* params) OVERRIDE {
 290     callback_.Run(base::FilePath());
 291     Release();  // Balanced in Show().
 292   }
 293
 294  private:
 295   friend class base::RefCounted<SelectDirectoryDialog>;
 296   virtual ~SelectDirectoryDialog() {}
 297
 298   scoped_refptr<ui::SelectFileDialog> select_file_dialog_;
 299   WebContents* web_contents_;
 300   Callback callback_;
 301
 302   DISALLOW_COPY_AND_ASSIGN(SelectDirectoryDialog);
 303 };
 304
 305 }  // namespace
 306
 307 MediaGalleriesEventRouter::MediaGalleriesEventRouter(
 308     content::BrowserContext* context)
 309     : profile_(Profile::FromBrowserContext(context)), weak_ptr_factory_(this) {
 310   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 311   DCHECK(profile_);
 312
 313   EventRouter::Get(profile_)->RegisterObserver(
 314       this, MediaGalleries::OnGalleryChanged::kEventName);
 315
 316   gallery_watch_manager()->AddObserver(profile_, this);
 317   media_scan_manager()->AddObserver(profile_, this);
 318 }
 319
 320 MediaGalleriesEventRouter::~MediaGalleriesEventRouter() {
 321 }
 322
 323 void MediaGalleriesEventRouter::Shutdown() {
 324   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 325   weak_ptr_factory_.InvalidateWeakPtrs();
 326
 327   EventRouter::Get(profile_)->UnregisterObserver(this);
 328
 329   gallery_watch_manager()->RemoveObserver(profile_);
 330   media_scan_manager()->RemoveObserver(profile_);
 331   media_scan_manager()->CancelScansForProfile(profile_);
 332 }
 333
 334 static base::LazyInstance<
 335     BrowserContextKeyedAPIFactory<MediaGalleriesEventRouter> > g_factory =
 336     LAZY_INSTANCE_INITIALIZER;
 337
 338 // static
 339 BrowserContextKeyedAPIFactory<MediaGalleriesEventRouter>*
 340 MediaGalleriesEventRouter::GetFactoryInstance() {
 341   return g_factory.Pointer();
 342 }
 343
 344 // static
 345 MediaGalleriesEventRouter* MediaGalleriesEventRouter::Get(
 346     content::BrowserContext* context) {
 347   DCHECK(media_file_system_registry()
 348              ->GetPreferences(Profile::FromBrowserContext(context))
 349              ->IsInitialized());
 350   return BrowserContextKeyedAPIFactory<MediaGalleriesEventRouter>::Get(context);
 351 }
 352
 353 bool MediaGalleriesEventRouter::ExtensionHasGalleryChangeListener(
 354     const std::string& extension_id) const {
 355   return EventRouter::Get(profile_)->ExtensionHasEventListener(
 356       extension_id, MediaGalleries::OnGalleryChanged::kEventName);
 357 }
 358
 359 bool MediaGalleriesEventRouter::ExtensionHasScanProgressListener(
 360     const std::string& extension_id) const {
 361   return EventRouter::Get(profile_)->ExtensionHasEventListener(
 362       extension_id, MediaGalleries::OnScanProgress::kEventName);
 363 }
 364
 365 void MediaGalleriesEventRouter::OnScanStarted(const std::string& extension_id) {
 366   MediaGalleries::ScanProgressDetails details;
 367   details.type = MediaGalleries::SCAN_PROGRESS_TYPE_START;
 368   DispatchEventToExtension(
 369       extension_id,
 370       MediaGalleries::OnScanProgress::kEventName,
 371       MediaGalleries::OnScanProgress::Create(details).Pass());
 372 }
 373
 374 void MediaGalleriesEventRouter::OnScanCancelled(
 375     const std::string& extension_id) {
 376   MediaGalleries::ScanProgressDetails details;
 377   details.type = MediaGalleries::SCAN_PROGRESS_TYPE_CANCEL;
 378   DispatchEventToExtension(
 379       extension_id,
 380       MediaGalleries::OnScanProgress::kEventName,
 381       MediaGalleries::OnScanProgress::Create(details).Pass());
 382 }
 383
 384 void MediaGalleriesEventRouter::OnScanFinished(
 385     const std::string& extension_id, int gallery_count,
 386     const MediaGalleryScanResult& file_counts) {
 387   media_galleries::UsageCount(media_galleries::SCAN_FINISHED);
 388   MediaGalleries::ScanProgressDetails details;
 389   details.type = MediaGalleries::SCAN_PROGRESS_TYPE_FINISH;
 390   details.gallery_count.reset(new int(gallery_count));
 391   details.audio_count.reset(new int(file_counts.audio_count));
 392   details.image_count.reset(new int(file_counts.image_count));
 393   details.video_count.reset(new int(file_counts.video_count));
 394   DispatchEventToExtension(
 395       extension_id,
 396       MediaGalleries::OnScanProgress::kEventName,
 397       MediaGalleries::OnScanProgress::Create(details).Pass());
 398 }
 399
 400 void MediaGalleriesEventRouter::OnScanError(
 401     const std::string& extension_id) {
 402   MediaGalleries::ScanProgressDetails details;
 403   details.type = MediaGalleries::SCAN_PROGRESS_TYPE_ERROR;
 404   DispatchEventToExtension(
 405       extension_id,
 406       MediaGalleries::OnScanProgress::kEventName,
 407       MediaGalleries::OnScanProgress::Create(details).Pass());
 408 }
 409
 410 void MediaGalleriesEventRouter::DispatchEventToExtension(
 411     const std::string& extension_id,
 412     const std::string& event_name,
 413     scoped_ptr<base::ListValue> event_args) {
 414   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 415   EventRouter* router = EventRouter::Get(profile_);
 416   if (!router->ExtensionHasEventListener(extension_id, event_name))
 417     return;
 418
 419   scoped_ptr<extensions::Event> event(
 420       new extensions::Event(event_name, event_args.Pass()));
 421   router->DispatchEventToExtension(extension_id, event.Pass());
 422 }
 423
 424 void MediaGalleriesEventRouter::OnGalleryChanged(
 425     const std::string& extension_id, MediaGalleryPrefId gallery_id) {
 426   MediaGalleries::GalleryChangeDetails details;
 427   details.type = MediaGalleries::GALLERY_CHANGE_TYPE_CONTENTS_CHANGED;
 428   details.gallery_id = base::Uint64ToString(gallery_id);
 429   DispatchEventToExtension(
 430       extension_id,
 431       MediaGalleries::OnGalleryChanged::kEventName,
 432       MediaGalleries::OnGalleryChanged::Create(details).Pass());
 433 }
 434
 435 void MediaGalleriesEventRouter::OnGalleryWatchDropped(
 436     const std::string& extension_id, MediaGalleryPrefId gallery_id) {
 437   MediaGalleries::GalleryChangeDetails details;
 438   details.type = MediaGalleries::GALLERY_CHANGE_TYPE_WATCH_DROPPED;
 439   details.gallery_id = gallery_id;
 440   DispatchEventToExtension(
 441       extension_id,
 442       MediaGalleries::OnGalleryChanged::kEventName,
 443       MediaGalleries::OnGalleryChanged::Create(details).Pass());
 444 }
 445
 446 void MediaGalleriesEventRouter::OnListenerRemoved(
 447     const EventListenerInfo& details) {
 448   if (details.event_name == MediaGalleries::OnGalleryChanged::kEventName &&
 449       !ExtensionHasGalleryChangeListener(details.extension_id)) {
 450     gallery_watch_manager()->RemoveAllWatches(profile_, details.extension_id);
 451   }
 452 }
 453
 454 ///////////////////////////////////////////////////////////////////////////////
 455 //               MediaGalleriesGetMediaFileSystemsFunction                   //
 456 ///////////////////////////////////////////////////////////////////////////////
 457 MediaGalleriesGetMediaFileSystemsFunction::
 458     ~MediaGalleriesGetMediaFileSystemsFunction() {}
 459
 460 bool MediaGalleriesGetMediaFileSystemsFunction::RunAsync() {
 461   media_galleries::UsageCount(media_galleries::GET_MEDIA_FILE_SYSTEMS);
 462   scoped_ptr<GetMediaFileSystems::Params> params(
 463       GetMediaFileSystems::Params::Create(*args_));
 464   EXTENSION_FUNCTION_VALIDATE(params.get());
 465   MediaGalleries::GetMediaFileSystemsInteractivity interactive =
 466       MediaGalleries::GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_NO;
 467   if (params->details.get() && params->details->interactive != MediaGalleries::
 468          GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_NONE) {
 469     interactive = params->details->interactive;
 470   }
 471
 472   return Setup(GetProfile(), &error_, base::Bind(
 473       &MediaGalleriesGetMediaFileSystemsFunction::OnPreferencesInit, this,
 474       interactive));
 475 }
 476
 477 void MediaGalleriesGetMediaFileSystemsFunction::OnPreferencesInit(
 478     MediaGalleries::GetMediaFileSystemsInteractivity interactive) {
 479   switch (interactive) {
 480     case MediaGalleries::GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_YES: {
 481       // The MediaFileSystemRegistry only updates preferences for extensions
 482       // that it knows are in use. Since this may be the first call to
 483       // chrome.getMediaFileSystems for this extension, call
 484       // GetMediaFileSystemsForExtension() here solely so that
 485       // MediaFileSystemRegistry will send preference changes.
 486       GetMediaFileSystemsForExtension(base::Bind(
 487           &MediaGalleriesGetMediaFileSystemsFunction::AlwaysShowDialog, this));
 488       return;
 489     }
 490     case MediaGalleries::GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_IF_NEEDED: {
 491       GetMediaFileSystemsForExtension(base::Bind(
 492           &MediaGalleriesGetMediaFileSystemsFunction::ShowDialogIfNoGalleries,
 493           this));
 494       return;
 495     }
 496     case MediaGalleries::GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_NO:
 497       GetAndReturnGalleries();
 498       return;
 499     case MediaGalleries::GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_NONE:
 500       NOTREACHED();
 501   }
 502   SendResponse(false);
 503 }
 504
 505 void MediaGalleriesGetMediaFileSystemsFunction::AlwaysShowDialog(
 506     const std::vector<MediaFileSystemInfo>& /*filesystems*/) {
 507   ShowDialog();
 508 }
 509
 510 void MediaGalleriesGetMediaFileSystemsFunction::ShowDialogIfNoGalleries(
 511     const std::vector<MediaFileSystemInfo>& filesystems) {
 512   if (filesystems.empty())
 513     ShowDialog();
 514   else
 515     ReturnGalleries(filesystems);
 516 }
 517
 518 void MediaGalleriesGetMediaFileSystemsFunction::GetAndReturnGalleries() {
 519   GetMediaFileSystemsForExtension(base::Bind(
 520       &MediaGalleriesGetMediaFileSystemsFunction::ReturnGalleries, this));
 521 }
 522
 523 void MediaGalleriesGetMediaFileSystemsFunction::ReturnGalleries(
 524     const std::vector<MediaFileSystemInfo>& filesystems) {
 525   scoped_ptr<base::ListValue> list(
 526       ConstructFileSystemList(render_view_host(), extension(), filesystems));
 527   if (!list.get()) {
 528     SendResponse(false);
 529     return;
 530   }
 531
 532   // The custom JS binding will use this list to create DOMFileSystem objects.
 533   SetResult(list.release());
 534   SendResponse(true);
 535 }
 536
 537 void MediaGalleriesGetMediaFileSystemsFunction::ShowDialog() {
 538   media_galleries::UsageCount(media_galleries::SHOW_DIALOG);
 539   WebContents* contents =
 540       GetWebContents(render_view_host(), GetProfile(), extension()->id());
 541   if (!contents) {
 542     SendResponse(false);
 543     return;
 544   }
 545
 546   // Controller will delete itself.
 547   base::Closure cb = base::Bind(
 548       &MediaGalleriesGetMediaFileSystemsFunction::GetAndReturnGalleries, this);
 549   new MediaGalleriesPermissionController(contents, *extension(), cb);
 550 }
 551
 552 void MediaGalleriesGetMediaFileSystemsFunction::GetMediaFileSystemsForExtension(
 553     const MediaFileSystemsCallback& cb) {
 554   if (!render_view_host()) {
 555     cb.Run(std::vector<MediaFileSystemInfo>());
 556     return;
 557   }
 558   MediaFileSystemRegistry* registry = media_file_system_registry();
 559   DCHECK(registry->GetPreferences(GetProfile())->IsInitialized());
 560   registry->GetMediaFileSystemsForExtension(
 561       render_view_host(), extension(), cb);
 562 }
 563
 564
 565 ///////////////////////////////////////////////////////////////////////////////
 566 //          MediaGalleriesGetAllMediaFileSystemMetadataFunction              //
 567 ///////////////////////////////////////////////////////////////////////////////
 568 MediaGalleriesGetAllMediaFileSystemMetadataFunction::
 569     ~MediaGalleriesGetAllMediaFileSystemMetadataFunction() {}
 570
 571 bool MediaGalleriesGetAllMediaFileSystemMetadataFunction::RunAsync() {
 572   media_galleries::UsageCount(
 573       media_galleries::GET_ALL_MEDIA_FILE_SYSTEM_METADATA);
 574   return Setup(GetProfile(), &error_, base::Bind(
 575       &MediaGalleriesGetAllMediaFileSystemMetadataFunction::OnPreferencesInit,
 576       this));
 577 }
 578
 579 void MediaGalleriesGetAllMediaFileSystemMetadataFunction::OnPreferencesInit() {
 580   MediaFileSystemRegistry* registry = media_file_system_registry();
 581   MediaGalleriesPreferences* prefs = registry->GetPreferences(GetProfile());
 582   DCHECK(prefs->IsInitialized());
 583   MediaGalleryPrefIdSet permitted_gallery_ids =
 584       prefs->GalleriesForExtension(*extension());
 585
 586   MediaStorageUtil::DeviceIdSet* device_ids = new MediaStorageUtil::DeviceIdSet;
 587   const MediaGalleriesPrefInfoMap& galleries = prefs->known_galleries();
 588   for (MediaGalleryPrefIdSet::const_iterator it = permitted_gallery_ids.begin();
 589        it != permitted_gallery_ids.end(); ++it) {
 590     MediaGalleriesPrefInfoMap::const_iterator gallery_it = galleries.find(*it);
 591     DCHECK(gallery_it != galleries.end());
 592     device_ids->insert(gallery_it->second.device_id);
 593   }
 594
 595   MediaStorageUtil::FilterAttachedDevices(
 596       device_ids,
 597       base::Bind(
 598           &MediaGalleriesGetAllMediaFileSystemMetadataFunction::OnGetGalleries,
 599           this,
 600           permitted_gallery_ids,
 601           base::Owned(device_ids)));
 602 }
 603
 604 void MediaGalleriesGetAllMediaFileSystemMetadataFunction::OnGetGalleries(
 605     const MediaGalleryPrefIdSet& permitted_gallery_ids,
 606     const MediaStorageUtil::DeviceIdSet* available_devices) {
 607   MediaFileSystemRegistry* registry = media_file_system_registry();
 608   MediaGalleriesPreferences* prefs = registry->GetPreferences(GetProfile());
 609
 610   base::ListValue* list = new base::ListValue();
 611   const MediaGalleriesPrefInfoMap& galleries = prefs->known_galleries();
 612   for (MediaGalleryPrefIdSet::const_iterator it = permitted_gallery_ids.begin();
 613        it != permitted_gallery_ids.end(); ++it) {
 614     MediaGalleriesPrefInfoMap::const_iterator gallery_it = galleries.find(*it);
 615     DCHECK(gallery_it != galleries.end());
 616     const MediaGalleryPrefInfo& gallery = gallery_it->second;
 617     MediaGalleries::MediaFileSystemMetadata metadata;
 618     metadata.name = base::UTF16ToUTF8(gallery.GetGalleryDisplayName());
 619     metadata.gallery_id = base::Uint64ToString(gallery.pref_id);
 620     metadata.is_removable = StorageInfo::IsRemovableDevice(gallery.device_id);
 621     metadata.is_media_device = StorageInfo::IsMediaDevice(gallery.device_id);
 622     metadata.is_available = ContainsKey(*available_devices, gallery.device_id);
 623     list->Append(metadata.ToValue().release());
 624   }
 625
 626   SetResult(list);
 627   SendResponse(true);
 628 }
 629
 630 ///////////////////////////////////////////////////////////////////////////////
 631 //               MediaGalleriesAddUserSelectedFolderFunction                 //
 632 ///////////////////////////////////////////////////////////////////////////////
 633 MediaGalleriesAddUserSelectedFolderFunction::
 634     ~MediaGalleriesAddUserSelectedFolderFunction() {}
 635
 636 bool MediaGalleriesAddUserSelectedFolderFunction::RunAsync() {
 637   media_galleries::UsageCount(media_galleries::ADD_USER_SELECTED_FOLDER);
 638   return Setup(GetProfile(), &error_, base::Bind(
 639       &MediaGalleriesAddUserSelectedFolderFunction::OnPreferencesInit, this));
 640 }
 641
 642 void MediaGalleriesAddUserSelectedFolderFunction::OnPreferencesInit() {
 643   Profile* profile = GetProfile();
 644   const std::string& app_id = extension()->id();
 645   WebContents* contents = GetWebContents(render_view_host(), profile, app_id);
 646   if (!contents) {
 647     // When the request originated from a background page, but there is no app
 648     // window open, check to see if it originated from a tab and display the
 649     // dialog in that tab.
 650     bool found_tab = extensions::ExtensionTabUtil::GetTabById(
 651         source_tab_id(), profile, profile->IsOffTheRecord(),
 652         NULL, NULL, &contents, NULL);
 653     if (!found_tab || !contents) {
 654       SendResponse(false);
 655       return;
 656     }
 657   }
 658
 659   if (!user_gesture()) {
 660     OnDirectorySelected(base::FilePath());
 661     return;
 662   }
 663
 664   base::FilePath last_used_path =
 665       extensions::file_system_api::GetLastChooseEntryDirectory(
 666           extensions::ExtensionPrefs::Get(profile), app_id);
 667   SelectDirectoryDialog::Callback callback = base::Bind(
 668       &MediaGalleriesAddUserSelectedFolderFunction::OnDirectorySelected, this);
 669   scoped_refptr<SelectDirectoryDialog> select_directory_dialog =
 670       new SelectDirectoryDialog(contents, callback);
 671   select_directory_dialog->Show(last_used_path);
 672 }
 673
 674 void MediaGalleriesAddUserSelectedFolderFunction::OnDirectorySelected(
 675     const base::FilePath& selected_directory) {
 676   if (selected_directory.empty()) {
 677     // User cancelled case.
 678     GetMediaFileSystemsForExtension(base::Bind(
 679         &MediaGalleriesAddUserSelectedFolderFunction::ReturnGalleriesAndId,
 680         this,
 681         kInvalidMediaGalleryPrefId));
 682     return;
 683   }
 684
 685   extensions::file_system_api::SetLastChooseEntryDirectory(
 686       extensions::ExtensionPrefs::Get(GetProfile()),
 687       extension()->id(),
 688       selected_directory);
 689
 690   MediaGalleriesPreferences* preferences =
 691       media_file_system_registry()->GetPreferences(GetProfile());
 692   MediaGalleryPrefId pref_id =
 693       preferences->AddGalleryByPath(selected_directory,
 694                                     MediaGalleryPrefInfo::kUserAdded);
 695   preferences->SetGalleryPermissionForExtension(*extension(), pref_id, true);
 696
 697   GetMediaFileSystemsForExtension(base::Bind(
 698       &MediaGalleriesAddUserSelectedFolderFunction::ReturnGalleriesAndId,
 699       this,
 700       pref_id));
 701 }
 702
 703 void MediaGalleriesAddUserSelectedFolderFunction::ReturnGalleriesAndId(
 704     MediaGalleryPrefId pref_id,
 705     const std::vector<MediaFileSystemInfo>& filesystems) {
 706   scoped_ptr<base::ListValue> list(
 707       ConstructFileSystemList(render_view_host(), extension(), filesystems));
 708   if (!list.get()) {
 709     SendResponse(false);
 710     return;
 711   }
 712
 713   int index = -1;
 714   if (pref_id != kInvalidMediaGalleryPrefId) {
 715     for (size_t i = 0; i < filesystems.size(); ++i) {
 716       if (filesystems[i].pref_id == pref_id) {
 717         index = i;
 718         break;
 719       }
 720     }
 721   }
 722   base::DictionaryValue* results = new base::DictionaryValue;
 723   results->SetWithoutPathExpansion("mediaFileSystems", list.release());
 724   results->SetIntegerWithoutPathExpansion("selectedFileSystemIndex", index);
 725   SetResult(results);
 726   SendResponse(true);
 727 }
 728
 729 void
 730 MediaGalleriesAddUserSelectedFolderFunction::GetMediaFileSystemsForExtension(
 731     const MediaFileSystemsCallback& cb) {
 732   if (!render_view_host()) {
 733     cb.Run(std::vector<MediaFileSystemInfo>());
 734     return;
 735   }
 736   MediaFileSystemRegistry* registry = media_file_system_registry();
 737   DCHECK(registry->GetPreferences(GetProfile())->IsInitialized());
 738   registry->GetMediaFileSystemsForExtension(
 739       render_view_host(), extension(), cb);
 740 }
 741
 742 ///////////////////////////////////////////////////////////////////////////////
 743 //         MediaGalleriesDropPermissionForMediaFileSystemFunction            //
 744 ///////////////////////////////////////////////////////////////////////////////
 745 MediaGalleriesDropPermissionForMediaFileSystemFunction::
 746     ~MediaGalleriesDropPermissionForMediaFileSystemFunction() {}
 747
 748 bool MediaGalleriesDropPermissionForMediaFileSystemFunction::RunAsync() {
 749   media_galleries::UsageCount(
 750       media_galleries::DROP_PERMISSION_FOR_MEDIA_FILE_SYSTEM);
 751
 752   scoped_ptr<DropPermissionForMediaFileSystem::Params> params(
 753       DropPermissionForMediaFileSystem::Params::Create(*args_));
 754   EXTENSION_FUNCTION_VALIDATE(params.get());
 755   MediaGalleryPrefId pref_id;
 756   if (!base::StringToUint64(params->gallery_id, &pref_id)) {
 757     error_ = kInvalidGalleryIdMsg;
 758     return false;
 759   }
 760
 761   base::Closure callback = base::Bind(
 762       &MediaGalleriesDropPermissionForMediaFileSystemFunction::
 763           OnPreferencesInit,
 764       this,
 765       pref_id);
 766   return Setup(GetProfile(), &error_, callback);
 767 }
 768
 769 void MediaGalleriesDropPermissionForMediaFileSystemFunction::OnPreferencesInit(
 770     MediaGalleryPrefId pref_id) {
 771   MediaGalleriesPreferences* preferences =
 772       media_file_system_registry()->GetPreferences(GetProfile());
 773   if (!ContainsKey(preferences->known_galleries(), pref_id)) {
 774     error_ = kNonExistentGalleryId;
 775     SendResponse(false);
 776     return;
 777   }
 778
 779   bool dropped = preferences->SetGalleryPermissionForExtension(
 780       *extension(), pref_id, false);
 781   if (dropped)
 782     SetResult(new base::StringValue(base::Uint64ToString(pref_id)));
 783   else
 784     error_ = kFailedToSetGalleryPermission;
 785   SendResponse(dropped);
 786 }
 787
 788 ///////////////////////////////////////////////////////////////////////////////
 789 //                 MediaGalleriesStartMediaScanFunction                      //
 790 ///////////////////////////////////////////////////////////////////////////////
 791 MediaGalleriesStartMediaScanFunction::~MediaGalleriesStartMediaScanFunction() {}
 792
 793 bool MediaGalleriesStartMediaScanFunction::RunAsync() {
 794   media_galleries::UsageCount(media_galleries::START_MEDIA_SCAN);
 795   if (!CheckScanPermission(extension(), &error_)) {
 796     MediaGalleriesEventRouter::Get(GetProfile())
 797         ->OnScanError(extension()->id());
 798     return false;
 799   }
 800   return Setup(GetProfile(), &error_, base::Bind(
 801       &MediaGalleriesStartMediaScanFunction::OnPreferencesInit, this));
 802 }
 803
 804 void MediaGalleriesStartMediaScanFunction::OnPreferencesInit() {
 805   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 806   MediaGalleriesEventRouter* api = MediaGalleriesEventRouter::Get(GetProfile());
 807   if (!api->ExtensionHasScanProgressListener(extension()->id())) {
 808     error_ = kMissingEventListener;
 809     SendResponse(false);
 810     return;
 811   }
 812
 813   media_scan_manager()->StartScan(GetProfile(), extension(), user_gesture());
 814   SendResponse(true);
 815 }
 816
 817 ///////////////////////////////////////////////////////////////////////////////
 818 //                MediaGalleriesCancelMediaScanFunction                      //
 819 ///////////////////////////////////////////////////////////////////////////////
 820 MediaGalleriesCancelMediaScanFunction::
 821     ~MediaGalleriesCancelMediaScanFunction() {
 822 }
 823
 824 bool MediaGalleriesCancelMediaScanFunction::RunAsync() {
 825   media_galleries::UsageCount(media_galleries::CANCEL_MEDIA_SCAN);
 826   if (!CheckScanPermission(extension(), &error_)) {
 827     MediaGalleriesEventRouter::Get(GetProfile())
 828         ->OnScanError(extension()->id());
 829     return false;
 830   }
 831   return Setup(GetProfile(), &error_, base::Bind(
 832       &MediaGalleriesCancelMediaScanFunction::OnPreferencesInit, this));
 833 }
 834
 835 void MediaGalleriesCancelMediaScanFunction::OnPreferencesInit() {
 836   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 837   media_scan_manager()->CancelScan(GetProfile(), extension());
 838   SendResponse(true);
 839 }
 840
 841 ///////////////////////////////////////////////////////////////////////////////
 842 //                MediaGalleriesAddScanResultsFunction                       //
 843 ///////////////////////////////////////////////////////////////////////////////
 844 MediaGalleriesAddScanResultsFunction::~MediaGalleriesAddScanResultsFunction() {}
 845
 846 bool MediaGalleriesAddScanResultsFunction::RunAsync() {
 847   media_galleries::UsageCount(media_galleries::ADD_SCAN_RESULTS);
 848   if (!CheckScanPermission(extension(), &error_)) {
 849     // We don't fire a scan progress error here, as it would be unintuitive.
 850     return false;
 851   }
 852   if (!user_gesture())
 853     return false;
 854
 855   return Setup(GetProfile(), &error_, base::Bind(
 856       &MediaGalleriesAddScanResultsFunction::OnPreferencesInit, this));
 857 }
 858
 859 MediaGalleriesScanResultController*
 860 MediaGalleriesAddScanResultsFunction::MakeDialog(
 861     content::WebContents* web_contents,
 862     const extensions::Extension& extension,
 863     const base::Closure& on_finish) {
 864   // Controller will delete itself.
 865   return new MediaGalleriesScanResultController(web_contents, extension,
 866                                                 on_finish);
 867 }
 868
 869 void MediaGalleriesAddScanResultsFunction::OnPreferencesInit() {
 870   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 871   MediaGalleriesPreferences* preferences =
 872       media_file_system_registry()->GetPreferences(GetProfile());
 873   if (MediaGalleriesScanResultController::ScanResultCountForExtension(
 874           preferences, extension()) == 0) {
 875     GetAndReturnGalleries();
 876     return;
 877   }
 878
 879   WebContents* contents =
 880       GetWebContents(render_view_host(), GetProfile(), extension()->id());
 881   if (!contents) {
 882     SendResponse(false);
 883     return;
 884   }
 885
 886   base::Closure cb = base::Bind(
 887       &MediaGalleriesAddScanResultsFunction::GetAndReturnGalleries, this);
 888   MakeDialog(contents, *extension(), cb);
 889 }
 890
 891 void MediaGalleriesAddScanResultsFunction::GetAndReturnGalleries() {
 892   if (!render_view_host()) {
 893     ReturnGalleries(std::vector<MediaFileSystemInfo>());
 894     return;
 895   }
 896   MediaFileSystemRegistry* registry = media_file_system_registry();
 897   DCHECK(registry->GetPreferences(GetProfile())->IsInitialized());
 898   registry->GetMediaFileSystemsForExtension(
 899       render_view_host(),
 900       extension(),
 901       base::Bind(&MediaGalleriesAddScanResultsFunction::ReturnGalleries, this));
 902 }
 903
 904 void MediaGalleriesAddScanResultsFunction::ReturnGalleries(
 905     const std::vector<MediaFileSystemInfo>& filesystems) {
 906   scoped_ptr<base::ListValue> list(
 907       ConstructFileSystemList(render_view_host(), extension(), filesystems));
 908   if (!list.get()) {
 909     SendResponse(false);
 910     return;
 911   }
 912
 913   // The custom JS binding will use this list to create DOMFileSystem objects.
 914   SetResult(list.release());
 915   SendResponse(true);
 916 }
 917
 918 ///////////////////////////////////////////////////////////////////////////////
 919 //                 MediaGalleriesGetMetadataFunction                         //
 920 ///////////////////////////////////////////////////////////////////////////////
 921 MediaGalleriesGetMetadataFunction::~MediaGalleriesGetMetadataFunction() {}
 922
 923 bool MediaGalleriesGetMetadataFunction::RunAsync() {
 924   std::string blob_uuid;
 925   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &blob_uuid));
 926
 927   const base::Value* options_value = NULL;
 928   if (!args_->Get(1, &options_value))
 929     return false;
 930   scoped_ptr<MediaGalleries::MediaMetadataOptions> options =
 931       MediaGalleries::MediaMetadataOptions::FromValue(*options_value);
 932   if (!options)
 933     return false;
 934
 935   return Setup(GetProfile(), &error_, base::Bind(
 936       &MediaGalleriesGetMetadataFunction::OnPreferencesInit, this,
 937       options->metadata_type, blob_uuid));
 938 }
 939
 940 void MediaGalleriesGetMetadataFunction::OnPreferencesInit(
 941     MediaGalleries::GetMetadataType metadata_type,
 942     const std::string& blob_uuid) {
 943   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 944
 945   // BlobReader is self-deleting.
 946   BlobReader* reader = new BlobReader(
 947       GetProfile(),
 948       blob_uuid,
 949       base::Bind(&MediaGalleriesGetMetadataFunction::GetMetadata, this,
 950                  metadata_type, blob_uuid));
 951   reader->SetByteRange(0, net::kMaxBytesToSniff);
 952   reader->Start();
 953 }
 954
 955 void MediaGalleriesGetMetadataFunction::GetMetadata(
 956     MediaGalleries::GetMetadataType metadata_type, const std::string& blob_uuid,
 957     scoped_ptr<std::string> blob_header, int64 total_blob_length) {
 958   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 959
 960   std::string mime_type;
 961   bool mime_type_sniffed = net::SniffMimeTypeFromLocalData(
 962       blob_header->c_str(), blob_header->size(), &mime_type);
 963
 964   if (!mime_type_sniffed) {
 965     SendResponse(false);
 966     return;
 967   }
 968
 969   if (metadata_type == MediaGalleries::GET_METADATA_TYPE_MIMETYPEONLY) {
 970     MediaGalleries::MediaMetadata metadata;
 971     metadata.mime_type = mime_type;
 972
 973     base::DictionaryValue* result_dictionary = new base::DictionaryValue;
 974     result_dictionary->Set(kMetadataKey, metadata.ToValue().release());
 975     SetResult(result_dictionary);
 976     SendResponse(true);
 977     return;
 978   }
 979
 980   // We get attached images by default. GET_METADATA_TYPE_NONE is the default
 981   // value if the caller doesn't specify the metadata type.
 982   bool get_attached_images =
 983       metadata_type == MediaGalleries::GET_METADATA_TYPE_ALL ||
 984       metadata_type == MediaGalleries::GET_METADATA_TYPE_NONE;
 985
 986   scoped_refptr<metadata::SafeMediaMetadataParser> parser(
 987       new metadata::SafeMediaMetadataParser(GetProfile(), blob_uuid,
 988                                             total_blob_length, mime_type,
 989                                             get_attached_images));
 990   parser->Start(base::Bind(
 991       &MediaGalleriesGetMetadataFunction::OnSafeMediaMetadataParserDone, this));
 992 }
 993
 994 void MediaGalleriesGetMetadataFunction::OnSafeMediaMetadataParserDone(
 995     bool parse_success, scoped_ptr<base::DictionaryValue> metadata_dictionary,
 996     scoped_ptr<std::vector<metadata::AttachedImage> > attached_images) {
 997   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 998
 999   if (!parse_success) {
1000     SendResponse(false);
1001     return;
1002   }
1003
1004   DCHECK(metadata_dictionary.get());
1005   DCHECK(attached_images.get());
1006
1007   scoped_ptr<base::DictionaryValue> result_dictionary(
1008       new base::DictionaryValue);
1009   result_dictionary->Set(kMetadataKey, metadata_dictionary.release());
1010
1011   if (attached_images->empty()) {
1012     SetResult(result_dictionary.release());
1013     SendResponse(true);
1014     return;
1015   }
1016
1017   result_dictionary->Set(kAttachedImagesBlobInfoKey, new base::ListValue);
1018   metadata::AttachedImage* first_image = &attached_images->front();
1019   content::BrowserContext::CreateMemoryBackedBlob(
1020       GetProfile(),
1021       first_image->data.c_str(),
1022       first_image->data.size(),
1023       base::Bind(&MediaGalleriesGetMetadataFunction::ConstructNextBlob,
1024                  this, base::Passed(&result_dictionary),
1025                  base::Passed(&attached_images),
1026                  base::Passed(make_scoped_ptr(new std::vector<std::string>))));
1027 }
1028
1029 void MediaGalleriesGetMetadataFunction::ConstructNextBlob(
1030     scoped_ptr<base::DictionaryValue> result_dictionary,
1031     scoped_ptr<std::vector<metadata::AttachedImage> > attached_images,
1032     scoped_ptr<std::vector<std::string> > blob_uuids,
1033     scoped_ptr<content::BlobHandle> current_blob) {
1034   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
1035
1036   DCHECK(result_dictionary.get());
1037   DCHECK(attached_images.get());
1038   DCHECK(blob_uuids.get());
1039   DCHECK(current_blob.get());
1040
1041   DCHECK(!attached_images->empty());
1042   DCHECK_LT(blob_uuids->size(), attached_images->size());
1043
1044   // For the newly constructed Blob, store its image's metadata and Blob UUID.
1045   base::ListValue* attached_images_list = NULL;
1046   result_dictionary->GetList(kAttachedImagesBlobInfoKey, &attached_images_list);
1047   DCHECK(attached_images_list);
1048   DCHECK_LT(attached_images_list->GetSize(), attached_images->size());
1049
1050   metadata::AttachedImage* current_image =
1051       &(*attached_images)[blob_uuids->size()];
1052   base::DictionaryValue* attached_image = new base::DictionaryValue;
1053   attached_image->Set(kBlobUUIDKey, new base::StringValue(
1054       current_blob->GetUUID()));
1055   attached_image->Set(kTypeKey, new base::StringValue(
1056       current_image->type));
1057   attached_image->Set(kSizeKey, new base::FundamentalValue(
1058       base::checked_cast<int>(current_image->data.size())));
1059   attached_images_list->Append(attached_image);
1060
1061   blob_uuids->push_back(current_blob->GetUUID());
1062   WebContents* contents = WebContents::FromRenderViewHost(render_view_host());
1063   extensions::BlobHolder* holder =
1064       extensions::BlobHolder::FromRenderProcessHost(
1065           contents->GetRenderProcessHost());
1066   holder->HoldBlobReference(current_blob.Pass());
1067
1068   // Construct the next Blob if necessary.
1069   if (blob_uuids->size() < attached_images->size()) {
1070     metadata::AttachedImage* next_image =
1071         &(*attached_images)[blob_uuids->size()];
1072     content::BrowserContext::CreateMemoryBackedBlob(
1073         GetProfile(),
1074         next_image->data.c_str(),
1075         next_image->data.size(),
1076         base::Bind(&MediaGalleriesGetMetadataFunction::ConstructNextBlob,
1077                    this, base::Passed(&result_dictionary),
1078                    base::Passed(&attached_images), base::Passed(&blob_uuids)));
1079     return;
1080   }
1081
1082   // All Blobs have been constructed. The renderer will take ownership.
1083   SetResult(result_dictionary.release());
1084   SetTransferredBlobUUIDs(*blob_uuids);
1085   SendResponse(true);
1086 }
1087
1088 ///////////////////////////////////////////////////////////////////////////////
1089 //              MediaGalleriesAddGalleryWatchFunction                        //
1090 ///////////////////////////////////////////////////////////////////////////////
1091 MediaGalleriesAddGalleryWatchFunction::
1092     ~MediaGalleriesAddGalleryWatchFunction() {
1093 }
1094
1095 bool MediaGalleriesAddGalleryWatchFunction::RunAsync() {
1096   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
1097   DCHECK(GetProfile());
1098   if (!render_view_host() || !render_view_host()->GetProcess())
1099     return false;
1100
1101   scoped_ptr<AddGalleryWatch::Params> params(
1102       AddGalleryWatch::Params::Create(*args_));
1103   EXTENSION_FUNCTION_VALIDATE(params.get());
1104
1105   MediaGalleriesPreferences* preferences =
1106       g_browser_process->media_file_system_registry()->GetPreferences(
1107           GetProfile());
1108   preferences->EnsureInitialized(
1109       base::Bind(&MediaGalleriesAddGalleryWatchFunction::OnPreferencesInit,
1110                  this,
1111                  params->gallery_id));
1112
1113   return true;
1114 }
1115
1116 void MediaGalleriesAddGalleryWatchFunction::OnPreferencesInit(
1117     const std::string& pref_id) {
1118   base::FilePath gallery_file_path;
1119   MediaGalleryPrefId gallery_pref_id = kInvalidMediaGalleryPrefId;
1120   if (!GetGalleryFilePathAndId(pref_id,
1121                                GetProfile(),
1122                                extension(),
1123                                &gallery_file_path,
1124                                &gallery_pref_id)) {
1125     api::media_galleries::AddGalleryWatchResult result;
1126     error_ = kInvalidGalleryIdMsg;
1127     result.gallery_id = kInvalidGalleryId;
1128     result.success = false;
1129     SetResult(result.ToValue().release());
1130     SendResponse(false);
1131     return;
1132   }
1133
1134   gallery_watch_manager()->AddWatch(
1135       GetProfile(),
1136       extension(),
1137       gallery_pref_id,
1138       base::Bind(&MediaGalleriesAddGalleryWatchFunction::HandleResponse,
1139                  this,
1140                  gallery_pref_id));
1141 }
1142
1143 void MediaGalleriesAddGalleryWatchFunction::HandleResponse(
1144     MediaGalleryPrefId gallery_id,
1145     const std::string& error) {
1146   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
1147
1148   // If an app added a file watch without any event listeners on the
1149   // onGalleryChanged event, that's an error.
1150   MediaGalleriesEventRouter* api = MediaGalleriesEventRouter::Get(GetProfile());
1151   api::media_galleries::AddGalleryWatchResult result;
1152   result.gallery_id = base::Uint64ToString(gallery_id);
1153
1154   if (!api->ExtensionHasGalleryChangeListener(extension()->id())) {
1155     result.success = false;
1156     SetResult(result.ToValue().release());
1157     error_ = kMissingEventListener;
1158     SendResponse(false);
1159     return;
1160   }
1161
1162   result.success = error.empty();
1163   SetResult(result.ToValue().release());
1164   if (error.empty()) {
1165     SendResponse(true);
1166   } else {
1167     error_ = error.c_str();
1168     SendResponse(false);
1169   }
1170 }
1171
1172 ///////////////////////////////////////////////////////////////////////////////
1173 //              MediaGalleriesRemoveGalleryWatchFunction                     //
1174 ///////////////////////////////////////////////////////////////////////////////
1175
1176 MediaGalleriesRemoveGalleryWatchFunction::
1177     ~MediaGalleriesRemoveGalleryWatchFunction() {
1178 }
1179
1180 bool MediaGalleriesRemoveGalleryWatchFunction::RunAsync() {
1181   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
1182   if (!render_view_host() || !render_view_host()->GetProcess())
1183     return false;
1184
1185   scoped_ptr<RemoveGalleryWatch::Params> params(
1186       RemoveGalleryWatch::Params::Create(*args_));
1187   EXTENSION_FUNCTION_VALIDATE(params.get());
1188
1189   MediaGalleriesPreferences* preferences =
1190       g_browser_process->media_file_system_registry()->GetPreferences(
1191           GetProfile());
1192   preferences->EnsureInitialized(
1193       base::Bind(&MediaGalleriesRemoveGalleryWatchFunction::OnPreferencesInit,
1194                  this,
1195                  params->gallery_id));
1196   return true;
1197 }
1198
1199 void MediaGalleriesRemoveGalleryWatchFunction::OnPreferencesInit(
1200     const std::string& pref_id) {
1201   base::FilePath gallery_file_path;
1202   MediaGalleryPrefId gallery_pref_id = 0;
1203   if (!GetGalleryFilePathAndId(pref_id,
1204                                GetProfile(),
1205                                extension(),
1206                                &gallery_file_path,
1207                                &gallery_pref_id)) {
1208     error_ = kInvalidGalleryIdMsg;
1209     SendResponse(false);
1210     return;
1211   }
1212
1213   gallery_watch_manager()->RemoveWatch(
1214       GetProfile(), extension_id(), gallery_pref_id);
1215   SendResponse(true);
1216 }
1217
1218 ///////////////////////////////////////////////////////////////////////////////
1219 //              MediaGalleriesGetAllGalleryWatchFunction                     //
1220 ///////////////////////////////////////////////////////////////////////////////
1221
1222 MediaGalleriesGetAllGalleryWatchFunction::
1223     ~MediaGalleriesGetAllGalleryWatchFunction() {
1224 }
1225
1226 bool MediaGalleriesGetAllGalleryWatchFunction::RunAsync() {
1227   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
1228   if (!render_view_host() || !render_view_host()->GetProcess())
1229     return false;
1230
1231   MediaGalleriesPreferences* preferences =
1232       g_browser_process->media_file_system_registry()->GetPreferences(
1233           GetProfile());
1234   preferences->EnsureInitialized(base::Bind(
1235       &MediaGalleriesGetAllGalleryWatchFunction::OnPreferencesInit, this));
1236   return true;
1237 }
1238
1239 void MediaGalleriesGetAllGalleryWatchFunction::OnPreferencesInit() {
1240   std::vector<std::string> result;
1241   MediaGalleryPrefIdSet gallery_ids =
1242       gallery_watch_manager()->GetWatchSet(GetProfile(), extension_id());
1243   for (MediaGalleryPrefIdSet::const_iterator iter = gallery_ids.begin();
1244        iter != gallery_ids.end();
1245        ++iter) {
1246     result.push_back(base::Uint64ToString(*iter));
1247   }
1248   results_ = GetAllGalleryWatch::Results::Create(result);
1249   SendResponse(true);
1250 }
1251
1252 ///////////////////////////////////////////////////////////////////////////////
1253 //              MediaGalleriesRemoveAllGalleryWatchFunction                  //
1254 ///////////////////////////////////////////////////////////////////////////////
1255
1256 MediaGalleriesRemoveAllGalleryWatchFunction::
1257     ~MediaGalleriesRemoveAllGalleryWatchFunction() {
1258 }
1259
1260 bool MediaGalleriesRemoveAllGalleryWatchFunction::RunAsync() {
1261   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
1262   if (!render_view_host() || !render_view_host()->GetProcess())
1263     return false;
1264
1265   MediaGalleriesPreferences* preferences =
1266       g_browser_process->media_file_system_registry()->GetPreferences(
1267           GetProfile());
1268   preferences->EnsureInitialized(base::Bind(
1269       &MediaGalleriesRemoveAllGalleryWatchFunction::OnPreferencesInit, this));
1270   return true;
1271 }
1272
1273 void MediaGalleriesRemoveAllGalleryWatchFunction::OnPreferencesInit() {
1274   gallery_watch_manager()->RemoveAllWatches(GetProfile(), extension_id());
1275   SendResponse(true);
1276 }
1277
1278 }  // namespace extensions