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 {
 
+char kUnpackedAppsFolder[] = "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> FolderLs(const base::FilePath path) {

[miket_OOO, 2013/04/18 03:22:28]

This isn't a great name for this function. Please choose something that uses
real words.

[kinuko, 2013/04/18 08:15:12]

ListFolder maybe?

[Gaurav, 2013/04/18 23:08:46]

Done.

[Gaurav, 2013/04/18 23:08:46]

Done.

+  file_util::FileEnumerator files(path, false,
+      file_util::FileEnumerator::DIRECTORIES
+      | file_util::FileEnumerator::FILES);

[miket_OOO, 2013/04/18 03:22:28]

Is this right? You're asking for both directories and files, but putting all the
results in something called paths?

[Gaurav, 2013/04/18 23:08:46]

Thought paths represent both files and folders ?

+  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;
+}
+
 }  // 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 723 matching lines @@
 
   for (size_t i = 0; i < file_list.size(); ++i) {
     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(file_list[i].name)));
     base::FilePath target_path(profile()->GetPath());
     target_path =
-        target_path.Append(FILE_PATH_LITERAL("apps_target"));
+        target_path.Append(FILE_PATH_LITERAL(kUnpackedAppsFolder));
     target_path = target_path.Append(project_name);
     target_path = target_path.Append(file_list[i].name);
 
     base::PlatformFileError error_code;
     fileapi::FileSystemOperation* op =
         context_->CreateFileSystemOperation(url, &error_code);
     DCHECK(op);
 
     if (error_code != base::PLATFORM_FILE_OK) {
       DLOG(ERROR) << "Error in copying files from sync filesystem.";
@@ skipping 40 matching lines @@
   file_util::CopyFile(src_path, target_path);
 }
 
 DeveloperPrivateExportSyncfsFolderToLocalfsFunction::
     DeveloperPrivateExportSyncfsFolderToLocalfsFunction()
 {}
 
 DeveloperPrivateExportSyncfsFolderToLocalfsFunction::
     ~DeveloperPrivateExportSyncfsFolderToLocalfsFunction() {}
 
+bool DeveloperPrivateLoadProjectToSyncfsFunction::RunImpl() {
+  base::FilePath::StringType project_name;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &project_name));
+
+  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(FILE_PATH_LITERAL(kUnpackedAppsFolder));
+  path = path.Append(FILE_PATH_LITERAL(project_name));

[miket_OOO, 2013/04/18 03:22:28]

Again, dangerous -- assume this name is maliciously formed.

[Gaurav, 2013/04/18 23:08:46]

Ensuring that the project_name contains only alpha-numeric, underscore, hyphen
and dot.

+
+  std::vector<base::FilePath> paths = FolderLs(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()));
+
+  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().MaybeAsASCII())));
+
+    op->AsLocalFileSystemOperation()->CopyInForeignFile(paths[i], dest_url,
+        base::Bind(&DeveloperPrivateLoadProjectToSyncfsFunction::
+                   CopyFilesCallback,
+                   this));

[miket_OOO, 2013/04/18 03:22:28]

It looks like this will immediately queue up N operations on the IO thread,
which I *think* is OK and in fact the most efficient way to do it, but you might
want to ask Antony whether this makes sense (vs. waiting for each to complete
before firing off the next operation, which would be slower but might somehow
give another pending operation from another task a chance to do its work).

[Gaurav, 2013/04/18 23:08:46]

Discussed with Antony. Looks to be an optimal approach.

+  }
+}
+
+void DeveloperPrivateLoadProjectToSyncfsFunction::CopyFilesCallback(
+    const base::PlatformFileError result) {
+  if (result != base::PLATFORM_FILE_OK) {
+    DLOG(ERROR) << "Error in copying files to sync filesystem.";
+    return;

[kinuko, 2013/04/18 08:15:12]

If the # of file was 1 and we got error here we seem to fail to send response to
the app.  Should we call SetError() and SendResponse(false) (and ignore
succeeding callback responses) or just ignore all errors?

[Gaurav, 2013/04/18 23:08:46]

Fixed. Send true response if all callbacks are successful, false otherwise.

+  }
+
+  content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
+      base::Bind(&DeveloperPrivateLoadProjectToSyncfsFunction::SendResponse,
+                 this,
+                 true));

[miket_OOO, 2013/04/18 03:22:28]

Wait a minute -- won't this send the response after the first file copy, not the
last one?

[kinuko, 2013/04/18 08:15:12]

Looks like it does, we should count up the number of paths we copied here and
send back response when it's done.

[Gaurav, 2013/04/18 23:08:46]

Done.

[Gaurav, 2013/04/18 23:08:46]

Done.

+}
+
+DeveloperPrivateLoadProjectToSyncfsFunction::
+    DeveloperPrivateLoadProjectToSyncfsFunction() {}
+
+DeveloperPrivateLoadProjectToSyncfsFunction::
+    ~DeveloperPrivateLoadProjectToSyncfsFunction() {}
+
+bool DeveloperPrivateGetProjectsInfoFunction::RunImpl() {
+  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(FILE_PATH_LITERAL(kUnpackedAppsFolder));
+
+  std::vector<base::FilePath> paths = FolderLs(path);
+  ProjectInfoList info_list;
+  for (size_t i = 0; i <  paths.size(); ++i) {
+    scoped_ptr<developer::ProjectInfo> info(new developer::ProjectInfo());
+    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() {
+  std::string project_name;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &project_name));
+  base::FilePath path(profile()->GetPath());
+  path = path.Append(FILE_PATH_LITERAL(kUnpackedAppsFolder));
+  path = path.Append(project_name);

[miket_OOO, 2013/04/18 03:22:28]

Scary

[Gaurav, 2013/04/18 23:08:46]

As above.

+  ExtensionService* service = profile()->GetExtensionService();
+  UnpackedInstaller::Create(service)->Load(path);
+  SendResponse(true);
+  return true;
+}
+
+DeveloperPrivateLoadProjectFunction::DeveloperPrivateLoadProjectFunction() {}
+
+DeveloperPrivateLoadProjectFunction::~DeveloperPrivateLoadProjectFunction() {}
+
 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) {
     type = ui::SelectFileDialog::SELECT_OPEN_FILE;
@@ skipping 119 matching lines @@
 
   #undef   SET_STRING
   return true;
 }
 
 DeveloperPrivateGetStringsFunction::~DeveloperPrivateGetStringsFunction() {}
 
 } // namespace api
 
 } // namespace extensions