DevTools: Replace .allow-devtools-edit file check with confirmation infobar.

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"
@@ skipping 37 matching lines @@
 base::LazyInstance<base::FilePath>::Leaky
     g_last_save_path = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 namespace {
 
 typedef Callback<void(const base::FilePath&)> SelectedCallback;
 typedef Callback<void(void)> CanceledCallback;
 
-const base::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 79 matching lines @@
 
   // 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<base::FilePath>&)>
-    ValidateFoldersCallback;
-
-void ValidateFoldersOnFileThread(const std::vector<base::FilePath>& file_paths,
-                                 const ValidateFoldersCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  std::vector<base::FilePath> permitted_paths;
-  std::vector<base::FilePath>::const_iterator it;
-  for (it = file_paths.begin(); it != file_paths.end(); ++it) {
-    base::FilePath security_file_path = it->Append(kMagicFileName);
-    if (file_util::PathExists(security_file_path))
-      permitted_paths.push_back(*it);
-  }
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          Bind(callback, permitted_paths));
-}
-
 DevToolsFileHelper::FileSystem CreateFileSystemStruct(
     WebContents* web_contents,
     const std::string& file_system_id,
     const std::string& registered_name,
     const std::string& file_system_path) {
   const GURL origin = web_contents->GetURL().GetOrigin();
   std::string file_system_name = fileapi::GetIsolatedFileSystemName(
       origin,
       file_system_id);
   std::string root_url = fileapi::GetIsolatedFileSystemRootURIString(
@@ skipping 100 matching lines @@
   files_map->SetWithoutPathExpansion(base::MD5String(url),
                                      base::CreateFilePathValue(path));
   callback.Run();
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                           Bind(&WriteToFile, path, content));
 }
 
 void DevToolsFileHelper::SaveAsFileSelectionCanceled() {
 }
 
-void DevToolsFileHelper::AddFileSystem(const AddFileSystemCallback& callback) {
+void DevToolsFileHelper::AddFileSystem(
+    const AddFileSystemCallback& callback,
+    const ShowInfoBarCallback& show_info_bar_callback) {
   scoped_refptr<SelectFileDialog> select_file_dialog = new SelectFileDialog(
       Bind(&DevToolsFileHelper::InnerAddFileSystem,
            weak_factory_.GetWeakPtr(),
-           callback),
-      Bind(callback, "", FileSystem()));
+           callback,
+           show_info_bar_callback),
+      Bind(callback, FileSystem()));
   select_file_dialog->Show(ui::SelectFileDialog::SELECT_FOLDER,
                            base::FilePath());
 }
 
 void DevToolsFileHelper::InnerAddFileSystem(
     const AddFileSystemCallback& callback,
+    const ShowInfoBarCallback& show_info_bar_callback,
     const base::FilePath& path) {
-  std::vector<base::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));
+  string16 message = l10n_util::GetStringFUTF16(
+      IDS_DEV_TOOLS_CONFIRM_ADD_FILE_SYSTEM_MESSAGE,
+      UTF8ToUTF16(path.AsUTF8Unsafe() + "/"));
+  show_info_bar_callback.Run(
+      message,
+      Bind(&DevToolsFileHelper::AddUserConfirmedFileSystem,
+           weak_factory_.GetWeakPtr(),
+           callback, path));
 }
 
-void DevToolsFileHelper::AddValidatedFileSystem(
+void DevToolsFileHelper::AddUserConfirmedFileSystem(
     const AddFileSystemCallback& callback,
-    const std::vector<base::FilePath>& permitted_paths) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (permitted_paths.empty()) {
-    std::string magic_file_name = base::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());
+    const base::FilePath& path,
+    bool allowed) {
+  if (!allowed) {
+    callback.Run(FileSystem());
     return;
   }
-  base::FilePath path = permitted_paths.at(0);
   std::string registered_name;
   std::string file_system_id = RegisterFileSystem(web_contents_,
                                                   path,
                                                   &registered_name);
   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 = CreateFileSystemStruct(web_contents_,
                                                  file_system_id,
                                                  registered_name,
                                                  file_system_path);
-  callback.Run(std::string(), filesystem);
+  callback.Run(filesystem);
 }
 
 void DevToolsFileHelper::RequestFileSystems(
     const RequestFileSystemsCallback& callback) {
   const DictionaryValue* file_systems_paths_value =
       profile_->GetPrefs()->GetDictionary(prefs::kDevToolsFileSystemPaths);
-  std::vector<base::FilePath> saved_paths;
+  std::vector<FileSystem> file_systems;
   for (DictionaryValue::Iterator it(*file_systems_paths_value); !it.IsAtEnd();
        it.Advance()) {
     std::string file_system_path = it.key();
     base::FilePath path = base::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<base::FilePath>& permitted_paths) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  std::vector<FileSystem> file_systems;
-  std::vector<base::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,
+                                                    path,
                                                     &registered_name);
-    std::string file_system_path = it->AsUTF8Unsafe();
     FileSystem filesystem = CreateFileSystemStruct(web_contents_,
                                                    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));
   base::FilePath path = base::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);
 }