Support file system access in DevTools with isolated file system.

chrome/browser/devtools/devtools_file_helper.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/devtools/devtools_file_helper.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/md5.h"
+#include "base/utf_string_conversions.h"
 #include "base/value_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/download_manager.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/common/content_client.h"
+#include "grit/generated_resources.h"
 #include "ui/base/dialogs/select_file_dialog.h"
+#include "ui/base/l10n/l10n_util.h"
+#include "webkit/fileapi/isolated_context.h"
 
 using base::Bind;
 using base::Callback;
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DownloadManager;
+using content::RenderViewHost;
+using content::WebContents;
 
 namespace {
 
 base::LazyInstance<FilePath>::Leaky
     g_last_save_path = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 namespace {
 
 typedef Callback<void(const FilePath&)> SelectedCallback;
 typedef Callback<void(void)> CanceledCallback;
 
+const FilePath::CharType kMagicFileName[] =
+    FILE_PATH_LITERAL(".allow-devtools-edit");
+
 class SelectFileDialog : public ui::SelectFileDialog::Listener,
                          public base::RefCounted<SelectFileDialog> {
  public:
   SelectFileDialog(const SelectedCallback& selected_callback,
                    const CanceledCallback& canceled_callback)
       : selected_callback_(selected_callback),
         canceled_callback_(canceled_callback) {
     select_file_dialog_ = ui::SelectFileDialog::Create(
         this, new ChromeSelectFilePolicy(NULL));
   }
@@ skipping 44 matching lines @@
   file_util::WriteFile(path, content.c_str(), content.length());
 }
 
 void AppendToFile(const FilePath& path, const std::string& content) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(!path.empty());
 
   file_util::AppendToFile(path, content.c_str(), content.length());
 }
 
+fileapi::IsolatedContext* isolated_context() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  fileapi::IsolatedContext* isolated_context =
+      fileapi::IsolatedContext::GetInstance();
+  DCHECK(isolated_context);
+  return isolated_context;
+}
+
+std::string RegisterFileSystem(WebContents* web_contents,
+                               const FilePath& path,
+                               std::string* registered_name) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CHECK(content::GetContentClient()->HasWebUIScheme(web_contents->GetURL()));
+  std::string file_system_id = isolated_context()->RegisterFileSystemForPath(
+      fileapi::kFileSystemTypeNativeLocal, path, registered_name);
+
+  content::ChildProcessSecurityPolicy* policy =
+      content::ChildProcessSecurityPolicy::GetInstance();
+  RenderViewHost* render_view_host = web_contents->GetRenderViewHost();
+  int renderer_id = render_view_host->GetProcess()->GetID();
+  policy->GrantReadWriteFileSystem(renderer_id, file_system_id);
+
+  // We only need file level access for reading FileEntries. Saving FileEntries
+  // just needs the file system to have read/write access, which is granted
+  // above if required.
+  if (!policy->CanReadFile(renderer_id, path))
+    policy->GrantReadFile(renderer_id, path);
+
+  return file_system_id;
+}
+
+typedef Callback<void(const std::vector<FilePath>&)> ValidateFoldersCallback;
+
+void ValidateFoldersOnFileThread(const std::vector<FilePath>& file_paths,
+                                 const ValidateFoldersCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  std::vector<FilePath> permitted_paths;
+  std::vector<FilePath>::const_iterator it;
+  for (it = file_paths.begin(); it != file_paths.end(); ++it) {
+    FilePath security_file_path = it->Append(kMagicFileName);
+    if (file_util::PathExists(security_file_path))
+      permitted_paths.push_back(*it);

[kinuko, 2013/01/09 15:17:50]

I'm afraid I don't fully understand this 'kMagicFileName' logic.  So if a user
creates the '.allow-devtools-edit' file the directory will become writable from
Inspector?

[vsevik, 2013/01/09 17:13:17]

The directory will become writable only if the corresponding file system was
added through addFileSystem method, that is once user selects this directory in
file selection dialog, provided that magic file exists in this directory.

[kinuko, 2013/01/10 07:33:58]

Who creates the magic file? Sorry if I'm asking something obvious.

[vsevik, 2013/01/10 08:14:21]

User should create a magic file in order to add a folder to DevTools. This way
we double check that it is safe enough to grant permissions for this folder: we
know that user has selected this folder in the dialog and created a magic file
separately.

+  }
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          Bind(callback, permitted_paths));
+}
+
 }  // namespace
 
