Media Galleries: Add chrome.mediaGalleries.addUserSelectedFolder().

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>
 #include <vector>
 
 #include "apps/shell_window.h"
 #include "apps/shell_window_registry.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/platform_file.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task_runner_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/media_galleries/media_file_system_registry.h"
 #include "chrome/browser/media_galleries/media_galleries_dialog_controller.h"
 #include "chrome/browser/media_galleries/media_galleries_histograms.h"
 #include "chrome/browser/media_galleries/media_galleries_preferences.h"
+#include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/storage_monitor/storage_info.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/common/extensions/api/media_galleries.h"
 #include "chrome/common/extensions/permissions/media_galleries_permission.h"
 #include "chrome/common/pref_names.h"
 #include "components/web_modal/web_contents_modal_dialog_manager.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_contents_view.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/permissions/api_permission.h"
 #include "extensions/common/permissions/permissions_data.h"
 
 using content::WebContents;
 using web_modal::WebContentsModalDialogManager;
 
 namespace extensions {
 
 namespace MediaGalleries = api::media_galleries;
 namespace GetMediaFileSystems = MediaGalleries::GetMediaFileSystems;
+namespace ManageMediaLocations = MediaGalleries::ManageMediaLocations;
 
 namespace {
 
 const char kDisallowedByPolicy[] =
     "Media Galleries API is disallowed by policy: ";
+const char kInvalidManageRequestType[] =
+    "Invalid manageMediaLocations request type";
 
 const char kDeviceIdKey[] = "deviceId";
 const char kGalleryIdKey[] = "galleryId";
 const char kIsAvailableKey[] = "isAvailable";
 const char kIsMediaDeviceKey[] = "isMediaDevice";
 const char kIsRemovableKey[] = "isRemovable";
 const char kNameKey[] = "name";
 
 // Checks whether the MediaGalleries API is currently accessible (it may be
 // disallowed even if an extension has the requisite permission).
 bool ApiIsAccessible(std::string* error) {
   if (!ChromeSelectFilePolicy::FileSelectDialogsAllowed()) {
     *error = std::string(kDisallowedByPolicy) +
         prefs::kAllowFileSelectionDialogs;
     return false;
   }
 
   return true;
 }
 
 MediaFileSystemRegistry* media_file_system_registry() {
   return g_browser_process->media_file_system_registry();
 }
 
+class SelectDirectoryDialog : public ui::SelectFileDialog::Listener,
+                              public base::RefCounted<SelectDirectoryDialog> {
+ public:
+  // Selected file path, or an empty path if the user canceled.
+  typedef base::Callback<void(const base::FilePath&)> Callback;
+
+  SelectDirectoryDialog(WebContents* web_contents, const Callback& callback)
+      : web_contents_(web_contents),
+        callback_(callback) {
+    select_file_dialog_ = ui::SelectFileDialog::Create(
+        this, new ChromeSelectFilePolicy(web_contents));
+  }
+
+  void Show() {
+    AddRef();  // Balanced in the two reachable listener outcomes.
+    select_file_dialog_->SelectFile(
+      ui::SelectFileDialog::SELECT_FOLDER,
+      base::string16(),
+      base::FilePath(),
+      NULL,
+      0,
+      base::FilePath::StringType(),
+      platform_util::GetTopLevel(web_contents_->GetView()->GetNativeView()),
+      NULL);
+  }
+
+  // ui::SelectFileDialog::Listener implementation.
+  virtual void FileSelected(const base::FilePath& path,
+                            int index,
+                            void* params) OVERRIDE {
+    callback_.Run(path);
+    Release();  // Balanced in Show().
+  }
+
+  virtual void MultiFilesSelected(const std::vector<base::FilePath>& files,
+                                  void* params) OVERRIDE {
+    NOTREACHED() << "Should not be able to select multiple files";
+  }
+
+  virtual void FileSelectionCanceled(void* params) OVERRIDE {
+    callback_.Run(base::FilePath());
+    Release();  // Balanced in Show().
+  }
+
+ private:
+  friend class base::RefCounted<SelectDirectoryDialog>;
+  virtual ~SelectDirectoryDialog() {}
+
+  scoped_refptr<ui::SelectFileDialog> select_file_dialog_;
+  WebContents* web_contents_;
+  Callback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(SelectDirectoryDialog);
+};
+
 }  // namespace
 
-MediaGalleriesGetMediaFileSystemsFunction::
-    ~MediaGalleriesGetMediaFileSystemsFunction() {}
+MediaGalleriesGetMediaFileSystemsBase::
+    ~MediaGalleriesGetMediaFileSystemsBase() {}
 
-bool MediaGalleriesGetMediaFileSystemsFunction::RunImpl() {
-  if (!ApiIsAccessible(&error_))
-    return false;
-
-  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;
-  if (params->details.get() && params->details->interactive != MediaGalleries::
-         GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_NONE) {
-    interactive = params->details->interactive;
-  }
-
-  MediaGalleriesPreferences* preferences =
-      media_file_system_registry()->GetPreferences(GetProfile());
-  preferences->EnsureInitialized(base::Bind(
-      &MediaGalleriesGetMediaFileSystemsFunction::OnPreferencesInit,
-      this,
-      interactive));
-  return true;
+void MediaGalleriesGetMediaFileSystemsBase::ReadPrefsAndShowDialog() {
+  // The MediaFileSystemRegistry only updates preferences for extensions
+  // that it knows are in use. Since this may be the first call to
+  // chrome.{getMediaFileSystems, manageMediaLocations} for this extension,
+  // call GetMediaFileSystemsForExtension() here solely so that
+  // MediaFileSystemRegistry will send preference changes.
+  GetMediaFileSystemsForExtension(base::Bind(
+      &MediaGalleriesGetMediaFileSystemsBase::AlwaysShowDialog, this));
 }
 
-void MediaGalleriesGetMediaFileSystemsFunction::OnPreferencesInit(
-    MediaGalleries::GetMediaFileSystemsInteractivity interactive) {
-  switch (interactive) {
-    case MediaGalleries::GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_YES: {
-      // The MediaFileSystemRegistry only updates preferences for extensions
-      // that it knows are in use. Since this may be the first call to
-      // chrome.getMediaFileSystems for this extension, call
-      // GetMediaFileSystemsForExtension() here solely so that
-      // MediaFileSystemRegistry will send preference changes.
-      GetMediaFileSystemsForExtension(base::Bind(
-          &MediaGalleriesGetMediaFileSystemsFunction::AlwaysShowDialog, this));
-      return;
-    }
-    case MediaGalleries::GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_IF_NEEDED: {
-      GetMediaFileSystemsForExtension(base::Bind(
-          &MediaGalleriesGetMediaFileSystemsFunction::ShowDialogIfNoGalleries,
-          this));
-      return;
-    }
-    case MediaGalleries::GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_NO:
-      GetAndReturnGalleries();
-      return;
-    case MediaGalleries::GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_NONE:
-      NOTREACHED();
-  }
-  SendResponse(false);
-}
+void MediaGalleriesGetMediaFileSystemsBase::ShowDialog() {
+  media_galleries::UsageCount(media_galleries::SHOW_DIALOG);
 
-void MediaGalleriesGetMediaFileSystemsFunction::AlwaysShowDialog(
-    const std::vector<MediaFileSystemInfo>& /*filesystems*/) {
-  ShowDialog();
-}
-
-void MediaGalleriesGetMediaFileSystemsFunction::ShowDialogIfNoGalleries(
-    const std::vector<MediaFileSystemInfo>& filesystems) {
-  if (filesystems.empty())
-    ShowDialog();
-  else
-    ReturnGalleries(filesystems);
-}
-
-void MediaGalleriesGetMediaFileSystemsFunction::GetAndReturnGalleries() {
-  GetMediaFileSystemsForExtension(base::Bind(
-      &MediaGalleriesGetMediaFileSystemsFunction::ReturnGalleries, this));
-}
-
-void MediaGalleriesGetMediaFileSystemsFunction::ReturnGalleries(
-    const std::vector<MediaFileSystemInfo>& filesystems) {
-  content::RenderViewHost* rvh = render_view_host();
-  if (!rvh) {
+  WebContents* contents = GetWebContents();
+  if (!contents) {
     SendResponse(false);
     return;
   }
+
+  // Controller will delete itself.
+  new MediaGalleriesDialogController(
+      contents,
+      *GetExtension(),
+      base::Bind(
+          &MediaGalleriesGetMediaFileSystemsBase::GetAndReturnGalleries, this));
+}
+
+void MediaGalleriesGetMediaFileSystemsBase::GetAndReturnGalleries() {
+  GetMediaFileSystemsForExtension(base::Bind(
+      &MediaGalleriesGetMediaFileSystemsBase::ReturnGalleries, this));
+}
+
+void MediaGalleriesGetMediaFileSystemsBase::ReturnGalleries(
+    const std::vector<MediaFileSystemInfo>& filesystems) {
+  scoped_ptr<base::ListValue> list(ConstructFileSystemList(filesystems));
+  if (!list.get()) {
+    SendResponse(false);
+    return;
+  }
+
+  SetResult(list.release());
+  SendResponse(true);
+}
+
+base::ListValue* MediaGalleriesGetMediaFileSystemsBase::ConstructFileSystemList(
+    const std::vector<MediaFileSystemInfo>& filesystems) {
+  content::RenderViewHost* rvh = render_view_host();
+  if (!rvh)
+    return NULL;
+
   MediaGalleriesPermission::CheckParam read_param(
       MediaGalleriesPermission::kReadPermission);
   bool has_read_permission = PermissionsData::CheckAPIPermissionWithParam(
       GetExtension(), APIPermission::kMediaGalleries, &read_param);
   MediaGalleriesPermission::CheckParam copy_to_param(
       MediaGalleriesPermission::kCopyToPermission);
   bool has_copy_to_permission = PermissionsData::CheckAPIPermissionWithParam(
       GetExtension(), APIPermission::kMediaGalleries, &copy_to_param);
   MediaGalleriesPermission::CheckParam delete_param(
       MediaGalleriesPermission::kDeletePermission);
   bool has_delete_permission = PermissionsData::CheckAPIPermissionWithParam(
       GetExtension(), APIPermission::kMediaGalleries, &delete_param);
 
   const int child_id = rvh->GetProcess()->GetID();
   base::ListValue* list = new base::ListValue();

[vandebo (ex-Chrome), 2013/12/03 21:08:02]

nit: this should probably be a scoped_ptr with a return list.release() at the
end.  There's a lot of space between the allocation and ownership transfer
(return), so a lot of room for someone to later add a return NULL in between.

[Lei Zhang, 2013/12/05 05:52:15]

Done.

   for (size_t i = 0; i < filesystems.size(); i++) {
     scoped_ptr<base::DictionaryValue> file_system_dict_value(
         new base::DictionaryValue());
 
     // Send the file system id so the renderer can create a valid FileSystem
     // object.
     file_system_dict_value->SetStringWithoutPathExpansion(
         "fsid", filesystems[i].fsid);
 
     file_system_dict_value->SetStringWithoutPathExpansion(
@@ skipping 23 matching lines @@
       policy->GrantReadFileSystem(child_id, filesystems[i].fsid);
       if (has_delete_permission) {
         policy->GrantDeleteFromFileSystem(child_id, filesystems[i].fsid);
         if (has_copy_to_permission) {
           policy->GrantCopyIntoFileSystem(child_id, filesystems[i].fsid);
         }
       }
     }
   }
 
-  // The custom JS binding will use this list to create DOMFileSystem objects.
-  SetResult(list);
-  SendResponse(true);
+  return list;
 }
 
-void MediaGalleriesGetMediaFileSystemsFunction::ShowDialog() {
-  media_galleries::UsageCount(media_galleries::SHOW_DIALOG);
-  WebContents* contents = WebContents::FromRenderViewHost(render_view_host());
-  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 shell window to
-    // host the dialog.
-    apps::ShellWindow* window = apps::ShellWindowRegistry::Get(
-        GetProfile())->GetCurrentShellWindowForApp(GetExtension()->id());
-    if (window) {
-      contents = window->web_contents();
-    } else {
-      // Abort showing the dialog. TODO(estade) Perhaps return an error instead.
-      GetAndReturnGalleries();
-      return;
-    }
-  }
-
-  // Controller will delete itself.
-  base::Closure cb = base::Bind(
-      &MediaGalleriesGetMediaFileSystemsFunction::GetAndReturnGalleries, this);
-  new MediaGalleriesDialogController(contents, *GetExtension(), cb);
-}
-
-void MediaGalleriesGetMediaFileSystemsFunction::GetMediaFileSystemsForExtension(
+void MediaGalleriesGetMediaFileSystemsBase::GetMediaFileSystemsForExtension(
     const MediaFileSystemsCallback& cb) {
   if (!render_view_host()) {
     cb.Run(std::vector<MediaFileSystemInfo>());
     return;
   }
-  MediaFileSystemRegistry* registry = media_file_system_registry();
-  DCHECK(registry->GetPreferences(GetProfile())->IsInitialized());
-  registry->GetMediaFileSystemsForExtension(
+  DCHECK(GetMediaGalleriesPreferences()->IsInitialized());
+  media_file_system_registry()->GetMediaFileSystemsForExtension(
       render_view_host(), GetExtension(), cb);
 }
 
+WebContents* MediaGalleriesGetMediaFileSystemsBase::GetWebContents() {
+  WebContents* contents = WebContents::FromRenderViewHost(render_view_host());
+  WebContentsModalDialogManager* web_contents_modal_dialog_manager =
+      WebContentsModalDialogManager::FromWebContents(contents);
+  if (web_contents_modal_dialog_manager)
+    return contents;
+
+  // If there is no WebContentsModalDialogManager, then this contents is
+  // probably the background page for an app. Try to find a shell window to
+  // host the dialog.
+  apps::ShellWindow* window = apps::ShellWindowRegistry::Get(
+      GetProfile())->GetCurrentShellWindowForApp(GetExtension()->id());
+  return window ? window->web_contents() : NULL;
+}
+
+MediaGalleriesPreferences*
+MediaGalleriesGetMediaFileSystemsBase::GetMediaGalleriesPreferences() {
+  return media_file_system_registry()->GetPreferences(GetProfile());
+}
+
+void MediaGalleriesGetMediaFileSystemsBase::AlwaysShowDialog(
+    const std::vector<MediaFileSystemInfo>& /*filesystems*/) {
+  ShowDialog();
+}
+
+
+MediaGalleriesGetMediaFileSystemsFunction::
+    ~MediaGalleriesGetMediaFileSystemsFunction() {}
+
+bool MediaGalleriesGetMediaFileSystemsFunction::RunImpl() {
+  if (!ApiIsAccessible(&error_))
+    return false;
+
+  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;
+  if (params->details.get() && params->details->interactive != MediaGalleries::
+         GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_NONE) {
+    interactive = params->details->interactive;
+  }
+
+  MediaGalleriesPreferences* preferences = GetMediaGalleriesPreferences();
+  preferences->EnsureInitialized(base::Bind(
+      &MediaGalleriesGetMediaFileSystemsFunction::OnPreferencesInit,
+      this,
+      interactive));
+  return true;
+}
+
+void MediaGalleriesGetMediaFileSystemsFunction::OnPreferencesInit(
+    MediaGalleries::GetMediaFileSystemsInteractivity interactive) {
+  switch (interactive) {
+    case MediaGalleries::GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_YES: {
+      ReadPrefsAndShowDialog();
+      return;
+    }
+    case MediaGalleries::GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_IF_NEEDED: {
+      GetMediaFileSystemsForExtension(base::Bind(
+          &MediaGalleriesGetMediaFileSystemsFunction::ShowDialogIfNoGalleries,
+          this));
+      return;
+    }
+    case MediaGalleries::GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_NO:
+      GetAndReturnGalleries();
+      return;
+    case MediaGalleries::GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_NONE:
+      NOTREACHED();
+  }
+  SendResponse(false);
+}
+
+void MediaGalleriesGetMediaFileSystemsFunction::ShowDialogIfNoGalleries(
+    const std::vector<MediaFileSystemInfo>& filesystems) {
+  if (filesystems.empty())
+    ShowDialog();
+  else
+    ReturnGalleries(filesystems);
+}
+
+
 MediaGalleriesGetAllMediaFileSystemMetadataFunction::
     ~MediaGalleriesGetAllMediaFileSystemMetadataFunction() {}
 
 bool MediaGalleriesGetAllMediaFileSystemMetadataFunction::RunImpl() {
   if (!ApiIsAccessible(&error_))
     return false;
 
   media_galleries::UsageCount(
       media_galleries::GET_ALL_MEDIA_FILE_SYSTEM_METADATA);
   MediaGalleriesPreferences* preferences =
       media_file_system_registry()->GetPreferences(GetProfile());
   preferences->EnsureInitialized(base::Bind(
       &MediaGalleriesGetAllMediaFileSystemMetadataFunction::OnPreferencesInit,
       this));
   return true;
 }
 
 void MediaGalleriesGetAllMediaFileSystemMetadataFunction::OnPreferencesInit() {
-  MediaFileSystemRegistry* registry = media_file_system_registry();
-  MediaGalleriesPreferences* prefs = registry->GetPreferences(GetProfile());
+  MediaGalleriesPreferences* prefs =
+      media_file_system_registry()->GetPreferences(GetProfile());
   DCHECK(prefs->IsInitialized());
   MediaGalleryPrefIdSet permitted_gallery_ids =
       prefs->GalleriesForExtension(*GetExtension());
 
   MediaStorageUtil::DeviceIdSet* device_ids = new MediaStorageUtil::DeviceIdSet;
   const MediaGalleriesPrefInfoMap& galleries = prefs->known_galleries();
   for (MediaGalleryPrefIdSet::const_iterator it = permitted_gallery_ids.begin();
        it != permitted_gallery_ids.end(); ++it) {
     MediaGalleriesPrefInfoMap::const_iterator gallery_it = galleries.find(*it);
     DCHECK(gallery_it != galleries.end());
     device_ids->insert(gallery_it->second.device_id);
   }
 
   MediaStorageUtil::FilterAttachedDevices(
       device_ids,
       base::Bind(
           &MediaGalleriesGetAllMediaFileSystemMetadataFunction::OnGetGalleries,
           this,
           permitted_gallery_ids,
           base::Owned(device_ids)));
 }
 
 void MediaGalleriesGetAllMediaFileSystemMetadataFunction::OnGetGalleries(
     const MediaGalleryPrefIdSet& permitted_gallery_ids,
     const MediaStorageUtil::DeviceIdSet* available_devices) {
-  MediaFileSystemRegistry* registry = media_file_system_registry();
-  MediaGalleriesPreferences* prefs = registry->GetPreferences(GetProfile());
+  MediaGalleriesPreferences* prefs =
+      media_file_system_registry()->GetPreferences(GetProfile());
 
   base::ListValue* list = new base::ListValue();
   const MediaGalleriesPrefInfoMap& galleries = prefs->known_galleries();
   for (MediaGalleryPrefIdSet::const_iterator it = permitted_gallery_ids.begin();
        it != permitted_gallery_ids.end(); ++it) {
     MediaGalleriesPrefInfoMap::const_iterator gallery_it = galleries.find(*it);
     DCHECK(gallery_it != galleries.end());
     const MediaGalleryPrefInfo& gallery = gallery_it->second;
     MediaGalleries::MediaFileSystemMetadata metadata;
     metadata.name = base::UTF16ToUTF8(gallery.GetGalleryDisplayName());
     metadata.gallery_id = base::Uint64ToString(gallery.pref_id);
     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);
 }
 
+MediaGalleriesManageMediaLocationsFunction::
+    ~MediaGalleriesManageMediaLocationsFunction() {}
+
+bool MediaGalleriesManageMediaLocationsFunction::RunImpl() {
+  if (!ApiIsAccessible(&error_))
+    return false;
+
+  media_galleries::UsageCount(media_galleries::MANAGE_MEDIA_LOCATIONS);
+  scoped_ptr<ManageMediaLocations::Params> params(
+      ManageMediaLocations::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+  if (params->details.type == MediaGalleries::MANAGE_REQUEST_TYPE_NONE)
+    EXTENSION_FUNCTION_ERROR(kInvalidManageRequestType);  // returns false
+
+  MediaGalleriesPreferences* preferences = GetMediaGalleriesPreferences();
+  preferences->EnsureInitialized(base::Bind(
+      &MediaGalleriesManageMediaLocationsFunction::OnPreferencesInit,
+      this,
+      params->details.type));
+  return true;
+}
+
+void MediaGalleriesManageMediaLocationsFunction::OnPreferencesInit(
+    MediaGalleries::ManageRequestType request_type) {
+  switch (request_type) {
+    case MediaGalleries::MANAGE_REQUEST_TYPE_MANAGE: {
+      ReadPrefsAndShowDialog();
+      return;
+    }
+    case MediaGalleries::MANAGE_REQUEST_TYPE_DIRECTORY_PROMPT: {
+      WebContents* contents = GetWebContents();
+      if (!contents) {
+        SendResponse(false);
+        return;
+      }
+      SelectDirectoryDialog::Callback cb = base::Bind(
+          &MediaGalleriesManageMediaLocationsFunction::OnDirectorySelected,
+          this);
+      scoped_refptr<SelectDirectoryDialog> select_directory_dialog =
+          new SelectDirectoryDialog(contents, cb);
+      select_directory_dialog->Show();
+      return;
+    }
+    case MediaGalleries::MANAGE_REQUEST_TYPE_NONE:
+      NOTREACHED();
+  }
+  SendResponse(false);
+}
+
+void MediaGalleriesManageMediaLocationsFunction::OnDirectorySelected(
+    const base::FilePath& selected_directory) {
+  if (selected_directory.empty()) {
+    SetResult(new base::ListValue());
+    SendResponse(true);
+    return;
+  }
+
+  bool posted = base::PostTaskAndReplyWithResult(
+      content::BrowserThread::GetBlockingPool(),
+      FROM_HERE,
+      base::Bind(&base::PathExists, selected_directory),
+      base::Bind(
+          &MediaGalleriesManageMediaLocationsFunction::OnDirectoryChecked,
+          this,
+          selected_directory));
+  if (posted)
+    return;
+  SendResponse(false);
+}
+
+void MediaGalleriesManageMediaLocationsFunction::OnDirectoryChecked(
+    const base::FilePath& selected_directory, bool exists) {
+  DCHECK(!selected_directory.empty());
+
+  if (!exists) {
+    SendResponse(false);
+    return;
+  }
+
+  MediaGalleryPrefInfo gallery;
+  MediaGalleriesPreferences* preferences = GetMediaGalleriesPreferences();
+  MediaGalleryPrefId pref_id =
+      preferences->AddGalleryByPath(selected_directory);
+  preferences->SetGalleryPermissionForExtension(*GetExtension(), pref_id, true);
+
+  GetMediaFileSystemsForExtension(base::Bind(
+      &MediaGalleriesManageMediaLocationsFunction::FindGalleryWithPrefId,
+      this,
+      pref_id));
+}
+
+void MediaGalleriesManageMediaLocationsFunction::FindGalleryWithPrefId(
+    MediaGalleryPrefId pref_id,
+    const std::vector<MediaFileSystemInfo>& filesystems) {
+  for (size_t i = 0; i < filesystems.size(); i++) {
+    if (filesystems[i].pref_id == pref_id) {
+      std::vector<MediaFileSystemInfo> found_filesystem;
+      found_filesystem.push_back(filesystems[i]);
+      scoped_ptr<base::ListValue> list(
+          ConstructFileSystemList(found_filesystem));
+      if (!list.get())
+        break;
+
+      SetResult(list.release());
+      SendResponse(true);
+      return;
+    }
+  }
+  SendResponse(false);
+}
+
 }  // namespace extensions