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,

[vandebo (ex-Chrome), 2013/12/02 18:01:30]

Should this live in c/b/media_galleries?
Should it share code with MediaGalleriesDialogController ?

[Lei Zhang, 2013/12/03 03:33:23]

Probably not? The two workflows are different and I don't think there's much
shared code.

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

They both have a directory picker which results in a added gallery...

+                              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 three 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 {
+    Release();  // Balanced in Show().

[vandebo (ex-Chrome), 2013/12/02 18:01:30]

Should the callback be called with an empty path in this case?  It shouldn't
happen, but if it does the API would never return, right?

[Lei Zhang, 2013/12/03 03:33:23]

No, we should never handle a NOTREACHED() per the Chromium style guide. I'll
remove the Release() as well.

+    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.

[vandebo (ex-Chrome), 2013/12/02 18:01:30]

nit: move to line 166

[Lei Zhang, 2013/12/03 03:33:23]

Done.

+  base::Closure cb = base::Bind(

[vandebo (ex-Chrome), 2013/12/02 18:01:30]

nit: cb -> callback.  Would it be more consistent (172) to inline this?

[Lei Zhang, 2013/12/03 03:33:23]

I inlined it, but now it's 5 lines. Meh.

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

How about:
  new MediaGalleriesDialogController(
      contents, *GetExtension(), base::Bind(
          &MediaGalleriesGetMediaFileSystemsBase::GetAndReturnGalleries, this));

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

Done.

+      &MediaGalleriesGetMediaFileSystemsBase::GetAndReturnGalleries, this);
+  new MediaGalleriesDialogController(contents, *GetExtension(), cb);
+}
+
+void MediaGalleriesGetMediaFileSystemsBase::GetAndReturnGalleries() {
+  GetMediaFileSystemsForExtension(base::Bind(
+      &MediaGalleriesGetMediaFileSystemsBase::ReturnGalleries, this));
+}
+
+void MediaGalleriesGetMediaFileSystemsBase::ReturnGalleries(
+    const std::vector<MediaFileSystemInfo>& filesystems) {
+  base::ListValue* list = ConstructFileSystemList(filesystems);

[vandebo (ex-Chrome), 2013/12/02 18:01:30]

Should this be scoped_ptr<base::ListValue> list ?

[Lei Zhang, 2013/12/03 03:33:23]

Done. We haven't always used scoped_ptrs in all cases.

+  if (!list) {
+    SendResponse(false);

[vandebo (ex-Chrome), 2013/12/02 18:01:30]

The API didn't necessarily fail if there's an empty list.

[Lei Zhang, 2013/12/03 03:33:23]

This is not the empty list case. |list| is only NULL on failure.

+    return;
+  }
+
+  SetResult(list);
+  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);
@@ skipping 38 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()) {
+    base::ListValue* empty_list = new base::ListValue();

[vandebo (ex-Chrome), 2013/12/02 18:01:30]

nit: inline in next line

[Lei Zhang, 2013/12/03 03:33:23]

Done.

+    SetResult(empty_list);
+    SendResponse(true);
+    return;
+  }
+
+  bool posted = base::PostTaskAndReplyWithResult(

[vandebo (ex-Chrome), 2013/12/02 18:01:30]

This appears to be different than MediaGalleriesDialogController::FileSelected,
but the two should be consistent - probably should share code.

[Lei Zhang, 2013/12/03 03:33:23]

MediaGalleriesDialogController::FileSelected has to keep track of the added, but
not saved galleries. ( |new_galleries_| ) Whereas this workflow does not have
that issue to deal with. I don't think they share that much code.

+      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]);
+      base::ListValue* list = ConstructFileSystemList(found_filesystem);

[vandebo (ex-Chrome), 2013/12/02 18:01:30]

Ahh, I see - you're returning a set of zero or one file systems. (This doesn't
match the comments in the idl file.) I'm not sure if we can do this.  The
current semantic is that you can add a directory that doesn't exist, but we
don't return file systems for directories that don't exist....

[Lei Zhang, 2013/12/03 03:33:23]

Leaving this one open. I'll check tomorrow if file dialog pickers let you select
a non-existent path. Even if they do, we can still return a list of 0 galleries
in that case. Even if the file picker lets you, why would a user want to do
that? Even if the user does it, it's a non-existent path, so what can we return
but an empty list?

+      if (!list)
+        break;
+
+      SetResult(list);
+      SendResponse(true);
+      return;
+    }
+  }
+  SendResponse(false);
+}
+
 }  // namespace extensions