| // Copyright 2009-2010 Google Inc. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // ======================================================================== |
| |
| import "oaidl.idl"; |
| import "ocidl.idl"; |
| |
| // When adding interfaces to this file: |
| // * Do not use "Google" or "GoogleUpdate" directly. Instead, use preprocessor |
| // defines. |
| // * Add a test for the Google-specific value to |
| // omaha_customization_goopdate_apis_unittest.cc. |
| |
| // |
| // Enums. |
| // These values can be passed to interface methods and/or compared to their |
| // output. |
| // |
| |
| // Must be kept in sync with the enum in base/browser_utils.h. |
| typedef enum BrowserType { |
| BROWSER_UNKNOWN = 0, |
| BROWSER_DEFAULT = 1, |
| BROWSER_INTERNET_EXPLORER = 2, |
| BROWSER_FIREFOX = 3, |
| BROWSER_CHROME = 4, |
| } BrowserType; |
| |
| // The normal install flow proceeds from STATE_INIT through |
| // STATE_INSTALL_COMPLETE in order, skipping states that are not relevant. |
| // All exceptions and terminal states are start with STATE_INSTALL_COMPLETE. |
| typedef enum CurrentState { |
| STATE_INIT = 1, |
| STATE_WAITING_TO_CHECK_FOR_UPDATE = 2, |
| STATE_CHECKING_FOR_UPDATE = 3, |
| STATE_UPDATE_AVAILABLE = 4, |
| STATE_WAITING_TO_DOWNLOAD = 5, |
| STATE_RETRYING_DOWNLOAD = 6, |
| STATE_DOWNLOADING = 7, |
| STATE_DOWNLOAD_COMPLETE = 8, |
| STATE_EXTRACTING = 9, |
| STATE_APPLYING_DIFFERENTIAL_PATCH = 10, |
| // TODO(omaha3): Should we move STATE_DOWNLOAD_COMPLETE here and eliminate |
| // STATE_READY_TO_INSTALL? |
| STATE_READY_TO_INSTALL = 11, |
| STATE_WAITING_TO_INSTALL = 12, |
| STATE_INSTALLING = 13, |
| STATE_INSTALL_COMPLETE = 14, |
| STATE_PAUSED = 15, |
| STATE_NO_UPDATE = 16, |
| STATE_ERROR = 17, |
| } CurrentState; |
| |
| typedef enum InstallPriority { |
| INSTALL_PRIORITY_LOW = 0, |
| INSTALL_PRIORITY_HIGH = 10, |
| } InstallPriority; |
| |
| // Specifies what the client should do after installation. |
| typedef enum PostInstallAction { |
| POST_INSTALL_ACTION_DEFAULT = 0, |
| |
| // Caller should exit silently. |
| POST_INSTALL_ACTION_EXIT_SILENTLY = 1, |
| |
| // Caller should launch the command. |
| POST_INSTALL_ACTION_LAUNCH_COMMAND = 2, |
| |
| // Caller should launch the command and exit silently. |
| POST_INSTALL_ACTION_EXIT_SILENTLY_ON_LAUNCH_COMMAND = 3, |
| |
| // The caller should ask the user to restart the browser. If the value of |
| // IApp's browser is supported and postInstallUrl is valid, the client should |
| // offer to restart the browser. If the user chooses to do so, the client |
| // should launch the ICurrentState::postInstallUrl after shutting down and |
| // restarting the browser. |
| POST_INSTALL_ACTION_RESTART_BROWSER = 4, |
| |
| // Similar to POST_INSTALL_ACTION_RESTART_BROWSER, but ask the user to shut |
| // down all browsers. |
| POST_INSTALL_ACTION_RESTART_ALL_BROWSERS = 5, |
| |
| // The caller should ask the user to reboot the machine. |
| POST_INSTALL_ACTION_REBOOT = 6, |
| } PostInstallAction; |
| |
| enum AppCommandStatus { |
| // The command has never been executed. |
| COMMAND_STATUS_INIT = 1, |
| // The command is running. |
| COMMAND_STATUS_RUNNING = 2, |
| // An error occurred while launching or monitoring the command. |
| COMMAND_STATUS_ERROR = 3, |
| // The command has completed execution. |
| COMMAND_STATUS_COMPLETE = 4, |
| }; |
| |
| [ |
| object, |
| dual, |
| uuid(6DB17455-4E85-46e7-9D23-E555E4B005AF), |
| helpstring("IGoogleUpdate3 Interface"), |
| pointer_default(unique) |
| ] |
| interface IGoogleUpdate3 : IDispatch { |
| // TODO(Omaha): Perhaps this interface exposes helpers such as |
| // RestartBrowsers, etc. |
| |
| // Returns the count of the AppBundles in this IGoogleUpdate3 interface. |
| [id(1), propget] HRESULT Count([out, retval] long* count); |
| |
| // Returns an IDispatch of the AppBundle in this IGoogleUpdate3 interface at |
| // the specified 0-based index. This property has the dispid of DISPID_VALUE |
| // to make it the default property of IGoogleUpdate3. |
| [id(DISPID_VALUE), propget] HRESULT Item([in] long index, |
| [out, retval] IDispatch** bundle); |
| // Returns an IDispatch to a newly created empty AppBundle. |
| [id(2)] HRESULT createAppBundle([out, retval] IDispatch** app_bundle); |
| } |
| |
| [ |
| object, |
| dual, |
| uuid(fe908cdd-22bb-472a-9870-1a0390e42f36), |
| helpstring("IAppBundle Interface"), |
| pointer_default(unique) |
| ] |
| interface IAppBundle : IDispatch { |
| // TODO(omaha3): AppBundle::display_name_ is never used. Should we remove? |
| [propget] HRESULT displayName([out, retval] BSTR*); |
| [propput] HRESULT displayName([in] BSTR); |
| |
| [propget] HRESULT displayLanguage([out, retval] BSTR*); |
| [propput] HRESULT displayLanguage([in] BSTR); |
| |
| [propget] HRESULT installSource([out, retval] BSTR*); |
| [propput] HRESULT installSource([in] BSTR); |
| |
| [propget] HRESULT originURL([out, retval] BSTR*); |
| [propput] HRESULT originURL([in] BSTR); |
| |
| [propget] HRESULT offlineDirectory([out, retval] BSTR* offline_dir); |
| [propput] HRESULT offlineDirectory([in] BSTR offline_dir); |
| |
| [propget] HRESULT sessionId([out, retval] BSTR* session_id); |
| [propput] HRESULT sessionId([in] BSTR session_id); |
| |
| // Controls whether or not event pings should be sent at the end of |
| // an operation. |
| [propget] HRESULT sendPings([out, retval] VARIANT_BOOL* send_pings); |
| [propput] HRESULT sendPings([in] VARIANT_BOOL send_pings); |
| |
| // The priority property determines download speed/priority and the number/ |
| // frequency of retries. Use values from the InstallPriority enum. |
| [propget] HRESULT priority([out, retval] long* priority); |
| [propput] HRESULT priority([in] long priority); |
| |
| // Returns the count of the Apps in the AppBundle. |
| [id(1), propget] HRESULT Count([out, retval] long* count); |
| |
| // Returns an IDispatch of the App in the AppBundle at the specified 0-based |
| // index. This property has the dispid of DISPID_VALUE to make it the default |
| // property of IAppBundle. |
| [id(DISPID_VALUE), propget] HRESULT Item([in] long index, |
| [out, retval] IDispatch** app); |
| |
| // Impersonation and primary tokens set by the client. Typically only |
| // set by the gupdatem service. The gupdatem service exposes a narrow |
| // interface to medium integrity clients. When a medium integrity client calls |
| // into the gupdatem service, the gupdatem service captures the token of the |
| // caller, and then calls put_altTokens() on the gupdate service, so that the |
| // gupdate service can use it for future download() and install() requests. |
| [propput] HRESULT altTokens([in] ULONG_PTR impersonation_token, |
| [in] ULONG_PTR primary_token, |
| [in] DWORD caller_proc_id); |
| |
| // Sets a HWND to associate with the client, if any. This will be used as |
| // the parent window for any dialogs that the server may need to display. |
| [propput] HRESULT parentHWND([in] ULONG_PTR hwnd); |
| |
| // Initializes the bundle with the properties that have been set. |
| [id(2)] HRESULT initialize(); |
| |
| // Returns an IDispatch to a new App for the specified app id. |
| // The App is added to the Bundle. |
| [id(3)] HRESULT createApp([in] BSTR app_id, |
| [out, retval] IDispatch** app); |
| |
| // Returns an IDispatch to a newly created App for the specified app ID. The |
| // App is populated with information from the existing installation and added |
| // to the Bundle. Fails if the specified app is not installed. |
| [id(4)] HRESULT createInstalledApp([in] BSTR app_id, |
| [out, retval] IDispatch** app); |
| |
| // Creates App instances for all installed apps managed by this Omaha |
| // instance. Each App is populated with information from the existing install. |
| [id(5)] HRESULT createAllInstalledApps(); |
| |
| // These methods are non-blocking. The operation is scheduled. |
| [id(6)] HRESULT checkForUpdate(); |
| [id(7)] HRESULT download(); |
| [id(8)] HRESULT install(); |
| |
| // All-in-one function for automatically updating all apps. Populates the |
| // bundle then schedules the update, which includes the update check and |
| // download and install, if necessary. |
| [id(9)] HRESULT updateAllApps(); |
| |
| // These three methods are non-blocking. The operation is requested. |
| [id(10)] HRESULT stop(); |
| [id(11)] HRESULT pause(); |
| [id(12)] HRESULT resume(); |
| |
| // Returns true if the bundle has an uncompleted non-blocking request. |
| [id(13)] HRESULT isBusy([out, retval] VARIANT_BOOL* is_busy); |
| |
| // Downloads a package of an installed application. |
| [id(14)] HRESULT downloadPackage([in] BSTR app_id, [in] BSTR package_name); |
| |
| // TODO(omaha): Define this aggregated bundle state. Is this really a property |
| // or should it be getCurrentState? |
| // The server and bundle are the only thing that can provide aggregated |
| // time estimates for downloads. Also, aggregate percentage is not currently |
| // available to the client because the total bytes to download is not |
| // available from App in all post-update check states. |
| // To do this, we will probably need to know the total expected download |
| // size for all packages to be installed - those that are required or in use - |
| // by the time the update check phase is complete. |
| [id(15), propget] HRESULT currentState([out, retval] VARIANT* current_state); |
| }; |
| |
| [ |
| object, |
| dual, |
| uuid(76F7B787-A67C-4c73-82C7-31F5E3AABC5C), |
| helpstring("IApp Interface"), |
| pointer_default(unique) |
| ] |
| interface IApp : IDispatch { |
| // Returns a version IDispatch object. |
| [id(1), propget] HRESULT currentVersion([out, retval] IDispatch** current); |
| [id(2), propget] HRESULT nextVersion([out, retval] IDispatch** next); |
| |
| [propget] HRESULT appId([out, retval] BSTR*); |
| |
| [propget] HRESULT displayName([out, retval] BSTR*); |
| [propput] HRESULT displayName([in] BSTR); |
| |
| [propget] HRESULT language([out, retval] BSTR*); |
| [propput] HRESULT language([in] BSTR); |
| |
| [propget] HRESULT ap([out, retval] BSTR*); |
| [propput] HRESULT ap([in] BSTR); |
| |
| [propget] HRESULT ttToken([out, retval] BSTR*); |
| [propput] HRESULT ttToken([in] BSTR); |
| |
| [propget] HRESULT iid([out, retval] BSTR*); |
| [propput] HRESULT iid([in] BSTR); |
| |
| [propget] HRESULT brandCode([out, retval] BSTR*); |
| [propput] HRESULT brandCode([in] BSTR); |
| |
| [propget] HRESULT clientId([out, retval] BSTR*); |
| [propput] HRESULT clientId([in] BSTR); |
| |
| [propget] HRESULT labels([out, retval] BSTR*); |
| [propput] HRESULT labels([in] BSTR); |
| |
| [propget] HRESULT referralId([out, retval] BSTR*); |
| [propput] HRESULT referralId([in] BSTR); |
| |
| // Returns an IDispatch to a command defined by this installed app with the |
| // specified ID, or NULL if this app is not installed or the command ID is not |
| // recognized. |
| [propget] HRESULT command([in] BSTR command_id, |
| [out, retval] IDispatch** command); |
| |
| // Use values from the BrowserType enum. |
| [propget] HRESULT browserType([out, retval] UINT*); |
| [propput] HRESULT browserType([in] UINT); |
| |
| [propget] HRESULT clientInstallData([out, retval] BSTR*); |
| [propput] HRESULT clientInstallData([in] BSTR); |
| |
| [propget] HRESULT serverInstallDataIndex([out, retval] BSTR*); |
| [propput] HRESULT serverInstallDataIndex([in] BSTR); |
| |
| // Set as soon as possible. Error pings are disabled until set to true. |
| [propget] HRESULT isEulaAccepted([out, retval] VARIANT_BOOL*); |
| [propput] HRESULT isEulaAccepted([in] VARIANT_BOOL); |
| |
| [propget] HRESULT usageStatsEnable([out, retval] UINT*); |
| [propput] HRESULT usageStatsEnable([in] UINT); |
| |
| [propget] HRESULT installTimeDiffSec([out, retval] UINT*); |
| |
| // Returns an ICurrentState interface. The object underlying the interface has |
| // static data that does not get updated as the server state changes. To get |
| // the most "current" state, the currentState property needs to be queried |
| // again. |
| [propget] HRESULT currentState([out, retval] IDispatch**); |
| }; |
| |
| [ |
| object, |
| dual, |
| uuid(084D78A8-B084-4E14-A629-A2C419B0E3D9), |
| helpstring("IApp2 Interface"), |
| pointer_default(unique) |
| ] |
| interface IApp2 : IApp { |
| [propget] HRESULT untrustedData([out, retval] BSTR*); |
| [propput] HRESULT untrustedData([in] BSTR); |
| }; |
| |
| [ |
| object, |
| dual, |
| uuid(4DE778FE-F195-4ee3-9DAB-FE446C239221), |
| helpstring("IAppCommand Interface"), |
| pointer_default(unique) |
| ] |
| interface IAppCommand : IDispatch { |
| [propget] HRESULT isWebAccessible([out, retval] VARIANT_BOOL*); |
| // Use values from the AppCommandStatus enum. |
| [propget] HRESULT status([out, retval] UINT*); |
| [propget] HRESULT exitCode([out, retval] DWORD*); |
| HRESULT execute([in, optional] VARIANT arg1, |
| [in, optional] VARIANT arg2, |
| [in, optional] VARIANT arg3, |
| [in, optional] VARIANT arg4, |
| [in, optional] VARIANT arg5, |
| [in, optional] VARIANT arg6, |
| [in, optional] VARIANT arg7, |
| [in, optional] VARIANT arg8, |
| [in, optional] VARIANT arg9); |
| }; |
| |
| [ |
| object, |
| dual, |
| uuid(3D05F64F-71E3-48A5-BF6B-83315BC8AE1F), |
| helpstring("IAppCommand2 Interface"), |
| pointer_default(unique) |
| ] |
| interface IAppCommand2 : IAppCommand { |
| [propget] HRESULT output([out, retval] BSTR*); |
| }; |
| |
| [ |
| object, |
| dual, |
| uuid(BCDCB538-01C0-46d1-A6A7-52F4D021C272), |
| helpstring("IAppVersion Interface"), |
| pointer_default(unique) |
| ] |
| interface IAppVersion : IDispatch { |
| [propget] HRESULT version([out, retval] BSTR*); |
| |
| // [propget] HRESULT installManifest([out, retval] BSTR*); |
| |
| // Returns the count of the Packages in the AppVersion. |
| [propget] HRESULT packageCount([out, retval] long* count); |
| |
| // Returns an IDispatch of the Package in the AppVersion at the specified |
| // 0-based index. |
| [propget] HRESULT package([in] long index, |
| [out, retval] IDispatch** package); |
| }; |
| |
| [ |
| object, |
| dual, |
| uuid(DCAB8386-4F03-4dbd-A366-D90BC9F68DE6), |
| helpstring("IPackage Interface"), |
| pointer_default(unique) |
| ] |
| interface IPackage : IDispatch { |
| // Retrieves the package from the package cache and copies it to the |
| // directory provided. Returns an error is the package is not available |
| // locally. |
| [id(1)] HRESULT get([in] BSTR dir); |
| |
| // Returns true if the package has been downloaded and is available |
| // locally. |
| [propget] HRESULT isAvailable([out, retval] VARIANT_BOOL*); |
| |
| // Returns the manifest name of the package. |
| [propget] HRESULT filename([out, retval] BSTR*); |
| }; |
| |
| // TODO(omaha3): We should figure out what else we are going to want in this |
| // interface before dogfood even if we do not implement it. |
| [ |
| object, |
| dual, |
| uuid(247954F9-9EDC-4E68-8CC3-150C2B89EADF), |
| helpstring("ICurrentState Interface"), |
| pointer_default(unique) |
| ] |
| interface ICurrentState : IDispatch { |
| // This interface is exposed to web clients! |
| // TODO(omaha3): Update valid comments once we settle on an implementation. |
| |
| // A value from the CurrentState enum. This value determines which of the |
| // properties below are valid. |
| [propget] HRESULT stateValue([out, retval] LONG*); |
| |
| // The remaining properties are only valid in the specified states. For all |
| // other states, the values are not specified. |
| |
| // This property is valid only when stateValue is STATE_UPDATE_AVAILABLE. |
| [propget] HRESULT availableVersion([out, retval] BSTR*); |
| |
| // The following three properties are only valid when stateValue is |
| // STATE_WAITING_TO_DOWNLOAD, STATE_RETRYING_DOWNLOAD, STATE_DOWNLOADING, |
| // STATE_DOWNLOAD_COMPLETE, STATE_EXTRACTING, |
| // STATE_APPLYING_DIFFERENTIAL_PATCH, or STATE_READY_TO_INSTALL. |
| |
| // Bytes downloaded so far. |
| [propget] HRESULT bytesDownloaded([out, retval] ULONG*); |
| |
| // Total bytes to download. |
| [propget] HRESULT totalBytesToDownload([out, retval] ULONG*); |
| |
| // Estimated download time remaining in ms. -1 indicates unknown. |
| // Progress may not always be available, so clients should handle the -1 case. |
| [propget] HRESULT downloadTimeRemainingMs([out, retval] LONG*); |
| |
| [propget] HRESULT nextRetryTime([out, retval] ULONGLONG*); |
| |
| // TODO(omaha 3): Need some way to indicate reconnecting, retrying, etc. |
| |
| // The following two properties are only valid when stateValue is |
| // STATE_INSTALLING or STATE_INSTALL_COMPLETE. |
| |
| // Current install progress in percentage from 0 to 100. -1 indicates unknown. |
| // Progress may not always be available, so clients should handle the -1 case. |
| [propget] HRESULT installProgress([out, retval] LONG*); |
| |
| // Estimated download time remaining in ms. -1 indicates unknown. |
| // Progress may not always be available, so clients should handle the -1 case. |
| [propget] HRESULT installTimeRemainingMs([out, retval] LONG*); |
| |
| // The following four properties are only valid when stateValue is |
| // STATE_ERROR: |
| |
| // Returns true if the app has been canceled. |
| [propget] HRESULT isCanceled([out, retval] VARIANT_BOOL* is_canceled); |
| |
| // Error code. |
| [propget] HRESULT errorCode([out, retval] LONG*); |
| |
| // Error extra code. |
| [propget] HRESULT extraCode1([out, retval] LONG*); |
| |
| // The following three properties are only valid when stateValue is |
| // STATE_ERROR or STATE_INSTALL_COMPLETE. |
| // TODO(omaha3): If STATE_DOWNLOAD_COMPLETE or STATE_READY_TO_INSTALL becomes |
| // a terminal state, does it support completion messages? |
| |
| // Completion message, localized in the specified language. |
| // TODO(omaha3): If we're going to have bundle error messages too, should the |
| // language be at bundle level? Should bundle have its own language setter? |
| [propget] HRESULT completionMessage([out, retval] BSTR*); |
| |
| // Application installer result code. This is to be used as additional |
| // information only. Success/failure should be determined using errorCode. |
| // This is an error if errorCode is GOOPDATEINSTALL_E_INSTALLER_FAILED. |
| [propget] HRESULT installerResultCode([out, retval] LONG*); |
| |
| // Application installer extra code. |
| [propget] HRESULT installerResultExtraCode1([out, retval] LONG*); |
| |
| // A command that needs to be launched by the client after installation. |
| [propget] HRESULT postInstallLaunchCommandLine([out, retval] BSTR*); |
| |
| // URL to be launched after restarting the browser. |
| [propget] HRESULT postInstallUrl([out, retval] BSTR*); |
| |
| // Returns a PostInstallAction value indicating the action to be taken by the |
| // client after installation. |
| [propget] HRESULT postInstallAction([out, retval] LONG*); |
| } |
| |
| [ |
| object, |
| dual, |
| uuid(4E223325-C16B-4eeb-AEDC-19AA99A237FA), |
| helpstring("IRegistrationUpdateHook Interface"), |
| pointer_default(unique) |
| ] |
| interface IRegistrationUpdateHook : IDispatch { |
| HRESULT UpdateRegistry([in] BSTR app_id, [in] VARIANT_BOOL is_machine); |
| }; |
| |
| [ |
| object, |
| uuid(b3a47570-0a85-4aea-8270-529d47899603), |
| helpstring("ICredentialDialog Interface"), |
| pointer_default(unique) |
| ] |
| interface ICredentialDialog : IUnknown { |
| HRESULT QueryUserForCredentials([in] ULONG_PTR owner_hwnd, |
| [in] BSTR server, |
| [in] BSTR message, |
| [out] BSTR* username, |
| [out] BSTR* password); |
| }; |
| |
| // This is a legacy interface that could be removed in future versions. Do not |
| // use. |
| [ |
| object, |
| dual, |
| uuid(F63F6F8B-ACD5-413C-A44B-0409136D26CB), |
| helpstring("IPolicyStatus Interface"), |
| pointer_default(unique) |
| ] |
| interface IPolicyStatus : IDispatch { |
| // Global Update Policies |
| |
| // Returns the time interval between update checks in minutes. |
| // 0 indicates updates are disabled. |
| [propget] HRESULT lastCheckPeriodMinutes([out, retval] DWORD* minutes); |
| |
| // For domain-joined machines, returns the suppressed times if any, and also |
| // checks the current time against the times that updates are suppressed. |
| // Updates are suppressed if the current time falls between the start time and |
| // the duration. |
| // The duration does not account for daylight savings time. For instance, if |
| // the start time is 22:00 hours, and with a duration of 8 hours, the updates |
| // will be suppressed for 8 hours regardless of whether daylight savings time |
| // changes happen in between. |
| [propget] HRESULT updatesSuppressedTimes( |
| [out] DWORD* start_hour, |
| [out] DWORD* start_min, |
| [out] DWORD* duration_min, |
| [out] VARIANT_BOOL* are_updates_suppressed); |
| |
| // Returns the value of the "DownloadPreference" group policy or an |
| // empty string if the group policy does not exist, the policy is unknown, or |
| // an error happened. |
| [propget] HRESULT downloadPreferenceGroupPolicy([out, retval] BSTR* pref); |
| |
| // Gets the total disk size limit for cached packages. When this limit is hit, |
| // packages may be deleted from oldest until total size is below the limit. |
| [propget] HRESULT packageCacheSizeLimitMBytes([out, retval] DWORD* limit); |
| |
| // Gets the package cache life limit. If a cached package is older than this |
| // limit, it may be deleted. |
| [propget] HRESULT packageCacheExpirationTimeDays([out, retval] DWORD* days); |
| |
| // Application Update Policies |
| |
| // Returns 1 if installation of the specified app is allowed. |
| // Otherwise, returns 0. |
| [propget] HRESULT effectivePolicyForAppInstalls([in] BSTR app_id, |
| [out, retval] DWORD* policy); |
| |
| // Returns 1 if updates of the specified app is allowed. |
| // Otherwise, returns one of 0 (Disabled), 2 (ManualUpdatesOnly), or |
| // 3 (AutomaticUpdatesOnly). |
| [propget] HRESULT effectivePolicyForAppUpdates([in] BSTR app_id, |
| [out, retval] DWORD* policy); |
| |
| // Returns the target version prefix for the app, if the machine is joined to |
| // a domain and has the corresponding policy set. |
| // Examples: |
| // * "" (or not configured): update to latest version available. |
| // * "55.": update to any minor version of 55 (e.g. 55.24.34 or 55.60.2). |
| // * "55.2.": update to any minor version of 55.2 (e.g. 55.2.34 or 55.2.2). |
| // * "55.24.34": update to this specific version only. |
| [propget] HRESULT targetVersionPrefix([in] BSTR app_id, |
| [out, retval] BSTR* prefix); |
| |
| // Returns whether the RollbackToTargetVersion policy has been set for the |
| // app. If RollbackToTargetVersion is set, the TargetVersionPrefix policy |
| // governs the version to rollback clients with higher versions to. |
| [propget] HRESULT isRollbackToTargetVersionAllowed( |
| [in] BSTR app_id, |
| [out, retval] VARIANT_BOOL* rollback_allowed); |
| }; |
| |
| // IPolicyStatusValue represents the managed state of a single Google Update |
| // policy. It contains the current source and value, as well as if any conflicts |
| // exist with that policy. |
| [ |
| object, |
| dual, |
| uuid(27634814-8E41-4C35-8577-980134A96544), |
| helpstring("IPolicyStatusValue Interface"), |
| pointer_default(unique) |
| ] |
| interface IPolicyStatusValue : IDispatch { |
| [propget] HRESULT source([out, retval] BSTR*); |
| [propget] HRESULT value([out, retval] BSTR*); |
| [propget] HRESULT hasConflict([out, retval] VARIANT_BOOL* has_conflict); |
| [propget] HRESULT conflictSource([out, retval] BSTR*); |
| [propget] HRESULT conflictValue([out, retval] BSTR*); |
| } |
| |
| // IPolicyStatus2 exposes the following: |
| // * properties for Google Update that includes Global Update state, such as the |
| // Version of the Updater, the Time that Updates were checked for last. |
| // * A way to refresh the latest policies from the DM Server. |
| // * the managed state of Omaha policies. Each policy returns an |
| // IPolicyStatusValue that can be queried for the current source and value, as |
| // well as if any conflicts exist with that policy. |
| // IPolicyStatusValue is implemented by an object that marshals itself by |
| // value. To get the "current" value, the policy needs to be queried fresh. |
| [ |
| object, |
| dual, |
| uuid(34527502-D3DB-4205-A69B-789B27EE0414), |
| helpstring("IPolicyStatus2 Interface"), |
| pointer_default(unique) |
| ] |
| interface IPolicyStatus2 : IDispatch { |
| // Global Update Status. |
| |
| // Returns the running version of the Updater. For instance, 1.3.35.454. |
| [propget] HRESULT updaterVersion([out, retval] BSTR* version); |
| |
| // Returns the last time that the Updater successfully checked for updates. |
| [propget] HRESULT lastCheckedTime([out, retval] DATE* last_checked); |
| |
| // DM policy cache refresh. |
| |
| // Gets the latest policies from the DM Server. |
| HRESULT refreshPolicies(); |
| |
| // Global Update Policies |
| |
| // Returns the time interval between update checks in minutes. |
| // 0 indicates updates are disabled. |
| [propget] HRESULT lastCheckPeriodMinutes( |
| [out, retval] IPolicyStatusValue** value); |
| |
| // For domain-joined machines, returns the suppressed times if any, and also |
| // checks the current time against the times that updates are suppressed. |
| // Updates are suppressed if the current time falls between the start time and |
| // the duration. |
| // The duration does not account for daylight savings time. For instance, if |
| // the start time is 22:00 hours, and with a duration of 8 hours, the updates |
| // will be suppressed for 8 hours regardless of whether daylight savings time |
| // changes happen in between. |
| [propget] HRESULT updatesSuppressedTimes( |
| [out] IPolicyStatusValue** value, |
| VARIANT_BOOL* are_updates_suppressed); |
| |
| // Returns the value of the "DownloadPreference" group policy or an |
| // empty string if the group policy does not exist, the policy is unknown, or |
| // an error happened. |
| [propget] HRESULT downloadPreferenceGroupPolicy( |
| [out, retval] IPolicyStatusValue** value); |
| |
| // Gets the total disk size limit for cached packages. When this limit is hit, |
| // packages may be deleted from oldest until total size is below the limit. |
| [propget] HRESULT packageCacheSizeLimitMBytes( |
| [out, retval] IPolicyStatusValue** value); |
| |
| // Gets the package cache life limit. If a cached package is older than this |
| // limit, it may be deleted. |
| [propget] HRESULT packageCacheExpirationTimeDays( |
| [out, retval] IPolicyStatusValue** value); |
| |
| // Gets the proxy policy values. |
| [propget] HRESULT proxyMode([out, retval] IPolicyStatusValue** value); |
| [propget] HRESULT proxyPacUrl([out, retval] IPolicyStatusValue** value); |
| [propget] HRESULT proxyServer([out, retval] IPolicyStatusValue** value); |
| |
| // Application Update Policies |
| |
| // Returns 1 if installation of the specified app is allowed. |
| // Otherwise, returns 0. |
| [propget] HRESULT effectivePolicyForAppInstalls( |
| [in] BSTR app_id, |
| [out, retval] IPolicyStatusValue** value); |
| |
| // Returns 1 if updates of the specified app is allowed. |
| // Otherwise, returns one of 0 (Disabled), 2 (ManualUpdatesOnly), or |
| // 3 (AutomaticUpdatesOnly). |
| [propget] HRESULT effectivePolicyForAppUpdates( |
| [in] BSTR app_id, |
| [out, retval] IPolicyStatusValue** value); |
| |
| // Returns the target version prefix for the app, if the machine is joined to |
| // a domain and has the corresponding policy set. |
| // Examples: |
| // * "" (or not configured): update to latest version available. |
| // * "55.": update to any minor version of 55 (e.g. 55.24.34 or 55.60.2). |
| // * "55.2.": update to any minor version of 55.2 (e.g. 55.2.34 or 55.2.2). |
| // * "55.24.34": update to this specific version only. |
| [propget] HRESULT targetVersionPrefix( |
| [in] BSTR app_id, |
| [out, retval] IPolicyStatusValue** value); |
| |
| // Returns whether the RollbackToTargetVersion policy has been set for the |
| // app. If RollbackToTargetVersion is set, the TargetVersionPrefix policy |
| // governs the version to rollback clients with higher versions to. |
| [propget] HRESULT isRollbackToTargetVersionAllowed( |
| [in] BSTR app_id, [out, retval] IPolicyStatusValue** value); |
| |
| // Returns the target channel for the app, if the machine is joined to a |
| // domain and has the corresponding policy set. |
| [propget] HRESULT targetChannel([in] BSTR app_id, |
| [out, retval] IPolicyStatusValue** value); |
| }; |
| |
| // BEGIN gupdatem interfaces. |
| |
| // The following interfaces are exposed as a narrower version of the |
| // IGoogleUpdate3 interface from the gupdatem service. These interfaces are |
| // meant for use from medium and low integrity clients. |
| |
| [ |
| object, |
| dual, |
| uuid(494B20CF-282E-4BDD-9F5D-B70CB09D351E), |
| helpstring("IGoogleUpdate3Web Interface"), |
| pointer_default(unique) |
| ] |
| interface IGoogleUpdate3Web : IDispatch { |
| HRESULT createAppBundleWeb([out, retval] IDispatch** app_bundle_web); |
| }; |
| |
| [ |
| object, |
| uuid(2D363682-561D-4c3a-81C6-F2F82107562A), |
| helpstring("IGoogleUpdate3WebSecurity Interface"), |
| pointer_default(unique) |
| ] |
| interface IGoogleUpdate3WebSecurity : IUnknown { |
| HRESULT setOriginURL([in] BSTR origin_url); |
| }; |
| |
| [ |
| object, |
| dual, |
| uuid(DD42475D-6D46-496a-924E-BD5630B4CBBA), |
| helpstring("IAppBundleWeb Interface"), |
| pointer_default(unique) |
| ] |
| interface IAppBundleWeb : IDispatch { |
| [id(2)] HRESULT createApp([in] BSTR app_guid, |
| [in] BSTR brand_code, |
| [in] BSTR language, |
| [in] BSTR ap); |
| [id(3)] HRESULT createInstalledApp([in] BSTR app_id); |
| [id(4)] HRESULT createAllInstalledApps(); |
| |
| [propget] HRESULT displayLanguage([out, retval] BSTR*); |
| [propput] HRESULT displayLanguage([in] BSTR); |
| |
| [propput] HRESULT parentHWND([in] ULONG_PTR hwnd); |
| |
| [propget] HRESULT length([out, retval] int* index); |
| [id(DISPID_VALUE), propget] HRESULT appWeb( |
| [in] int index, [out, retval] IDispatch** app_web); |
| |
| HRESULT initialize(); |
| |
| HRESULT checkForUpdate(); |
| HRESULT download(); |
| HRESULT install(); |
| |
| HRESULT pause(); |
| HRESULT resume(); |
| HRESULT cancel(); |
| |
| HRESULT downloadPackage([in] BSTR app_id, [in] BSTR package_name); |
| |
| [propget] HRESULT currentState([out, retval] VARIANT* current_state); |
| }; |
| |
| [ |
| object, |
| dual, |
| uuid(18D0F672-18B4-48e6-AD36-6E6BF01DBBC4), |
| helpstring("IAppWeb Interface"), |
| pointer_default(unique) |
| ] |
| interface IAppWeb : IDispatch { |
| [propget] HRESULT appId([out, retval] BSTR*); |
| |
| // Returns an IAppVersionWeb IDispatch object. |
| [propget] HRESULT currentVersionWeb([out, retval] IDispatch** current); |
| [propget] HRESULT nextVersionWeb([out, retval] IDispatch** next); |
| |
| // Returns an IAppCommandWeb IDispatch object, or NULL. |
| [propget] HRESULT command([in] BSTR command_id, |
| [out, retval] IDispatch** command); |
| |
| HRESULT cancel(); |
| |
| [propget] HRESULT currentState([out, retval] IDispatch** current_state); |
| |
| HRESULT launch(); |
| HRESULT uninstall(); |
| |
| [propget] HRESULT serverInstallDataIndex([out, retval] BSTR*); |
| [propput] HRESULT serverInstallDataIndex([in] BSTR); |
| }; |
| |
| [ |
| object, |
| dual, |
| uuid(8476CE12-AE1F-4198-805C-BA0F9B783F57), |
| helpstring("IAppCommandWeb Interface"), |
| pointer_default(unique) |
| ] |
| interface IAppCommandWeb : IDispatch { |
| // Use values from the AppCommandStatus enum. |
| [propget] HRESULT status([out, retval] UINT*); |
| [propget] HRESULT exitCode([out, retval] DWORD*); |
| [propget] HRESULT output([out, retval] BSTR*); |
| HRESULT execute([in, optional] VARIANT arg1, |
| [in, optional] VARIANT arg2, |
| [in, optional] VARIANT arg3, |
| [in, optional] VARIANT arg4, |
| [in, optional] VARIANT arg5, |
| [in, optional] VARIANT arg6, |
| [in, optional] VARIANT arg7, |
| [in, optional] VARIANT arg8, |
| [in, optional] VARIANT arg9); |
| }; |
| |
| [ |
| object, |
| dual, |
| uuid(0CD01D1E-4A1C-489d-93B9-9B6672877C57), |
| helpstring("IAppVersionWeb Interface"), |
| pointer_default(unique) |
| ] |
| interface IAppVersionWeb : IDispatch { |
| [propget] HRESULT version([out, retval] BSTR*); |
| |
| // Returns the count of the Packages in the AppVersion. |
| [propget] HRESULT packageCount([out, retval] long* count); |
| |
| // TODO(omaha3): Implement this after a security review. |
| // Returns an IDispatch of the Package in the AppVersion at the specified |
| // 0-based index. |
| [propget] HRESULT packageWeb([in] long index, |
| [out, retval] IDispatch** package); |
| }; |
| |
| [ |
| object, |
| dual, |
| uuid(2E629606-312A-482f-9B12-2C4ABF6F0B6D), |
| helpstring("ICoCreateAsyncStatus Interface"), |
| pointer_default(unique) |
| ] |
| interface ICoCreateAsyncStatus : IDispatch { |
| [propget] HRESULT isDone([out, retval] VARIANT_BOOL* is_done); |
| [propget] HRESULT completionHResult([out, retval] LONG* hr); |
| [propget] HRESULT createdInstance([out, retval] IDispatch** instance); |
| }; |
| |
| [ |
| object, |
| uuid(DAB1D343-1B2A-47f9-B445-93DC50704BFE), |
| helpstring("ICoCreateAsync Interface"), |
| pointer_default(unique) |
| ] |
| interface ICoCreateAsync : IUnknown { |
| HRESULT createOmahaMachineServerAsync( |
| [in] BSTR origin_url, |
| [in] BOOL create_elevated, |
| [out, retval] ICoCreateAsyncStatus** status); |
| }; |
| |
| // END gupdatem interfaces. |
| |
| // BEGIN Legacy google_update_idl interfaces. |
| |
| [ |
| object, |
| uuid(5B25A8DC-1780-4178-A629-6BE8B8DEFAA2), |
| oleautomation, |
| nonextensible, |
| pointer_default(unique) |
| ] |
| interface IBrowserHttpRequest2 : IUnknown { |
| // This method will send request/data from the browser process. |
| // @param url URL where request will be send. |
| // @param post_data POST data, if any. Can be NULL. |
| // @param request_headers HTTP request headers, if any. Can be NULL. |
| // @param response_headers_needed HTTP response headers that are needed. |
| // Should be one of the values listed here: |
| // http://msdn.microsoft.com/aa385351.aspx |
| // The input is a SAFEARRAY of DWORD. Can be a |
| // VT_EMPTY. |
| // @param response_headers HTTP response headers, returned as SAFEARRAY |
| // of BSTR. The values corresponding one-to-one |
| // with the response_headers_needed values. Can |
| // be NULL if response_headers_needed==VT_EMPTY |
| // @param response_code HTTP response code. |
| // @param cache_filename Cache file that contains the response data. |
| HRESULT Send([in] BSTR url, |
| [in] BSTR post_data, |
| [in] BSTR request_headers, |
| [in] VARIANT response_headers_needed, |
| [out] VARIANT* response_headers, |
| [out] DWORD* response_code, |
| [out] BSTR* cache_filename); |
| }; |
| |
| [ |
| object, |
| oleautomation, |
| uuid(128C2DA6-2BC0-44c0-B3F6-4EC22E647964), |
| helpstring("Google Update IProcessLauncher Interface"), |
| pointer_default(unique) |
| ] |
| interface IProcessLauncher : IUnknown { |
| // @param cmd_line The full command line to execute. |
| HRESULT LaunchCmdLine([in, string] const WCHAR* cmd_line); |
| |
| // @param browser_type The browser to start. |
| // @param url The url to launch the browser with. |
| HRESULT LaunchBrowser([in] DWORD browser_type, |
| [in, string] const WCHAR* url); |
| |
| // @param app_id Unique id to identify the calling client application |
| // @param event_id Unique id for the command |
| // @param caller_proc_id The process id of the calling process |
| // @param proc_handle The process handle valid in the caller's context |
| HRESULT LaunchCmdElevated([in, string] const WCHAR* app_guid, |
| [in, string] const WCHAR* cmd_id, |
| [in] DWORD caller_proc_id, |
| [out] ULONG_PTR* proc_handle); |
| }; |
| |
| [ |
| object, |
| oleautomation, |
| uuid(D106AB5F-A70E-400E-A21B-96208C1D8DBB), |
| helpstring("Google Update IProcessLauncher2 Interface"), |
| pointer_default(unique) |
| ] |
| interface IProcessLauncher2 : IProcessLauncher { |
| // Launches the command line, returning the COM server's process ID and |
| // handles to the launched process and its stdout. The caller is responsible |
| // for closing the returned handles (by passing DUPLICATE_CLOSE_SOURCE to |
| // DuplicateHandle, for instance). |
| // @param cmd_line The full command line to execute. |
| // @param server_proc_id The process id of the IProcessLauncher2 COM server. |
| // @param proc_handle The process handle valid in the server's context |
| // @param stdout_handle The child process's stdout handle valid in the |
| // server's context. |
| HRESULT LaunchCmdLineEx([in, string] const WCHAR* cmd_line, |
| [out] DWORD* server_proc_id, |
| [out] ULONG_PTR* proc_handle, |
| [out] ULONG_PTR* stdout_handle); |
| }; |
| |
| typedef enum { |
| COMPLETION_CODE_SUCCESS = 1, |
| COMPLETION_CODE_SUCCESS_CLOSE_UI, |
| COMPLETION_CODE_ERROR, |
| COMPLETION_CODE_RESTART_ALL_BROWSERS, |
| COMPLETION_CODE_REBOOT, |
| COMPLETION_CODE_RESTART_BROWSER, |
| COMPLETION_CODE_RESTART_ALL_BROWSERS_NOTICE_ONLY, |
| COMPLETION_CODE_REBOOT_NOTICE_ONLY, |
| COMPLETION_CODE_RESTART_BROWSER_NOTICE_ONLY, |
| COMPLETION_CODE_RUN_COMMAND, |
| } LegacyCompletionCodes; |
| |
| [ |
| object, |
| oleautomation, |
| uuid(1C642CED-CA3B-4013-A9DF-CA6CE5FF6503), |
| helpstring("GoogleUpdate UI-specific events Interface"), |
| pointer_default(unique) |
| ] |
| interface IProgressWndEvents : IUnknown { |
| // The UI is closing down. The user has clicked on either the "X" or the |
| // other buttons of the UI to close the window. |
| HRESULT DoClose(); |
| |
| // Pause has been clicked on. |
| HRESULT DoPause(); |
| |
| // Resume has been clicked on. |
| HRESULT DoResume(); |
| |
| // RestartBrowsers button has been clicked on. |
| HRESULT DoRestartBrowsers(); |
| |
| // Reboot button has been clicked on. |
| HRESULT DoReboot(); |
| |
| // Launch Browser. |
| HRESULT DoLaunchBrowser([in, string] const WCHAR* url); |
| }; |
| |
| |
| [ |
| object, |
| oleautomation, |
| uuid(49D7563B-2DDB-4831-88C8-768A53833837), |
| helpstring("IJobObserver Interface"), |
| pointer_default(unique) |
| ] |
| interface IJobObserver : IUnknown { |
| HRESULT OnShow(); |
| HRESULT OnCheckingForUpdate(); |
| HRESULT OnUpdateAvailable([in, string] const WCHAR* version_string); |
| HRESULT OnWaitingToDownload(); |
| HRESULT OnDownloading([in] int time_remaining_ms, [in] int pos); |
| HRESULT OnWaitingToInstall(); |
| HRESULT OnInstalling(); |
| HRESULT OnPause(); |
| HRESULT OnComplete([in] LegacyCompletionCodes code, |
| [in, string] const WCHAR* completion_text); |
| HRESULT SetEventSink([in] IProgressWndEvents* ui_sink); |
| }; |
| |
| [ |
| object, |
| oleautomation, |
| uuid(19692F10-ADD2-4EFF-BE54-E61C62E40D13), |
| helpstring("IJobObserver2 Interface"), |
| pointer_default(unique) |
| ] |
| interface IJobObserver2 : IUnknown { |
| // @param time_remaining_ms Remaining install time. |
| // @param pos Current install progress in percentage from 0 to 100. -1 |
| // indicates unknown. |
| HRESULT OnInstalling2([in] int time_remaining_ms, [in] int pos); |
| }; |
| |
| [ |
| object, |
| oleautomation, |
| uuid(31AC3F11-E5EA-4a85-8A3D-8E095A39C27B), |
| helpstring("IGoogleUpdate Interface"), |
| pointer_default(unique) |
| ] |
| interface IGoogleUpdate : IUnknown { |
| // @param guid The guid for the app to be updated. |
| // @param observer The eventing interface. |
| HRESULT CheckForUpdate([in, string] const WCHAR* guid, |
| [in] IJobObserver* observer); |
| |
| // @param guid The guid for the app to be updated. |
| // @param observer The eventing interface. |
| HRESULT Update([in, string] const WCHAR* guid, |
| [in] IJobObserver* observer); |
| }; |
| |
| // IGoogleUpdateCore is an internal Omaha interface. |
| [ |
| object, |
| oleautomation, |
| uuid(909489C2-85A6-4322-AA56-D25278649D67), |
| helpstring("Google Update Core Interface"), |
| pointer_default(unique) |
| ] |
| interface IGoogleUpdateCore : IUnknown |
| { |
| // Runs a command elevated. |
| // |
| // @param app_id Unique id to identify the calling client application |
| // @param event_id Unique id for the command |
| // @param caller_proc_id The process id of the calling process |
| // @param proc_handle The process handle valid in the caller's context |
| HRESULT LaunchCmdElevated([in, string] const WCHAR* app_guid, |
| [in, string] const WCHAR* cmd_id, |
| [in] DWORD caller_proc_id, |
| [out] ULONG_PTR* proc_handle); |
| }; |
| |
| // END Legacy google_update_idl interfaces. |
| |
| [ |
| uuid(655DD85A-3C0D-4674-9C58-AF7168C5861E), |
| version(1.0), |
| helpstring("Google Update 3.0 Type Library") |
| ] |
| library GoogleUpdate3Lib { |
| importlib("stdole2.tlb"); |
| |
| // These Interfaces are forward declared to ensure that they are described in |
| // the generated TLB file. This is required for ATL to correctly implement the |
| // corresponding IDispatch interfaces. |
| interface IGoogleUpdate3; |
| interface IAppBundle; |
| interface IApp; |
| interface IApp2; |
| interface IAppCommand; |
| interface IAppCommand2; |
| interface IAppVersion; |
| interface IPackage; |
| interface ICurrentState; |
| |
| interface IPolicyStatus; |
| interface IPolicyStatus2; |
| interface IPolicyStatusValue; |
| interface IGoogleUpdate3Web; |
| interface IAppBundleWeb; |
| interface IAppWeb; |
| interface IAppCommandWeb; |
| interface IAppVersionWeb; |
| interface ICoCreateAsyncStatus; |
| |
| [ |
| uuid(022105BD-948A-40c9-AB42-A3300DDF097F), |
| helpstring("GoogleUpdate3 Class for per-user applications") |
| ] |
| coclass GoogleUpdate3UserClass { |
| [default] interface IDispatch; |
| } |
| |
| [ |
| uuid(4EB61BAC-A3B6-4760-9581-655041EF4D69), |
| helpstring("GoogleUpdate3 Service Class for machine applications") |
| ] |
| coclass GoogleUpdate3ServiceClass { |
| [default] interface IDispatch; |
| } |
| |
| [ |
| uuid(22181302-A8A6-4f84-A541-E5CBFC70CC43), |
| helpstring("GoogleUpdate3Web for user applications") |
| ] |
| coclass GoogleUpdate3WebUserClass { |
| [default] interface IDispatch; |
| } |
| |
| [ |
| uuid(8A1D4361-2C08-4700-A351-3EAA9CBFF5E4), |
| helpstring("Pass-through broker for the GoogleUpdate3WebServiceClass") |
| ] |
| coclass GoogleUpdate3WebMachineClass { |
| [default] interface IDispatch; |
| } |
| |
| [ |
| uuid(534F5323-3569-4f42-919D-1E1CF93E5BF6), |
| helpstring("GoogleUpdate3Web") |
| ] |
| coclass GoogleUpdate3WebServiceClass { |
| [default] interface IDispatch; |
| } |
| |
| [ |
| uuid(598FE0E5-E02D-465d-9A9D-37974A28FD42), |
| helpstring("Fallback mechanism if GoogleUpdate3WebServiceClass fails") |
| ] |
| coclass GoogleUpdate3WebMachineFallbackClass { |
| [default] interface IDispatch; |
| } |
| |
| [ |
| uuid(E8CF3E55-F919-49d9-ABC0-948E6CB34B9F), |
| helpstring("CurrentStateUserClass") |
| ] |
| coclass CurrentStateUserClass { |
| [default] interface ICurrentState; |
| } |
| |
| [ |
| uuid(9D6AA569-9F30-41ad-885A-346685C74928), |
| helpstring("CurrentStateMachineClass") |
| ] |
| coclass CurrentStateMachineClass { |
| [default] interface ICurrentState; |
| } |
| |
| [ |
| uuid(7DE94008-8AFD-4c70-9728-C6FBFFF6A73E), |
| helpstring("CoCreateAsyncClass") |
| ] |
| coclass CoCreateAsyncClass { |
| [default] interface IUnknown; |
| } |
| |
| [ |
| uuid(e67be843-bbbe-4484-95fb-05271ae86750), |
| helpstring("CredentialDialogUserClass") |
| ] |
| coclass CredentialDialogUserClass { |
| [default] interface IUnknown; |
| } |
| |
| [ |
| uuid(25461599-633d-42b1-84fb-7cd68d026e53), |
| helpstring("CredentialDialogMachineClass") |
| ] |
| coclass CredentialDialogMachineClass { |
| [default] interface IUnknown; |
| } |
| |
| [ |
| uuid(85D8EE2F-794F-41F0-BB03-49D56A23BEF4), |
| helpstring("PolicyStatusValueUserClass") |
| ] |
| coclass PolicyStatusValueUserClass { |
| [default] interface IUnknown; |
| } |
| |
| [ |
| uuid(C6271107-A214-4F11-98C0-3F16BC670D28), |
| helpstring("PolicyStatusValueMachineClass") |
| ] |
| coclass PolicyStatusValueMachineClass { |
| [default] interface IUnknown; |
| } |
| |
| [ |
| uuid(6DDCE70D-A4AE-4E97-908C-BE7B2DB750AD), |
| helpstring("Policy Status for per-user applications.") |
| ] |
| coclass PolicyStatusUserClass { |
| [default] interface IUnknown; |
| } |
| |
| [ |
| uuid(521FDB42-7130-4806-822A-FC5163FAD983), |
| helpstring("Policy Status pass-through broker for machine applications.") |
| ] |
| coclass PolicyStatusMachineClass { |
| [default] interface IUnknown; |
| } |
| |
| [ |
| uuid(1C4CDEFF-756A-4804-9E77-3E8EB9361016), |
| helpstring("Policy Status for per-machine applications.") |
| ] |
| coclass PolicyStatusMachineServiceClass { |
| [default] interface IUnknown; |
| } |
| |
| [ |
| uuid(ADDF22CF-3E9B-4CD7-9139-8169EA6636E4), |
| helpstring("Fallback for if PolicyStatusMachineServiceClass fails.") |
| ] |
| coclass PolicyStatusMachineFallbackClass { |
| [default] interface IUnknown; |
| } |
| |
| [ |
| uuid(02B24573-5230-485A-8787-AD56B20E8ADB), |
| helpstring("GoogleComProxyMachineClass") |
| ] |
| coclass GoogleComProxyMachineClass { |
| [default] interface IUnknown; |
| } |
| |
| [ |
| uuid(D89179AA-B869-4491-AC5F-615D2B10696E), |
| helpstring("GoogleComProxyUserClass") |
| ] |
| coclass GoogleComProxyUserClass { |
| [default] interface IUnknown; |
| } |
| |
| // BEGIN Legacy google_update_idl coclasses. |
| |
| [ |
| uuid(ABC01078-F197-4b0b-ADBC-CFE684B39C82), |
| helpstring("ProcessLauncherClass Class") |
| ] |
| coclass ProcessLauncherClass { |
| [default] interface IUnknown; |
| } |
| |
| [ |
| uuid(2F0E2680-9FF5-43c0-B76E-114A56E93598), |
| helpstring("OnDemand updates for per-user applications.") |
| ] |
| coclass OnDemandUserAppsClass { |
| [default] interface IUnknown; |
| } |
| |
| [ |
| uuid(6F8BD55B-E83D-4a47-85BE-81FFA8057A69), |
| helpstring("OnDemand pass-through broker for machine applications.") |
| ] |
| coclass OnDemandMachineAppsClass { |
| [default] interface IUnknown; |
| } |
| |
| [ |
| uuid(9465B4B4-5216-4042-9A2C-754D3BCDC410), |
| helpstring("OnDemand updates for per-machine applications.") |
| ] |
| coclass OnDemandMachineAppsServiceClass { |
| [default] interface IUnknown; |
| } |
| |
| [ |
| uuid(B3D28DBD-0DFA-40e4-8071-520767BADC7E), |
| helpstring("Fallback for if OnDemandMachineAppsServiceClass fails.") |
| ] |
| coclass OnDemandMachineAppsFallbackClass { |
| [default] interface IUnknown; |
| } |
| |
| [ |
| uuid(E225E692-4B47-4777-9BED-4FD7FE257F0E), |
| helpstring("GoogleUpdateCore Class") |
| ] |
| coclass GoogleUpdateCoreClass |
| { |
| [default] interface IUnknown; |
| } |
| |
| [ |
| uuid(9B2340A0-4068-43d6-B404-32E27217859D), |
| helpstring("GoogleUpdateCore Machine Class") |
| ] |
| coclass GoogleUpdateCoreMachineClass |
| { |
| [default] interface IUnknown; |
| } |
| |
| // END Legacy google_update_idl coclasses. |
| }; |