Add a whitelist for chrome.fileSystem.requestFileSystem.

chrome/browser/extensions/api/file_system/file_system_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.
 
 #include "chrome/browser/extensions/api/file_system/file_system_api.h"
 
 #include <set>
 
 #include "apps/saved_files_service.h"
 #include "base/bind.h"
@@ skipping 42 matching lines @@
 #include "ui/shell_dialogs/selected_file_info.h"
 
 #if defined(OS_MACOSX)
 #include <CoreFoundation/CoreFoundation.h>
 #include "base/mac/foundation_util.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
+#include "chrome/browser/chromeos/file_manager/app_id.h"
 #include "chrome/browser/chromeos/file_manager/filesystem_api_util.h"
 #include "chrome/browser/chromeos/file_manager/volume_manager.h"
 #include "components/user_manager/user_manager.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/manifest_handlers/kiosk_mode_info.h"
 #include "url/url_constants.h"
 #endif
 
 using apps::SavedFileEntry;
 using apps::SavedFilesService;
@@ skipping 12 matching lines @@
 const char kUnknownIdError[] = "Unknown id";
 
 #if !defined(OS_CHROMEOS)
 const char kNotSupportedOnCurrentPlatformError[] =
     "Operation not supported on the current platform.";
 #else
 const char kNotSupportedOnNonKioskSessionError[] =
     "Operation only supported for kiosk apps running in a kiosk session.";
 const char kVolumeNotFoundError[] = "Volume not found.";
 const char kSecurityError[] = "Security error.";
+
+// List of whitelisted component apps and extensions by their ids for
+// chrome.fileSystem.requestFileSystem.
+const char* const kRequestFileSystemComponentWhitelist[] = {

[benwells, 2015/03/23 06:34:31]

Can we use the hashed ids? See
https://code.google.com/p/chromium/codesearch#chromium/src/extensions/browser...
for an example.

[mtomasz, 2015/03/23 06:39:10]

Would they be better? We already have constants with ids. Hashing wouldn't hide
these apps, as everyone can see which apps have the access via cs.chromium.org,
or via git grep for requestFileSystem manifest entry.

[benwells, 2015/03/23 09:30:09]

We normally use the hashed IDs everywhere for consistency, so we don't need to
think about whether ids are public or not. Are there hashed versions of these
IDs about?

[benwells, 2015/03/23 09:31:01]

Are these all component apps? I guess in that case it is OK.

[mtomasz, 2015/03/23 09:38:51]

Yes, they are all component apps. We don't have hashes for them, but we could
calculate. However, we use kFileManagerAppId all over the Chromium code base, so
keeping it also here is IMHO easier to maintain (grep friendly, less constants).

If you're fine with it, let's keep it as it is for now. I'm happy to convert it
to hashes once we have any external apps added to the list.

+    file_manager::kFileManagerAppId,
+    file_manager::kVideoPlayerAppId,
+    file_manager::kGalleryAppId,
+    file_manager::kAudioPlayerAppId,
+    file_manager::kImageLoaderExtensionId,
+    "pkplfbidichfdicaijlchgnapepdginl"  // Testing extensions.
+};
 #endif
 
 namespace file_system = extensions::api::file_system;
 namespace ChooseEntry = file_system::ChooseEntry;
 
 namespace {
 
 bool g_skip_picker_for_test = false;
 bool g_use_suggested_path_for_test = false;
 base::FilePath* g_path_to_be_picked_for_test;
@@ skipping 912 matching lines @@
 ExtensionFunction::ResponseAction FileSystemRequestFileSystemFunction::Run() {
   using extensions::api::file_system::RequestFileSystem::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
 #if !defined(OS_CHROMEOS)
   NOTIMPLEMENTED();
   return RespondNow(Error(kNotSupportedOnCurrentPlatformError));
 
 #else
-  // Only kiosk apps in kiosk sessions can use this API. Additionally component
-  // extensions and apps, which is not documented though.
+  // Only kiosk apps in kiosk sessions can use this API.
+  // Additionally whitelisted component extensions and apps.
+  bool is_whitelisted_component = false;
+  if (extension()->location() == Manifest::COMPONENT) {
+    for (const auto& whitelisted_id : kRequestFileSystemComponentWhitelist) {
+      if (extension_id().compare(whitelisted_id) == 0) {
+        is_whitelisted_component = true;
+        break;
+      }
+    }
+  }
   if ((!user_manager::UserManager::Get()->IsLoggedInAsKioskApp() ||
        !KioskModeInfo::IsKioskEnabled(extension())) &&
-      extension()->location() != Manifest::COMPONENT) {
+      !is_whitelisted_component) {
     return RespondNow(Error(kNotSupportedOnNonKioskSessionError));
   }
 
   using file_manager::VolumeManager;
   using file_manager::VolumeInfo;
   VolumeManager* const volume_manager =
       VolumeManager::Get(chrome_details_.GetProfile());
   DCHECK(volume_manager);
 
   const bool writable =
@@ skipping 22 matching lines @@
   if (!backend->GetVirtualPath(volume_info.mount_path, &virtual_path))
     return RespondNow(Error(kSecurityError));
 
   if (writable && (volume_info.is_read_only))
     return RespondNow(Error(kSecurityError));
 
   chromeos::KioskAppManager::App app_info;
   const bool is_auto_launched =
       chromeos::KioskAppManager::Get()->GetApp(extension_id(), &app_info) &&
       app_info.was_auto_launched_with_zero_delay;
-  const bool requires_consent =
-      !is_auto_launched && extension()->location() != Manifest::COMPONENT;
+  const bool requires_consent = !is_auto_launched && !is_whitelisted_component;
 
   if (!requires_consent) {
     // Grant the permission without showing the dialog.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&FileSystemRequestFileSystemFunction::OnConsentReceived,
                    this, volume_info.volume_id, writable, true /* granted */));
   } else {
     // TODO(mtomasz): Create a better display name, which is the most meaningful
     // to the user.
@@ skipping 120 matching lines @@
   base::DictionaryValue* const dict = new base::DictionaryValue();
   dict->SetString("file_system_id", file_system_id);
   dict->SetString("file_system_path", register_name);
 
   SetResult(dict);
   SendResponse(true);
 }
 #endif
 
 }  // namespace extensions