dlls/windows.media.speech/async.c

   1 /* WinRT Windows.Media.Speech implementation
   2  *
   3  * Copyright 2022 Bernhard Kölbl for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "private.h"
  21
  22 #include "wine/debug.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(speech);
  25
  26 #define Closed 4
  27 #define HANDLER_NOT_SET ((void *)~(ULONG_PTR)0)
  28
  29 /*
  30  *
  31  * IAsyncAction
  32  *
  33  */
  34
  35 struct async_void
  36 {
  37     IAsyncAction IAsyncAction_iface;
  38     IAsyncInfo IAsyncInfo_iface;
  39     LONG ref;
  40
  41     IAsyncActionCompletedHandler *handler;
  42
  43     async_action_callback callback;
  44     TP_WORK *async_run_work;
  45     IInspectable *invoker;
  46
  47     CRITICAL_SECTION cs;
  48     AsyncStatus status;
  49     HRESULT hr;
  50 };
  51
  52 static inline struct async_void *impl_from_IAsyncAction( IAsyncAction *iface )
  53 {
  54     return CONTAINING_RECORD(iface, struct async_void, IAsyncAction_iface);
  55 }
  56
  57 HRESULT WINAPI async_void_QueryInterface( IAsyncAction *iface, REFIID iid, void **out )
  58 {
  59     struct async_void *impl = impl_from_IAsyncAction(iface);
  60
  61     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  62
  63     if (IsEqualGUID(iid, &IID_IUnknown) ||
  64         IsEqualGUID(iid, &IID_IInspectable) ||
  65         IsEqualGUID(iid, &IID_IAgileObject) ||
  66         IsEqualGUID(iid, &IID_IAsyncAction))
  67     {
  68         IInspectable_AddRef((*out = &impl->IAsyncAction_iface));
  69         return S_OK;
  70     }
  71
  72     if (IsEqualGUID(iid, &IID_IAsyncInfo))
  73     {
  74         IInspectable_AddRef((*out = &impl->IAsyncInfo_iface));
  75         return S_OK;
  76     }
  77
  78     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  79     *out = NULL;
  80     return E_NOINTERFACE;
  81 }
  82
  83 ULONG WINAPI async_void_AddRef( IAsyncAction *iface )
  84 {
  85     struct async_void *impl = impl_from_IAsyncAction(iface);
  86     ULONG ref = InterlockedIncrement(&impl->ref);
  87     TRACE("iface %p, ref %lu.\n", iface, ref);
  88     return ref;
  89 }
  90
  91 ULONG WINAPI async_void_Release( IAsyncAction *iface )
  92 {
  93     struct async_void *impl = impl_from_IAsyncAction(iface);
  94     ULONG ref = InterlockedDecrement(&impl->ref);
  95     TRACE("iface %p, ref %lu.\n", iface, ref);
  96
  97     if (!ref)
  98     {
  99         IAsyncInfo_Close(&impl->IAsyncInfo_iface);
 100
 101         if (impl->invoker)
 102             IInspectable_Release(impl->invoker);
 103         if (impl->handler && impl->handler != HANDLER_NOT_SET)
 104             IAsyncActionCompletedHandler_Release(impl->handler);
 105
 106         impl->cs.DebugInfo->Spare[0] = 0;
 107         DeleteCriticalSection(&impl->cs);
 108         free(impl);
 109     }
 110
 111     return ref;
 112 }
 113
 114 HRESULT WINAPI async_void_GetIids( IAsyncAction *iface, ULONG *iid_count, IID **iids )
 115 {
 116     FIXME("iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids);
 117     return E_NOTIMPL;
 118 }
 119
 120 HRESULT WINAPI async_void_GetRuntimeClassName( IAsyncAction *iface, HSTRING *class_name )
 121 {
 122     FIXME("iface %p, class_name %p stub!\n", iface, class_name);
 123     return E_NOTIMPL;
 124 }
 125
 126 HRESULT WINAPI async_void_GetTrustLevel( IAsyncAction *iface, TrustLevel *trust_level )
 127 {
 128     FIXME("iface %p, trust_level %p stub!\n", iface, trust_level);
 129     return E_NOTIMPL;
 130 }
 131
 132 HRESULT WINAPI async_void_put_Completed( IAsyncAction *iface, IAsyncActionCompletedHandler *handler )
 133 {
 134     struct async_void *impl = impl_from_IAsyncAction(iface);
 135     HRESULT hr = S_OK;
 136
 137     TRACE("iface %p, handler %p.\n", iface, handler);
 138
 139     EnterCriticalSection(&impl->cs);
 140     if (impl->status == Closed)
 141         hr = E_ILLEGAL_METHOD_CALL;
 142     else if (impl->handler != HANDLER_NOT_SET)
 143         hr = E_ILLEGAL_DELEGATE_ASSIGNMENT;
 144     /*
 145         impl->handler can only be set once with async_void_put_Completed,
 146         so by default we set a non HANDLER_NOT_SET value, in this case handler.
 147     */
 148     else if ((impl->handler = handler))
 149     {
 150         IAsyncActionCompletedHandler_AddRef(impl->handler);
 151
 152         if (impl->status > Started)
 153         {
 154             IAsyncAction *action = &impl->IAsyncAction_iface;
 155             AsyncStatus status = impl->status;
 156             impl->handler = NULL; /* Prevent concurrent invoke. */
 157             LeaveCriticalSection(&impl->cs);
 158
 159             IAsyncActionCompletedHandler_Invoke(handler, action, status);
 160             IAsyncActionCompletedHandler_Release(handler);
 161
 162             return S_OK;
 163         }
 164     }
 165     LeaveCriticalSection(&impl->cs);
 166
 167     return hr;
 168 }
 169
 170 HRESULT WINAPI async_void_get_Completed( IAsyncAction *iface, IAsyncActionCompletedHandler **handler )
 171 {
 172     struct async_void *impl = impl_from_IAsyncAction(iface);
 173     HRESULT hr = S_OK;
 174
 175     FIXME("iface %p, handler %p semi stub!\n", iface, handler);
 176
 177     EnterCriticalSection(&impl->cs);
 178     if (impl->status == Closed)
 179         hr = E_ILLEGAL_METHOD_CALL;
 180     *handler = (impl->handler != HANDLER_NOT_SET) ? impl->handler : NULL;
 181     LeaveCriticalSection(&impl->cs);
 182
 183     return hr;
 184 }
 185
 186 HRESULT WINAPI async_void_GetResults( IAsyncAction *iface )
 187 {
 188     /* According to the docs, this function doesn't return anything, so it's left empty. */
 189     TRACE("iface %p.\n", iface);
 190     return S_OK;
 191 }
 192
 193 static const struct IAsyncActionVtbl async_void_vtbl =
 194 {
 195     /* IUnknown methods */
 196     async_void_QueryInterface,
 197     async_void_AddRef,
 198     async_void_Release,
 199     /* IInspectable methods */
 200     async_void_GetIids,
 201     async_void_GetRuntimeClassName,
 202     async_void_GetTrustLevel,
 203     /* IAsyncAction methods */
 204     async_void_put_Completed,
 205     async_void_get_Completed,
 206     async_void_GetResults
 207 };
 208
 209 /*
 210  *
 211  * IAsyncInfo for IAsyncAction
 212  *
 213  */
 214
 215 DEFINE_IINSPECTABLE_(async_void_info, IAsyncInfo, struct async_void, impl_from_async_void_IAsyncInfo, IAsyncInfo_iface, &impl->IAsyncAction_iface)
 216
 217 static HRESULT WINAPI async_void_info_get_Id( IAsyncInfo *iface, UINT32 *id )
 218 {
 219     FIXME("iface %p, id %p stub!\n", iface, id);
 220     return E_NOTIMPL;
 221 }
 222
 223 static HRESULT WINAPI async_void_info_get_Status( IAsyncInfo *iface, AsyncStatus *status )
 224 {
 225     struct async_void *impl = impl_from_async_void_IAsyncInfo(iface);
 226     HRESULT hr = S_OK;
 227
 228     TRACE("iface %p, status %p.\n", iface, status);
 229
 230     EnterCriticalSection(&impl->cs);
 231     if (impl->status == Closed)
 232         hr = E_ILLEGAL_METHOD_CALL;
 233     *status = impl->status;
 234     LeaveCriticalSection(&impl->cs);
 235
 236     return hr;
 237 }
 238
 239 static HRESULT WINAPI async_void_info_get_ErrorCode( IAsyncInfo *iface, HRESULT *error_code )
 240 {
 241     struct async_void *impl = impl_from_async_void_IAsyncInfo(iface);
 242     HRESULT hr = S_OK;
 243
 244     TRACE("iface %p, error_code %p.\n", iface, error_code);
 245
 246     EnterCriticalSection(&impl->cs);
 247     if (impl->status == Closed)
 248         *error_code = hr = E_ILLEGAL_METHOD_CALL;
 249     else
 250         *error_code = impl->hr;
 251     LeaveCriticalSection(&impl->cs);
 252
 253     return hr;
 254 }
 255
 256 static HRESULT WINAPI async_void_info_Cancel( IAsyncInfo *iface )
 257 {
 258     struct async_void *impl = impl_from_async_void_IAsyncInfo(iface);
 259     HRESULT hr = S_OK;
 260
 261     TRACE("iface %p.\n", iface);
 262
 263     EnterCriticalSection(&impl->cs);
 264     if (impl->status == Closed)
 265         hr = E_ILLEGAL_METHOD_CALL;
 266     else if (impl->status == Started)
 267         impl->status = Canceled;
 268     LeaveCriticalSection(&impl->cs);
 269
 270     return hr;
 271 }
 272
 273 static HRESULT WINAPI async_void_info_Close( IAsyncInfo *iface )
 274 {
 275     struct async_void *impl = impl_from_async_void_IAsyncInfo(iface);
 276     HRESULT hr = S_OK;
 277
 278     TRACE("iface %p.\n", iface);
 279
 280     EnterCriticalSection(&impl->cs);
 281     if (impl->status == Started)
 282         hr = E_ILLEGAL_STATE_CHANGE;
 283     else if (impl->status != Closed)
 284     {
 285         CloseThreadpoolWork(impl->async_run_work);
 286         impl->async_run_work = NULL;
 287         impl->status = Closed;
 288     }
 289     LeaveCriticalSection(&impl->cs);
 290
 291     return hr;
 292 }
 293
 294 static const struct IAsyncInfoVtbl async_void_info_vtbl =
 295 {
 296     /* IUnknown methods */
 297     async_void_info_QueryInterface,
 298     async_void_info_AddRef,
 299     async_void_info_Release,
 300     /* IInspectable methods */
 301     async_void_info_GetIids,
 302     async_void_info_GetRuntimeClassName,
 303     async_void_info_GetTrustLevel,
 304     /* IAsyncInfo */
 305     async_void_info_get_Id,
 306     async_void_info_get_Status,
 307     async_void_info_get_ErrorCode,
 308     async_void_info_Cancel,
 309     async_void_info_Close
 310 };
 311
 312 static void CALLBACK async_void_run_cb(TP_CALLBACK_INSTANCE *instance, void *data, TP_WORK *work)
 313 {
 314     IAsyncAction *action = data;
 315     struct async_void *impl = impl_from_IAsyncAction(action);
 316     HRESULT hr;
 317
 318     hr = impl->callback(impl->invoker);
 319
 320     EnterCriticalSection(&impl->cs);
 321     if (impl->status < Closed)
 322         impl->status = FAILED(hr) ? Error : Completed;
 323
 324     impl->hr = hr;
 325
 326     if (impl->handler != NULL && impl->handler != HANDLER_NOT_SET)
 327     {
 328         IAsyncActionCompletedHandler*handler = impl->handler;
 329         AsyncStatus status = impl->status;
 330         impl->handler = NULL; /* Prevent concurrent invoke. */
 331         LeaveCriticalSection(&impl->cs);
 332
 333         IAsyncActionCompletedHandler_Invoke(handler, action, status);
 334         IAsyncActionCompletedHandler_Release(handler);
 335     }
 336     else LeaveCriticalSection(&impl->cs);
 337
 338     IAsyncAction_Release(action);
 339 }
 340
 341 HRESULT async_action_create( IInspectable *invoker, async_action_callback callback, IAsyncAction **out )
 342 {
 343     struct async_void *impl;
 344
 345     TRACE("invoker %p, callback %p, out %p.\n", invoker, callback, out);
 346
 347     if (!(impl = calloc(1, sizeof(*impl))))
 348     {
 349         *out = NULL;
 350         return E_OUTOFMEMORY;
 351     }
 352
 353     impl->IAsyncAction_iface.lpVtbl = &async_void_vtbl;
 354     impl->IAsyncInfo_iface.lpVtbl = &async_void_info_vtbl;
 355     impl->ref = 1;
 356
 357     impl->handler = HANDLER_NOT_SET;
 358     impl->callback = callback;
 359     impl->status = Started;
 360
 361     if (!(impl->async_run_work = CreateThreadpoolWork(async_void_run_cb, &impl->IAsyncAction_iface, NULL)))
 362     {
 363         free(impl);
 364         return HRESULT_FROM_WIN32(GetLastError());
 365     }
 366
 367     if (invoker) IInspectable_AddRef((impl->invoker = invoker));
 368
 369     InitializeCriticalSectionEx(&impl->cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
 370     impl->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": async_action.cs");
 371
 372     /* AddRef to keep the obj alive in the callback. */
 373     IAsyncAction_AddRef(&impl->IAsyncAction_iface);
 374     SubmitThreadpoolWork(impl->async_run_work);
 375
 376     *out = &impl->IAsyncAction_iface;
 377     TRACE("created %p\n", *out);
 378     return S_OK;
 379 }
 380
 381 /*
 382  *
 383  * IAsyncOperation<IInspectable*>
 384  *
 385  */
 386
 387 struct async_inspectable
 388 {
 389     IAsyncOperation_IInspectable IAsyncOperation_IInspectable_iface;
 390     IAsyncInfo IAsyncInfo_iface;
 391     const GUID *iid;
 392     LONG ref;
 393
 394     IAsyncOperationCompletedHandler_IInspectable *handler;
 395     IInspectable *result;
 396
 397     async_operation_inspectable_callback callback;
 398     TP_WORK *async_run_work;
 399     IInspectable *invoker;
 400
 401     CRITICAL_SECTION cs;
 402     AsyncStatus status;
 403     HRESULT hr;
 404 };
 405
 406 static inline struct async_inspectable *impl_from_IAsyncOperation_IInspectable(IAsyncOperation_IInspectable *iface)
 407 {
 408     return CONTAINING_RECORD(iface, struct async_inspectable, IAsyncOperation_IInspectable_iface);
 409 }
 410
 411 static HRESULT WINAPI async_inspectable_QueryInterface( IAsyncOperation_IInspectable *iface, REFIID iid, void **out )
 412 {
 413     struct async_inspectable *impl = impl_from_IAsyncOperation_IInspectable(iface);
 414
 415     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 416
 417     if (IsEqualGUID(iid, &IID_IUnknown) ||
 418         IsEqualGUID(iid, &IID_IInspectable) ||
 419         IsEqualGUID(iid, &IID_IAgileObject) ||
 420         IsEqualGUID(iid, impl->iid))
 421     {
 422         IInspectable_AddRef((*out = &impl->IAsyncOperation_IInspectable_iface));
 423         return S_OK;
 424     }
 425
 426     if (IsEqualGUID(iid, &IID_IAsyncInfo))
 427     {
 428         IInspectable_AddRef((*out = &impl->IAsyncInfo_iface));
 429         return S_OK;
 430     }
 431
 432     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 433     *out = NULL;
 434     return E_NOINTERFACE;
 435 }
 436
 437 static ULONG WINAPI async_inspectable_AddRef( IAsyncOperation_IInspectable *iface )
 438 {
 439     struct async_inspectable *impl = impl_from_IAsyncOperation_IInspectable(iface);
 440     ULONG ref = InterlockedIncrement(&impl->ref);
 441     TRACE("iface %p, ref %lu.\n", iface, ref);
 442     return ref;
 443 }
 444
 445 static ULONG WINAPI async_inspectable_Release( IAsyncOperation_IInspectable *iface )
 446 {
 447     struct async_inspectable *impl = impl_from_IAsyncOperation_IInspectable(iface);
 448
 449     ULONG ref = InterlockedDecrement(&impl->ref);
 450     TRACE("iface %p, ref %lu.\n", iface, ref);
 451
 452     if (!ref)
 453     {
 454         IAsyncInfo_Close(&impl->IAsyncInfo_iface);
 455
 456         if (impl->invoker)
 457             IInspectable_Release(impl->invoker);
 458         if (impl->handler && impl->handler != HANDLER_NOT_SET)
 459             IAsyncOperationCompletedHandler_IInspectable_Release(impl->handler);
 460         if (impl->result)
 461             IInspectable_Release(impl->result);
 462
 463         impl->cs.DebugInfo->Spare[0] = 0;
 464         DeleteCriticalSection(&impl->cs);
 465         free(impl);
 466     }
 467
 468     return ref;
 469 }
 470
 471 static HRESULT WINAPI async_inspectable_GetIids( IAsyncOperation_IInspectable *iface, ULONG *iid_count, IID **iids )
 472 {
 473     FIXME("iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids);
 474     return E_NOTIMPL;
 475 }
 476
 477 static HRESULT WINAPI async_inspectable_GetRuntimeClassName( IAsyncOperation_IInspectable *iface, HSTRING *class_name )
 478 {
 479     FIXME("iface %p, class_name %p stub!\n", iface, class_name);
 480     return E_NOTIMPL;
 481 }
 482
 483 static HRESULT WINAPI async_inspectable_GetTrustLevel( IAsyncOperation_IInspectable *iface, TrustLevel *trust_level )
 484 {
 485     FIXME("iface %p, trust_level %p stub!\n", iface, trust_level);
 486     return E_NOTIMPL;
 487 }
 488
 489 static HRESULT WINAPI async_inspectable_put_Completed( IAsyncOperation_IInspectable *iface,
 490                                                        IAsyncOperationCompletedHandler_IInspectable *handler )
 491 {
 492     struct async_inspectable *impl = impl_from_IAsyncOperation_IInspectable(iface);
 493     HRESULT hr = S_OK;
 494
 495     TRACE("iface %p, handler %p.\n", iface, handler);
 496
 497     EnterCriticalSection(&impl->cs);
 498     if (impl->status == Closed)
 499         hr = E_ILLEGAL_METHOD_CALL;
 500     else if (impl->handler != HANDLER_NOT_SET)
 501         hr = E_ILLEGAL_DELEGATE_ASSIGNMENT;
 502     /*
 503         impl->handler can only be set once with async_inspectable_put_Completed,
 504         so by default we set a non HANDLER_NOT_SET value, in this case handler.
 505     */
 506     else if ((impl->handler = handler))
 507     {
 508         IAsyncOperationCompletedHandler_IInspectable_AddRef(impl->handler);
 509
 510         if (impl->status > Started)
 511         {
 512             IAsyncOperation_IInspectable *operation = &impl->IAsyncOperation_IInspectable_iface;
 513             AsyncStatus status = impl->status;
 514             impl->handler = NULL; /* Prevent concurrent invoke. */
 515             LeaveCriticalSection(&impl->cs);
 516
 517             IAsyncOperationCompletedHandler_IInspectable_Invoke(handler, operation, status);
 518             IAsyncOperationCompletedHandler_IInspectable_Release(handler);
 519
 520             return S_OK;
 521         }
 522     }
 523     LeaveCriticalSection(&impl->cs);
 524
 525     return hr;
 526 }
 527
 528 static HRESULT WINAPI async_inspectable_get_Completed( IAsyncOperation_IInspectable *iface,
 529                                                        IAsyncOperationCompletedHandler_IInspectable **handler )
 530 {
 531     struct async_inspectable *impl = impl_from_IAsyncOperation_IInspectable(iface);
 532     HRESULT hr = S_OK;
 533
 534     FIXME("iface %p, handler %p semi stub!\n", iface, handler);
 535
 536     EnterCriticalSection(&impl->cs);
 537     if (impl->status == Closed)
 538         hr = E_ILLEGAL_METHOD_CALL;
 539     *handler = (impl->handler != HANDLER_NOT_SET) ? impl->handler : NULL;
 540     LeaveCriticalSection(&impl->cs);
 541
 542     return hr;
 543 }
 544
 545 static HRESULT WINAPI async_inspectable_GetResults( IAsyncOperation_IInspectable *iface, IInspectable **results )
 546 {
 547     /* NOTE: Despite the name, this function only returns one result! */
 548     struct async_inspectable *impl = impl_from_IAsyncOperation_IInspectable(iface);
 549     HRESULT hr;
 550
 551     TRACE("iface %p, results %p.\n", iface, results);
 552
 553     EnterCriticalSection(&impl->cs);
 554     if (impl->status != Completed && impl->status != Error)
 555         hr = E_ILLEGAL_METHOD_CALL;
 556     else if (!impl->result)
 557         hr = E_UNEXPECTED;
 558     else
 559     {
 560         *results = impl->result;
 561         impl->result = NULL; /* NOTE: AsyncOperation gives up it's reference to result here! */
 562         hr = impl->hr;
 563     }
 564     LeaveCriticalSection(&impl->cs);
 565
 566     return hr;
 567 }
 568
 569 static const struct IAsyncOperation_IInspectableVtbl async_inspectable_vtbl =
 570 {
 571     /* IUnknown methods */
 572     async_inspectable_QueryInterface,
 573     async_inspectable_AddRef,
 574     async_inspectable_Release,
 575     /* IInspectable methods */
 576     async_inspectable_GetIids,
 577     async_inspectable_GetRuntimeClassName,
 578     async_inspectable_GetTrustLevel,
 579     /* IAsyncOperation<IInspectable*> */
 580     async_inspectable_put_Completed,
 581     async_inspectable_get_Completed,
 582     async_inspectable_GetResults
 583 };
 584
 585 /*
 586  *
 587  * IAsyncInfo for IAsyncOperation<IInspectable*>
 588  *
 589  */
 590
 591 DEFINE_IINSPECTABLE_(async_inspectable_info, IAsyncInfo, struct async_inspectable,
 592                      async_inspectable_impl_from_IAsyncInfo, IAsyncInfo_iface, &impl->IAsyncOperation_IInspectable_iface)
 593
 594 static HRESULT WINAPI async_inspectable_info_get_Id( IAsyncInfo *iface, UINT32 *id )
 595 {
 596     FIXME("iface %p, id %p stub!\n", iface, id);
 597     return E_NOTIMPL;
 598 }
 599
 600 static HRESULT WINAPI async_inspectable_info_get_Status( IAsyncInfo *iface, AsyncStatus *status )
 601 {
 602     struct async_inspectable *impl = async_inspectable_impl_from_IAsyncInfo(iface);
 603     HRESULT hr = S_OK;
 604
 605     TRACE("iface %p, status %p.\n", iface, status);
 606
 607     EnterCriticalSection(&impl->cs);
 608     if (impl->status == Closed)
 609         hr = E_ILLEGAL_METHOD_CALL;
 610     *status = impl->status;
 611     LeaveCriticalSection(&impl->cs);
 612
 613     return hr;
 614 }
 615
 616 static HRESULT WINAPI async_inspectable_info_get_ErrorCode( IAsyncInfo *iface, HRESULT *error_code )
 617 {
 618     struct async_inspectable *impl = async_inspectable_impl_from_IAsyncInfo(iface);
 619     HRESULT hr = S_OK;
 620
 621     TRACE("iface %p, error_code %p.\n", iface, error_code);
 622
 623     EnterCriticalSection(&impl->cs);
 624     if (impl->status == Closed)
 625         *error_code = hr = E_ILLEGAL_METHOD_CALL;
 626     else
 627         *error_code = impl->hr;
 628     LeaveCriticalSection(&impl->cs);
 629
 630     return hr;
 631 }
 632
 633 static HRESULT WINAPI async_inspectable_info_Cancel( IAsyncInfo *iface )
 634 {
 635     struct async_inspectable *impl = async_inspectable_impl_from_IAsyncInfo(iface);
 636     HRESULT hr = S_OK;
 637
 638     TRACE("iface %p.\n", iface);
 639
 640     EnterCriticalSection(&impl->cs);
 641     if (impl->status == Closed)
 642         hr = E_ILLEGAL_METHOD_CALL;
 643     else if (impl->status == Started)
 644         impl->status = Canceled;
 645     LeaveCriticalSection(&impl->cs);
 646
 647     return hr;
 648 }
 649
 650 static HRESULT WINAPI async_inspectable_info_Close( IAsyncInfo *iface )
 651 {
 652     struct async_inspectable *impl = async_inspectable_impl_from_IAsyncInfo(iface);
 653     HRESULT hr = S_OK;
 654
 655     TRACE("iface %p.\n", iface);
 656
 657     EnterCriticalSection(&impl->cs);
 658     if (impl->status == Started)
 659         hr = E_ILLEGAL_STATE_CHANGE;
 660     else if (impl->status != Closed)
 661     {
 662         CloseThreadpoolWork(impl->async_run_work);
 663         impl->async_run_work = NULL;
 664         impl->status = Closed;
 665     }
 666     LeaveCriticalSection(&impl->cs);
 667
 668     return hr;
 669 }
 670
 671 static const struct IAsyncInfoVtbl async_inspectable_info_vtbl =
 672 {
 673     /* IUnknown methods */
 674     async_inspectable_info_QueryInterface,
 675     async_inspectable_info_AddRef,
 676     async_inspectable_info_Release,
 677     /* IInspectable methods */
 678     async_inspectable_info_GetIids,
 679     async_inspectable_info_GetRuntimeClassName,
 680     async_inspectable_info_GetTrustLevel,
 681     /* IAsyncInfo */
 682     async_inspectable_info_get_Id,
 683     async_inspectable_info_get_Status,
 684     async_inspectable_info_get_ErrorCode,
 685     async_inspectable_info_Cancel,
 686     async_inspectable_info_Close
 687 };
 688
 689 static void CALLBACK async_inspectable_run_cb(TP_CALLBACK_INSTANCE *instance, void *data, TP_WORK *work)
 690 {
 691     IAsyncOperation_IInspectable *operation = data;
 692     IInspectable *result = NULL;
 693     struct async_inspectable *impl = impl_from_IAsyncOperation_IInspectable(operation);
 694     HRESULT hr;
 695
 696     hr = impl->callback(impl->invoker, &result);
 697
 698     EnterCriticalSection(&impl->cs);
 699     if (impl->status < Closed)
 700         impl->status = FAILED(hr) ? Error : Completed;
 701
 702     impl->result = result;
 703     impl->hr = hr;
 704
 705     if (impl->handler != NULL && impl->handler != HANDLER_NOT_SET)
 706     {
 707         IAsyncOperationCompletedHandler_IInspectable *handler = impl->handler;
 708         AsyncStatus status = impl->status;
 709         impl->handler = NULL; /* Prevent concurrent invoke. */
 710         LeaveCriticalSection(&impl->cs);
 711
 712         IAsyncOperationCompletedHandler_IInspectable_Invoke(handler, operation, status);
 713         IAsyncOperationCompletedHandler_IInspectable_Release(handler);
 714     }
 715     else LeaveCriticalSection(&impl->cs);
 716
 717     IAsyncOperation_IInspectable_Release(operation);
 718 }
 719
 720 HRESULT async_operation_inspectable_create( const GUID *iid,
 721                                             IInspectable *invoker,
 722                                             async_operation_inspectable_callback callback,
 723                                             IAsyncOperation_IInspectable **out )
 724 {
 725     struct async_inspectable *impl;
 726
 727     TRACE("iid %s, invoker %p, callback %p, out %p.\n", debugstr_guid(iid), invoker, callback, out);
 728
 729     *out = NULL;
 730     if (!(impl = calloc(1, sizeof(*impl)))) return E_OUTOFMEMORY;
 731     impl->IAsyncOperation_IInspectable_iface.lpVtbl = &async_inspectable_vtbl;
 732     impl->IAsyncInfo_iface.lpVtbl = &async_inspectable_info_vtbl;
 733     impl->iid = iid;
 734     impl->ref = 1;
 735
 736     impl->handler = HANDLER_NOT_SET;
 737     impl->callback = callback;
 738     impl->status = Started;
 739
 740     if (!(impl->async_run_work = CreateThreadpoolWork(async_inspectable_run_cb, &impl->IAsyncOperation_IInspectable_iface, NULL)))
 741     {
 742         free(impl);
 743         return HRESULT_FROM_WIN32(GetLastError());
 744     }
 745
 746     if (invoker) IInspectable_AddRef((impl->invoker = invoker));
 747
 748     InitializeCriticalSectionEx(&impl->cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
 749     impl->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": async_operation.cs");
 750
 751     /* AddRef to keep the obj alive in the callback. */
 752     IAsyncOperation_IInspectable_AddRef(&impl->IAsyncOperation_IInspectable_iface);
 753     SubmitThreadpoolWork(impl->async_run_work);
 754
 755     *out = &impl->IAsyncOperation_IInspectable_iface;
 756     TRACE("created %p\n", *out);
 757     return S_OK;
 758 }