New API to copy syncfs folder to localfs.

chrome/browser/extensions/api/developer_private/developer_private_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/developer_private/developer_private_api.h"
 
 #include "apps/app_load_service.h"
 #include "apps/app_restore_service.h"
 #include "apps/saved_files_service.h"
 #include "apps/shell_window.h"
@@ skipping 48 matching lines @@
 #include "extensions/common/manifest_handlers/incognito_info.h"
 #include "extensions/common/manifest_handlers/offline_enabled_info.h"
 #include "extensions/common/switches.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/webui/web_ui_util.h"
+#include "webkit/browser/fileapi/external_mount_points.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/common/blob/shareable_file_reference.h"
 
 using apps::ShellWindow;
 using apps::ShellWindowRegistry;
 using content::RenderViewHost;
 
 namespace extensions {
@@ skipping 46 matching lines @@
 
   return GetImageURLFromData(contents);
 }
 
 bool ValidateFolderName(const base::FilePath::StringType& name) {
   base::FilePath::StringType name_sanitized(name);
   file_util::ReplaceIllegalCharactersInPath(&name_sanitized, '_');
   return name == name_sanitized;
 }
 
-const Extension* GetExtensionByPath(const extensions::ExtensionSet* extensions,
-                                    const base::FilePath& path) {
-  base::FilePath extension_path = base::MakeAbsoluteFilePath(path);
-  for (extensions::ExtensionSet::const_iterator iter = extensions->begin();
-       iter != extensions->end(); ++iter) {
-    if ((*iter)->path() == extension_path)
-      return iter->get();
-  }
-  return NULL;
-}
-
 std::string GetExtensionID(const RenderViewHost* render_view_host) {
   if (!render_view_host->GetSiteInstance())
     return std::string();
 
   return render_view_host->GetSiteInstance()->GetSiteURL().host();
 }
 
 }  // namespace
 
 namespace AllowFileAccess = api::developer_private::AllowFileAccess;
@@ skipping 798 matching lines @@
 }
 
 DeveloperPrivatePackDirectoryFunction::DeveloperPrivatePackDirectoryFunction()
 {}
 
 DeveloperPrivatePackDirectoryFunction::~DeveloperPrivatePackDirectoryFunction()
 {}
 
 DeveloperPrivateLoadUnpackedFunction::~DeveloperPrivateLoadUnpackedFunction() {}
 
-bool DeveloperPrivateExportSyncfsFolderToLocalfsFunction::RunImpl() {
+bool DeveloperPrivateLoadDirectoryFunction::RunImpl() {
   // TODO(grv) : add unittests.
-  base::FilePath::StringType project_name;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &project_name));
-  if (!ValidateFolderName(project_name)) {
-    DVLOG(0) << "Invalid project_name : [" << project_name << "]";
-    return false;
+  std::string directory_url_str;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &directory_url_str));
+  size_t pos = 0;
+
+  std::string syncfs_url_prefix = "filesystem:chrome-extension://"
+      + GetExtensionID(render_view_host()) + "/external/syncfs";
+
+  bool is_syncfs_url = (directory_url_str.find(syncfs_url_prefix)
+                            != std::string::npos);
+
+  if (is_syncfs_url) {

[kinuko, 2014/01/16 04:42:24]

A preferred way to check this is get FileSystemURL by CrackURL() and check its
type, like:

fileapi::FileSystemURL directory_url =
context_->CrackURL(GURL(directory_url_str));

if (directory_url.is_valid() && directory_url.type() ==
fileapi::kFileSystemTypeSyncable) {
  ...
}

(You'll need to move line 984-986 before this code snippet to set context_)

+
+    base::FilePath::StringType project_name;
+    // Parse the project directory name from the project url. The project url is
+    // expected to have project name as the suffix.
+    if ((pos = directory_url_str.rfind("/")) == std::string::npos) {
+      SetError("Invalid Directory entry.");
+      return false;
+    }
+
+    project_name = directory_url_str.substr(pos + 1);
+    project_base_url_ = directory_url_str.substr(0, pos + 1);
+
+    if (!ValidateFolderName(project_name)) {
+      DVLOG(0) << "Invalid project_name : [" << project_name << "]";
+      return false;
+    }
+
+    context_ = content::BrowserContext::GetStoragePartition(
+        GetProfile(), render_view_host()->GetSiteInstance())
+                   ->GetFileSystemContext();
+
+    base::FilePath project_path(GetProfile()->GetPath());
+    project_path = project_path.Append(kUnpackedAppsFolder);
+    project_path = project_path.Append(project_name);
+
+    path_ = project_path;
+
+    content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
+        base::Bind(&DeveloperPrivateLoadDirectoryFunction::
+                       ClearExistingDirectoryContent,
+                   this,
+                   path_));
+  } else {
+
+    base::FilePath::StringType path_str(directory_url_str);
+    path_ = path_.Append(path_str);
+    Load();
   }
 
