Support file system access in DevTools with isolated file system.

chrome/browser/devtools/devtools_window.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 <algorithm>
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/string_number_conversions.h"
@@ skipping 78 matching lines @@
 // static
 void DevToolsWindow::RegisterUserPrefs(PrefServiceSyncable* prefs) {
   prefs->RegisterBooleanPref(prefs::kDevToolsOpenDocked,
                              true,
                              PrefServiceSyncable::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(prefs::kDevToolsDockSide,
                             kDockSideBottom,
                             PrefServiceSyncable::UNSYNCABLE_PREF);
   prefs->RegisterDictionaryPref(prefs::kDevToolsEditedFiles,
                                 PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterDictionaryPref(prefs::kDevToolsSavedFileSystemPathes,

[pfeldman, 2012/12/24 19:01:03]

Paths

+                                PrefServiceSyncable::UNSYNCABLE_PREF);
 }
 
 // static
 DevToolsWindow* DevToolsWindow::GetDockedInstanceForInspectedTab(
     WebContents* inspected_web_contents) {
   if (!inspected_web_contents)
     return NULL;
 
   if (!DevToolsAgentHostRegistry::HasDevToolsAgentHost(
       inspected_web_contents->GetRenderViewHost()))
@@ skipping 100 matching lines @@
       web_contents_(web_contents),
       browser_(NULL),
       dock_side_(dock_side),
       is_loaded_(false),
       action_on_load_(DEVTOOLS_TOGGLE_ACTION_SHOW),
       width_(-1),
       height_(-1) {
   frontend_host_ = DevToolsClientHost::CreateDevToolsFrontendHost(web_contents,
                                                                   this);
   file_helper_.reset(new DevToolsFileHelper(profile, this));
+  file_system_helper_ = new DevToolsFileSystemHelper(web_contents,
+                                                     profile,
+                                                     this);
 
   g_instances.Get().push_back(this);
   // Wipe out page icon so that the default application icon is used.
   NavigationEntry* entry = web_contents->GetController().GetActiveEntry();
   entry->GetFavicon().image = gfx::Image();
   entry->GetFavicon().valid = true;
 
   // Register on-load actions.
   registrar_.Add(
       this,
@@ skipping 271 matching lines @@
 }
 
 WebContents* DevToolsWindow::OpenURLFromTab(WebContents* source,
                                             const OpenURLParams& params) {
   if (inspected_web_contents_)
     return inspected_web_contents_->OpenURL(params);
   return NULL;
 }
 
 void DevToolsWindow::CallClientFunction(const std::string& function_name,
-                                        const Value* arg) {
-  std::string json;
-  if (arg)
-    base::JSONWriter::Write(arg, &json);
-
-  string16 javascript =
-      ASCIIToUTF16(function_name + "(" + json + ");");
+                                        const Value* arg1,
+                                        const Value* arg2) {
+  std::string params;
+  if (arg1) {
+    std::string json;
+    base::JSONWriter::Write(arg1, &json);
+    params.append(json);
+    if (arg2) {
+      base::JSONWriter::Write(arg2, &json);
+      params.append(", " + json);
+    }
+  }
+  string16 javascript = ASCIIToUTF16(function_name + "(" + params + ");");
   web_contents_->GetRenderViewHost()->
       ExecuteJavascriptInWebFrame(string16(), javascript);
 }
 
 void DevToolsWindow::Observe(int type,
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
   if (type == content::NOTIFICATION_LOAD_STOP && !is_loaded_) {
     is_loaded_ = true;
     UpdateTheme();
@@ skipping 288 matching lines @@
                                 const std::string& content,
                                 bool save_as) {
   file_helper_->Save(url, content, save_as);
 }
 
 void DevToolsWindow::AppendToFile(const std::string& url,
                                   const std::string& content) {
   file_helper_->Append(url, content);
 }
 
+namespace {
+
+DictionaryValue* CreateFileSystemValue(

[pfeldman, 2012/12/24 19:01:03]

You should also make this function static instead of putting into an anonymous
namespace.

+    DevToolsFileSystemHelper::FileSystem file_system) {
+  DictionaryValue* file_system_value = new DictionaryValue();
+  file_system_value->SetString("fileSystemId", file_system.filesystem_id);
+  file_system_value->SetString("registeredName", file_system.registered_name);
+  file_system_value->SetString("fileSystemPath", file_system.file_system_path);
+  return file_system_value;
+}
+
+} // namespace
+
+void DevToolsWindow::RequestFileSystemPermissions() {
+  file_system_helper_->RequestPermissions();
+}
+
+void DevToolsWindow::SelectFolderAndGrantFileSystemPermission() {
+  file_system_helper_->SelectFolderAndGrantPermission();
+}
+
+void DevToolsWindow::RevokeFileSystemPermission(
+    const std::string& file_system_path) {
+  file_system_helper_->RevokePermission(file_system_path);
+
+  StringValue file_system_path_value(file_system_path);
+  CallClientFunction("InspectorFrontendAPI.fileSystemFolderPermissionsRevoked",
+                     &file_system_path_value);
+}
+
 void DevToolsWindow::FileSavedAs(const std::string& url) {
   StringValue url_value(url);
   CallClientFunction("InspectorFrontendAPI.savedURL", &url_value);
 }
 
 void DevToolsWindow::AppendedTo(const std::string& url) {
   StringValue url_value(url);
   CallClientFunction("InspectorFrontendAPI.appendedToURL", &url_value);
 }
 
+void DevToolsWindow::FileSystemPermissionsLoaded(
+    std::vector<DevToolsFileSystemHelper::FileSystem> file_systems) {
+  ListValue file_systems_value;
+  for (size_t i = 0; i < file_systems.size(); ++i) {
+    file_systems_value.Append(CreateFileSystemValue(file_systems[i]));
+  }
+  CallClientFunction("InspectorFrontendAPI.fileSystemPermissionsLoaded",
+                     &file_systems_value);
+}
+
+void DevToolsWindow::FileSystemFolderSelected(
+    DevToolsFileSystemHelper::FileSystem file_system) {
+  DictionaryValue* file_system_value = CreateFileSystemValue(file_system);
+  StringValue error_string_value("");
+  CallClientFunction("InspectorFrontendAPI.fileSystemFolderSelected",
+                     &error_string_value,
+                     file_system_value);
+  delete file_system_value;
+}
+
+void DevToolsWindow::FileSystemFolderSelectionCanceled() {
+  CallClientFunction("InspectorFrontendAPI.fileSystemFolderSelected");
+}
+
+void DevToolsWindow::FileSystemFolderSelectionError(std::string error_string) {
+  StringValue error_string_value(error_string);
+  CallClientFunction("InspectorFrontendAPI.fileSystemFolderSelected",
+                     &error_string_value);
+}
+
 content::JavaScriptDialogCreator* DevToolsWindow::GetJavaScriptDialogCreator() {
   if (inspected_web_contents_ && inspected_web_contents_->GetDelegate()) {
     return inspected_web_contents_->GetDelegate()->
         GetJavaScriptDialogCreator();
   }
   return content::WebContentsDelegate::GetJavaScriptDialogCreator();
 }
 
 void DevToolsWindow::RunFileChooser(WebContents* web_contents,
                                     const FileChooserParams& params) {
@@ skipping 57 matching lines @@
 
 // static
 DevToolsDockSide DevToolsWindow::SideFromString(
     const std::string& dock_side) {
   if (dock_side == kDockSideRight)
     return DEVTOOLS_DOCK_SIDE_RIGHT;
   if (dock_side == kDockSideBottom)
     return DEVTOOLS_DOCK_SIDE_BOTTOM;
   return DEVTOOLS_DOCK_SIDE_UNDOCKED;
 }