VirtualBox

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

Last change on this file since 16558 was 16558, checked in by vboxsync, 15 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use