Adds functionality to pack an extension / app from the app.

chrome/browser/extensions/api/developer_private/developer_private_api.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_API_DEVELOPER_PRIVATE_DEVELOPER_PRIVATE_API_H_
 #define CHROME_BROWSER_EXTENSIONS_API_DEVELOPER_PRIVATE_DEVELOPER_PRIVATE_API_H_
 
 #include "chrome/browser/extensions/api/developer_private/entry_picker.h"
 #include "chrome/browser/extensions/api/file_system/file_system_api.h"
 #include "chrome/browser/extensions/extension_function.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_uninstall_dialog.h"
+#include "chrome/browser/extensions/pack_extension_job.h"
 #include "chrome/browser/extensions/requirements_checker.h"
 #include "chrome/browser/profiles/profile_keyed_service.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/render_view_host.h"
 #include "ui/shell_dialogs/select_file_dialog.h"
 
 class ExtensionService;
 
 namespace extensions {
@@ skipping 30 matching lines @@
                             public content::NotificationObserver {
  public:
   // Convenience method to get the DeveloperPrivateAPI for a profile.
   static DeveloperPrivateAPI* Get(Profile* profile);
 
   explicit DeveloperPrivateAPI(Profile* profile);
   virtual ~DeveloperPrivateAPI();
 
   void SetLastUnpackedDirectory(const FilePath& path);
 
-  FilePath& getLastUnpackedDirectory() { return last_unpacked_directory_; }
+  FilePath& GetLastUnpackedDirectory() { return last_unpacked_directory_; }
 
   // ProfileKeyedService implementation
   virtual void Shutdown() OVERRIDE;
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
  private:
@@ skipping 114 matching lines @@
   // Callback for requirements checker.
   void OnRequirementsChecked(std::string extension_id,
                              std::vector<std::string> requirements_errors);
   // ExtensionFunction:
   virtual bool RunImpl() OVERRIDE;
 
  private:
   scoped_ptr<extensions::RequirementsChecker> requirements_checker_;
 };
 
-class DeveloperPrivateChooseEntryFunction : public SyncExtensionFunction,
+class DeveloperPrivateChooseEntryFunction : public AsyncExtensionFunction,
                                             public EntryPickerClient {
  protected:
   virtual ~DeveloperPrivateChooseEntryFunction();
   virtual bool RunImpl() OVERRIDE;
   bool ShowPicker(ui::SelectFileDialog::Type picker_type,
                   const FilePath& last_directory,
-                  const string16& select_title);
+                  const string16& select_title,
+                  const ui::SelectFileDialog::FileTypeInfo& info,
+                  int file_type_index);
 
-  // EntryPickerCLient functions.
+  // EntryPickerClient functions.
   virtual void FileSelected(const FilePath& path) = 0;
   virtual void FileSelectionCanceled() = 0;
 };
 
 
 class DeveloperPrivateLoadUnpackedFunction
     : public DeveloperPrivateChooseEntryFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("developerPrivate.loadUnpacked",
                              DEVELOPERPRIVATE_LOADUNPACKED);
 
  protected:
   virtual ~DeveloperPrivateLoadUnpackedFunction();
   virtual bool RunImpl() OVERRIDE;
 
   // EntryPickerCLient implementation.
   virtual void FileSelected(const FilePath& path) OVERRIDE;
   virtual void FileSelectionCanceled() OVERRIDE;
+};
 
+class DeveloperPrivateChoosePathFunction
+    : public DeveloperPrivateChooseEntryFunction {
+ public:
+  DECLARE_EXTENSION_FUNCTION("developerPrivate.choosePath",
+                             DEVELOPERPRIVATE_CHOOSEPATH);
+
+ protected:
+  virtual ~DeveloperPrivateChoosePathFunction();
+  virtual bool RunImpl() OVERRIDE;
+
+  // EntryPickerClient functions.
+  virtual void FileSelected(const FilePath& path) OVERRIDE;
+  virtual void FileSelectionCanceled() OVERRIDE;
+};
+
+class DeveloperPrivatePackDirectoryFunction
+    : public AsyncExtensionFunction,
+      public extensions::PackExtensionJob::Client {
+
+ public:
+  DECLARE_EXTENSION_FUNCTION("developerPrivate.packDirectory",
+                             DEVELOPERPRIVATE_PACKDIRECTORY);
+
+  DeveloperPrivatePackDirectoryFunction();
+
+  // ExtensionPackJob::Client implementation.
+  virtual void OnPackSuccess(const FilePath& crx_file,
+                             const FilePath& key_file) OVERRIDE;
+  virtual void OnPackFailure(
+      const std::string& error,
+      extensions::ExtensionCreator::ErrorType error_type) OVERRIDE;
+
+ protected:
+  virtual ~DeveloperPrivatePackDirectoryFunction();
+  virtual bool RunImpl() OVERRIDE;
+
+ private:
+  scoped_refptr<extensions::PackExtensionJob> pack_job_;
+  std::string item_path_str_;
+  std::string key_path_str_;

[asargent_no_longer_on_chrome, 2013/02/09 00:38:45]

naming suggestion: consider omitting the "_str" part from these names since it's
clear from their types that they are strings. 

[Gaurav, 2013/02/11 20:01:55]

Added str as when they are used they might be confused to be "FilePath" instead
of strings.
On 2013/02/09 00:38:45, Antony Sargent wrote:

[asargent_no_longer_on_chrome, 2013/02/11 20:07:27]

Yep, I assumed that's why you had that suffix. If I recall correctly though you
used "_path" on names of FilePath variables in places where you had both a
std::string and a FilePath, and that seemed sufficient to me to disambiguate
them. Anyhow, no big deal either way. 

 };
 
 class DeveloperPrivateGetStringsFunction : public SyncExtensionFunction {
   public:
    DECLARE_EXTENSION_FUNCTION("developerPrivate.getStrings",
                               DEVELOPERPRIVATE_GETSTRINGS);
 
   protected:
    virtual ~DeveloperPrivateGetStringsFunction();
 
    // ExtensionFunction
    virtual bool RunImpl() OVERRIDE;
 };
 
 }  // namespace api
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_DEVELOPER_PRIVATE_DEVELOPER_PRIVATE_API_H_