Add API to load a unpacked project to developerPrivate.

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 38 matching lines @@
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/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;
@@ skipping 740 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() {
+  // TODO(grv) : implement
+  return true;
+}
+
+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));
+
+  file_util::FileEnumerator files(
+      path, false, file_util::FileEnumerator::DIRECTORIES);
+  ProjectInfoList info_list;
+  for (base::FilePath current_path = files.Next(); !current_path.empty();
+       current_path = files.Next()) {
+    scoped_ptr<developer::ProjectInfo> info(new developer::ProjectInfo());
+    info->name = current_path.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:12:00]

Please add a TODO to sanitize this value, and further to assert that the end
result is within kUnpackedAppsFolder. I know that it's a private API, but it's
still taking user-generated, external values, and this would be the appropriate
place to assert that it's not a value like "../../../My Documents/taxes." 

[Gaurav, 2013/04/18 17:24:06]

Done.

[miket_OOO, 2013/04/23 17:02:47]

This didn't happen. What's going on?

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

Added the checks for folder name validation (was thinking that will ensure, that
the path will be within apps_target).

Will use the function as suggested by you in other diff.

Sorry about that.

+  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