VirtualBoxImpl.h@ 16188

Last change on this file since 16188 was 16188, checked in by vboxsync, 16 years ago
Merge OVF branch.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 20.1 KB

Line
1	/* $Id: VirtualBoxImpl.h 16188 2009-01-22 19:58:31Z vboxsync $ */
2
3	/** @file
4	*
5	* VirtualBox COM class implementation
6	*/
7
8	/*
9	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License (GPL) as published by the Free Software
15	* Foundation, in version 2 as it comes in the "COPYING" file of the
16	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18	*
19	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
20	* Clara, CA 95054 USA or visit http://www.sun.com if you need
21	* additional information or have any questions.
22	*/
23
24	#ifndef ____H_VIRTUALBOXIMPL
25	#define ____H_VIRTUALBOXIMPL
26
27	#include "VirtualBoxBase.h"
28
29	#include "VBox/com/EventQueue.h"
30
31	#include <list>
32	#include <vector>
33	#include <map>
34
35	#ifdef RT_OS_WINDOWS
36	# include "win/resource.h"
37	#endif
38
39	#ifdef VBOX_WITH_RESOURCE_USAGE_API
40	#include "PerformanceImpl.h"
41	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
42
43
44	class Machine;
45	class SessionMachine;
46	class HardDisk2;
47	class DVDImage2;
48	class FloppyImage2;
49	class MachineCollection;
50	class GuestOSType;
51	class GuestOSTypeCollection;
52	class SharedFolder;
53	class Progress;
54	class ProgressCollection;
55	class Host;
56	class SystemProperties;
57	class IAppliance;
58
59	#ifdef RT_OS_WINDOWS
60	class SVCHlpClient;
61	#endif
62
63	struct VMClientWatcherData;
64
65	class ATL_NO_VTABLE VirtualBox :
66	public VirtualBoxBaseWithChildrenNEXT,
67	public VirtualBoxSupportErrorInfoImpl <VirtualBox, IVirtualBox>,
68	public VirtualBoxSupportTranslation <VirtualBox>,
69	#ifdef RT_OS_WINDOWS
70	public IDispatchImpl<IVirtualBox, &IID_IVirtualBox, &LIBID_VirtualBox,
71	kTypeLibraryMajorVersion, kTypeLibraryMinorVersion>,
72	public CComCoClass<VirtualBox, &CLSID_VirtualBox>
73	#else
74	public IVirtualBox
75	#endif
76	{
77
78	public:
79
80	typedef std::list <ComPtr <IVirtualBoxCallback> > CallbackList;
81	typedef std::vector <ComPtr <IVirtualBoxCallback> > CallbackVector;
82
83	typedef std::vector <ComObjPtr <SessionMachine> > SessionMachineVector;
84	typedef std::vector <ComObjPtr <Machine> > MachineVector;
85
86	typedef std::vector <ComPtr <IInternalSessionControl> > InternalControlVector;
87
88	class CallbackEvent;
89	friend class CallbackEvent;
90
91	VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (VirtualBox)
92
93	DECLARE_CLASSFACTORY_SINGLETON(VirtualBox)
94
95	DECLARE_REGISTRY_RESOURCEID(IDR_VIRTUALBOX)
96	DECLARE_NOT_AGGREGATABLE(VirtualBox)
97
98	DECLARE_PROTECT_FINAL_CONSTRUCT()
99
100	BEGIN_COM_MAP(VirtualBox)
101	COM_INTERFACE_ENTRY(IDispatch)
102	COM_INTERFACE_ENTRY(ISupportErrorInfo)
103	COM_INTERFACE_ENTRY(IVirtualBox)
104	END_COM_MAP()
105
106	NS_DECL_ISUPPORTS
107
108	/* to postpone generation of the default ctor/dtor */
109	VirtualBox();
110	~VirtualBox();
111
112	HRESULT FinalConstruct();
113	void FinalRelease();
114
115	/* public initializer/uninitializer for internal purposes only */
116	HRESULT init();
117	void uninit();
118
119	/* IVirtualBox properties */
120	STDMETHOD(COMGETTER(Version)) (BSTR *aVersion);
121	STDMETHOD(COMGETTER(Revision)) (ULONG *aRevision);
122	STDMETHOD(COMGETTER(PackageType)) (BSTR *aPackageType);
123	STDMETHOD(COMGETTER(HomeFolder)) (BSTR *aHomeFolder);
124	STDMETHOD(COMGETTER(SettingsFilePath)) (BSTR *aSettingsFilePath);
125	STDMETHOD(COMGETTER(SettingsFileVersion)) (BSTR *aSettingsFileVersion);
126	STDMETHOD(COMGETTER(SettingsFormatVersion)) (BSTR *aSettingsFormatVersion);
127	STDMETHOD(COMGETTER(Host)) (IHost **aHost);
128	STDMETHOD(COMGETTER(SystemProperties)) (ISystemProperties **aSystemProperties);
129	STDMETHOD(COMGETTER(Machines2)) (ComSafeArrayOut (IMachine *, aMachines));
130	STDMETHOD(COMGETTER(HardDisks2)) (ComSafeArrayOut (IHardDisk2 *, aHardDisks));
131	STDMETHOD(COMGETTER(DVDImages)) (ComSafeArrayOut (IDVDImage2 *, aDVDImages));
132	STDMETHOD(COMGETTER(FloppyImages)) (ComSafeArrayOut (IFloppyImage2 *, aFloppyImages));
133	STDMETHOD(COMGETTER(ProgressOperations)) (IProgressCollection **aOperations);
134	STDMETHOD(COMGETTER(GuestOSTypes)) (IGuestOSTypeCollection **aGuestOSTypes);
135	STDMETHOD(COMGETTER(SharedFolders)) (ISharedFolderCollection **aSharedFolders);
136	STDMETHOD(COMGETTER(PerformanceCollector)) (IPerformanceCollector **aPerformanceCollector);
137
138	/* IVirtualBox methods */
139
140	STDMETHOD(CreateMachine) (IN_BSTR aName, IN_BSTR aOsTypeId, IN_BSTR aBaseFolder,
141	IN_GUID aId, IMachine **aMachine);
142	STDMETHOD(CreateLegacyMachine) (IN_BSTR aName, IN_BSTR aOsTypeId, IN_BSTR aSettingsFile,
143	IN_GUID aId, IMachine **aMachine);
144	STDMETHOD(OpenMachine) (IN_BSTR aSettingsFile, IMachine **aMachine);
145	STDMETHOD(RegisterMachine) (IMachine *aMachine);
146	STDMETHOD(GetMachine) (IN_GUID aId, IMachine **aMachine);
147	STDMETHOD(FindMachine) (IN_BSTR aName, IMachine **aMachine);
148	STDMETHOD(UnregisterMachine) (IN_GUID aId, IMachine **aMachine);
149	STDMETHOD(OpenAppliance) (IN_BSTR aName, IAppliance **anAppliance);
150
151	STDMETHOD(CreateHardDisk2) (IN_BSTR aFormat, IN_BSTR aLocation,
152	IHardDisk2 **aHardDisk);
153	STDMETHOD(OpenHardDisk2) (IN_BSTR aLocation, IHardDisk2 **aHardDisk);
154	STDMETHOD(GetHardDisk2) (IN_GUID aId, IHardDisk2 **aHardDisk);
155	STDMETHOD(FindHardDisk2) (IN_BSTR aLocation, IHardDisk2 **aHardDisk);
156
157	STDMETHOD(OpenDVDImage) (IN_BSTR aLocation, IN_GUID aId,
158	IDVDImage2 **aDVDImage);
159	STDMETHOD(GetDVDImage) (IN_GUID aId, IDVDImage2 **aDVDImage);
160	STDMETHOD(FindDVDImage) (IN_BSTR aLocation, IDVDImage2 **aDVDImage);
161
162	STDMETHOD(OpenFloppyImage) (IN_BSTR aLocation, IN_GUID aId,
163	IFloppyImage2 **aFloppyImage);
164	STDMETHOD(GetFloppyImage) (IN_GUID aId, IFloppyImage2 **aFloppyImage);
165	STDMETHOD(FindFloppyImage) (IN_BSTR aLocation, IFloppyImage2 **aFloppyImage);
166
167	STDMETHOD(GetGuestOSType) (IN_BSTR aId, IGuestOSType **aType);
168	STDMETHOD(CreateSharedFolder) (IN_BSTR aName, IN_BSTR aHostPath, BOOL aWritable);
169	STDMETHOD(RemoveSharedFolder) (IN_BSTR aName);
170	STDMETHOD(GetNextExtraDataKey) (IN_BSTR aKey, BSTR aNextKey, BSTR aNextValue);
171	STDMETHOD(GetExtraData) (IN_BSTR aKey, BSTR *aValue);
172	STDMETHOD(SetExtraData) (IN_BSTR aKey, IN_BSTR aValue);
173	STDMETHOD(OpenSession) (ISession *aSession, IN_GUID aMachineId);
174	STDMETHOD(OpenRemoteSession) (ISession *aSession, IN_GUID aMachineId,
175	IN_BSTR aType, IN_BSTR aEnvironment,
176	IProgress **aProgress);
177	STDMETHOD(OpenExistingSession) (ISession *aSession, IN_GUID aMachineId);
178
179	STDMETHOD(RegisterCallback) (IVirtualBoxCallback *aCallback);
180	STDMETHOD(UnregisterCallback) (IVirtualBoxCallback *aCallback);
181
182	STDMETHOD(WaitForPropertyChange) (IN_BSTR aWhat, ULONG aTimeout,
183	BSTR aChanged, BSTR aValues);
184
185	STDMETHOD(SaveSettings)();
186	STDMETHOD(SaveSettingsWithBackup) (BSTR *aBakFileName);
187
188	/* public methods only for internal purposes */
189
190	HRESULT postEvent (Event *event);
191
192	HRESULT addProgress (IProgress *aProgress);
193	HRESULT removeProgress (IN_GUID aId);
194
195	#ifdef RT_OS_WINDOWS
196	typedef DECLCALLBACKPTR (HRESULT, SVCHelperClientFunc)
197	(SVCHlpClient aClient, Progress aProgress, void aUser, int aVrc);
198	HRESULT startSVCHelperClient (bool aPrivileged,
199	SVCHelperClientFunc aFunc,
200	void aUser, Progress aProgress);
201	#endif
202
203	void addProcessToReap (RTPROCESS pid);
204	void updateClientWatcher();
205
206	void onMachineStateChange (const Guid &aId, MachineState_T aState);
207	void onMachineDataChange (const Guid &aId);
208	BOOL onExtraDataCanChange(const Guid &aId, IN_BSTR aKey, IN_BSTR aValue,
209	Bstr &aError);
210	void onExtraDataChange(const Guid &aId, IN_BSTR aKey, IN_BSTR aValue);
211	void onMachineRegistered (const Guid &aId, BOOL aRegistered);
212	void onSessionStateChange (const Guid &aId, SessionState_T aState);
213
214	void onSnapshotTaken (const Guid &aMachineId, const Guid &aSnapshotId);
215	void onSnapshotDiscarded (const Guid &aMachineId, const Guid &aSnapshotId);
216	void onSnapshotChange (const Guid &aMachineId, const Guid &aSnapshotId);
217	void onGuestPropertyChange (const Guid &aMachineId, IN_BSTR aName, IN_BSTR aValue,
218	IN_BSTR aFlags);
219
220	ComObjPtr <GuestOSType> getUnknownOSType();
221
222	void getOpenedMachines (SessionMachineVector &aMachines,
223	InternalControlVector *aControls = NULL);
224
225	/** Shortcut to #getOpenedMachines (aMachines, &aControls). */
226	void getOpenedMachinesAndControls (SessionMachineVector &aMachines,
227	InternalControlVector &aControls)
228	{ getOpenedMachines (aMachines, &aControls); }
229
230	bool isMachineIdValid (const Guid &aId)
231	{
232	return SUCCEEDED (findMachine (aId, false /* aSetError */, NULL));
233	}
234
235	HRESULT findMachine (const Guid &aId, bool aSetError,
236	ComObjPtr <Machine> *machine = NULL);
237
238	HRESULT findHardDisk2 (const Guid *aId, CBSTR aLocation,
239	bool aSetError, ComObjPtr <HardDisk2> *aHardDisk = NULL);
240	HRESULT findDVDImage2 (const Guid *aId, CBSTR aLocation,
241	bool aSetError, ComObjPtr <DVDImage2> *aImage = NULL);
242	HRESULT findFloppyImage2 (const Guid *aId, CBSTR aLocation,
243	bool aSetError, ComObjPtr <FloppyImage2> *aImage = NULL);
244
245	const ComObjPtr <Host> &host() { return mData.mHost; }
246	const ComObjPtr <SystemProperties> &systemProperties()
247	{ return mData.mSystemProperties; }
248	#ifdef VBOX_WITH_RESOURCE_USAGE_API
249	const ComObjPtr <PerformanceCollector> &performanceCollector()
250	{ return mData.mPerformanceCollector; }
251	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
252
253
254	/** Returns the VirtualBox home directory */
255	const Utf8Str &homeDir() { return mData.mHomeDir; }
256
257	int calculateFullPath (const char *aPath, Utf8Str &aResult);
258	void calculateRelativePath (const char *aPath, Utf8Str &aResult);
259
260	HRESULT registerHardDisk2 (HardDisk2 *aHardDisk, bool aSaveRegistry = true);
261	HRESULT unregisterHardDisk2 (HardDisk2 *aHardDisk, bool aSaveRegistry = true);
262
263	HRESULT registerDVDImage (DVDImage2 *aImage, bool aSaveRegistry = true);
264	HRESULT unregisterDVDImage (DVDImage2 *aImage, bool aSaveRegistry = true);
265
266	HRESULT registerFloppyImage (FloppyImage2 *aImage, bool aSaveRegistry = true);
267	HRESULT unregisterFloppyImage (FloppyImage2 *aImage, bool aSaveRegistry = true);
268
269	HRESULT cast (IHardDisk2 *aFrom, ComObjPtr <HardDisk2> &aTo);
270
271	HRESULT saveSettings();
272	HRESULT updateSettings (const char aOldPath, const char aNewPath);
273
274	const Bstr &settingsFileName() { return mData.mCfgFile.mName; }
275
276	static HRESULT ensureFilePathExists (const char *aFileName);
277
278	class SettingsTreeHelper : public settings::XmlTreeBackend::InputResolver
279	, public settings::XmlTreeBackend::AutoConverter
280	{
281	public:
282
283	// InputResolver interface
284	xml::Input resolveEntity (const char aURI, const char *aID);
285
286	// AutoConverter interface
287	bool needsConversion (const settings::Key &aRoot, char **aOldVersion) const;
288	const char *templateUri() const;
289	};
290
291	static HRESULT loadSettingsTree (settings::XmlTreeBackend &aTree,
292	xml::File &aFile,
293	bool aValidate,
294	bool aCatchLoadErrors,
295	bool aAddDefaults,
296	Utf8Str *aFormatVersion = NULL);
297
298	/**
299	* Shortcut to loadSettingsTree (aTree, aFile, true, true, true).
300	*
301	* Used when the settings file is to be loaded for the first time for the
302	* given object in order to recreate it from the stored settings.
303	*
304	* @param aFormatVersion Where to store the current format version of the
305	* loaded settings tree.
306	*/
307	static HRESULT loadSettingsTree_FirstTime (settings::XmlTreeBackend &aTree,
308	xml::File &aFile,
309	Utf8Str &aFormatVersion)
310	{
311	return loadSettingsTree (aTree, aFile, true, true, true,
312	&aFormatVersion);
313	}
314
315	/**
316	* Shortcut to loadSettingsTree (aTree, aFile, true, false, true).
317	*
318	* Used when the settings file is loaded again (after it has been fully
319	* checked and validated by #loadSettingsTree_FirstTime()) in order to
320	* look at settings that don't have any representation within object's
321	* data fields.
322	*/
323	static HRESULT loadSettingsTree_Again (settings::XmlTreeBackend &aTree,
324	xml::File &aFile)
325	{
326	return loadSettingsTree (aTree, aFile, true, false, true);
327	}
328
329	/**
330	* Shortcut to loadSettingsTree (aTree, aFile, true, false, false).
331	*
332	* Used when the settings file is loaded again (after it has been fully
333	* checked and validated by #loadSettingsTree_FirstTime()) in order to
334	* update some settings and then save them back.
335	*/
336	static HRESULT loadSettingsTree_ForUpdate (settings::XmlTreeBackend &aTree,
337	xml::File &aFile)
338	{
339	return loadSettingsTree (aTree, aFile, true, false, false);
340	}
341
342	static HRESULT saveSettingsTree (settings::TreeBackend &aTree,
343	xml::File &aFile,
344	Utf8Str &aFormatVersion);
345
346	static HRESULT backupSettingsFile (const Bstr &aFileName,
347	const Utf8Str &aOldFormat,
348	Bstr &aBakFileName);
349
350	static HRESULT handleUnexpectedExceptions (RT_SRC_POS_DECL);
351
352	/**
353	* Returns a lock handle used to protect changes to the hard disk hierarchy
354	* (e.g. serialize access to the HardDisk2::mParent fields and methods
355	* adding/removing children). When using this lock, the following rules must
356	* be obeyed:
357	*
358	* 1. The write lock on this handle must be either held alone on the thread
359	* or requested after the VirtualBox object lock. Mixing with other
360	* locks is prohibited.
361	*
362	* 2. The read lock on this handle may be intermixed with any other lock
363	* with the exception that it must be requested after the VirtualBox
364	* object lock.
365	*/
366	RWLockHandle *hardDiskTreeLockHandle() { return &mHardDiskTreeLockHandle; }
367
368	/* for VirtualBoxSupportErrorInfoImpl */
369	static const wchar_t *getComponentName() { return L"VirtualBox"; }
370
371	private:
372
373	typedef std::list <ComObjPtr <Machine> > MachineList;
374	typedef std::list <ComObjPtr <GuestOSType> > GuestOSTypeList;
375
376	typedef std::map <Guid, ComPtr <IProgress> > ProgressMap;
377
378	typedef std::list <ComObjPtr <HardDisk2> > HardDisk2List;
379	typedef std::list <ComObjPtr <DVDImage2> > DVDImage2List;
380	typedef std::list <ComObjPtr <FloppyImage2> > FloppyImage2List;
381	typedef std::list <ComObjPtr <SharedFolder> > SharedFolderList;
382
383	typedef std::map <Guid, ComObjPtr <HardDisk2> > HardDisk2Map;
384
385	/**
386	* Reimplements VirtualBoxWithTypedChildren::childrenLock() to return a
387	* dedicated lock instead of the main object lock. The dedicated lock for
388	* child map operations frees callers of init() methods of these children
389	* from acquiring a write parent (VirtualBox) lock (which would be mandatory
390	* otherwise). Since VirtualBox has a lot of heterogenous children which
391	* init() methods are called here and there, it definitely makes sense.
392	*/
393	RWLockHandle *childrenLock() { return &mChildrenMapLockHandle; }
394
395	HRESULT checkMediaForConflicts2 (const Guid &aId, const Bstr &aLocation,
396	Utf8Str &aConflictType);
397
398	HRESULT loadMachines (const settings::Key &aGlobal);
399	HRESULT loadMedia (const settings::Key &aGlobal);
400
401	HRESULT registerMachine (Machine *aMachine);
402
403	HRESULT lockConfig();
404	HRESULT unlockConfig();
405
406	/** @note This method is not thread safe */
407	bool isConfigLocked() { return mData.mCfgFile.mHandle != NIL_RTFILE; }
408
409	/**
410	* Main VirtualBox data structure.
411	* @note \|const\| members are persistent during lifetime so can be accessed
412	* without locking.
413	*/
414	struct Data
415	{
416	Data();
417
418	struct CfgFile
419	{
420	CfgFile() : mHandle (NIL_RTFILE) {}
421
422	const Bstr mName;
423	RTFILE mHandle;
424	};
425
426	// const data members not requiring locking
427	const Utf8Str mHomeDir;
428
429	// const objects not requiring locking
430	const ComObjPtr <Host> mHost;
431	const ComObjPtr <SystemProperties> mSystemProperties;
432	#ifdef VBOX_WITH_RESOURCE_USAGE_API
433	const ComObjPtr <PerformanceCollector> mPerformanceCollector;
434	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
435
436	CfgFile mCfgFile;
437
438	Utf8Str mSettingsFileVersion;
439
440	MachineList mMachines;
441	GuestOSTypeList mGuestOSTypes;
442
443	ProgressMap mProgressOperations;
444
445	HardDisk2List mHardDisks2;
446	DVDImage2List mDVDImages2;
447	FloppyImage2List mFloppyImages2;
448	SharedFolderList mSharedFolders;
449
450	/// @todo NEWMEDIA do we really need this map? Used only in
451	/// find() it seems
452	HardDisk2Map mHardDisk2Map;
453
454	CallbackList mCallbacks;
455	};
456
457	Data mData;
458
459	/** Client watcher thread data structure */
460	struct ClientWatcherData
461	{
462	ClientWatcherData()
463	#if defined(RT_OS_WINDOWS)
464	: mUpdateReq (NULL)
465	#elif defined(RT_OS_OS2)
466	: mUpdateReq (NIL_RTSEMEVENT)
467	#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
468	: mUpdateReq (NIL_RTSEMEVENT)
469	#else
470	# error "Port me!"
471	#endif
472	, mThread (NIL_RTTHREAD) {}
473
474	// const objects not requiring locking
475	#if defined(RT_OS_WINDOWS)
476	const HANDLE mUpdateReq;
477	#elif defined(RT_OS_OS2)
478	const RTSEMEVENT mUpdateReq;
479	#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
480	const RTSEMEVENT mUpdateReq;
481	#else
482	# error "Port me!"
483	#endif
484	const RTTHREAD mThread;
485
486	typedef std::list <RTPROCESS> ProcessList;
487	ProcessList mProcesses;
488	};
489
490	ClientWatcherData mWatcherData;
491
492	const RTTHREAD mAsyncEventThread;
493	EventQueue * const mAsyncEventQ;
494
495	/**
496	* "Safe" lock. May only be used if guaranteed that no other locks are
497	* requested while holding it and no functions that may do so are called.
498	* Currently, protects the following:
499	*
500	* - mProgressOperations
501	*/
502	RWLockHandle mSafeLock;
503
504	RWLockHandle mHardDiskTreeLockHandle;
505	RWLockHandle mChildrenMapLockHandle;
506
507	static Bstr sVersion;
508	static ULONG sRevision;
509	static Bstr sPackageType;
510	static Bstr sSettingsFormatVersion;
511
512	static DECLCALLBACK(int) ClientWatcher (RTTHREAD thread, void *pvUser);
513	static DECLCALLBACK(int) AsyncEventHandler (RTTHREAD thread, void *pvUser);
514
515	#ifdef RT_OS_WINDOWS
516	static DECLCALLBACK(int) SVCHelperClientThread (RTTHREAD aThread, void *aUser);
517	#endif
518	};
519
520	////////////////////////////////////////////////////////////////////////////////
521
522	/**
523	* Abstract callback event class to asynchronously call VirtualBox callbacks
524	* on a dedicated event thread. Subclasses reimplement #handleCallback()
525	* to call appropriate IVirtualBoxCallback methods depending on the event
526	* to be dispatched.
527	*
528	* @note The VirtualBox instance passed to the constructor is strongly
529	* referenced, so that the VirtualBox singleton won't be released until the
530	* event gets handled by the event thread.
531	*/
532	class VirtualBox::CallbackEvent : public Event
533	{
534	public:
535
536	CallbackEvent (VirtualBox *aVirtualBox) : mVirtualBox (aVirtualBox)
537	{
538	Assert (aVirtualBox);
539	}
540
541	void *handler();
542
543	virtual void handleCallback (const ComPtr <IVirtualBoxCallback> &aCallback) = 0;
544
545	private:
546
547	/*
548	* Note that this is a weak ref -- the CallbackEvent handler thread
549	* is bound to the lifetime of the VirtualBox instance, so it's safe.
550	*/
551	ComObjPtr <VirtualBox, ComWeakRef> mVirtualBox;
552	};
553
554	#endif // ____H_VIRTUALBOXIMPL
555	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/include/VirtualBoxImpl.h@ 16188

Download in other formats: