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/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/base/dialogs/select_file_dialog.h"
 
 class ExtensionService;
 
 namespace extensions {
@@ skipping 200 matching lines @@
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("developerPrivate.uninstall");
 
  protected:
   virtual ~DeveloperPrivateUninstallFunction();
 
   // ExtensionFunction:
   virtual bool RunImpl() OVERRIDE;
 };
 
-class DeveloperPrivateChooseEntryFunction : public SyncExtensionFunction {
+class DeveloperPrivateChooseEntryFunction : public AsyncExtensionFunction {
  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
+                  );
 
   friend EntryPicker;
   // FileSelected and FileSelectionCanceled are called by the entry picker.
-  void FileSelected(const FilePath& path);
-  void FileSelectionCanceled();
+  virtual void FileSelected(const FilePath& path);
+  virtual void FileSelectionCanceled();
  private:
 };
 
 
 class DeveloperPrivateLoadUnpackedFunction
     : public DeveloperPrivateChooseEntryFunction {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("developerPrivate.loadUnpacked");
 
  protected:
   virtual ~DeveloperPrivateLoadUnpackedFunction();
   virtual bool RunImpl() OVERRIDE;
+};
+
+class DeveloperPrivateChooseItemFunction
+    : public DeveloperPrivateChooseEntryFunction {

[asargent_no_longer_on_chrome, 2013/01/09 00:48:05]

I'm a little wary of using inheritance of another concrete ExtensionFunction.
Two better options would be:

a) Have a common superclass that inherits from AsyncExtensionFunction with a
concrete ShowPicker method but pure virtual FileSelected/FileSelectionCanceled
methods. Then both DeveloperPrivateChooseEntryFunction and
DeveloperPrivateChooseItemFunction would derive from this class.

b) Have a ShowPicker method definied in the .cc file here (either static, or in
an anonymous namespace) that gets necessary dependencies passed in as input
parameters, and takes a base::Callback as well which it will use to report
success or failure.

[miket_OOO, 2013/01/09 18:52:41]

I agree with Antony's suggestion. This kind of inheritance seems to have a short
shelf life.

[Gaurav, 2013/01/12 01:08:26]

Done.

[Gaurav, 2013/01/12 01:08:26]

Done.

+ public:
+  DECLARE_EXTENSION_FUNCTION_NAME("developerPrivate.chooseItem");
+
+ protected:
+  virtual ~DeveloperPrivateChooseItemFunction();
+  virtual bool RunImpl() OVERRIDE;
+
+  virtual void FileSelected(const FilePath& path) OVERRIDE;
+  virtual void FileSelectionCanceled() OVERRIDE;
+};
+
+class DeveloperPrivatePackItemFunction
+    : public AsyncExtensionFunction,
+      public extensions::PackExtensionJob::Client {
+
+ public:
+  DECLARE_EXTENSION_FUNCTION_NAME("developerPrivate.packItem");
+
+  DeveloperPrivatePackItemFunction();
+
+  // 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) OVERRIDE;

[miket_OOO, 2013/01/09 18:52:41]

Even if you don't need it, please include a parameter name.

[Gaurav, 2013/01/12 01:08:26]

Done.

+
+ protected:
+  virtual ~DeveloperPrivatePackItemFunction();
+  virtual bool RunImpl() OVERRIDE;
+
+ private:
+  scoped_refptr<extensions::PackExtensionJob> pack_job_;
+  std::string item_path_str_;
+  std::string key_path_str_;
 
 };
 
 class DeveloperPrivateGetStringsFunction : public SyncExtensionFunction {
   public:
    DECLARE_EXTENSION_FUNCTION_NAME("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_