[Extensions] Make a chrome.developerPrivate.getExtensionsInfo function

chrome/common/extensions/api/developer_private.idl

 // 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.
 
 // developerPrivate API.
 // This is a private API exposing developing and debugging functionalities for
 // apps and extensions.
 namespace developerPrivate {
 
+  // DEPRECATED: Prefer ExtensionType.
   enum ItemType {
     hosted_app,
     packaged_app,
     legacy_packaged_app,
     extension,
     theme
   };
 
+  // DEPRECATED: Prefer ExtensionView.
   dictionary ItemInspectView {
     // path to the inspect page.
     DOMString path;
 
     // For lazy background pages, the value is -1.
     long render_process_id;
 
     long render_view_id;
     boolean incognito;
     boolean generatedBackgroundPage;
   };
 
   dictionary InstallWarning {
     DOMString message;
   };
 
+  enum ExtensionType {
+    HOSTED_APP,
+    PLATFORM_APP,
+    LEGACY_PACKAGED_APP,
+    EXTENSION,
+    THEME,
+    SHARED_MODULE
+  };
+
+  enum RunStateValue {

[Devlin, 2015/03/07 06:16:43]

On second thought, I may change this into a
dictionary AccessModifier {
  boolean isEnabled;
  boolean isActive;
};

(name pending)

Mostly because in some cases, the idea that a feature is active/enabled could be
different.  For instance, in the case of script injection.  Could probably work
either way, but the dictionary might be clearer...

[not at google - send to devlin, 2015/03/09 18:44:01]

Yes this enum doesn't make sense to me.

+    CANT_HAVE_STATE,
+    WANTS_STATE,
+    HAS_STATE
+  };
+
+  enum Location {
+    FROM_STORE,
+    UNPACKED,
+    UNKNOWN

[not at google - send to devlin, 2015/03/09 18:44:01]

there is also local CRX's (like drag-drop into chrome://extensions)

[Devlin, 2015/03/09 19:28:20]

Hmm... good point.  Though if we match this up with "locationText", that is
lumped into "UNKNOWN" (and I don't think we really say "installed from chrome
extensions page" anywhere).  Thoughts?

+  };
+
+  enum ErrorType {
+    MANIFEST,
+    RUNTIME
+  };
+
+  enum ErrorSeverity {
+    LOG,
+    WARNING,
+    ERROR
+  };
+
+  enum ExtensionState {
+    ENABLED,
+    DISABLED,
+    TERMINATED
+  };
+
+  dictionary StackFrame {
+    long lineNumber;
+    long columnNumber;
+    DOMString source;
+    DOMString function;

[not at google - send to devlin, 2015/03/09 18:44:01]

You might have a problem with calling something "function", it's a reserved word
in JS (yes you could put it in a string, but that's awkward).

[Devlin, 2015/03/09 19:28:20]

There's no problem having a "function" property on an object.

+  };
+
+  dictionary ManifestError {
+    ErrorType type;
+    DOMString extensionId;
+    boolean fromIncognito;
+    DOMString source;
+    DOMString message;
+    DOMString manifestKey;
+    DOMString? manifestSpecific;
+  };
+
+  dictionary RuntimeError {

[not at google - send to devlin, 2015/03/09 18:44:01]

This shares a lot with ManifestError, you could have a separate dictionary type
like, err, "Error"?

[Devlin, 2015/03/09 19:28:20]

But (our) IDL doesn't have inheritance, and, of course, it's kind of annoying to
have an object with a bunch of things that are *always* null in some cases, and
*always* not in others - it limits the usefulness of the closurecompiler and
type-ing comments.  Unless you meant using encapsulation, and having something
like:
RuntimeError {
  Error error;
  <runtime-error-specific>
}?

Which works, but is ever-so-slightly annoying to work with (in js,
error.error.message is ugly, compared to error.message).

[not at google - send to devlin, 2015/03/09 21:11:39]

I mean:

dictionary ErrorBase {
  ErrorType type;
  DOMString extensionId;
  boolean fromIncognito;
  DOMString source;
  DOMString message;
};

dictionary ManifestError {
  ErrorBase base;
  DOMString manifestKey;
  DOMString? manifestSpecific;
};

dictionary RuntimeError {
  ErrorBase base;
  long occurrences;
  long renderViewId;
  long renderProcessId;
  boolean canInspect;
  StackFrame[] stackFrame;
};

+    ErrorType type;
+    DOMString extension_id;
+    boolean fromIncognito;
+    DOMString source;
+    DOMString message;
+    long occurrences;
+    long renderViewId;
+    long renderProcessId;
+    boolean canInspect;
+    StackFrame[] stackTrace;
+  };
+
+  dictionary DisableReasons {
+    boolean suspiciousInstall;
+    boolean corruptInstall;
+    boolean updateRequired;
+  };
+
+  dictionary OptionsPage {
+    boolean openInTab;
+    DOMString url;
+  };
+
+  dictionary HomePage {
+    DOMString url;
+    boolean specified;
+  };
+
+  dictionary ExtensionView {
+    DOMString path;
+    long renderProcessId;
+    long renderViewId;
+    boolean incognito;
+    boolean generatedBackgroundPage;
+  };
+
+  dictionary ExtensionInfo {
+    boolean actionButtonHidden;  // enable_show_button

[Devlin, 2015/03/07 03:21:03]

The chickenscratch comments map to the names in extension_list.js.

+    DOMString? blacklistText;
+    DOMString[] dependentExtensions;
+    DOMString description;
+    DisableReasons disableReasons;  //suspicious, corrupt, updaterequired

[not at google - send to devlin, 2015/03/09 18:44:01]

space after //

[Devlin, 2015/03/09 19:28:20]

Chickenscratch will be removed. :P  Only left it in if you wanted a mapping to
extension_list.js's version for reference.  I don't plan on landing it with it.

+    RunStateValue errorCollection;  // errorCollectionEd, wantsErrorCollection;
+    RunStateValue fileAccess;  // allowFileAccess, wantsFileAccess
+    HomePage homePage;  // homepageProvided && homepageUrl
+    DOMString iconUrl;  // icon
+    DOMString id;
+    RunStateValue incognitoAccess;  // enabled/can be enabled incognito
+    boolean installedByCustodian;
+    DOMString[] installWarnings;
+    DOMString? launchUrl;
+    Location location;  // is_unpacked, is from store, allow reload

[not at google - send to devlin, 2015/03/09 18:44:01]

is from store --> is_from_store --> etc.

[Devlin, 2015/03/09 19:28:20]

Ditto.

+    DOMString? locationText;
+    ManifestError[] manifestErrors;
+    boolean mustRemainInstalled;  // recommendedInstall
+    DOMString name;
+    boolean offlineEnabled;
+    OptionsPage? optionsPage;
+    DOMString? path;
+    DOMString? policyText;
+    DOMString? prettifiedPath;
+    RunStateValue runOnAllUrls;  // allowAllUrls, showAllUrls
+    RuntimeError[] runtimeErrors;
+    DOMString[] runtimeWarnings;  // warnings
+    ExtensionState state;
+    ExtensionType type;  // is_hosted_app, is_platform_app, etc
+    DOMString updateUrl;
+    boolean userMayModify;  // managed install
+    DOMString version;
+    ExtensionView[] views;
+  };
+
+  // DEPRECATED: Prefer ExtensionInfo.
   dictionary ItemInfo {
     DOMString id;
     DOMString name;
     DOMString version;
     DOMString description;
     boolean may_disable;
     boolean enabled;
     DOMString? disabled_reason;
     boolean isApp;
     ItemType type;
     boolean allow_activity;
     boolean allow_file_access;
     boolean wants_file_access;
     boolean incognito_enabled;
     boolean is_unpacked;
     boolean allow_reload;
     boolean terminated;
     boolean allow_incognito;
     DOMString icon_url;
 
     // Path of an unpacked extension.
     DOMString? path;
 
     // Options settings page for the item.
     DOMString? options_url;
     DOMString? app_launch_url;
     DOMString? homepage_url;
     DOMString? update_url;
     InstallWarning[] install_warnings;
-    any[] manifest_errors;
-    any[] runtime_errors;
+    ManifestError[] manifest_errors;
+    RuntimeError[] runtime_errors;
     boolean offline_enabled;
 
     // All views of the current extension.
     ItemInspectView[] views;
   };
 
+  dictionary GetExtensionsInfoOptions {
+    boolean? includeDisabled;
+    boolean? includeTerminated;
+  };
+
   dictionary InspectOptions {
     DOMString extension_id;
     DOMString render_process_id;
     DOMString render_view_id;
     boolean incognito;
   };
 
   dictionary ReloadOptions {
     // If false, an alert dialog will show in the event of a reload error.
     // Defaults to false.
@@ skipping 111 matching lines @@
 
     // The line to focus the devtools at.
     long? lineNumber;
 
     // The column to focus the devtools at.
     long? columnNumber;
   };
 
   callback VoidCallback = void ();
   callback BooleanCallback = void (boolean result);
+  callback ExtensionInfosCallback = void (ExtensionInfo[] result);
+  callback ExtensionInfoCallback = void (ExtensionInfo result);
   callback ItemsInfoCallback = void (ItemInfo[] result);
   callback GetProjectsInfoCallback = void (ProjectInfo[] result);
   callback PathCallback = void (DOMString path);
   callback PackCallback = void (PackDirectoryResponse response);
   callback VoidCallback = void();
   callback RequestFileSourceCallback =
       void (RequestFileSourceResponse response);
 
   interface Functions {
     // Runs auto update for extensions and apps immediately.
     // |callback| : Called with the boolean result, true if autoUpdate is
     // successful.
     static void autoUpdate(optional BooleanCallback callback);
 
     // Returns information of all the extensions and apps installed.
+    // |options| : Options to restrict the items returned.
+    // |callback| : Called with extensions info.
+    static void getExtensionsInfo(optional GetExtensionsInfoOptions options,
+                                  ExtensionInfosCallback callback);
+
+    // Returns information of a particular extension.
+    // |id| : The id of the extension.
+    // |callback| : Called with the result.
+    static void getExtensionInfo(DOMString id,
+                                 ExtensionInfoCallback callback);
+
+    // Returns information of all the extensions and apps installed.
     // |includeDisabled| : include disabled items.
     // |includeTerminated| : include terminated items.
     // |callback| : Called with items info.
+    // DEPRECATED: Prefer getExtensionsInfo.
     static void getItemsInfo(boolean includeDisabled,
                              boolean includeTerminated,
                              ItemsInfoCallback callback);
 
     // Opens a permissions dialog.
     // |extensionId| : The id of the extension to show permissions for.
     static void showPermissionsDialog(DOMString extensionId,
                                       optional VoidCallback callback);
 
     // Opens a developer tools inspection window.
@@ skipping 63 matching lines @@
     // Open the developer tools to focus on a particular error.
     static void openDevTools(OpenDevToolsProperties properties);
   };
 
   interface Events {
     // Fired when a item state is changed.
     static void onItemStateChanged(EventData response);
   };
 
 };