-  context_ = content::BrowserContext::GetStoragePartition(
-      GetProfile(), render_view_host()->GetSiteInstance())
-                 ->GetFileSystemContext();
-
-  base::FilePath project_path(GetProfile()->GetPath());
-  project_path = project_path.Append(kUnpackedAppsFolder);
-  project_path = project_path.Append(project_name);
-
-  content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(&DeveloperPrivateExportSyncfsFolderToLocalfsFunction::
-                     ClearPrexistingDirectoryContent,
-                 this,
-                 project_path));
-
   return true;
 }
 
-void DeveloperPrivateExportSyncfsFolderToLocalfsFunction::
-    ClearPrexistingDirectoryContent(const base::FilePath& project_path) {
+void DeveloperPrivateLoadDirectoryFunction::Load() {
+
+  ExtensionService* service = GetProfile()->GetExtensionService();
+  UnpackedInstaller::Create(service)->Load(path_);
+
+  // TODO(grv) : The unpacked installer should fire an event when complete
+  // and return the extension_id.
+    SetResult(new base::StringValue("-1"));
+    SendResponse(true);
+}
+
+void DeveloperPrivateLoadDirectoryFunction::ClearExistingDirectoryContent(
+    const base::FilePath& project_path) {
 
   // Clear the project directory before copying new files.
   base::DeleteFile(project_path, true/*recursive*/);
 
-  pendingCopyOperationsCount_ = 1;
+  pending_copy_operations_count_ = 1;
 
   content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&DeveloperPrivateExportSyncfsFolderToLocalfsFunction::
+      base::Bind(&DeveloperPrivateLoadDirectoryFunction::
                  ReadSyncFileSystemDirectory,
                  this, project_path, project_path.BaseName()));
 }
 
