1 // Copyright 2017 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #ifndef MEDIA_BASE_WIN_D3D11_MOCKS_H_
6 #define MEDIA_BASE_WIN_D3D11_MOCKS_H_
7 
8 #include <d3d11_4.h>
9 #include <dxgi1_4.h>
10 #include <dxgi1_6.h>
11 #include <wrl/client.h>
12 #include <wrl/implements.h>
13 
14 #include "media/base/win/test_utils.h"
15 #include "testing/gmock/include/gmock/gmock.h"
16 
17 namespace media {
18 
19 class D3D11Texture2DMock
20     : public Microsoft::WRL::RuntimeClass<
21           Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
22           ID3D11Texture2D> {
23  public:
24   D3D11Texture2DMock();
25   ~D3D11Texture2DMock() override;
26   MOCK_STDCALL_METHOD1(GetDevice, void(ID3D11Device**));
27   MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(const GUID&, UINT*, void*));
28   MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*));
29   MOCK_STDCALL_METHOD2(SetPrivateDataInterface,
30                        HRESULT(const GUID&, const IUnknown*));
31   MOCK_STDCALL_METHOD1(GetType, void(D3D11_RESOURCE_DIMENSION*));
32   MOCK_STDCALL_METHOD1(SetEvictionPriority, void(UINT));
33   MOCK_STDCALL_METHOD0(GetEvictionPriority, UINT());
34   MOCK_STDCALL_METHOD1(GetDesc, void(D3D11_TEXTURE2D_DESC*));
35 };
36 
37 class D3D11BufferMock
38     : public Microsoft::WRL::RuntimeClass<
39           Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
40           ID3D11Buffer> {
41  public:
42   D3D11BufferMock();
43   ~D3D11BufferMock() override;
44   MOCK_STDCALL_METHOD1(GetDevice, void(ID3D11Device**));
45   MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(const GUID&, UINT*, void*));
46   MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*));
47   MOCK_STDCALL_METHOD2(SetPrivateDataInterface,
48                        HRESULT(const GUID&, const IUnknown*));
49   MOCK_STDCALL_METHOD1(GetType, void(D3D11_RESOURCE_DIMENSION*));
50   MOCK_STDCALL_METHOD1(SetEvictionPriority, void(UINT));
51   MOCK_STDCALL_METHOD0(GetEvictionPriority, UINT());
52   MOCK_STDCALL_METHOD1(GetDesc, void(D3D11_BUFFER_DESC*));
53 };
54 
55 // This class must mock QueryInterface, since a lot of things are
56 // QueryInterfac()ed thru this class.
57 class D3D11DeviceMock
58     : public Microsoft::WRL::RuntimeClass<
59           Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
60           ID3D11Device5> {
61  public:
62   D3D11DeviceMock();
63   ~D3D11DeviceMock() override;
64 
65   MOCK_STDCALL_METHOD2(QueryInterface, HRESULT(REFIID riid, void** ppv));
66 
67   MOCK_STDCALL_METHOD3(CreateBuffer,
68                        HRESULT(const D3D11_BUFFER_DESC*,
69                                const D3D11_SUBRESOURCE_DATA*,
70                                ID3D11Buffer**));
71   MOCK_STDCALL_METHOD3(CreateTexture1D,
72                        HRESULT(const D3D11_TEXTURE1D_DESC*,
73                                const D3D11_SUBRESOURCE_DATA*,
74                                ID3D11Texture1D**));
75   MOCK_STDCALL_METHOD3(CreateTexture2D,
76                        HRESULT(const D3D11_TEXTURE2D_DESC*,
77                                const D3D11_SUBRESOURCE_DATA*,
78                                ID3D11Texture2D**));
79   MOCK_STDCALL_METHOD3(CreateTexture3D,
80                        HRESULT(const D3D11_TEXTURE3D_DESC*,
81                                const D3D11_SUBRESOURCE_DATA*,
82                                ID3D11Texture3D**));
83   MOCK_STDCALL_METHOD3(CreateShaderResourceView,
84                        HRESULT(ID3D11Resource*,
85                                const D3D11_SHADER_RESOURCE_VIEW_DESC*,
86                                ID3D11ShaderResourceView**));
87   MOCK_STDCALL_METHOD3(CreateUnorderedAccessView,
88                        HRESULT(ID3D11Resource*,
89                                const D3D11_UNORDERED_ACCESS_VIEW_DESC*,
90                                ID3D11UnorderedAccessView**));
91   MOCK_STDCALL_METHOD3(CreateRenderTargetView,
92                        HRESULT(ID3D11Resource*,
93                                const D3D11_RENDER_TARGET_VIEW_DESC*,
94                                ID3D11RenderTargetView**));
95   MOCK_STDCALL_METHOD3(CreateDepthStencilView,
96                        HRESULT(ID3D11Resource*,
97                                const D3D11_DEPTH_STENCIL_VIEW_DESC*,
98                                ID3D11DepthStencilView**));
99   MOCK_STDCALL_METHOD5(CreateInputLayout,
100                        HRESULT(const D3D11_INPUT_ELEMENT_DESC*,
101                                UINT,
102                                const void*,
103                                SIZE_T,
104                                ID3D11InputLayout**));
105 
106   MOCK_STDCALL_METHOD4(
107       CreateVertexShader,
108       HRESULT(const void*, SIZE_T, ID3D11ClassLinkage*, ID3D11VertexShader**));
109 
110   MOCK_STDCALL_METHOD4(CreateGeometryShader,
111                        HRESULT(const void*,
112                                SIZE_T,
113                                ID3D11ClassLinkage*,
114                                ID3D11GeometryShader**));
115 
116   MOCK_STDCALL_METHOD9(CreateGeometryShaderWithStreamOutput,
117                        HRESULT(const void*,
118                                SIZE_T,
119                                const D3D11_SO_DECLARATION_ENTRY*,
120                                UINT,
121                                const UINT*,
122                                UINT,
123                                UINT,
124                                ID3D11ClassLinkage*,
125                                ID3D11GeometryShader**));
126 
127   MOCK_STDCALL_METHOD4(
128       CreatePixelShader,
129       HRESULT(const void*, SIZE_T, ID3D11ClassLinkage*, ID3D11PixelShader**));
130 
131   MOCK_STDCALL_METHOD4(
132       CreateHullShader,
133       HRESULT(const void*, SIZE_T, ID3D11ClassLinkage*, ID3D11HullShader**));
134 
135   MOCK_STDCALL_METHOD4(
136       CreateDomainShader,
137       HRESULT(const void*, SIZE_T, ID3D11ClassLinkage*, ID3D11DomainShader**));
138 
139   MOCK_STDCALL_METHOD4(
140       CreateComputeShader,
141       HRESULT(const void*, SIZE_T, ID3D11ClassLinkage*, ID3D11ComputeShader**));
142 
143   MOCK_STDCALL_METHOD1(CreateClassLinkage, HRESULT(ID3D11ClassLinkage**));
144 
145   MOCK_STDCALL_METHOD2(CreateBlendState,
146                        HRESULT(const D3D11_BLEND_DESC*, ID3D11BlendState**));
147 
148   MOCK_STDCALL_METHOD2(CreateDepthStencilState,
149                        HRESULT(const D3D11_DEPTH_STENCIL_DESC*,
150                                ID3D11DepthStencilState**));
151 
152   MOCK_STDCALL_METHOD2(CreateRasterizerState,
153                        HRESULT(const D3D11_RASTERIZER_DESC*,
154                                ID3D11RasterizerState**));
155 
156   MOCK_STDCALL_METHOD2(CreateSamplerState,
157                        HRESULT(const D3D11_SAMPLER_DESC*,
158                                ID3D11SamplerState**));
159 
160   MOCK_STDCALL_METHOD2(CreateQuery,
161                        HRESULT(const D3D11_QUERY_DESC*, ID3D11Query**));
162 
163   MOCK_STDCALL_METHOD2(CreatePredicate,
164                        HRESULT(const D3D11_QUERY_DESC*, ID3D11Predicate**));
165 
166   MOCK_STDCALL_METHOD2(CreateCounter,
167                        HRESULT(const D3D11_COUNTER_DESC*, ID3D11Counter**));
168 
169   MOCK_STDCALL_METHOD2(CreateDeferredContext,
170                        HRESULT(UINT, ID3D11DeviceContext**));
171 
172   MOCK_STDCALL_METHOD3(OpenSharedResource, HRESULT(HANDLE, const IID&, void**));
173 
174   MOCK_STDCALL_METHOD2(CheckFormatSupport, HRESULT(DXGI_FORMAT, UINT*));
175 
176   MOCK_STDCALL_METHOD3(CheckMultisampleQualityLevels,
177                        HRESULT(DXGI_FORMAT, UINT, UINT*));
178 
179   MOCK_STDCALL_METHOD1(CheckCounterInfo, void(D3D11_COUNTER_INFO*));
180 
181   MOCK_STDCALL_METHOD9(CheckCounter,
182                        HRESULT(const D3D11_COUNTER_DESC*,
183                                D3D11_COUNTER_TYPE*,
184                                UINT*,
185                                LPSTR,
186                                UINT*,
187                                LPSTR,
188                                UINT*,
189                                LPSTR,
190                                UINT*));
191 
192   MOCK_STDCALL_METHOD3(CheckFeatureSupport,
193                        HRESULT(D3D11_FEATURE, void*, UINT));
194 
195   MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(const GUID&, UINT*, void*));
196 
197   MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*));
198 
199   MOCK_STDCALL_METHOD2(SetPrivateDataInterface,
200                        HRESULT(const GUID&, const IUnknown*));
201 
202   MOCK_STDCALL_METHOD0(GetFeatureLevel, D3D_FEATURE_LEVEL());
203 
204   MOCK_STDCALL_METHOD0(GetCreationFlags, UINT());
205 
206   MOCK_STDCALL_METHOD0(GetDeviceRemovedReason, HRESULT());
207 
208   MOCK_STDCALL_METHOD1(GetImmediateContext, void(ID3D11DeviceContext**));
209 
210   MOCK_STDCALL_METHOD1(SetExceptionMode, HRESULT(UINT));
211 
212   MOCK_STDCALL_METHOD0(GetExceptionMode, UINT());
213 
214   // ID3D11Device1
215   MOCK_STDCALL_METHOD1(GetImmediateContext1, void(ID3D11DeviceContext1**));
216 
217   MOCK_STDCALL_METHOD2(CreateDeferredContext1,
218                        HRESULT(UINT, ID3D11DeviceContext1**));
219 
220   MOCK_STDCALL_METHOD2(CreateBlendState1,
221                        HRESULT(const D3D11_BLEND_DESC1*, ID3D11BlendState1**));
222 
223   MOCK_STDCALL_METHOD2(CreateRasterizerState1,
224                        HRESULT(const D3D11_RASTERIZER_DESC1*,
225                                ID3D11RasterizerState1**));
226 
227   MOCK_STDCALL_METHOD7(CreateDeviceContextState,
228                        HRESULT(UINT,
229                                const D3D_FEATURE_LEVEL*,
230                                UINT,
231                                UINT,
232                                REFIID,
233                                D3D_FEATURE_LEVEL*,
234                                ID3DDeviceContextState**));
235 
236   MOCK_STDCALL_METHOD3(OpenSharedResource1, HRESULT(HANDLE, REFIID, void**));
237 
238   MOCK_STDCALL_METHOD4(OpenSharedResourceByName,
239                        HRESULT(LPCWSTR, DWORD, REFIID, void**));
240 
241   // ID3D11Device2
242   MOCK_STDCALL_METHOD4(CheckMultisampleQualityLevels1,
243                        HRESULT(DXGI_FORMAT, UINT, UINT, UINT*));
244 
245   MOCK_STDCALL_METHOD2(CreateDeferredContext2,
246                        HRESULT(UINT, ID3D11DeviceContext2**));
247 
248   MOCK_STDCALL_METHOD1(GetImmediateContext2, void(ID3D11DeviceContext2**));
249 
250   MOCK_STDCALL_METHOD7(GetResourceTiling,
251                        void(ID3D11Resource*,
252                             UINT*,
253                             D3D11_PACKED_MIP_DESC*,
254                             D3D11_TILE_SHAPE*,
255                             UINT*,
256                             UINT,
257                             D3D11_SUBRESOURCE_TILING*));
258 
259   // ID3D11Device3
260   MOCK_STDCALL_METHOD3(CreateTexture2D1,
261                        HRESULT(const D3D11_TEXTURE2D_DESC1*,
262                                const D3D11_SUBRESOURCE_DATA*,
263                                ID3D11Texture2D1**));
264 
265   MOCK_STDCALL_METHOD3(CreateTexture3D1,
266                        HRESULT(const D3D11_TEXTURE3D_DESC1*,
267                                const D3D11_SUBRESOURCE_DATA*,
268                                ID3D11Texture3D1**));
269 
270   MOCK_STDCALL_METHOD2(CreateRasterizerState2,
271                        HRESULT(const D3D11_RASTERIZER_DESC2*,
272                                ID3D11RasterizerState2**));
273 
274   MOCK_STDCALL_METHOD3(CreateShaderResourceView1,
275                        HRESULT(ID3D11Resource*,
276                                const D3D11_SHADER_RESOURCE_VIEW_DESC1*,
277                                ID3D11ShaderResourceView1**));
278 
279   MOCK_STDCALL_METHOD3(CreateUnorderedAccessView1,
280                        HRESULT(ID3D11Resource*,
281                                const D3D11_UNORDERED_ACCESS_VIEW_DESC1*,
282                                ID3D11UnorderedAccessView1**));
283 
284   MOCK_STDCALL_METHOD3(CreateRenderTargetView1,
285                        HRESULT(ID3D11Resource*,
286                                const D3D11_RENDER_TARGET_VIEW_DESC1*,
287                                ID3D11RenderTargetView1**));
288 
289   MOCK_STDCALL_METHOD2(CreateQuery1,
290                        HRESULT(const D3D11_QUERY_DESC1*, ID3D11Query1**));
291 
292   MOCK_STDCALL_METHOD1(GetImmediateContext3, void(ID3D11DeviceContext3**));
293 
294   MOCK_STDCALL_METHOD2(CreateDeferredContext3,
295                        HRESULT(UINT, ID3D11DeviceContext3**));
296 
297   MOCK_STDCALL_METHOD6(
298       WriteToSubresource,
299       void(ID3D11Resource*, UINT, const D3D11_BOX*, const void*, UINT, UINT));
300 
301   MOCK_STDCALL_METHOD6(
302       ReadFromSubresource,
303       void(void*, UINT, UINT, ID3D11Resource*, UINT, const D3D11_BOX*));
304 
305   // ID3D11Device4
306   MOCK_STDCALL_METHOD2(RegisterDeviceRemovedEvent, HRESULT(HANDLE, DWORD*));
307 
308   MOCK_STDCALL_METHOD1(UnregisterDeviceRemoved, void(DWORD));
309 
310   // ID3D11Device5
311   MOCK_STDCALL_METHOD3(OpenSharedFence, HRESULT(HANDLE, REFIID, void**));
312 
313   MOCK_STDCALL_METHOD4(CreateFence,
314                        HRESULT(UINT64, D3D11_FENCE_FLAG, REFIID, void**));
315 };
316 
317 class DXGIFactoryMock
318     : public Microsoft::WRL::RuntimeClass<
319           Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
320           IDXGIFactory> {
321  public:
322   DXGIFactoryMock();
323   ~DXGIFactoryMock() override;
324   MOCK_STDCALL_METHOD2(CreateSoftwareAdapter, HRESULT(HMODULE, IDXGIAdapter**));
325   MOCK_STDCALL_METHOD3(CreateSwapChain,
326                        HRESULT(IUnknown*,
327                                DXGI_SWAP_CHAIN_DESC*,
328                                IDXGISwapChain**));
329   MOCK_STDCALL_METHOD2(EnumAdapters, HRESULT(UINT, IDXGIAdapter**));
330   MOCK_STDCALL_METHOD1(GetWindowAssociation, HRESULT(HWND*));
331   MOCK_STDCALL_METHOD2(MakeWindowAssociation, HRESULT(HWND, UINT));
332   MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(REFGUID, UINT, const void*));
333   MOCK_STDCALL_METHOD2(SetPrivateDataInterface,
334                        HRESULT(REFGUID, const IUnknown*));
335   MOCK_STDCALL_METHOD2(GetParent, HRESULT(REFIID, void**));
336   MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(REFGUID, UINT*, void*));
337 };
338 
339 class DXGIDeviceMock
340     : public Microsoft::WRL::RuntimeClass<
341           Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
342           IDXGIDevice> {
343  public:
344   DXGIDeviceMock();
345   ~DXGIDeviceMock() override;
346 
347   MOCK_STDCALL_METHOD5(CreateSurface,
348                        HRESULT(const DXGI_SURFACE_DESC*,
349                                UINT,
350                                DXGI_USAGE,
351                                const DXGI_SHARED_RESOURCE*,
352                                IDXGISurface**));
353   MOCK_STDCALL_METHOD1(GetAdapter, HRESULT(IDXGIAdapter**));
354   MOCK_STDCALL_METHOD1(GetGPUThreadPriority, HRESULT(INT*));
355   MOCK_STDCALL_METHOD3(QueryResourceResidency,
356                        HRESULT(IUnknown* const*, DXGI_RESIDENCY*, UINT));
357   MOCK_STDCALL_METHOD1(SetGPUThreadPriority, HRESULT(INT));
358   MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(REFGUID, UINT, const void*));
359   MOCK_STDCALL_METHOD2(SetPrivateDataInterface,
360                        HRESULT(REFGUID, const IUnknown*));
361   MOCK_STDCALL_METHOD2(GetParent, HRESULT(REFIID, void**));
362   MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(REFGUID, UINT*, void*));
363 };
364 
365 class DXGIAdapterMock
366     : public Microsoft::WRL::RuntimeClass<
367           Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
368           IDXGIAdapter> {
369  public:
370   DXGIAdapterMock();
371   ~DXGIAdapterMock() override;
372 
373   MOCK_STDCALL_METHOD3(QueryVideoMemoryInfo,
374                        HRESULT(UINT,
375                                DXGI_MEMORY_SEGMENT_GROUP,
376                                DXGI_QUERY_VIDEO_MEMORY_INFO*));
377   MOCK_STDCALL_METHOD2(RegisterHardwareContentProtectionTeardownStatusEvent,
378                        HRESULT(HANDLE, DWORD*));
379   MOCK_STDCALL_METHOD2(RegisterVideoMemoryBudgetChangeNotificationEvent,
380                        HRESULT(HANDLE, DWORD*));
381   MOCK_STDCALL_METHOD3(SetVideoMemoryReservation,
382                        HRESULT(UINT, DXGI_MEMORY_SEGMENT_GROUP, UINT64));
383   MOCK_STDCALL_METHOD1(UnregisterHardwareContentProtectionTeardownStatus,
384                        void(DWORD));
385   MOCK_STDCALL_METHOD1(UnregisterVideoMemoryBudgetChangeNotification,
386                        void(DWORD));
387   MOCK_STDCALL_METHOD1(GetDesc2, HRESULT(DXGI_ADAPTER_DESC2*));
388   MOCK_STDCALL_METHOD1(GetDesc1, HRESULT(DXGI_ADAPTER_DESC1*));
389   MOCK_STDCALL_METHOD2(CheckInterfaceSupport, HRESULT(REFGUID, LARGE_INTEGER*));
390   MOCK_STDCALL_METHOD2(EnumOutputs, HRESULT(UINT, IDXGIOutput**));
391   MOCK_STDCALL_METHOD1(GetDesc, HRESULT(DXGI_ADAPTER_DESC*));
392   MOCK_STDCALL_METHOD2(GetParent, HRESULT(REFIID, void**));
393   MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(REFGUID, UINT*, void*));
394   MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(REFGUID, UINT, const void*));
395   MOCK_STDCALL_METHOD2(SetPrivateDataInterface,
396                        HRESULT(REFGUID, const IUnknown*));
397 };
398 
399 class DXGIOutputMock
400     : public Microsoft::WRL::RuntimeClass<
401           Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
402           IDXGIOutput> {
403  public:
404   DXGIOutputMock();
405   ~DXGIOutputMock() override;
406   MOCK_STDCALL_METHOD3(FindClosestMatchingMode,
407                        HRESULT(const DXGI_MODE_DESC*,
408                                DXGI_MODE_DESC*,
409                                IUnknown*));
410   MOCK_STDCALL_METHOD1(GetDesc, HRESULT(DXGI_OUTPUT_DESC*));
411   MOCK_STDCALL_METHOD4(GetDisplayModeList,
412                        HRESULT(DXGI_FORMAT, UINT, UINT*, DXGI_MODE_DESC*));
413   MOCK_STDCALL_METHOD1(GetDisplaySurfaceData, HRESULT(IDXGISurface*));
414   MOCK_STDCALL_METHOD1(GetFrameStatistics, HRESULT(DXGI_FRAME_STATISTICS*));
415   MOCK_STDCALL_METHOD1(GetGammaControl, HRESULT(DXGI_GAMMA_CONTROL*));
416   MOCK_STDCALL_METHOD1(GetGammaControlCapabilities,
417                        HRESULT(DXGI_GAMMA_CONTROL_CAPABILITIES*));
418   MOCK_STDCALL_METHOD0(ReleaseOwnership, void());
419   MOCK_STDCALL_METHOD1(SetDisplaySurface, HRESULT(IDXGISurface*));
420   MOCK_STDCALL_METHOD1(SetGammaControl, HRESULT(const DXGI_GAMMA_CONTROL*));
421   MOCK_STDCALL_METHOD2(TakeOwnership, HRESULT(IUnknown*, BOOL));
422   MOCK_STDCALL_METHOD0(WaitForVBlank, HRESULT());
423 
424   MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(REFGUID, UINT, const void*));
425   MOCK_STDCALL_METHOD2(SetPrivateDataInterface,
426                        HRESULT(REFGUID, const IUnknown*));
427   MOCK_STDCALL_METHOD2(GetParent, HRESULT(REFIID, void**));
428   MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(REFGUID, UINT*, void*));
429 
430   // IUnknown
431   MOCK_STDCALL_METHOD2(QueryInterface, HRESULT(REFIID riid, void** ppv));
432 };
433 
434 class DXGIOutput6Mock
435     : public Microsoft::WRL::RuntimeClass<
436           Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
437           IDXGIOutput6> {
438  public:
439   DXGIOutput6Mock();
440   ~DXGIOutput6Mock() override;
441 
442   // IDXGIOutput6
443   MOCK_STDCALL_METHOD1(GetDesc1, HRESULT(DXGI_OUTPUT_DESC1*));
444   MOCK_STDCALL_METHOD1(CheckHardwareCompositionSupport, HRESULT(UINT*));
445 
446   // IDXGIOutput5
447   MOCK_STDCALL_METHOD5(DuplicateOutput1,
448                        HRESULT(IUnknown*,
449                                UINT,
450                                UINT,
451                                const DXGI_FORMAT*,
452                                IDXGIOutputDuplication**));
453 
454   // IDXGIOutput4
455   MOCK_STDCALL_METHOD4(
456       CheckOverlayColorSpaceSupport,
457       HRESULT(DXGI_FORMAT, DXGI_COLOR_SPACE_TYPE, IUnknown*, UINT*));
458 
459   // IDXGIOutput3
460   MOCK_STDCALL_METHOD3(CheckOverlaySupport,
461                        HRESULT(DXGI_FORMAT, IUnknown*, UINT*));
462 
463   // IDXGIOutput2
464   MOCK_STDCALL_METHOD0(SupportsOverlays, BOOL());
465 
466   // IDXGIOutput1
467   MOCK_STDCALL_METHOD2(DuplicateOutput,
468                        HRESULT(IUnknown*, IDXGIOutputDuplication**));
469   MOCK_STDCALL_METHOD3(FindClosestMatchingMode1,
470                        HRESULT(const DXGI_MODE_DESC1*,
471                                DXGI_MODE_DESC1*,
472                                IUnknown*));
473   MOCK_STDCALL_METHOD4(GetDisplayModeList1,
474                        HRESULT(DXGI_FORMAT, UINT, UINT*, DXGI_MODE_DESC1*));
475   MOCK_STDCALL_METHOD1(GetDisplaySurfaceData1, HRESULT(IDXGIResource*));
476 
477   // IDXGIOutput
478   MOCK_STDCALL_METHOD3(FindClosestMatchingMode,
479                        HRESULT(const DXGI_MODE_DESC*,
480                                DXGI_MODE_DESC*,
481                                IUnknown*));
482   MOCK_STDCALL_METHOD1(GetDesc, HRESULT(DXGI_OUTPUT_DESC*));
483   MOCK_STDCALL_METHOD4(GetDisplayModeList,
484                        HRESULT(DXGI_FORMAT, UINT, UINT*, DXGI_MODE_DESC*));
485   MOCK_STDCALL_METHOD1(GetDisplaySurfaceData, HRESULT(IDXGISurface*));
486   MOCK_STDCALL_METHOD1(GetFrameStatistics, HRESULT(DXGI_FRAME_STATISTICS*));
487   MOCK_STDCALL_METHOD1(GetGammaControl, HRESULT(DXGI_GAMMA_CONTROL*));
488   MOCK_STDCALL_METHOD1(GetGammaControlCapabilities,
489                        HRESULT(DXGI_GAMMA_CONTROL_CAPABILITIES*));
490   MOCK_STDCALL_METHOD0(ReleaseOwnership, void());
491   MOCK_STDCALL_METHOD1(SetDisplaySurface, HRESULT(IDXGISurface*));
492   MOCK_STDCALL_METHOD1(SetGammaControl, HRESULT(const DXGI_GAMMA_CONTROL*));
493   MOCK_STDCALL_METHOD2(TakeOwnership, HRESULT(IUnknown*, BOOL));
494   MOCK_STDCALL_METHOD0(WaitForVBlank, HRESULT());
495 
496   // IDXGIObject
497   MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(REFGUID, UINT, const void*));
498   MOCK_STDCALL_METHOD2(SetPrivateDataInterface,
499                        HRESULT(REFGUID, const IUnknown*));
500   MOCK_STDCALL_METHOD2(GetParent, HRESULT(REFIID, void**));
501   MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(REFGUID, UINT*, void*));
502 };
503 
504 class D3D11VideoDeviceMock
505     : public Microsoft::WRL::RuntimeClass<
506           Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
507           ID3D11VideoDevice> {
508  public:
509   D3D11VideoDeviceMock();
510   ~D3D11VideoDeviceMock() override;
511   MOCK_STDCALL_METHOD3(CreateVideoDecoder,
512                        HRESULT(const D3D11_VIDEO_DECODER_DESC*,
513                                const D3D11_VIDEO_DECODER_CONFIG*,
514                                ID3D11VideoDecoder**));
515 
516   MOCK_STDCALL_METHOD3(CreateVideoProcessor,
517                        HRESULT(ID3D11VideoProcessorEnumerator*,
518                                UINT,
519                                ID3D11VideoProcessor**));
520 
521   MOCK_STDCALL_METHOD2(CreateAuthenticatedChannel,
522                        HRESULT(D3D11_AUTHENTICATED_CHANNEL_TYPE,
523                                ID3D11AuthenticatedChannel**));
524 
525   MOCK_STDCALL_METHOD4(
526       CreateCryptoSession,
527       HRESULT(const GUID*, const GUID*, const GUID*, ID3D11CryptoSession**));
528 
529   MOCK_STDCALL_METHOD3(CreateVideoDecoderOutputView,
530                        HRESULT(ID3D11Resource*,
531                                const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC*,
532                                ID3D11VideoDecoderOutputView**));
533 
534   MOCK_STDCALL_METHOD4(CreateVideoProcessorInputView,
535                        HRESULT(ID3D11Resource*,
536                                ID3D11VideoProcessorEnumerator*,
537                                const D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC*,
538                                ID3D11VideoProcessorInputView**));
539 
540   MOCK_STDCALL_METHOD4(CreateVideoProcessorOutputView,
541                        HRESULT(ID3D11Resource*,
542                                ID3D11VideoProcessorEnumerator*,
543                                const D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC*,
544                                ID3D11VideoProcessorOutputView**));
545 
546   MOCK_STDCALL_METHOD2(CreateVideoProcessorEnumerator,
547                        HRESULT(const D3D11_VIDEO_PROCESSOR_CONTENT_DESC*,
548                                ID3D11VideoProcessorEnumerator**));
549 
550   MOCK_STDCALL_METHOD0(GetVideoDecoderProfileCount, UINT());
551 
552   MOCK_STDCALL_METHOD2(GetVideoDecoderProfile, HRESULT(UINT, GUID*));
553 
554   MOCK_STDCALL_METHOD3(CheckVideoDecoderFormat,
555                        HRESULT(const GUID*, DXGI_FORMAT, BOOL*));
556   MOCK_STDCALL_METHOD2(GetVideoDecoderConfigCount,
557                        HRESULT(const D3D11_VIDEO_DECODER_DESC*, UINT*));
558 
559   MOCK_STDCALL_METHOD3(GetVideoDecoderConfig,
560                        HRESULT(const D3D11_VIDEO_DECODER_DESC*,
561                                UINT,
562                                D3D11_VIDEO_DECODER_CONFIG*));
563 
564   MOCK_STDCALL_METHOD3(GetContentProtectionCaps,
565                        HRESULT(const GUID*,
566                                const GUID*,
567                                D3D11_VIDEO_CONTENT_PROTECTION_CAPS*));
568   MOCK_STDCALL_METHOD4(CheckCryptoKeyExchange,
569                        HRESULT(const GUID*, const GUID*, UINT, GUID*));
570   MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*));
571   MOCK_STDCALL_METHOD2(SetPrivateDataInterface,
572                        HRESULT(const GUID&, const IUnknown*));
573 };
574 
575 class D3D11VideoProcessorEnumeratorMock
576     : public Microsoft::WRL::RuntimeClass<
577           Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
578           ID3D11VideoProcessorEnumerator> {
579  public:
580   D3D11VideoProcessorEnumeratorMock();
581   ~D3D11VideoProcessorEnumeratorMock() override;
582 
583   MOCK_STDCALL_METHOD1(GetDevice, void(ID3D11Device**));
584   MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(const GUID&, UINT*, void*));
585   MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*));
586   MOCK_STDCALL_METHOD2(SetPrivateDataInterface,
587                        HRESULT(const GUID&, const IUnknown*));
588 
589   MOCK_STDCALL_METHOD2(GetVideoProcessorRateConversionCaps,
590                        HRESULT(UINT,
591                                D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS*));
592 
593   MOCK_STDCALL_METHOD2(GetVideoProcessorFilterRange,
594                        HRESULT(D3D11_VIDEO_PROCESSOR_FILTER,
595                                D3D11_VIDEO_PROCESSOR_FILTER_RANGE*));
596 
597   MOCK_STDCALL_METHOD3(GetVideoProcessorCustomRate,
598                        HRESULT(UINT, UINT, D3D11_VIDEO_PROCESSOR_CUSTOM_RATE*));
599 
600   MOCK_STDCALL_METHOD1(GetVideoProcessorContentDesc,
601                        HRESULT(D3D11_VIDEO_PROCESSOR_CONTENT_DESC*));
602 
603   MOCK_STDCALL_METHOD1(GetVideoProcessorCaps,
604                        HRESULT(D3D11_VIDEO_PROCESSOR_CAPS*));
605 
606   MOCK_STDCALL_METHOD2(CheckVideoProcessorFormat, HRESULT(DXGI_FORMAT, UINT*));
607 };
608 
609 class D3D11VideoProcessorMock
610     : public Microsoft::WRL::RuntimeClass<
611           Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
612           ID3D11VideoProcessor> {
613  public:
614   D3D11VideoProcessorMock();
615   ~D3D11VideoProcessorMock() override;
616 
617   MOCK_STDCALL_METHOD1(GetDevice, void(ID3D11Device**));
618   MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(const GUID&, UINT*, void*));
619   MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*));
620   MOCK_STDCALL_METHOD2(SetPrivateDataInterface,
621                        HRESULT(const GUID&, const IUnknown*));
622 
623   MOCK_STDCALL_METHOD1(GetContentDesc,
624                        void(D3D11_VIDEO_PROCESSOR_CONTENT_DESC*));
625 
626   MOCK_STDCALL_METHOD1(GetRateConversionCaps,
627                        void(D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS*));
628 };
629 
630 class D3D11VideoContextMock
631     : public Microsoft::WRL::RuntimeClass<
632           Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
633           ID3D11VideoContext> {
634  public:
635   D3D11VideoContextMock();
636   ~D3D11VideoContextMock() override;
637   MOCK_STDCALL_METHOD1(GetDevice, void(ID3D11Device**));
638   MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(const GUID&, UINT*, void*));
639   MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*));
640   MOCK_STDCALL_METHOD2(SetPrivateDataInterface,
641                        HRESULT(const GUID&, const IUnknown*));
642   MOCK_STDCALL_METHOD4(GetDecoderBuffer,
643                        HRESULT(ID3D11VideoDecoder*,
644                                D3D11_VIDEO_DECODER_BUFFER_TYPE,
645                                UINT*,
646                                void**));
647   MOCK_STDCALL_METHOD2(ReleaseDecoderBuffer,
648                        HRESULT(ID3D11VideoDecoder*,
649                                D3D11_VIDEO_DECODER_BUFFER_TYPE));
650   MOCK_STDCALL_METHOD4(DecoderBeginFrame,
651                        HRESULT(ID3D11VideoDecoder*,
652                                ID3D11VideoDecoderOutputView*,
653                                UINT,
654                                const void*));
655   MOCK_STDCALL_METHOD1(DecoderEndFrame, HRESULT(ID3D11VideoDecoder*));
656   MOCK_STDCALL_METHOD3(SubmitDecoderBuffers,
657                        HRESULT(ID3D11VideoDecoder*,
658                                UINT,
659                                const D3D11_VIDEO_DECODER_BUFFER_DESC*));
660   MOCK_STDCALL_METHOD2(
661       DecoderExtension,
662       APP_DEPRECATED_HRESULT(ID3D11VideoDecoder*,
663                              const D3D11_VIDEO_DECODER_EXTENSION*));
664   MOCK_STDCALL_METHOD3(VideoProcessorSetOutputTargetRect,
665                        void(ID3D11VideoProcessor*, BOOL, const RECT*));
666   MOCK_STDCALL_METHOD3(VideoProcessorSetOutputBackgroundColor,
667                        void(ID3D11VideoProcessor*,
668                             BOOL,
669                             const D3D11_VIDEO_COLOR*));
670   MOCK_STDCALL_METHOD2(VideoProcessorSetOutputColorSpace,
671                        void(ID3D11VideoProcessor*,
672                             const D3D11_VIDEO_PROCESSOR_COLOR_SPACE*));
673   MOCK_STDCALL_METHOD3(VideoProcessorSetOutputAlphaFillMode,
674                        void(ID3D11VideoProcessor*,
675                             D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE,
676                             UINT));
677   MOCK_STDCALL_METHOD3(VideoProcessorSetOutputConstriction,
678                        void(ID3D11VideoProcessor*, BOOL, SIZE));
679   MOCK_STDCALL_METHOD2(VideoProcessorSetOutputStereoMode,
680                        void(ID3D11VideoProcessor*, BOOL));
681   MOCK_STDCALL_METHOD4(
682       VideoProcessorSetOutputExtension,
683       APP_DEPRECATED_HRESULT(ID3D11VideoProcessor*, const GUID*, UINT, void*));
684   MOCK_STDCALL_METHOD3(VideoProcessorGetOutputTargetRect,
685                        void(ID3D11VideoProcessor*, BOOL*, RECT*));
686   MOCK_STDCALL_METHOD3(VideoProcessorGetOutputBackgroundColor,
687                        void(ID3D11VideoProcessor*, BOOL*, D3D11_VIDEO_COLOR*));
688   MOCK_STDCALL_METHOD2(VideoProcessorGetOutputColorSpace,
689                        void(ID3D11VideoProcessor*,
690                             D3D11_VIDEO_PROCESSOR_COLOR_SPACE*));
691   MOCK_STDCALL_METHOD3(VideoProcessorGetOutputAlphaFillMode,
692                        void(ID3D11VideoProcessor*,
693                             D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE*,
694                             UINT*));
695   MOCK_STDCALL_METHOD3(VideoProcessorGetOutputConstriction,
696                        void(ID3D11VideoProcessor*, BOOL*, SIZE*));
697   MOCK_STDCALL_METHOD2(VideoProcessorGetOutputStereoMode,
698                        void(ID3D11VideoProcessor*, BOOL*));
699   MOCK_STDCALL_METHOD4(
700       VideoProcessorGetOutputExtension,
701       APP_DEPRECATED_HRESULT(ID3D11VideoProcessor*, const GUID*, UINT, void*));
702   MOCK_STDCALL_METHOD3(VideoProcessorSetStreamFrameFormat,
703                        void(ID3D11VideoProcessor*,
704                             UINT,
705                             D3D11_VIDEO_FRAME_FORMAT));
706   MOCK_STDCALL_METHOD3(VideoProcessorSetStreamColorSpace,
707                        void(ID3D11VideoProcessor*,
708                             UINT,
709                             const D3D11_VIDEO_PROCESSOR_COLOR_SPACE*));
710   MOCK_STDCALL_METHOD5(VideoProcessorSetStreamOutputRate,
711                        void(ID3D11VideoProcessor*,
712                             UINT,
713                             D3D11_VIDEO_PROCESSOR_OUTPUT_RATE,
714                             BOOL,
715                             const DXGI_RATIONAL*));
716   MOCK_STDCALL_METHOD4(VideoProcessorSetStreamSourceRect,
717                        void(ID3D11VideoProcessor*, UINT, BOOL, const RECT*));
718   MOCK_STDCALL_METHOD4(VideoProcessorSetStreamDestRect,
719                        void(ID3D11VideoProcessor*, UINT, BOOL, const RECT*));
720   MOCK_STDCALL_METHOD4(VideoProcessorSetStreamAlpha,
721                        void(ID3D11VideoProcessor*, UINT, BOOL, FLOAT));
722   MOCK_STDCALL_METHOD4(VideoProcessorSetStreamPalette,
723                        void(ID3D11VideoProcessor*, UINT, UINT, const UINT*));
724   MOCK_STDCALL_METHOD5(VideoProcessorSetStreamPixelAspectRatio,
725                        void(ID3D11VideoProcessor*,
726                             UINT,
727                             BOOL,
728                             const DXGI_RATIONAL*,
729                             const DXGI_RATIONAL*));
730   MOCK_STDCALL_METHOD5(VideoProcessorSetStreamLumaKey,
731                        void(ID3D11VideoProcessor*, UINT, BOOL, FLOAT, FLOAT));
732   MOCK_STDCALL_METHOD8(VideoProcessorSetStreamStereoFormat,
733                        void(ID3D11VideoProcessor*,
734                             UINT,
735                             BOOL,
736                             D3D11_VIDEO_PROCESSOR_STEREO_FORMAT,
737                             BOOL,
738                             BOOL,
739                             D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE,
740                             int));
741   MOCK_STDCALL_METHOD3(VideoProcessorSetStreamAutoProcessingMode,
742                        void(ID3D11VideoProcessor*, UINT, BOOL));
743   MOCK_STDCALL_METHOD5(VideoProcessorSetStreamFilter,
744                        void(ID3D11VideoProcessor*,
745                             UINT,
746                             D3D11_VIDEO_PROCESSOR_FILTER,
747                             BOOL,
748                             int));
749   MOCK_STDCALL_METHOD5(VideoProcessorSetStreamExtension,
750                        APP_DEPRECATED_HRESULT(ID3D11VideoProcessor*,
751                                               UINT,
752                                               const GUID*,
753                                               UINT,
754                                               void*));
755   MOCK_STDCALL_METHOD3(VideoProcessorGetStreamFrameFormat,
756                        void(ID3D11VideoProcessor*,
757                             UINT,
758                             D3D11_VIDEO_FRAME_FORMAT*));
759   MOCK_STDCALL_METHOD3(VideoProcessorGetStreamColorSpace,
760                        void(ID3D11VideoProcessor*,
761                             UINT,
762                             D3D11_VIDEO_PROCESSOR_COLOR_SPACE*));
763   MOCK_STDCALL_METHOD5(VideoProcessorGetStreamOutputRate,
764                        void(ID3D11VideoProcessor*,
765                             UINT,
766                             D3D11_VIDEO_PROCESSOR_OUTPUT_RATE*,
767                             BOOL*,
768                             DXGI_RATIONAL*));
769   MOCK_STDCALL_METHOD4(VideoProcessorGetStreamSourceRect,
770                        void(ID3D11VideoProcessor*, UINT, BOOL*, RECT*));
771   MOCK_STDCALL_METHOD4(VideoProcessorGetStreamDestRect,
772                        void(ID3D11VideoProcessor*, UINT, BOOL*, RECT*));
773   MOCK_STDCALL_METHOD4(VideoProcessorGetStreamAlpha,
774                        void(ID3D11VideoProcessor*, UINT, BOOL*, FLOAT*));
775   MOCK_STDCALL_METHOD4(VideoProcessorGetStreamPalette,
776                        void(ID3D11VideoProcessor*, UINT, UINT, UINT*));
777   MOCK_STDCALL_METHOD5(
778       VideoProcessorGetStreamPixelAspectRatio,
779       void(ID3D11VideoProcessor*, UINT, BOOL*, DXGI_RATIONAL*, DXGI_RATIONAL*));
780   MOCK_STDCALL_METHOD5(
781       VideoProcessorGetStreamLumaKey,
782       void(ID3D11VideoProcessor*, UINT, BOOL*, FLOAT*, FLOAT*));
783   MOCK_STDCALL_METHOD8(VideoProcessorGetStreamStereoFormat,
784                        void(ID3D11VideoProcessor*,
785                             UINT,
786                             BOOL*,
787                             D3D11_VIDEO_PROCESSOR_STEREO_FORMAT*,
788                             BOOL*,
789                             BOOL*,
790                             D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE*,
791                             int*));
792   MOCK_STDCALL_METHOD3(VideoProcessorGetStreamAutoProcessingMode,
793                        void(ID3D11VideoProcessor*, UINT, BOOL*));
794   MOCK_STDCALL_METHOD5(VideoProcessorGetStreamFilter,
795                        void(ID3D11VideoProcessor*,
796                             UINT,
797                             D3D11_VIDEO_PROCESSOR_FILTER,
798                             BOOL*,
799                             int*));
800   MOCK_STDCALL_METHOD5(VideoProcessorGetStreamExtension,
801                        APP_DEPRECATED_HRESULT(ID3D11VideoProcessor*,
802                                               UINT,
803                                               const GUID*,
804                                               UINT,
805                                               void*));
806   MOCK_STDCALL_METHOD5(VideoProcessorBlt,
807                        HRESULT(ID3D11VideoProcessor*,
808                                ID3D11VideoProcessorOutputView*,
809                                UINT,
810                                UINT,
811                                const D3D11_VIDEO_PROCESSOR_STREAM*));
812   MOCK_STDCALL_METHOD3(NegotiateCryptoSessionKeyExchange,
813                        HRESULT(ID3D11CryptoSession*, UINT, void*));
814   MOCK_STDCALL_METHOD5(EncryptionBlt,
815                        void(ID3D11CryptoSession*,
816                             ID3D11Texture2D*,
817                             ID3D11Texture2D*,
818                             UINT,
819                             void*));
820   MOCK_STDCALL_METHOD8(DecryptionBlt,
821                        void(ID3D11CryptoSession*,
822                             ID3D11Texture2D*,
823                             ID3D11Texture2D*,
824                             D3D11_ENCRYPTED_BLOCK_INFO*,
825                             UINT,
826                             const void*,
827                             UINT,
828                             void*));
829   MOCK_STDCALL_METHOD3(StartSessionKeyRefresh,
830                        void(ID3D11CryptoSession*, UINT, void*));
831   MOCK_STDCALL_METHOD1(FinishSessionKeyRefresh, void(ID3D11CryptoSession*));
832   MOCK_STDCALL_METHOD3(GetEncryptionBltKey,
833                        HRESULT(ID3D11CryptoSession*, UINT, void*));
834   MOCK_STDCALL_METHOD3(NegotiateAuthenticatedChannelKeyExchange,
835                        HRESULT(ID3D11AuthenticatedChannel*, UINT, void*));
836   MOCK_STDCALL_METHOD5(
837       QueryAuthenticatedChannel,
838       HRESULT(ID3D11AuthenticatedChannel*, UINT, const void*, UINT, void*));
839   MOCK_STDCALL_METHOD4(ConfigureAuthenticatedChannel,
840                        HRESULT(ID3D11AuthenticatedChannel*,
841                                UINT,
842                                const void*,
843                                D3D11_AUTHENTICATED_CONFIGURE_OUTPUT*));
844   MOCK_STDCALL_METHOD4(
845       VideoProcessorSetStreamRotation,
846       void(ID3D11VideoProcessor*, UINT, BOOL, D3D11_VIDEO_PROCESSOR_ROTATION));
847   MOCK_STDCALL_METHOD4(VideoProcessorGetStreamRotation,
848                        void(ID3D11VideoProcessor*,
849                             UINT,
850                             BOOL*,
851                             D3D11_VIDEO_PROCESSOR_ROTATION*));
852 };
853 
854 class D3D11VideoDecoderMock
855     : public Microsoft::WRL::RuntimeClass<
856           Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
857           ID3D11VideoDecoder> {
858  public:
859   D3D11VideoDecoderMock();
860   ~D3D11VideoDecoderMock() override;
861   MOCK_STDCALL_METHOD1(GetDevice, void(ID3D11Device**));
862   MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(const GUID&, UINT*, void*));
863   MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*));
864   MOCK_STDCALL_METHOD2(SetPrivateDataInterface,
865                        HRESULT(const GUID&, const IUnknown*));
866   MOCK_STDCALL_METHOD2(GetCreationParameters,
867                        HRESULT(D3D11_VIDEO_DECODER_DESC*,
868                                D3D11_VIDEO_DECODER_CONFIG*));
869   MOCK_STDCALL_METHOD1(GetDriverHandle, HRESULT(HANDLE*));
870 };
871 
872 // This classs must mock QueryInterface, since a lot of things are
873 // QueryInterfac()ed thru this class.
874 class D3D11DeviceContextMock
875     : public Microsoft::WRL::RuntimeClass<
876           Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
877           ID3D11DeviceContext4> {
878  public:
879   D3D11DeviceContextMock();
880   ~D3D11DeviceContextMock() override;
881 
882   MOCK_STDCALL_METHOD2(QueryInterface, HRESULT(REFIID riid, void** ppv));
883 
884   // ID3D11DevieChild methods.
885   MOCK_STDCALL_METHOD1(GetDevice, void(ID3D11Device** ppDevice));
886   MOCK_STDCALL_METHOD3(GetPrivateData,
887                        HRESULT(REFGUID guid, UINT* pDataSize, void* pData));
888   MOCK_STDCALL_METHOD3(SetPrivateData,
889                        HRESULT(REFGUID guid, UINT DataSize, const void* pData));
890   MOCK_STDCALL_METHOD2(SetPrivateDataInterface,
891                        HRESULT(REFGUID guid, const IUnknown* pData));
892 
893   // ID3D11DeviceContext methods.
894   MOCK_STDCALL_METHOD3(VSSetConstantBuffers,
895                        void(UINT StartSlot,
896                             UINT NumBuffers,
897                             ID3D11Buffer* const* ppConstantBuffers));
898 
899   MOCK_STDCALL_METHOD3(
900       PSSetShaderResources,
901       void(UINT StartSlot,
902            UINT NumViews,
903            ID3D11ShaderResourceView* const* ppShaderResourceViews));
904 
905   MOCK_STDCALL_METHOD3(PSSetShader,
906                        void(ID3D11PixelShader* pPixelShader,
907                             ID3D11ClassInstance* const* ppClassInstances,
908                             UINT NumClassInstances));
909 
910   MOCK_STDCALL_METHOD3(PSSetSamplers,
911                        void(UINT StartSlot,
912                             UINT NumSamplers,
913                             ID3D11SamplerState* const* ppSamplers));
914 
915   MOCK_STDCALL_METHOD3(VSSetShader,
916                        void(ID3D11VertexShader* pVertexShader,
917                             ID3D11ClassInstance* const* ppClassInstances,
918                             UINT NumClassInstances));
919 
920   MOCK_STDCALL_METHOD3(DrawIndexed,
921                        void(UINT IndexCount,
922                             UINT StartIndexLocation,
923                             INT BaseVertexLocation));
924 
925   MOCK_STDCALL_METHOD2(Draw, void(UINT VertexCount, UINT StartVertexLocation));
926 
927   MOCK_STDCALL_METHOD5(Map,
928                        HRESULT(ID3D11Resource* pResource,
929                                UINT Subresource,
930                                D3D11_MAP MapType,
931                                UINT MapFlags,
932                                D3D11_MAPPED_SUBRESOURCE* pMappedResource));
933 
934   MOCK_STDCALL_METHOD2(Unmap,
935                        void(ID3D11Resource* pResource, UINT Subresource));
936 
937   MOCK_STDCALL_METHOD3(PSSetConstantBuffers,
938                        void(UINT StartSlot,
939                             UINT NumBuffers,
940                             ID3D11Buffer* const* ppConstantBuffers));
941 
942   MOCK_STDCALL_METHOD1(IASetInputLayout, void(ID3D11InputLayout* pInputLayout));
943 
944   MOCK_STDCALL_METHOD5(IASetVertexBuffers,
945                        void(UINT StartSlot,
946                             UINT NumBuffers,
947                             ID3D11Buffer* const* ppVertexBuffers,
948                             const UINT* pStrides,
949                             const UINT* pOffsets));
950 
951   MOCK_STDCALL_METHOD3(IASetIndexBuffer,
952                        void(ID3D11Buffer* pIndexBuffer,
953                             DXGI_FORMAT Format,
954                             UINT Offset));
955 
956   MOCK_STDCALL_METHOD5(DrawIndexedInstanced,
957                        void(UINT IndexCountPerInstance,
958                             UINT InstanceCount,
959                             UINT StartIndexLocation,
960                             INT BaseVertexLocation,
961                             UINT StartInstanceLocation));
962 
963   MOCK_STDCALL_METHOD4(DrawInstanced,
964                        void(UINT VertexCountPerInstance,
965                             UINT InstanceCount,
966                             UINT StartVertexLocation,
967                             UINT StartInstanceLocation));
968 
969   MOCK_STDCALL_METHOD3(GSSetConstantBuffers,
970                        void(UINT StartSlot,
971                             UINT NumBuffers,
972                             ID3D11Buffer* const* ppConstantBuffers));
973 
974   MOCK_STDCALL_METHOD3(GSSetShader,
975                        void(ID3D11GeometryShader* pShader,
976                             ID3D11ClassInstance* const* ppClassInstances,
977                             UINT NumClassInstances));
978 
979   MOCK_STDCALL_METHOD1(IASetPrimitiveTopology,
980                        void(D3D11_PRIMITIVE_TOPOLOGY Topology));
981 
982   MOCK_STDCALL_METHOD3(
983       VSSetShaderResources,
984       void(UINT StartSlot,
985            UINT NumViews,
986            ID3D11ShaderResourceView* const* ppShaderResourceViews));
987 
988   MOCK_STDCALL_METHOD3(VSSetSamplers,
989                        void(UINT StartSlot,
990                             UINT NumSamplers,
991                             ID3D11SamplerState* const* ppSamplers));
992 
993   MOCK_STDCALL_METHOD1(Begin, void(ID3D11Asynchronous* pAsync));
994 
995   MOCK_STDCALL_METHOD1(End, void(ID3D11Asynchronous* pAsync));
996 
997   MOCK_STDCALL_METHOD4(GetData,
998                        HRESULT(ID3D11Asynchronous* pAsync,
999                                void* pData,
1000                                UINT DataSize,
1001                                UINT GetDataFlags));
1002 
1003   MOCK_STDCALL_METHOD2(SetPredication,
1004                        void(ID3D11Predicate* pPredicate, BOOL PredicateValue));
1005 
1006   MOCK_STDCALL_METHOD3(
1007       GSSetShaderResources,
1008       void(UINT StartSlot,
1009            UINT NumViews,
1010            ID3D11ShaderResourceView* const* ppShaderResourceViews));
1011 
1012   MOCK_STDCALL_METHOD3(GSSetSamplers,
1013                        void(UINT StartSlot,
1014                             UINT NumSamplers,
1015                             ID3D11SamplerState* const* ppSamplers));
1016 
1017   MOCK_STDCALL_METHOD3(OMSetRenderTargets,
1018                        void(UINT NumViews,
1019                             ID3D11RenderTargetView* const* ppRenderTargetViews,
1020                             ID3D11DepthStencilView* pDepthStencilView));
1021 
1022   MOCK_STDCALL_METHOD7(
1023       OMSetRenderTargetsAndUnorderedAccessViews,
1024       void(UINT NumRTVs,
1025            ID3D11RenderTargetView* const* ppRenderTargetViews,
1026            ID3D11DepthStencilView* pDepthStencilView,
1027            UINT UAVStartSlot,
1028            UINT NumUAVs,
1029            ID3D11UnorderedAccessView* const* ppUnorderedAccessViews,
1030            const UINT* pUAVInitialCounts));
1031 
1032   MOCK_STDCALL_METHOD3(OMSetBlendState,
1033                        void(ID3D11BlendState* pBlendState,
1034                             const FLOAT BlendFactor[4],
1035                             UINT SampleMask));
1036 
1037   MOCK_STDCALL_METHOD2(OMSetDepthStencilState,
1038                        void(ID3D11DepthStencilState* pDepthStencilState,
1039                             UINT StencilRef));
1040 
1041   MOCK_STDCALL_METHOD3(SOSetTargets,
1042                        void(UINT NumBuffers,
1043                             ID3D11Buffer* const* ppSOTargets,
1044                             const UINT* pOffsets));
1045 
1046   MOCK_STDCALL_METHOD0(DrawAuto, void());
1047 
1048   MOCK_STDCALL_METHOD2(DrawIndexedInstancedIndirect,
1049                        void(ID3D11Buffer* pBufferForArgs,
1050                             UINT AlignedByteOffsetForArgs));
1051 
1052   MOCK_STDCALL_METHOD2(DrawInstancedIndirect,
1053                        void(ID3D11Buffer* pBufferForArgs,
1054                             UINT AlignedByteOffsetForArgs));
1055 
1056   MOCK_STDCALL_METHOD3(Dispatch,
1057                        void(UINT ThreadGroupCountX,
1058                             UINT ThreadGroupCountY,
1059                             UINT ThreadGroupCountZ));
1060 
1061   MOCK_STDCALL_METHOD2(DispatchIndirect,
1062                        void(ID3D11Buffer* pBufferForArgs,
1063                             UINT AlignedByteOffsetForArgs));
1064 
1065   MOCK_STDCALL_METHOD1(RSSetState,
1066                        void(ID3D11RasterizerState* pRasterizerState));
1067 
1068   MOCK_STDCALL_METHOD2(RSSetViewports,
1069                        void(UINT NumViewports,
1070                             const D3D11_VIEWPORT* pViewports));
1071 
1072   MOCK_STDCALL_METHOD2(RSSetScissorRects,
1073                        void(UINT NumRects, const D3D11_RECT* pRects));
1074 
1075   MOCK_STDCALL_METHOD8(CopySubresourceRegion,
1076                        void(ID3D11Resource* pDstResource,
1077                             UINT DstSubresource,
1078                             UINT DstX,
1079                             UINT DstY,
1080                             UINT DstZ,
1081                             ID3D11Resource* pSrcResource,
1082                             UINT SrcSubresource,
1083                             const D3D11_BOX* pSrcBox));
1084 
1085   MOCK_STDCALL_METHOD2(CopyResource,
1086                        void(ID3D11Resource* pDstResource,
1087                             ID3D11Resource* pSrcResource));
1088 
1089   MOCK_STDCALL_METHOD6(UpdateSubresource,
1090                        void(ID3D11Resource* pDstResource,
1091                             UINT DstSubresource,
1092                             const D3D11_BOX* pDstBox,
1093                             const void* pSrcData,
1094                             UINT SrcRowPitch,
1095                             UINT SrcDepthPitch));
1096 
1097   MOCK_STDCALL_METHOD3(CopyStructureCount,
1098                        void(ID3D11Buffer* pDstBuffer,
1099                             UINT DstAlignedByteOffset,
1100                             ID3D11UnorderedAccessView* pSrcView));
1101 
1102   MOCK_STDCALL_METHOD2(ClearRenderTargetView,
1103                        void(ID3D11RenderTargetView* pRenderTargetView,
1104                             const FLOAT ColorRGBA[4]));
1105 
1106   MOCK_STDCALL_METHOD2(ClearUnorderedAccessViewUint,
1107                        void(ID3D11UnorderedAccessView* pUnorderedAccessView,
1108                             const UINT Values[4]));
1109 
1110   MOCK_STDCALL_METHOD2(ClearUnorderedAccessViewFloat,
1111                        void(ID3D11UnorderedAccessView* pUnorderedAccessView,
1112                             const FLOAT Values[4]));
1113 
1114   MOCK_STDCALL_METHOD4(ClearDepthStencilView,
1115                        void(ID3D11DepthStencilView* pDepthStencilView,
1116                             UINT ClearFlags,
1117                             FLOAT Depth,
1118                             UINT8 Stencil));
1119 
1120   MOCK_STDCALL_METHOD1(GenerateMips,
1121                        void(ID3D11ShaderResourceView* pShaderResourceView));
1122 
1123   MOCK_STDCALL_METHOD2(SetResourceMinLOD,
1124                        void(ID3D11Resource* pResource, FLOAT MinLOD));
1125 
1126   MOCK_STDCALL_METHOD1(GetResourceMinLOD, FLOAT(ID3D11Resource* pResource));
1127 
1128   MOCK_STDCALL_METHOD5(ResolveSubresource,
1129                        void(ID3D11Resource* pDstResource,
1130                             UINT DstSubresource,
1131                             ID3D11Resource* pSrcResource,
1132                             UINT SrcSubresource,
1133                             DXGI_FORMAT Format));
1134 
1135   MOCK_STDCALL_METHOD2(ExecuteCommandList,
1136                        void(ID3D11CommandList* pCommandList,
1137                             BOOL RestoreContextState));
1138 
1139   MOCK_STDCALL_METHOD3(
1140       HSSetShaderResources,
1141       void(UINT StartSlot,
1142            UINT NumViews,
1143            ID3D11ShaderResourceView* const* ppShaderResourceViews));
1144 
1145   MOCK_STDCALL_METHOD3(HSSetShader,
1146                        void(ID3D11HullShader* pHullShader,
1147                             ID3D11ClassInstance* const* ppClassInstances,
1148                             UINT NumClassInstances));
1149 
1150   MOCK_STDCALL_METHOD3(HSSetSamplers,
1151                        void(UINT StartSlot,
1152                             UINT NumSamplers,
1153                             ID3D11SamplerState* const* ppSamplers));
1154 
1155   MOCK_STDCALL_METHOD3(HSSetConstantBuffers,
1156                        void(UINT StartSlot,
1157                             UINT NumBuffers,
1158                             ID3D11Buffer* const* ppConstantBuffers));
1159 
1160   MOCK_STDCALL_METHOD3(
1161       DSSetShaderResources,
1162       void(UINT StartSlot,
1163            UINT NumViews,
1164            ID3D11ShaderResourceView* const* ppShaderResourceViews));
1165 
1166   MOCK_STDCALL_METHOD3(DSSetShader,
1167                        void(ID3D11DomainShader* pDomainShader,
1168                             ID3D11ClassInstance* const* ppClassInstances,
1169                             UINT NumClassInstances));
1170 
1171   MOCK_STDCALL_METHOD3(DSSetSamplers,
1172                        void(UINT StartSlot,
1173                             UINT NumSamplers,
1174                             ID3D11SamplerState* const* ppSamplers));
1175 
1176   MOCK_STDCALL_METHOD3(DSSetConstantBuffers,
1177                        void(UINT StartSlot,
1178                             UINT NumBuffers,
1179                             ID3D11Buffer* const* ppConstantBuffers));
1180 
1181   MOCK_STDCALL_METHOD3(
1182       CSSetShaderResources,
1183       void(UINT StartSlot,
1184            UINT NumViews,
1185            ID3D11ShaderResourceView* const* ppShaderResourceViews));
1186 
1187   MOCK_STDCALL_METHOD4(
1188       CSSetUnorderedAccessViews,
1189       void(UINT StartSlot,
1190            UINT NumUAVs,
1191            ID3D11UnorderedAccessView* const* ppUnorderedAccessViews,
1192            const UINT* pUAVInitialCounts));
1193 
1194   MOCK_STDCALL_METHOD3(CSSetShader,
1195                        void(ID3D11ComputeShader* pComputeShader,
1196                             ID3D11ClassInstance* const* ppClassInstances,
1197                             UINT NumClassInstances));
1198 
1199   MOCK_STDCALL_METHOD3(CSSetSamplers,
1200                        void(UINT StartSlot,
1201                             UINT NumSamplers,
1202                             ID3D11SamplerState* const* ppSamplers));
1203 
1204   MOCK_STDCALL_METHOD3(CSSetConstantBuffers,
1205                        void(UINT StartSlot,
1206                             UINT NumBuffers,
1207                             ID3D11Buffer* const* ppConstantBuffers));
1208 
1209   MOCK_STDCALL_METHOD3(VSGetConstantBuffers,
1210                        void(UINT StartSlot,
1211                             UINT NumBuffers,
1212                             ID3D11Buffer** ppConstantBuffers));
1213 
1214   MOCK_STDCALL_METHOD3(PSGetShaderResources,
1215                        void(UINT StartSlot,
1216                             UINT NumViews,
1217                             ID3D11ShaderResourceView** ppShaderResourceViews));
1218 
1219   MOCK_STDCALL_METHOD3(PSGetShader,
1220                        void(ID3D11PixelShader** ppPixelShader,
1221                             ID3D11ClassInstance** ppClassInstances,
1222                             UINT* pNumClassInstances));
1223 
1224   MOCK_STDCALL_METHOD3(PSGetSamplers,
1225                        void(UINT StartSlot,
1226                             UINT NumSamplers,
1227                             ID3D11SamplerState** ppSamplers));
1228 
1229   MOCK_STDCALL_METHOD3(VSGetShader,
1230                        void(ID3D11VertexShader** ppVertexShader,
1231                             ID3D11ClassInstance** ppClassInstances,
1232                             UINT* pNumClassInstances));
1233 
1234   MOCK_STDCALL_METHOD3(PSGetConstantBuffers,
1235                        void(UINT StartSlot,
1236                             UINT NumBuffers,
1237                             ID3D11Buffer** ppConstantBuffers));
1238 
1239   MOCK_STDCALL_METHOD1(IAGetInputLayout,
1240                        void(ID3D11InputLayout** ppInputLayout));
1241 
1242   MOCK_STDCALL_METHOD5(IAGetVertexBuffers,
1243                        void(UINT StartSlot,
1244                             UINT NumBuffers,
1245                             ID3D11Buffer** ppVertexBuffers,
1246                             UINT* pStrides,
1247                             UINT* pOffsets));
1248 
1249   MOCK_STDCALL_METHOD3(IAGetIndexBuffer,
1250                        void(ID3D11Buffer** pIndexBuffer,
1251                             DXGI_FORMAT* Format,
1252                             UINT* Offset));
1253 
1254   MOCK_STDCALL_METHOD3(GSGetConstantBuffers,
1255                        void(UINT StartSlot,
1256                             UINT NumBuffers,
1257                             ID3D11Buffer** ppConstantBuffers));
1258 
1259   MOCK_STDCALL_METHOD3(GSGetShader,
1260                        void(ID3D11GeometryShader** ppGeometryShader,
1261                             ID3D11ClassInstance** ppClassInstances,
1262                             UINT* pNumClassInstances));
1263 
1264   MOCK_STDCALL_METHOD1(IAGetPrimitiveTopology,
1265                        void(D3D11_PRIMITIVE_TOPOLOGY* pTopology));
1266 
1267   MOCK_STDCALL_METHOD3(VSGetShaderResources,
1268                        void(UINT StartSlot,
1269                             UINT NumViews,
1270                             ID3D11ShaderResourceView** ppShaderResourceViews));
1271 
1272   MOCK_STDCALL_METHOD3(VSGetSamplers,
1273                        void(UINT StartSlot,
1274                             UINT NumSamplers,
1275                             ID3D11SamplerState** ppSamplers));
1276 
1277   MOCK_STDCALL_METHOD2(GetPredication,
1278                        void(ID3D11Predicate** ppPredicate,
1279                             BOOL* pPredicateValue));
1280 
1281   MOCK_STDCALL_METHOD3(GSGetShaderResources,
1282                        void(UINT StartSlot,
1283                             UINT NumViews,
1284                             ID3D11ShaderResourceView** ppShaderResourceViews));
1285 
1286   MOCK_STDCALL_METHOD3(GSGetSamplers,
1287                        void(UINT StartSlot,
1288                             UINT NumSamplers,
1289                             ID3D11SamplerState** ppSamplers));
1290 
1291   MOCK_STDCALL_METHOD3(OMGetRenderTargets,
1292                        void(UINT NumViews,
1293                             ID3D11RenderTargetView** ppRenderTargetViews,
1294                             ID3D11DepthStencilView** ppDepthStencilView));
1295 
1296   MOCK_STDCALL_METHOD6(
1297       OMGetRenderTargetsAndUnorderedAccessViews,
1298       void(UINT NumRTVs,
1299            ID3D11RenderTargetView** ppRenderTargetViews,
1300            ID3D11DepthStencilView** ppDepthStencilView,
1301            UINT UAVStartSlot,
1302            UINT NumUAVs,
1303            ID3D11UnorderedAccessView** ppUnorderedAccessViews));
1304 
1305   MOCK_STDCALL_METHOD3(OMGetBlendState,
1306                        void(ID3D11BlendState** ppBlendState,
1307                             FLOAT BlendFactor[4],
1308                             UINT* pSampleMask));
1309 
1310   MOCK_STDCALL_METHOD2(OMGetDepthStencilState,
1311                        void(ID3D11DepthStencilState** ppDepthStencilState,
1312                             UINT* pStencilRef));
1313 
1314   MOCK_STDCALL_METHOD2(SOGetTargets,
1315                        void(UINT NumBuffers, ID3D11Buffer** ppSOTargets));
1316 
1317   MOCK_STDCALL_METHOD1(RSGetState,
1318                        void(ID3D11RasterizerState** ppRasterizerState));
1319 
1320   MOCK_STDCALL_METHOD2(RSGetViewports,
1321                        void(UINT* pNumViewports, D3D11_VIEWPORT* pViewports));
1322 
1323   MOCK_STDCALL_METHOD2(RSGetScissorRects,
1324                        void(UINT* pNumRects, D3D11_RECT* pRects));
1325 
1326   MOCK_STDCALL_METHOD3(HSGetShaderResources,
1327                        void(UINT StartSlot,
1328                             UINT NumViews,
1329                             ID3D11ShaderResourceView** ppShaderResourceViews));
1330 
1331   MOCK_STDCALL_METHOD3(HSGetShader,
1332                        void(ID3D11HullShader** ppHullShader,
1333                             ID3D11ClassInstance** ppClassInstances,
1334                             UINT* pNumClassInstances));
1335 
1336   MOCK_STDCALL_METHOD3(HSGetSamplers,
1337                        void(UINT StartSlot,
1338                             UINT NumSamplers,
1339                             ID3D11SamplerState** ppSamplers));
1340 
1341   MOCK_STDCALL_METHOD3(HSGetConstantBuffers,
1342                        void(UINT StartSlot,
1343                             UINT NumBuffers,
1344                             ID3D11Buffer** ppConstantBuffers));
1345 
1346   MOCK_STDCALL_METHOD3(DSGetShaderResources,
1347                        void(UINT StartSlot,
1348                             UINT NumViews,
1349                             ID3D11ShaderResourceView** ppShaderResourceViews));
1350 
1351   MOCK_STDCALL_METHOD3(DSGetShader,
1352                        void(ID3D11DomainShader** ppDomainShader,
1353                             ID3D11ClassInstance** ppClassInstances,
1354                             UINT* pNumClassInstances));
1355 
1356   MOCK_STDCALL_METHOD3(DSGetSamplers,
1357                        void(UINT StartSlot,
1358                             UINT NumSamplers,
1359                             ID3D11SamplerState** ppSamplers));
1360 
1361   MOCK_STDCALL_METHOD3(DSGetConstantBuffers,
1362                        void(UINT StartSlot,
1363                             UINT NumBuffers,
1364                             ID3D11Buffer** ppConstantBuffers));
1365 
1366   MOCK_STDCALL_METHOD3(CSGetShaderResources,
1367                        void(UINT StartSlot,
1368                             UINT NumViews,
1369                             ID3D11ShaderResourceView** ppShaderResourceViews));
1370 
1371   MOCK_STDCALL_METHOD3(
1372       CSGetUnorderedAccessViews,
1373       void(UINT StartSlot,
1374            UINT NumUAVs,
1375            ID3D11UnorderedAccessView** ppUnorderedAccessViews));
1376 
1377   MOCK_STDCALL_METHOD3(CSGetShader,
1378                        void(ID3D11ComputeShader** ppComputeShader,
1379                             ID3D11ClassInstance** ppClassInstances,
1380                             UINT* pNumClassInstances));
1381 
1382   MOCK_STDCALL_METHOD3(CSGetSamplers,
1383                        void(UINT StartSlot,
1384                             UINT NumSamplers,
1385                             ID3D11SamplerState** ppSamplers));
1386 
1387   MOCK_STDCALL_METHOD3(CSGetConstantBuffers,
1388                        void(UINT StartSlot,
1389                             UINT NumBuffers,
1390                             ID3D11Buffer** ppConstantBuffers));
1391 
1392   MOCK_STDCALL_METHOD0(ClearState, void());
1393 
1394   MOCK_STDCALL_METHOD0(Flush, void());
1395 
1396   MOCK_STDCALL_METHOD0(GetType, D3D11_DEVICE_CONTEXT_TYPE());
1397 
1398   MOCK_STDCALL_METHOD0(GetContextFlags, UINT());
1399 
1400   MOCK_STDCALL_METHOD2(FinishCommandList,
1401                        HRESULT(BOOL RestoreDeferredContextState,
1402                                ID3D11CommandList** ppCommandList));
1403 
1404   // ID3D11DeviceContext1
1405   MOCK_STDCALL_METHOD9(CopySubresourceRegion1,
1406                        void(ID3D11Resource*,
1407                             UINT,
1408                             UINT,
1409                             UINT,
1410                             UINT,
1411                             ID3D11Resource*,
1412                             UINT,
1413                             const D3D11_BOX*,
1414                             UINT));
1415 
1416   MOCK_STDCALL_METHOD7(UpdateSubresource1,
1417                        void(ID3D11Resource*,
1418                             UINT,
1419                             const D3D11_BOX*,
1420                             const void*,
1421                             UINT,
1422                             UINT,
1423                             UINT));
1424 
1425   MOCK_STDCALL_METHOD1(DiscardResource, void(ID3D11Resource*));
1426 
1427   MOCK_STDCALL_METHOD1(DiscardView, void(ID3D11View*));
1428 
1429   MOCK_STDCALL_METHOD5(
1430       VSSetConstantBuffers1,
1431       void(UINT, UINT, ID3D11Buffer* const*, const UINT*, const UINT*));
1432 
1433   MOCK_STDCALL_METHOD5(
1434       HSSetConstantBuffers1,
1435       void(UINT, UINT, ID3D11Buffer* const*, const UINT*, const UINT*));
1436 
1437   MOCK_STDCALL_METHOD5(
1438       DSSetConstantBuffers1,
1439       void(UINT, UINT, ID3D11Buffer* const*, const UINT*, const UINT*));
1440 
1441   MOCK_STDCALL_METHOD5(
1442       GSSetConstantBuffers1,
1443       void(UINT, UINT, ID3D11Buffer* const*, const UINT*, const UINT*));
1444 
1445   MOCK_STDCALL_METHOD5(
1446       PSSetConstantBuffers1,
1447       void(UINT, UINT, ID3D11Buffer* const*, const UINT*, const UINT*));
1448 
1449   MOCK_STDCALL_METHOD5(
1450       CSSetConstantBuffers1,
1451       void(UINT, UINT, ID3D11Buffer* const*, const UINT*, const UINT*));
1452 
1453   MOCK_STDCALL_METHOD5(VSGetConstantBuffers1,
1454                        void(UINT, UINT, ID3D11Buffer**, UINT*, UINT*));
1455 
1456   MOCK_STDCALL_METHOD5(HSGetConstantBuffers1,
1457                        void(UINT, UINT, ID3D11Buffer**, UINT*, UINT*));
1458 
1459   MOCK_STDCALL_METHOD5(DSGetConstantBuffers1,
1460                        void(UINT, UINT, ID3D11Buffer**, UINT*, UINT*));
1461 
1462   MOCK_STDCALL_METHOD5(GSGetConstantBuffers1,
1463                        void(UINT, UINT, ID3D11Buffer**, UINT*, UINT*));
1464 
1465   MOCK_STDCALL_METHOD5(PSGetConstantBuffers1,
1466                        void(UINT, UINT, ID3D11Buffer**, UINT*, UINT*));
1467 
1468   MOCK_STDCALL_METHOD5(CSGetConstantBuffers1,
1469                        void(UINT, UINT, ID3D11Buffer**, UINT*, UINT*));
1470 
1471   MOCK_STDCALL_METHOD2(SwapDeviceContextState,
1472                        void(ID3DDeviceContextState*, ID3DDeviceContextState**));
1473 
1474   MOCK_STDCALL_METHOD4(
1475       ClearView,
1476       void(ID3D11View*, const FLOAT[4], const D3D11_RECT*, UINT));
1477 
1478   MOCK_STDCALL_METHOD3(DiscardView1,
1479                        void(ID3D11View*, const D3D11_RECT*, UINT));
1480 
1481   // ID3D11DeviceContext2
1482   MOCK_STDCALL_METHOD10(UpdateTileMappings,
1483                         HRESULT(ID3D11Resource*,
1484                                 UINT,
1485                                 const D3D11_TILED_RESOURCE_COORDINATE*,
1486                                 const D3D11_TILE_REGION_SIZE*,
1487                                 ID3D11Buffer*,
1488                                 UINT,
1489                                 const UINT*,
1490                                 const UINT*,
1491                                 const UINT*,
1492                                 UINT));
1493 
1494   MOCK_STDCALL_METHOD6(CopyTileMappings,
1495                        HRESULT(ID3D11Resource*,
1496                                const D3D11_TILED_RESOURCE_COORDINATE*,
1497                                ID3D11Resource*,
1498                                const D3D11_TILED_RESOURCE_COORDINATE*,
1499                                const D3D11_TILE_REGION_SIZE*,
1500                                UINT));
1501 
1502   MOCK_STDCALL_METHOD6(CopyTiles,
1503                        void(ID3D11Resource*,
1504                             const D3D11_TILED_RESOURCE_COORDINATE*,
1505                             const D3D11_TILE_REGION_SIZE*,
1506                             ID3D11Buffer*,
1507                             UINT64,
1508                             UINT));
1509 
1510   MOCK_STDCALL_METHOD5(UpdateTiles,
1511                        void(ID3D11Resource*,
1512                             const D3D11_TILED_RESOURCE_COORDINATE*,
1513                             const D3D11_TILE_REGION_SIZE*,
1514                             const void*,
1515                             UINT));
1516 
1517   MOCK_STDCALL_METHOD2(ResizeTilePool, HRESULT(ID3D11Buffer*, UINT64));
1518 
1519   MOCK_STDCALL_METHOD2(TiledResourceBarrier,
1520                        void(ID3D11DeviceChild*, ID3D11DeviceChild*));
1521 
1522   MOCK_STDCALL_METHOD0(IsAnnotationEnabled, BOOL());
1523 
1524   MOCK_STDCALL_METHOD2(SetMarkerInt, void(LPCWSTR, INT));
1525 
1526   MOCK_STDCALL_METHOD2(BeginEventInt, void(LPCWSTR, INT));
1527 
1528   MOCK_STDCALL_METHOD0(EndEvent, void());
1529 
1530   // ID3D11DeviceContext3
1531   MOCK_STDCALL_METHOD2(Flush1, void(D3D11_CONTEXT_TYPE, HANDLE));
1532 
1533   MOCK_STDCALL_METHOD1(SetHardwareProtectionState, void(BOOL));
1534 
1535   MOCK_STDCALL_METHOD1(GetHardwareProtectionState, void(BOOL*));
1536 
1537   // ID3D11DeviceContext4
1538   MOCK_STDCALL_METHOD2(Signal, HRESULT(ID3D11Fence*, UINT64));
1539 
1540   MOCK_STDCALL_METHOD2(Wait, HRESULT(ID3D11Fence*, UINT64));
1541 };
1542 
1543 class D3D11FenceMock
1544     : public Microsoft::WRL::RuntimeClass<
1545           Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
1546           ID3D11Fence> {
1547  public:
1548   D3D11FenceMock();
1549   ~D3D11FenceMock() override;
1550 
1551   MOCK_STDCALL_METHOD1(GetDevice, void(ID3D11Device**));
1552   MOCK_STDCALL_METHOD3(GetPrivateData, HRESULT(const GUID&, UINT*, void*));
1553   MOCK_STDCALL_METHOD3(SetPrivateData, HRESULT(const GUID&, UINT, const void*));
1554   MOCK_STDCALL_METHOD2(SetPrivateDataInterface,
1555                        HRESULT(const GUID&, const IUnknown*));
1556 
1557   MOCK_STDCALL_METHOD4(
1558       CreateSharedHandle,
1559       HRESULT(const SECURITY_ATTRIBUTES*, DWORD, LPCWSTR, HANDLE*));
1560 
1561   MOCK_STDCALL_METHOD0(GetCompletedValue, UINT64());
1562 
1563   MOCK_STDCALL_METHOD2(SetEventOnCompletion, HRESULT(UINT64, HANDLE));
1564 };
1565 
1566 }  // namespace media
1567 
1568 #endif  // MEDIA_BASE_WIN_D3D11_MOCKS_H_
1569