-DevToolsFileHelper::DevToolsFileHelper(Profile* profile) : profile_(profile),
-                                                           weak_factory_(this) {
+DevToolsFileHelper::FileSystem::FileSystem() {
+}
+
+DevToolsFileHelper::FileSystem::FileSystem(const std::string& file_system_id,
+                                           const std::string& registered_name,
+                                           const std::string& file_system_path)
+    : file_system_id(file_system_id),
+      registered_name(registered_name),
+      file_system_path(file_system_path) {
+}
+
+DevToolsFileHelper::DevToolsFileHelper(WebContents* web_contents,
+                                       Profile* profile)
+    : web_contents_(web_contents),
+      profile_(profile),
+      weak_factory_(this) {

[kinuko, 2013/01/09 15:17:50]

I think you need to use ALLOW_THIS_IN_INITIALIZER_LIST(this) to avoid warnings
on some platforms (e.g. weak_factory_(ALLOW_...(this)) )

[vsevik, 2013/01/10 07:01:16]

Done.

 }
 
 DevToolsFileHelper::~DevToolsFileHelper() {
 }
 
 void DevToolsFileHelper::Save(const std::string& url,
                               const std::string& content,
                               bool save_as,
                               const SaveCallback& callback) {
   PathsMap::iterator it = saved_files_.find(url);
@@ skipping 41 matching lines @@
 }
 
 void DevToolsFileHelper::Append(const std::string& url,
                                 const std::string& content,
                                 const AppendCallback& callback) {
   PathsMap::iterator it = saved_files_.find(url);
   if (it == saved_files_.end())
     return;
   callback.Run();
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-                          base::Bind(&AppendToFile, it->second, content));
+                          Bind(&AppendToFile, it->second, content));
 }
 
 void DevToolsFileHelper::SaveAsFileSelected(const std::string& url,
                                             const std::string& content,
                                             const SaveCallback& callback,
                                             const FilePath& path) {
   *g_last_save_path.Pointer() = path;
   saved_files_[url] = path;
 
   DictionaryPrefUpdate update(profile_->GetPrefs(),
                               prefs::kDevToolsEditedFiles);
   DictionaryValue* files_map = update.Get();
   files_map->SetWithoutPathExpansion(base::MD5String(url),
                                      base::CreateFilePathValue(path));
   callback.Run();
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-                          base::Bind(&WriteToFile, path, content));
+                          Bind(&WriteToFile, path, content));
 }
 
 void DevToolsFileHelper::SaveAsFileSelectionCanceled() {
 }
+
+void DevToolsFileHelper::AddFileSystem(const AddFileSystemCallback& callback) {
+  scoped_refptr<SelectFileDialog> select_file_dialog = new SelectFileDialog(
+      Bind(&DevToolsFileHelper::InnerAddFileSystem,
+           weak_factory_.GetWeakPtr(),
+           callback),
+      Bind(callback, "", FileSystem()));
+  select_file_dialog->Show(ui::SelectFileDialog::SELECT_FOLDER, FilePath());
+}
+
+void DevToolsFileHelper::InnerAddFileSystem(
+    const AddFileSystemCallback& callback,
+    const FilePath& path) {
+  std::vector<FilePath> file_paths(1, path);
+  ValidateFoldersCallback validate_folders_callback = Bind(
+      &DevToolsFileHelper::AddValidatedFileSystem,
+      weak_factory_.GetWeakPtr(),
+      callback);
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+                          Bind(&ValidateFoldersOnFileThread,
+                               file_paths,
+                               validate_folders_callback));
+}
+
+void DevToolsFileHelper::AddValidatedFileSystem(
+    const AddFileSystemCallback& callback,
+    const std::vector<FilePath>& permitted_paths) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (permitted_paths.empty()) {
+    std::string magic_file_name = FilePath(kMagicFileName).AsUTF8Unsafe();
+    std::string error_string = l10n_util::GetStringFUTF8(
+        IDS_DEV_TOOLS_MAGIC_FILE_NOT_EXISTS_MESSAGE,
+        UTF8ToUTF16(magic_file_name));
+    callback.Run(error_string, FileSystem());
+    return;
+  }
+  FilePath path = permitted_paths.at(0);
+  std::string registered_name;
+  std::string file_system_id = RegisterFileSystem(web_contents_,
+                                                 path,
+                                                 &registered_name);