-void DeveloperPrivateExportSyncfsFolderToLocalfsFunction::
-    ReadSyncFileSystemDirectory(const base::FilePath& project_path,
-                                const base::FilePath& destination_path) {
-  std::string origin_url(
-      Extension::GetBaseURLFromExtensionId(extension_id()).spec());
-  fileapi::FileSystemURL url(sync_file_system::CreateSyncableFileSystemURL(
-      GURL(origin_url),
-      destination_path));
+void DeveloperPrivateLoadDirectoryFunction::ReadSyncFileSystemDirectory(
+    const base::FilePath& project_path,
+    const base::FilePath& destination_path) {
+
+  project_path_ = context_->CrackURL(GURL(project_base_url_)).path();
+
+  GURL project_url = GURL(project_base_url_ + destination_path.MaybeAsASCII());
+
+  fileapi::FileSystemURL url = context_->CrackURL(project_url);
 
   context_->operation_runner()->ReadDirectory(
-      url, base::Bind(&DeveloperPrivateExportSyncfsFolderToLocalfsFunction::
+      url, base::Bind(&DeveloperPrivateLoadDirectoryFunction::
                       ReadSyncFileSystemDirectoryCb,
                       this, project_path, destination_path));
 }
 
-void DeveloperPrivateExportSyncfsFolderToLocalfsFunction::
-    ReadSyncFileSystemDirectoryCb(
+void DeveloperPrivateLoadDirectoryFunction::ReadSyncFileSystemDirectoryCb(
     const base::FilePath& project_path,
     const base::FilePath& destination_path,
     base::PlatformFileError status,
     const fileapi::FileSystemOperation::FileEntryList& file_list,
     bool has_more) {
 
   if (status != base::PLATFORM_FILE_OK) {
     DLOG(ERROR) << "Error in copying files from sync filesystem.";
     return;
   }
 
   // We add 1 to the pending copy operations for both files and directories. We
   // release the directory copy operation once all the files under the directory
   // are added for copying. We do that to ensure that pendingCopyOperationsCount
   // does not become zero before all copy operations are finished.
   // In case the directory happens to be executing the last copy operation it
   // will call SendResponse to send the response to the API. The pending copy
   // operations of files are released by the CopyFile function.
-  pendingCopyOperationsCount_ += file_list.size();
+  pending_copy_operations_count_ += file_list.size();
 
   for (size_t i = 0; i < file_list.size(); ++i) {
     if (file_list[i].is_directory) {
       ReadSyncFileSystemDirectory(project_path.Append(file_list[i].name),
                                   destination_path.Append(file_list[i].name));
       continue;
     }
 
     std::string origin_url(
         Extension::GetBaseURLFromExtensionId(extension_id()).spec());
     fileapi::FileSystemURL url(sync_file_system::CreateSyncableFileSystemURL(
         GURL(origin_url),
-        destination_path.Append(file_list[i].name)));
+        project_path_.Append(destination_path.Append(file_list[i].name))));
     base::FilePath target_path = project_path;
     target_path = target_path.Append(file_list[i].name);
 
     context_->operation_runner()->CreateSnapshotFile(
         url,
-        base::Bind(
-            &DeveloperPrivateExportSyncfsFolderToLocalfsFunction::
-                SnapshotFileCallback,
+        base::Bind(&DeveloperPrivateLoadDirectoryFunction::SnapshotFileCallback,
             this,
             target_path));
 
   }
 
   // Directory copy operation released here.
-  pendingCopyOperationsCount_--;
+  pending_copy_operations_count_--;
 
-  if (!pendingCopyOperationsCount_) {
+  if (!pending_copy_operations_count_) {
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-        base::Bind(&DeveloperPrivateExportSyncfsFolderToLocalfsFunction::
-                       SendResponse,
+        base::Bind(&DeveloperPrivateLoadDirectoryFunction::SendResponse,
                    this,
                    success_));
   }
 }
 
-void DeveloperPrivateExportSyncfsFolderToLocalfsFunction::SnapshotFileCallback(
+void DeveloperPrivateLoadDirectoryFunction::SnapshotFileCallback(
     const base::FilePath& target_path,
     base::PlatformFileError result,
     const base::PlatformFileInfo& file_info,
     const base::FilePath& src_path,
     const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
   if (result != base::PLATFORM_FILE_OK) {
     SetError("Error in copying files from sync filesystem.");
     success_ = false;
     return;
   }
 
   content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(&DeveloperPrivateExportSyncfsFolderToLocalfsFunction::CopyFile,
+      base::Bind(&DeveloperPrivateLoadDirectoryFunction::CopyFile,
                  this,
                  src_path,
                  target_path));
 }
 
-void DeveloperPrivateExportSyncfsFolderToLocalfsFunction::CopyFile(
+void DeveloperPrivateLoadDirectoryFunction::CopyFile(
     const base::FilePath& src_path,
     const base::FilePath& target_path) {
   if (!base::CreateDirectory(target_path.DirName())) {
     SetError("Error in copying files from sync filesystem.");
     success_ = false;
   }
 
   if (success_)
     base::CopyFile(src_path, target_path);
 
-  CHECK(pendingCopyOperationsCount_ > 0);
-  pendingCopyOperationsCount_--;
+  CHECK(pending_copy_operations_count_ > 0);
+  pending_copy_operations_count_--;
 
-  if (!pendingCopyOperationsCount_) {
+  if (!pending_copy_operations_count_) {
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-        base::Bind(&DeveloperPrivateExportSyncfsFolderToLocalfsFunction::
-                       SendResponse,
-                   this,
-                   success_));
+        base::Bind(&DeveloperPrivateLoadDirectoryFunction::Load,
+                   this));
   }
 }
 
-DeveloperPrivateExportSyncfsFolderToLocalfsFunction::
-    DeveloperPrivateExportSyncfsFolderToLocalfsFunction()
-    : pendingCopyOperationsCount_(0), success_(true) {}
+DeveloperPrivateLoadDirectoryFunction::DeveloperPrivateLoadDirectoryFunction()
+    : pending_copy_operations_count_(0), success_(true) {}
 
-DeveloperPrivateExportSyncfsFolderToLocalfsFunction::
-    ~DeveloperPrivateExportSyncfsFolderToLocalfsFunction() {}
-
-bool DeveloperPrivateLoadProjectFunction::RunImpl() {
-  // TODO(grv) : add unit tests.
-  base::FilePath::StringType project_name;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &project_name));
-  if (!ValidateFolderName(project_name)) {
-    DVLOG(0) << "Invalid project_name : [" << project_name << "]";
-    return false;
-  }
-
-  base::FilePath path(GetProfile()->GetPath());
-  path = path.Append(kUnpackedAppsFolder);
-  // TODO(grv) : Sanitize / check project_name.
-  path = path.Append(project_name);
-  ExtensionService* service = GetProfile()->GetExtensionService();
-  UnpackedInstaller::Create(service)->Load(path);
-
-  const extensions::ExtensionSet* extensions = service->extensions();
-  // Released by GetUnpackedExtension.
-  AddRef();
-  content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(&DeveloperPrivateLoadProjectFunction::GetUnpackedExtension,
-                 this, path, extensions));
-  return true;
-}
-
-void DeveloperPrivateLoadProjectFunction::GetUnpackedExtension(
-    const base::FilePath& path,
-    const extensions::ExtensionSet* extensions) {
-  const Extension* extension = GetExtensionByPath(extensions, path);
-  bool success = true;
-  if (extension) {
-    SetResult(new base::StringValue(extension->id()));
-  } else {
-    SetError("unable to load the project");
-    success = false;
-  }
-  content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-      base::Bind(&DeveloperPrivateLoadProjectFunction::SendResponse,
-                 this,
-                 success));
-  Release();
-}
-
-DeveloperPrivateLoadProjectFunction::DeveloperPrivateLoadProjectFunction() {}
-
-DeveloperPrivateLoadProjectFunction::~DeveloperPrivateLoadProjectFunction() {}
+DeveloperPrivateLoadDirectoryFunction::~DeveloperPrivateLoadDirectoryFunction()
+    {}
 
 bool DeveloperPrivateChoosePathFunction::RunImpl() {
 
   scoped_ptr<developer::ChoosePath::Params> params(
       developer::ChoosePath::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   ui::SelectFileDialog::Type type = ui::SelectFileDialog::SELECT_FOLDER;
   ui::SelectFileDialog::FileTypeInfo info;
   if (params->select_type == developer::SELECT_TYPE_FILE) {
@@ skipping 162 matching lines @@
   return true;
 }
 
 DeveloperPrivateIsProfileManagedFunction::
     ~DeveloperPrivateIsProfileManagedFunction() {
 }
 
 } // namespace api
 
 } // namespace extensions