Add API to load project from localfs into syncfs.

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 "base/base64.h"
 #include "base/file_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
@@ skipping 30 matching lines @@
 #include "extensions/browser/view_type_utils.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_resource.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/blob/shareable_file_reference.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation.h"
+#include "webkit/fileapi/local_file_system_operation.h"
 #include "webkit/fileapi/syncable/syncable_file_system_util.h"
 
 using content::RenderViewHost;
 
 namespace extensions {
 
 namespace {
 
 const base::FilePath::CharType kUnpackedAppsFolder[]
     = FILE_PATH_LITERAL("apps_target");
 
 ExtensionUpdater* GetExtensionUpdater(Profile* profile) {
     return profile->GetExtensionService()->updater();
 }
 
 GURL ToDataURL(const base::FilePath& path) {
   std::string contents;
   if (!file_util::ReadFileToString(path, &contents))
     return GURL();
 
   std::string contents_base64;
   if (!base::Base64Encode(contents, &contents_base64))
     return GURL();
 
   const char kDataURLPrefix[] = "data:image;base64,";
   return GURL(kDataURLPrefix + contents_base64);
 }
 
+std::vector<base::FilePath> ListFolder(const base::FilePath path) {
+  file_util::FileEnumerator files(path, false,
+      file_util::FileEnumerator::DIRECTORIES
+      | file_util::FileEnumerator::FILES);
+  std::vector<base::FilePath> paths;
+
+  for (base::FilePath current_path = files.Next(); !current_path.empty();
+       current_path = files.Next()) {
+    paths.push_back(current_path);
+  }
+  return paths;
+}
+
+bool ValidateFolderName(const base::FilePath::StringType& name) {
+  if (!name.length() || name[0] == '.' || name[0] == '-')
+    return false;
+
+  for (size_t i = 0; i < name.length(); ++i) {
+    if (!((name[i] >= 'A' && name[i] <= 'Z') ||
+          (name[i] >= 'a' && name[i] <= 'z') ||
+          (name[i] >= '0' && name[i] <= '9') ||
+           (name[i] == '_' || name[i] == '-' || name[i] == '.'))) {
+      return false;
+    }
+  }
+  return true;
+}
+
 }  // namespace
 
 namespace AllowFileAccess = api::developer_private::AllowFileAccess;
 namespace AllowIncognito = api::developer_private::AllowIncognito;
 namespace ChoosePath = api::developer_private::ChoosePath;
 namespace Enable = api::developer_private::Enable;
 namespace GetItemsInfo = api::developer_private::GetItemsInfo;
 namespace Inspect = api::developer_private::Inspect;
 namespace PackDirectory = api::developer_private::PackDirectory;
 namespace Reload = api::developer_private::Reload;
@@ skipping 668 matching lines @@
 
 DeveloperPrivatePackDirectoryFunction::DeveloperPrivatePackDirectoryFunction()
 {}
 
 DeveloperPrivatePackDirectoryFunction::~DeveloperPrivatePackDirectoryFunction()
 {}
 
 DeveloperPrivateLoadUnpackedFunction::~DeveloperPrivateLoadUnpackedFunction() {}
 
 bool DeveloperPrivateExportSyncfsFolderToLocalfsFunction::RunImpl() {
+  // TODO(grv) : add unittests.
   base::FilePath::StringType project_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &project_name));
+  if (!ValidateFolderName(project_name)) {
+    DLOG(INFO) << "Invalid project_name : [" << project_name << "]";
+    return false;
+  }
 
   context_ = content::BrowserContext::GetStoragePartition(profile(),
       render_view_host()->GetSiteInstance())->GetFileSystemContext();
   content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
       base::Bind(&DeveloperPrivateExportSyncfsFolderToLocalfsFunction::
                  ReadSyncFileSystemDirectory,
                  this, project_name));
 
   return true;
 }
@@ skipping 88 matching lines @@
   // Return silently if the directory creation fails.
   if (!file_util::CreateDirectory(target_path.DirName())) {
     DLOG(ERROR) << "Error in copying files from sync filesystem.";
     return;
   }
 
   file_util::CopyFile(src_path, target_path);
 }
 
 DeveloperPrivateExportSyncfsFolderToLocalfsFunction::
-    DeveloperPrivateExportSyncfsFolderToLocalfsFunction()
-{}
+    DeveloperPrivateExportSyncfsFolderToLocalfsFunction() {}
 
 DeveloperPrivateExportSyncfsFolderToLocalfsFunction::
     ~DeveloperPrivateExportSyncfsFolderToLocalfsFunction() {}
 
 bool DeveloperPrivateLoadProjectToSyncfsFunction::RunImpl() {
-  // TODO(grv) : implement
+  // TODO(grv) : add unittests.
+  base::FilePath::StringType project_name;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &project_name));
+  if (!ValidateFolderName(project_name)) {
+    DLOG(INFO) << "Invalid project_name : [" << project_name << "]";
+    return false;
+  }
+
+  context_ = content::BrowserContext::GetStoragePartition(profile(),
+      render_view_host()->GetSiteInstance())->GetFileSystemContext();
+  content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
+      base::Bind(&DeveloperPrivateLoadProjectToSyncfsFunction::
+                 CopyFolder,
+                 this, project_name));
   return true;
 }
 
