// This file was GENERATED by command: // pump.py dispatch_win.h.pump // DO NOT EDIT BY HAND!!! // Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef REMOTING_BASE_IDISPATCH_DRIVER_WIN_H_ #define REMOTING_BASE_IDISPATCH_DRIVER_WIN_H_ #include <oaidl.h> #include "base/basictypes.h" #include "base/template_util.h" #include "base/win/scoped_variant.h" namespace remoting { namespace dispatch { namespace internal { // A helper wrapper for |VARIANTARG| that is used to pass parameters to and from // IDispatch::Invoke(). The latter accepts parameters as an array of // |VARIANTARG| structures. The calling convention of IDispatch::Invoke() is: // - [in] parameters are initialized and freed if needed by the caller. // - [out] parameters are initialized by IDispatch::Invoke(). It is up to // the caller to free leakable variants (such as VT_DISPATCH). // - [in] [out] parameters are combination of both: the caller initializes // them before the call and the callee assigns new values correctly // freeing leakable variants. // // Using |ScopedVariantArg| instead of naked |VARIANTARG| ensures that // the resources allocated during the call will be properly freed. It also // provides wrapping methods that convert between C++ types and VARIANTs. // At the moment the only supported parameter type is |VARIANT| (or // |VARIANTARG|). // // It must be possible to cast a pointer to an array of |ScopedVariantArg| to // a pointer to an array of |VARIANTARG| structures. class ScopedVariantArg : public VARIANTARG { public: ScopedVariantArg() { vt = VT_EMPTY; } ~ScopedVariantArg() { VariantClear(this); } // Wrap() routines pack the input parameters into VARIANTARG structures so // that they can be passed to IDispatch::Invoke. HRESULT Wrap(const VARIANT& param) { DCHECK(vt == VT_EMPTY); return VariantCopy(this, ¶m); } HRESULT Wrap(VARIANT* const & param) { DCHECK(vt == VT_EMPTY); // Make the input value of an [in] [out] parameter visible to // IDispatch::Invoke(). // // N.B. We treat both [out] and [in] [out] parameters as [in] [out]. In // other words the caller is always responsible for initializing and freeing // [out] and [in] [out] parameters. Swap(param); return S_OK; } // Unwrap() routines unpack the output parameters from VARIANTARG structures // to the locations specified by the caller. void Unwrap(const VARIANT& param_out) { // Do nothing for an [in] parameter. } void Unwrap(VARIANT* const & param_out) { // Return the output value of an [in] [out] parameter to the caller. Swap(param_out); } private: // Exchanges the value (and ownership) of the passed VARIANT with the one // wrapped by |ScopedVariantArg|. void Swap(VARIANT* other) { VARIANT temp = *other; *other = *this; *static_cast<VARIANTARG*>(this) = temp; } DISALLOW_COPY_AND_ASSIGN(ScopedVariantArg); }; // Make sure the layouts of |VARIANTARG| and |ScopedVariantArg| are identical. COMPILE_ASSERT(sizeof(ScopedVariantArg) == sizeof(VARIANTARG), scoped_variant_arg_should_not_add_data_members); } // namespace internal // Invoke() is a convenience wrapper for IDispatch::Invoke. It takes care of // calling the desired method by its ID and implements logic for passing // a variable number of in/out parameters to the called method. // // The calling convention is: // - [in] parameters are passsed as a constant reference or by value. // - [out] and [in] [out] parameters are passed by pointer. The pointed value // is overwritten when the function returns. The pointed-to value must // be initialized before the call, and will be replaced when it returns. // [out] parameters may be initialized to VT_EMPTY. // // Current limitations: // - more than 7 parameters are not supported. // - the method ID cannot be cached and reused. // - VARIANT is the only supported parameter type at the moment. HRESULT Invoke(IDispatch* object, LPOLESTR name, WORD flags, VARIANT* const & result_out) { // Retrieve the ID of the method to be called. DISPID disp_id; HRESULT hr = object->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &disp_id); if (FAILED(hr)) return hr; // Request the return value if asked by the caller. internal::ScopedVariantArg result; VARIANT* disp_result = NULL; if (result_out != NULL) disp_result = &result; // Invoke the method passing the parameters via the DISPPARAMS structure. // DISPATCH_PROPERTYPUT and DISPATCH_PROPERTYPUTREF require the parameter of // the property setter to be named, so |cNamedArgs| and |rgdispidNamedArgs| // structure members should be initialized. DISPPARAMS disp_params = { NULL, NULL, 0, 0 }; DISPID dispid_named = DISPID_PROPERTYPUT; if (flags == DISPATCH_PROPERTYPUT || flags == DISPATCH_PROPERTYPUTREF) { disp_params.cNamedArgs = 1; disp_params.rgdispidNamedArgs = &dispid_named; } hr = object->Invoke(disp_id, IID_NULL, LOCALE_USER_DEFAULT, flags, &disp_params, disp_result, NULL, NULL); if (FAILED(hr)) return hr; // Unwrap the return value. if (result_out != NULL) { result.Unwrap(result_out); } return S_OK; } template <typename P1> HRESULT Invoke(IDispatch* object, LPOLESTR name, WORD flags, const P1& p1, VARIANT* const & result_out) { // Retrieve the ID of the method to be called. DISPID disp_id; HRESULT hr = object->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &disp_id); if (FAILED(hr)) return hr; // Request the return value if asked by the caller. internal::ScopedVariantArg result; VARIANT* disp_result = NULL; if (result_out != NULL) disp_result = &result; // Wrap the parameters into an array of VARIANT structures. internal::ScopedVariantArg disp_args[1]; hr = disp_args[1 - 1].Wrap(p1); if (FAILED(hr)) return hr; // Invoke the method passing the parameters via the DISPPARAMS structure. // DISPATCH_PROPERTYPUT and DISPATCH_PROPERTYPUTREF require the parameter of // the property setter to be named, so |cNamedArgs| and |rgdispidNamedArgs| // structure members should be initialized. DISPPARAMS disp_params = { disp_args, NULL, 1, 0 }; DISPID dispid_named = DISPID_PROPERTYPUT; if (flags == DISPATCH_PROPERTYPUT || flags == DISPATCH_PROPERTYPUTREF) { disp_params.cNamedArgs = 1; disp_params.rgdispidNamedArgs = &dispid_named; } hr = object->Invoke(disp_id, IID_NULL, LOCALE_USER_DEFAULT, flags, &disp_params, disp_result, NULL, NULL); if (FAILED(hr)) return hr; // Unwrap the parameters. disp_args[1 - 1].Unwrap(p1); // Unwrap the return value. if (result_out != NULL) { result.Unwrap(result_out); } return S_OK; } template <typename P1, typename P2> HRESULT Invoke(IDispatch* object, LPOLESTR name, WORD flags, const P1& p1, const P2& p2, VARIANT* const & result_out) { // Retrieve the ID of the method to be called. DISPID disp_id; HRESULT hr = object->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &disp_id); if (FAILED(hr)) return hr; // Request the return value if asked by the caller. internal::ScopedVariantArg result; VARIANT* disp_result = NULL; if (result_out != NULL) disp_result = &result; // Wrap the parameters into an array of VARIANT structures. internal::ScopedVariantArg disp_args[2]; hr = disp_args[2 - 1].Wrap(p1); if (FAILED(hr)) return hr; hr = disp_args[2 - 2].Wrap(p2); if (FAILED(hr)) return hr; // Invoke the method passing the parameters via the DISPPARAMS structure. // DISPATCH_PROPERTYPUT and DISPATCH_PROPERTYPUTREF require the parameter of // the property setter to be named, so |cNamedArgs| and |rgdispidNamedArgs| // structure members should be initialized. DISPPARAMS disp_params = { disp_args, NULL, 2, 0 }; DISPID dispid_named = DISPID_PROPERTYPUT; if (flags == DISPATCH_PROPERTYPUT || flags == DISPATCH_PROPERTYPUTREF) { disp_params.cNamedArgs = 1; disp_params.rgdispidNamedArgs = &dispid_named; } hr = object->Invoke(disp_id, IID_NULL, LOCALE_USER_DEFAULT, flags, &disp_params, disp_result, NULL, NULL); if (FAILED(hr)) return hr; // Unwrap the parameters. disp_args[2 - 1].Unwrap(p1); disp_args[2 - 2].Unwrap(p2); // Unwrap the return value. if (result_out != NULL) { result.Unwrap(result_out); } return S_OK; } template <typename P1, typename P2, typename P3> HRESULT Invoke(IDispatch* object, LPOLESTR name, WORD flags, const P1& p1, const P2& p2, const P3& p3, VARIANT* const & result_out) { // Retrieve the ID of the method to be called. DISPID disp_id; HRESULT hr = object->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &disp_id); if (FAILED(hr)) return hr; // Request the return value if asked by the caller. internal::ScopedVariantArg result; VARIANT* disp_result = NULL; if (result_out != NULL) disp_result = &result; // Wrap the parameters into an array of VARIANT structures. internal::ScopedVariantArg disp_args[3]; hr = disp_args[3 - 1].Wrap(p1); if (FAILED(hr)) return hr; hr = disp_args[3 - 2].Wrap(p2); if (FAILED(hr)) return hr; hr = disp_args[3 - 3].Wrap(p3); if (FAILED(hr)) return hr; // Invoke the method passing the parameters via the DISPPARAMS structure. // DISPATCH_PROPERTYPUT and DISPATCH_PROPERTYPUTREF require the parameter of // the property setter to be named, so |cNamedArgs| and |rgdispidNamedArgs| // structure members should be initialized. DISPPARAMS disp_params = { disp_args, NULL, 3, 0 }; DISPID dispid_named = DISPID_PROPERTYPUT; if (flags == DISPATCH_PROPERTYPUT || flags == DISPATCH_PROPERTYPUTREF) { disp_params.cNamedArgs = 1; disp_params.rgdispidNamedArgs = &dispid_named; } hr = object->Invoke(disp_id, IID_NULL, LOCALE_USER_DEFAULT, flags, &disp_params, disp_result, NULL, NULL); if (FAILED(hr)) return hr; // Unwrap the parameters. disp_args[3 - 1].Unwrap(p1); disp_args[3 - 2].Unwrap(p2); disp_args[3 - 3].Unwrap(p3); // Unwrap the return value. if (result_out != NULL) { result.Unwrap(result_out); } return S_OK; } template <typename P1, typename P2, typename P3, typename P4> HRESULT Invoke(IDispatch* object, LPOLESTR name, WORD flags, const P1& p1, const P2& p2, const P3& p3, const P4& p4, VARIANT* const & result_out) { // Retrieve the ID of the method to be called. DISPID disp_id; HRESULT hr = object->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &disp_id); if (FAILED(hr)) return hr; // Request the return value if asked by the caller. internal::ScopedVariantArg result; VARIANT* disp_result = NULL; if (result_out != NULL) disp_result = &result; // Wrap the parameters into an array of VARIANT structures. internal::ScopedVariantArg disp_args[4]; hr = disp_args[4 - 1].Wrap(p1); if (FAILED(hr)) return hr; hr = disp_args[4 - 2].Wrap(p2); if (FAILED(hr)) return hr; hr = disp_args[4 - 3].Wrap(p3); if (FAILED(hr)) return hr; hr = disp_args[4 - 4].Wrap(p4); if (FAILED(hr)) return hr; // Invoke the method passing the parameters via the DISPPARAMS structure. // DISPATCH_PROPERTYPUT and DISPATCH_PROPERTYPUTREF require the parameter of // the property setter to be named, so |cNamedArgs| and |rgdispidNamedArgs| // structure members should be initialized. DISPPARAMS disp_params = { disp_args, NULL, 4, 0 }; DISPID dispid_named = DISPID_PROPERTYPUT; if (flags == DISPATCH_PROPERTYPUT || flags == DISPATCH_PROPERTYPUTREF) { disp_params.cNamedArgs = 1; disp_params.rgdispidNamedArgs = &dispid_named; } hr = object->Invoke(disp_id, IID_NULL, LOCALE_USER_DEFAULT, flags, &disp_params, disp_result, NULL, NULL); if (FAILED(hr)) return hr; // Unwrap the parameters. disp_args[4 - 1].Unwrap(p1); disp_args[4 - 2].Unwrap(p2); disp_args[4 - 3].Unwrap(p3); disp_args[4 - 4].Unwrap(p4); // Unwrap the return value. if (result_out != NULL) { result.Unwrap(result_out); } return S_OK; } template <typename P1, typename P2, typename P3, typename P4, typename P5> HRESULT Invoke(IDispatch* object, LPOLESTR name, WORD flags, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, VARIANT* const & result_out) { // Retrieve the ID of the method to be called. DISPID disp_id; HRESULT hr = object->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &disp_id); if (FAILED(hr)) return hr; // Request the return value if asked by the caller. internal::ScopedVariantArg result; VARIANT* disp_result = NULL; if (result_out != NULL) disp_result = &result; // Wrap the parameters into an array of VARIANT structures. internal::ScopedVariantArg disp_args[5]; hr = disp_args[5 - 1].Wrap(p1); if (FAILED(hr)) return hr; hr = disp_args[5 - 2].Wrap(p2); if (FAILED(hr)) return hr; hr = disp_args[5 - 3].Wrap(p3); if (FAILED(hr)) return hr; hr = disp_args[5 - 4].Wrap(p4); if (FAILED(hr)) return hr; hr = disp_args[5 - 5].Wrap(p5); if (FAILED(hr)) return hr; // Invoke the method passing the parameters via the DISPPARAMS structure. // DISPATCH_PROPERTYPUT and DISPATCH_PROPERTYPUTREF require the parameter of // the property setter to be named, so |cNamedArgs| and |rgdispidNamedArgs| // structure members should be initialized. DISPPARAMS disp_params = { disp_args, NULL, 5, 0 }; DISPID dispid_named = DISPID_PROPERTYPUT; if (flags == DISPATCH_PROPERTYPUT || flags == DISPATCH_PROPERTYPUTREF) { disp_params.cNamedArgs = 1; disp_params.rgdispidNamedArgs = &dispid_named; } hr = object->Invoke(disp_id, IID_NULL, LOCALE_USER_DEFAULT, flags, &disp_params, disp_result, NULL, NULL); if (FAILED(hr)) return hr; // Unwrap the parameters. disp_args[5 - 1].Unwrap(p1); disp_args[5 - 2].Unwrap(p2); disp_args[5 - 3].Unwrap(p3); disp_args[5 - 4].Unwrap(p4); disp_args[5 - 5].Unwrap(p5); // Unwrap the return value. if (result_out != NULL) { result.Unwrap(result_out); } return S_OK; } template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6> HRESULT Invoke(IDispatch* object, LPOLESTR name, WORD flags, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6, VARIANT* const & result_out) { // Retrieve the ID of the method to be called. DISPID disp_id; HRESULT hr = object->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &disp_id); if (FAILED(hr)) return hr; // Request the return value if asked by the caller. internal::ScopedVariantArg result; VARIANT* disp_result = NULL; if (result_out != NULL) disp_result = &result; // Wrap the parameters into an array of VARIANT structures. internal::ScopedVariantArg disp_args[6]; hr = disp_args[6 - 1].Wrap(p1); if (FAILED(hr)) return hr; hr = disp_args[6 - 2].Wrap(p2); if (FAILED(hr)) return hr; hr = disp_args[6 - 3].Wrap(p3); if (FAILED(hr)) return hr; hr = disp_args[6 - 4].Wrap(p4); if (FAILED(hr)) return hr; hr = disp_args[6 - 5].Wrap(p5); if (FAILED(hr)) return hr; hr = disp_args[6 - 6].Wrap(p6); if (FAILED(hr)) return hr; // Invoke the method passing the parameters via the DISPPARAMS structure. // DISPATCH_PROPERTYPUT and DISPATCH_PROPERTYPUTREF require the parameter of // the property setter to be named, so |cNamedArgs| and |rgdispidNamedArgs| // structure members should be initialized. DISPPARAMS disp_params = { disp_args, NULL, 6, 0 }; DISPID dispid_named = DISPID_PROPERTYPUT; if (flags == DISPATCH_PROPERTYPUT || flags == DISPATCH_PROPERTYPUTREF) { disp_params.cNamedArgs = 1; disp_params.rgdispidNamedArgs = &dispid_named; } hr = object->Invoke(disp_id, IID_NULL, LOCALE_USER_DEFAULT, flags, &disp_params, disp_result, NULL, NULL); if (FAILED(hr)) return hr; // Unwrap the parameters. disp_args[6 - 1].Unwrap(p1); disp_args[6 - 2].Unwrap(p2); disp_args[6 - 3].Unwrap(p3); disp_args[6 - 4].Unwrap(p4); disp_args[6 - 5].Unwrap(p5); disp_args[6 - 6].Unwrap(p6); // Unwrap the return value. if (result_out != NULL) { result.Unwrap(result_out); } return S_OK; } template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7> HRESULT Invoke(IDispatch* object, LPOLESTR name, WORD flags, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6, const P7& p7, VARIANT* const & result_out) { // Retrieve the ID of the method to be called. DISPID disp_id; HRESULT hr = object->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &disp_id); if (FAILED(hr)) return hr; // Request the return value if asked by the caller. internal::ScopedVariantArg result; VARIANT* disp_result = NULL; if (result_out != NULL) disp_result = &result; // Wrap the parameters into an array of VARIANT structures. internal::ScopedVariantArg disp_args[7]; hr = disp_args[7 - 1].Wrap(p1); if (FAILED(hr)) return hr; hr = disp_args[7 - 2].Wrap(p2); if (FAILED(hr)) return hr; hr = disp_args[7 - 3].Wrap(p3); if (FAILED(hr)) return hr; hr = disp_args[7 - 4].Wrap(p4); if (FAILED(hr)) return hr; hr = disp_args[7 - 5].Wrap(p5); if (FAILED(hr)) return hr; hr = disp_args[7 - 6].Wrap(p6); if (FAILED(hr)) return hr; hr = disp_args[7 - 7].Wrap(p7); if (FAILED(hr)) return hr; // Invoke the method passing the parameters via the DISPPARAMS structure. // DISPATCH_PROPERTYPUT and DISPATCH_PROPERTYPUTREF require the parameter of // the property setter to be named, so |cNamedArgs| and |rgdispidNamedArgs| // structure members should be initialized. DISPPARAMS disp_params = { disp_args, NULL, 7, 0 }; DISPID dispid_named = DISPID_PROPERTYPUT; if (flags == DISPATCH_PROPERTYPUT || flags == DISPATCH_PROPERTYPUTREF) { disp_params.cNamedArgs = 1; disp_params.rgdispidNamedArgs = &dispid_named; } hr = object->Invoke(disp_id, IID_NULL, LOCALE_USER_DEFAULT, flags, &disp_params, disp_result, NULL, NULL); if (FAILED(hr)) return hr; // Unwrap the parameters. disp_args[7 - 1].Unwrap(p1); disp_args[7 - 2].Unwrap(p2); disp_args[7 - 3].Unwrap(p3); disp_args[7 - 4].Unwrap(p4); disp_args[7 - 5].Unwrap(p5); disp_args[7 - 6].Unwrap(p6); disp_args[7 - 7].Unwrap(p7); // Unwrap the return value. if (result_out != NULL) { result.Unwrap(result_out); } return S_OK; } } // namespace dispatch } // namespace remoting #endif // REMOTING_BASE_IDISPATCH_DRIVER_WIN_H_