[kinuko, 2013/01/09 15:17:50]

nit: indent is off by 1 char? (line 310-311)

[vsevik, 2013/01/10 07:01:16]

Done.

+  std::string file_system_path = path.AsUTF8Unsafe();
+
+  DictionaryPrefUpdate update(profile_->GetPrefs(),
+                              prefs::kDevToolsFileSystemPaths);
+  DictionaryValue* file_systems_paths_value = update.Get();
+  file_systems_paths_value->Set(file_system_path, Value::CreateNullValue());
+
+  FileSystem filesystem(file_system_id, registered_name, file_system_path);
+  callback.Run("", filesystem);
+}
+
+void DevToolsFileHelper::RequestFileSystems(
+    const RequestFileSystemsCallback& callback) {
+  const DictionaryValue* file_systems_paths_value =
+      profile_->GetPrefs()->GetDictionary(prefs::kDevToolsFileSystemPaths);
+  std::vector<FilePath> saved_paths;
+  DictionaryValue::key_iterator it = file_systems_paths_value->begin_keys();
+  for (; it != file_systems_paths_value->end_keys(); ++it) {
+    std::string file_system_path = *it;
+    FilePath path = FilePath::FromUTF8Unsafe(file_system_path);
+    saved_paths.push_back(path);
+  }
+
+  ValidateFoldersCallback validate_folders_callback = Bind(
+      &DevToolsFileHelper::RestoreValidatedFileSystems,
+      weak_factory_.GetWeakPtr(),
+      callback);
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+                          Bind(&ValidateFoldersOnFileThread,
+                               saved_paths,
+                               validate_folders_callback));
+}
+
+void DevToolsFileHelper::RestoreValidatedFileSystems(
+    const RequestFileSystemsCallback& callback,
+    const std::vector<FilePath>& permitted_paths) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  std::vector<FileSystem> file_systems;
+  std::vector<FilePath>::const_iterator it;
+  for (it = permitted_paths.begin(); it != permitted_paths.end(); ++it) {
+    std::string registered_name;
+    std::string file_system_id = RegisterFileSystem(web_contents_,
+                                                   *it,
+                                                   &registered_name);

[kinuko, 2013/01/09 15:17:50]

nit: indent? (line 354-355)

[vsevik, 2013/01/10 07:01:16]

Done.

+    std::string file_system_path = it->AsUTF8Unsafe();
+    FileSystem filesystem(file_system_id, registered_name, file_system_path);
+    file_systems.push_back(filesystem);
+  }
+  callback.Run(file_systems);
+}
+
+void DevToolsFileHelper::RemoveFileSystem(const std::string& file_system_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  FilePath path = FilePath::FromUTF8Unsafe(file_system_path);
+  isolated_context()->RevokeFileSystemByPath(path);
+
+  DictionaryPrefUpdate update(profile_->GetPrefs(),
+                              prefs::kDevToolsFileSystemPaths);
+  DictionaryValue* file_systems_paths_value = update.Get();
+  file_systems_paths_value->RemoveWithoutPathExpansion(file_system_path, NULL);
+}