+void DeveloperPrivateLoadProjectToSyncfsFunction::CopyFolder(
+    const base::FilePath::StringType& project_name) {
+  base::FilePath path(profile()->GetPath());
+  path = path.Append(kUnpackedAppsFolder);
+  path = path.Append(project_name);
+
+  std::vector<base::FilePath> paths = ListFolder(path);
+  content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&DeveloperPrivateLoadProjectToSyncfsFunction::
+                 CopyFiles,
+                 this, paths));
+}
+
+void DeveloperPrivateLoadProjectToSyncfsFunction::CopyFiles(
+    const std::vector<base::FilePath>& paths) {
+  std::string origin_url(
+      Extension::GetBaseURLFromExtensionId(extension_id()).spec());
+  fileapi::FileSystemURL url(sync_file_system::CreateSyncableFileSystemURL(
+      GURL(origin_url),
+      sync_file_system::DriveFileSyncService::kServiceName,
+      base::FilePath()));
+
+  pendingCallbacksCount_ = paths.size();
+
+  for (size_t i = 0; i < paths.size(); ++i) {
+    base::PlatformFileError error_code;
+    fileapi::FileSystemOperation* op
+        = context_->CreateFileSystemOperation(url, &error_code);
+    DCHECK(op);
+
+    std::string origin_url(
+        Extension::GetBaseURLFromExtensionId(extension_id()).spec());
+    fileapi::FileSystemURL
+        dest_url(sync_file_system::CreateSyncableFileSystemURL(
+            GURL(origin_url),
+            sync_file_system::DriveFileSyncService::kServiceName,
+            base::FilePath(paths[i].BaseName())));
+
+    op->AsLocalFileSystemOperation()->CopyInForeignFile(paths[i], dest_url,
+        base::Bind(&DeveloperPrivateLoadProjectToSyncfsFunction::
+                   CopyFilesCallback,
+                   this));
+  }
+}
+
+void DeveloperPrivateLoadProjectToSyncfsFunction::CopyFilesCallback(
+    const base::PlatformFileError result) {
+
+  pendingCallbacksCount_--;
+
+  if (success_ && result != base::PLATFORM_FILE_OK) {
+    SetError("Error in copying files to sync filesystem.");
+    success_ = false;
+  }
+
+  if (!pendingCallbacksCount_) {
+    content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
+        base::Bind(&DeveloperPrivateLoadProjectToSyncfsFunction::SendResponse,
+                   this,
+                   success_));
+  }
+}
+
 DeveloperPrivateLoadProjectToSyncfsFunction::
-    DeveloperPrivateLoadProjectToSyncfsFunction() {}
+    DeveloperPrivateLoadProjectToSyncfsFunction()
+    : pendingCallbacksCount_(0), success_(true) {}
 
 DeveloperPrivateLoadProjectToSyncfsFunction::
     ~DeveloperPrivateLoadProjectToSyncfsFunction() {}
 
 bool DeveloperPrivateGetProjectsInfoFunction::RunImpl() {
+  // TODO(grv) : add unittests.
   content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&DeveloperPrivateGetProjectsInfoFunction::ReadFolder,
                  this));
 
   // Released by ReadFolder
   AddRef();
   return true;
 }
 
 void DeveloperPrivateGetProjectsInfoFunction::ReadFolder() {
   base::FilePath path(profile()->GetPath());
   path = path.Append(kUnpackedAppsFolder);
 
-  file_util::FileEnumerator files(
-      path, false, file_util::FileEnumerator::DIRECTORIES);
+  std::vector<base::FilePath> paths = ListFolder(path);
   ProjectInfoList info_list;
-  for (base::FilePath current_path = files.Next(); !current_path.empty();
-       current_path = files.Next()) {
+  for (size_t i = 0; i <  paths.size(); ++i) {
     scoped_ptr<developer::ProjectInfo> info(new developer::ProjectInfo());
-    info->name = current_path.BaseName().MaybeAsASCII();
+    info->name = paths[i].BaseName().MaybeAsASCII();
     info_list.push_back(
         make_linked_ptr<developer::ProjectInfo>(info.release()));
   }
+
   results_ = developer::GetProjectsInfo::Results::Create(info_list);
   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
       base::Bind(&DeveloperPrivateGetProjectsInfoFunction::SendResponse,
                  this,
                  true));
   Release();
 }
 
 DeveloperPrivateGetProjectsInfoFunction::
     DeveloperPrivateGetProjectsInfoFunction() {}
 
 DeveloperPrivateGetProjectsInfoFunction::
     ~DeveloperPrivateGetProjectsInfoFunction() {}
 
 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)) {
+    DLOG(INFO) << "Invalid project_name : [" << project_name << "]";
+    return false;
+  }
+
   base::FilePath path(profile()->GetPath());
   path = path.Append(kUnpackedAppsFolder);
   // TODO(grv) : Sanitize / check project_name.
   path = path.Append(project_name);
   ExtensionService* service = profile()->GetExtensionService();
   UnpackedInstaller::Create(service)->Load(path);
   SendResponse(true);
   return true;
 }
 
@@ skipping 133 matching lines @@
 
   #undef   SET_STRING
   return true;
 }
 
 DeveloperPrivateGetStringsFunction::~DeveloperPrivateGetStringsFunction() {}
 
 } // namespace api
 
 } // namespace extensions