Media Gallery: Implement a basic version of GetMediaFileSystems().

chrome/browser/extensions/api/media_gallery/media_gallery_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_gallery/media_gallery_api.h"
 
-#include "base/json/json_writer.h"
+#include <string>
+#include <vector>
+
+#include "base/platform_file.h"
 #include "base/values.h"
+#include "chrome/browser/media_gallery/media_file_system_registry.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"
 
 namespace extensions {
 
+using chrome::MediaFileSystemRegistry;
+using content::ChildProcessSecurityPolicy;
+
 GetMediaFileSystemsFunction::~GetMediaFileSystemsFunction() {}
 
 bool GetMediaFileSystemsFunction::RunImpl() {
-  // TODO(vandebo) Get the list of galleries.
-  result_.reset(new ListValue());
+  chrome::MediaFileSystemRegistry* media_fs_registry =
+      MediaFileSystemRegistry::GetInstance();
+  const std::vector<MediaFileSystemRegistry::MediaFSIDAndPath> filesystems =
+      media_fs_registry->GetMediaFileSystems();
+
+  base::ListValue* list = new base::ListValue();
+  for (size_t i = 0; i < filesystems.size(); i++) {
+    // TODO(thestig) Check permissions to file systems when that capability
+    // exists.
+    const MediaFileSystemRegistry::MediaFSIDAndPath& fsid_and_path =
+        filesystems[i];
+    const std::string& fsid = fsid_and_path.first;
+    const FilePath& path = fsid_and_path.second;
+    const FilePath::StringType basepath = path.BaseName().value();
+#if defined(OS_WIN)
+    // We standardize on UTF8 encoding for |basepath|.
+    const std::string basepath_utf8(base::SysWideToUTF8(basepath);
+#elif defined(OS_POSIX)
+    const std::string basepath_utf8(basepath);
+#endif
+
+    base::DictionaryValue* dict_value = new base::DictionaryValue();
+    dict_value->SetWithoutPathExpansion(
+        "fsid", Value::CreateStringValue(fsid));
+    dict_value->SetWithoutPathExpansion(
+        "dirname", Value::CreateStringValue(basepath_utf8));
+    list->Append(dict_value);
+
+    ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(

[kinuko, 2012/05/25 09:30:38]

Instead of specifying detailed permissions you can simply call GrantReadFile(id,
path).  Also I recommend you check if the file is already readable before
calling GrantReadFile. In your case it won't be a problem but granting
permissions to a file would overwrite any existing permissions given to the file
or to its parent.

if (!policy->CanReadFile(id, path))
  policy->CanReadFile(id, path);

[vandebo (ex-Chrome), 2012/05/29 16:46:07]

Should this be GrantReadDirectory or even GrantAccessFileSystem ?

[Lei Zhang, 2012/05/29 23:26:41]

Done.

[Lei Zhang, 2012/05/29 23:26:41]

In the current ChildProcessSecurityPolicy implementation, GrantReadFile() is
recursive - there's no GrantReadDirectory().

GrantAccessFileSystem() doesn't seem to do anything, though kinuko is working on
that.

[kinuko, 2012/05/30 09:45:13]

Yup... if my one lands earlier please change these lines to:
GrantReadFileSystem().

+        render_view_host()->GetProcess()->GetID(),
+        path,
+        (base::PLATFORM_FILE_OPEN |
+         base::PLATFORM_FILE_READ |
+         base::PLATFORM_FILE_EXCLUSIVE_READ |
+         base::PLATFORM_FILE_ASYNC));
+  }
+
+  result_.reset(list);
   return true;
 }
 
 OpenMediaGalleryManagerFunction::~OpenMediaGalleryManagerFunction() {}
 
 bool OpenMediaGalleryManagerFunction::RunImpl() {
   // TODO(vandebo) Open the Media Gallery Manager UI.
   result_.reset(Value::CreateNullValue());
   return true;
 }
 
 AssembleMediaFileFunction::~AssembleMediaFileFunction() {}
 
 bool AssembleMediaFileFunction::RunImpl() {
   // TODO(vandebo) Update the metadata and return the new file.
   result_.reset(Value::CreateNullValue());
   return true;
 }
 
 }  // namespace extensions