1// Code generated by MockGen. DO NOT EDIT.
2// Source: interfaces.go
3
4// Package mock_browser is a generated GoMock package.
5package mock_browser
6
7import (
8 reflect "reflect"
9
10 browser "github.com/bnema/dumber/internal/app/browser"
11 messaging "github.com/bnema/dumber/internal/app/messaging"
12 webkit "github.com/bnema/dumber/pkg/webkit"
13 gomock "github.com/golang/mock/gomock"
14)
15
16// MockWebViewInterface is a mock of WebViewInterface interface.
17type MockWebViewInterface struct {
18 ctrl *gomock.Controller
19 recorder *MockWebViewInterfaceMockRecorder
20}
21
22// MockWebViewInterfaceMockRecorder is the mock recorder for MockWebViewInterface.
23type MockWebViewInterfaceMockRecorder struct {
24 mock *MockWebViewInterface
25}
26
27// NewMockWebViewInterface creates a new mock instance.
28func NewMockWebViewInterface(ctrl *gomock.Controller) *MockWebViewInterface {
29 mock := &MockWebViewInterface{ctrl: ctrl}
30 mock.recorder = &MockWebViewInterfaceMockRecorder{mock}
31 return mock
32}
33
34// EXPECT returns an object that allows the caller to indicate expected use.
35func (m *MockWebViewInterface) EXPECT() *MockWebViewInterfaceMockRecorder {
36 return m.recorder
37}
38
39// Destroy mocks base method.
40func (m *MockWebViewInterface) Destroy() error {
41 m.ctrl.T.Helper()
42 ret := m.ctrl.Call(m, "Destroy")
43 ret0, _ := ret[0].(error)
44 return ret0
45}
46
47// Destroy indicates an expected call of Destroy.
48func (mr *MockWebViewInterfaceMockRecorder) Destroy() *gomock.Call {
49 mr.mock.ctrl.T.Helper()
50 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Destroy", reflect.TypeOf((*MockWebViewInterface)(nil).Destroy))
51}
52
53// DispatchCustomEvent mocks base method.
54func (m *MockWebViewInterface) DispatchCustomEvent(event string, detail map[string]any) error {
55 m.ctrl.T.Helper()
56 ret := m.ctrl.Call(m, "DispatchCustomEvent", event, detail)
57 ret0, _ := ret[0].(error)
58 return ret0
59}
60
61// DispatchCustomEvent indicates an expected call of DispatchCustomEvent.
62func (mr *MockWebViewInterfaceMockRecorder) DispatchCustomEvent(event, detail interface{}) *gomock.Call {
63 mr.mock.ctrl.T.Helper()
64 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DispatchCustomEvent", reflect.TypeOf((*MockWebViewInterface)(nil).DispatchCustomEvent), event, detail)
65}
66
67// GetCurrentURL mocks base method.
68func (m *MockWebViewInterface) GetCurrentURL() string {
69 m.ctrl.T.Helper()
70 ret := m.ctrl.Call(m, "GetCurrentURL")
71 ret0, _ := ret[0].(string)
72 return ret0
73}
74
75// GetCurrentURL indicates an expected call of GetCurrentURL.
76func (mr *MockWebViewInterfaceMockRecorder) GetCurrentURL() *gomock.Call {
77 mr.mock.ctrl.T.Helper()
78 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentURL", reflect.TypeOf((*MockWebViewInterface)(nil).GetCurrentURL))
79}
80
81// Hide mocks base method.
82func (m *MockWebViewInterface) Hide() error {
83 m.ctrl.T.Helper()
84 ret := m.ctrl.Call(m, "Hide")
85 ret0, _ := ret[0].(error)
86 return ret0
87}
88
89// Hide indicates an expected call of Hide.
90func (mr *MockWebViewInterfaceMockRecorder) Hide() *gomock.Call {
91 mr.mock.ctrl.T.Helper()
92 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Hide", reflect.TypeOf((*MockWebViewInterface)(nil).Hide))
93}
94
95// InjectScript mocks base method.
96func (m *MockWebViewInterface) InjectScript(script string) error {
97 m.ctrl.T.Helper()
98 ret := m.ctrl.Call(m, "InjectScript", script)
99 ret0, _ := ret[0].(error)
100 return ret0
101}
102
103// InjectScript indicates an expected call of InjectScript.
104func (mr *MockWebViewInterfaceMockRecorder) InjectScript(script interface{}) *gomock.Call {
105 mr.mock.ctrl.T.Helper()
106 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InjectScript", reflect.TypeOf((*MockWebViewInterface)(nil).InjectScript), script)
107}
108
109// LoadURL mocks base method.
110func (m *MockWebViewInterface) LoadURL(url string) error {
111 m.ctrl.T.Helper()
112 ret := m.ctrl.Call(m, "LoadURL", url)
113 ret0, _ := ret[0].(error)
114 return ret0
115}
116
117// LoadURL indicates an expected call of LoadURL.
118func (mr *MockWebViewInterfaceMockRecorder) LoadURL(url interface{}) *gomock.Call {
119 mr.mock.ctrl.T.Helper()
120 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadURL", reflect.TypeOf((*MockWebViewInterface)(nil).LoadURL), url)
121}
122
123// RegisterKeyboardShortcut mocks base method.
124func (m *MockWebViewInterface) RegisterKeyboardShortcut(key string, handler func()) error {
125 m.ctrl.T.Helper()
126 ret := m.ctrl.Call(m, "RegisterKeyboardShortcut", key, handler)
127 ret0, _ := ret[0].(error)
128 return ret0
129}
130
131// RegisterKeyboardShortcut indicates an expected call of RegisterKeyboardShortcut.
132func (mr *MockWebViewInterfaceMockRecorder) RegisterKeyboardShortcut(key, handler interface{}) *gomock.Call {
133 mr.mock.ctrl.T.Helper()
134 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterKeyboardShortcut", reflect.TypeOf((*MockWebViewInterface)(nil).RegisterKeyboardShortcut), key, handler)
135}
136
137// RegisterURIChangedHandler mocks base method.
138func (m *MockWebViewInterface) RegisterURIChangedHandler(handler func(string)) {
139 m.ctrl.T.Helper()
140 m.ctrl.Call(m, "RegisterURIChangedHandler", handler)
141}
142
143// RegisterURIChangedHandler indicates an expected call of RegisterURIChangedHandler.
144func (mr *MockWebViewInterfaceMockRecorder) RegisterURIChangedHandler(handler interface{}) *gomock.Call {
145 mr.mock.ctrl.T.Helper()
146 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterURIChangedHandler", reflect.TypeOf((*MockWebViewInterface)(nil).RegisterURIChangedHandler), handler)
147}
148
149// RootWidget mocks base method.
150func (m *MockWebViewInterface) RootWidget() uintptr {
151 m.ctrl.T.Helper()
152 ret := m.ctrl.Call(m, "RootWidget")
153 ret0, _ := ret[0].(uintptr)
154 return ret0
155}
156
157// RootWidget indicates an expected call of RootWidget.
158func (mr *MockWebViewInterfaceMockRecorder) RootWidget() *gomock.Call {
159 mr.mock.ctrl.T.Helper()
160 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RootWidget", reflect.TypeOf((*MockWebViewInterface)(nil).RootWidget))
161}
162
163// Show mocks base method.
164func (m *MockWebViewInterface) Show() error {
165 m.ctrl.T.Helper()
166 ret := m.ctrl.Call(m, "Show")
167 ret0, _ := ret[0].(error)
168 return ret0
169}
170
171// Show indicates an expected call of Show.
172func (mr *MockWebViewInterfaceMockRecorder) Show() *gomock.Call {
173 mr.mock.ctrl.T.Helper()
174 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Show", reflect.TypeOf((*MockWebViewInterface)(nil).Show))
175}
176
177// Widget mocks base method.
178func (m *MockWebViewInterface) Widget() uintptr {
179 m.ctrl.T.Helper()
180 ret := m.ctrl.Call(m, "Widget")
181 ret0, _ := ret[0].(uintptr)
182 return ret0
183}
184
185// Widget indicates an expected call of Widget.
186func (mr *MockWebViewInterfaceMockRecorder) Widget() *gomock.Call {
187 mr.mock.ctrl.T.Helper()
188 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Widget", reflect.TypeOf((*MockWebViewInterface)(nil).Widget))
189}
190
191// Window mocks base method.
192func (m *MockWebViewInterface) Window() *webkit.Window {
193 m.ctrl.T.Helper()
194 ret := m.ctrl.Call(m, "Window")
195 ret0, _ := ret[0].(*webkit.Window)
196 return ret0
197}
198
199// Window indicates an expected call of Window.
200func (mr *MockWebViewInterfaceMockRecorder) Window() *gomock.Call {
201 mr.mock.ctrl.T.Helper()
202 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Window", reflect.TypeOf((*MockWebViewInterface)(nil).Window))
203}
204
205// MockPaneInterface is a mock of PaneInterface interface.
206type MockPaneInterface struct {
207 ctrl *gomock.Controller
208 recorder *MockPaneInterfaceMockRecorder
209}
210
211// MockPaneInterfaceMockRecorder is the mock recorder for MockPaneInterface.
212type MockPaneInterfaceMockRecorder struct {
213 mock *MockPaneInterface
214}
215
216// NewMockPaneInterface creates a new mock instance.
217func NewMockPaneInterface(ctrl *gomock.Controller) *MockPaneInterface {
218 mock := &MockPaneInterface{ctrl: ctrl}
219 mock.recorder = &MockPaneInterfaceMockRecorder{mock}
220 return mock
221}
222
223// EXPECT returns an object that allows the caller to indicate expected use.
224func (m *MockPaneInterface) EXPECT() *MockPaneInterfaceMockRecorder {
225 return m.recorder
226}
227
228// Cleanup mocks base method.
229func (m *MockPaneInterface) Cleanup() {
230 m.ctrl.T.Helper()
231 m.ctrl.Call(m, "Cleanup")
232}
233
234// Cleanup indicates an expected call of Cleanup.
235func (mr *MockPaneInterfaceMockRecorder) Cleanup() *gomock.Call {
236 mr.mock.ctrl.T.Helper()
237 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cleanup", reflect.TypeOf((*MockPaneInterface)(nil).Cleanup))
238}
239
240// ClipboardController mocks base method.
241func (m *MockPaneInterface) ClipboardController() browser.ClipboardControllerInterface {
242 m.ctrl.T.Helper()
243 ret := m.ctrl.Call(m, "ClipboardController")
244 ret0, _ := ret[0].(browser.ClipboardControllerInterface)
245 return ret0
246}
247
248// ClipboardController indicates an expected call of ClipboardController.
249func (mr *MockPaneInterfaceMockRecorder) ClipboardController() *gomock.Call {
250 mr.mock.ctrl.T.Helper()
251 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClipboardController", reflect.TypeOf((*MockPaneInterface)(nil).ClipboardController))
252}
253
254// HasGUI mocks base method.
255func (m *MockPaneInterface) HasGUI() bool {
256 m.ctrl.T.Helper()
257 ret := m.ctrl.Call(m, "HasGUI")
258 ret0, _ := ret[0].(bool)
259 return ret0
260}
261
262// HasGUI indicates an expected call of HasGUI.
263func (mr *MockPaneInterfaceMockRecorder) HasGUI() *gomock.Call {
264 mr.mock.ctrl.T.Helper()
265 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasGUI", reflect.TypeOf((*MockPaneInterface)(nil).HasGUI))
266}
267
268// HasGUIComponent mocks base method.
269func (m *MockPaneInterface) HasGUIComponent(component string) bool {
270 m.ctrl.T.Helper()
271 ret := m.ctrl.Call(m, "HasGUIComponent", component)
272 ret0, _ := ret[0].(bool)
273 return ret0
274}
275
276// HasGUIComponent indicates an expected call of HasGUIComponent.
277func (mr *MockPaneInterfaceMockRecorder) HasGUIComponent(component interface{}) *gomock.Call {
278 mr.mock.ctrl.T.Helper()
279 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasGUIComponent", reflect.TypeOf((*MockPaneInterface)(nil).HasGUIComponent), component)
280}
281
282// ID mocks base method.
283func (m *MockPaneInterface) ID() string {
284 m.ctrl.T.Helper()
285 ret := m.ctrl.Call(m, "ID")
286 ret0, _ := ret[0].(string)
287 return ret0
288}
289
290// ID indicates an expected call of ID.
291func (mr *MockPaneInterfaceMockRecorder) ID() *gomock.Call {
292 mr.mock.ctrl.T.Helper()
293 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockPaneInterface)(nil).ID))
294}
295
296// MessageHandler mocks base method.
297func (m *MockPaneInterface) MessageHandler() browser.MessageHandlerInterface {
298 m.ctrl.T.Helper()
299 ret := m.ctrl.Call(m, "MessageHandler")
300 ret0, _ := ret[0].(browser.MessageHandlerInterface)
301 return ret0
302}
303
304// MessageHandler indicates an expected call of MessageHandler.
305func (mr *MockPaneInterfaceMockRecorder) MessageHandler() *gomock.Call {
306 mr.mock.ctrl.T.Helper()
307 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MessageHandler", reflect.TypeOf((*MockPaneInterface)(nil).MessageHandler))
308}
309
310// NavigationController mocks base method.
311func (m *MockPaneInterface) NavigationController() browser.NavigationControllerInterface {
312 m.ctrl.T.Helper()
313 ret := m.ctrl.Call(m, "NavigationController")
314 ret0, _ := ret[0].(browser.NavigationControllerInterface)
315 return ret0
316}
317
318// NavigationController indicates an expected call of NavigationController.
319func (mr *MockPaneInterfaceMockRecorder) NavigationController() *gomock.Call {
320 mr.mock.ctrl.T.Helper()
321 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NavigationController", reflect.TypeOf((*MockPaneInterface)(nil).NavigationController))
322}
323
324// SetGUIComponent mocks base method.
325func (m *MockPaneInterface) SetGUIComponent(component string, loaded bool) {
326 m.ctrl.T.Helper()
327 m.ctrl.Call(m, "SetGUIComponent", component, loaded)
328}
329
330// SetGUIComponent indicates an expected call of SetGUIComponent.
331func (mr *MockPaneInterfaceMockRecorder) SetGUIComponent(component, loaded interface{}) *gomock.Call {
332 mr.mock.ctrl.T.Helper()
333 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGUIComponent", reflect.TypeOf((*MockPaneInterface)(nil).SetGUIComponent), component, loaded)
334}
335
336// SetHasGUI mocks base method.
337func (m *MockPaneInterface) SetHasGUI(arg0 bool) {
338 m.ctrl.T.Helper()
339 m.ctrl.Call(m, "SetHasGUI", arg0)
340}
341
342// SetHasGUI indicates an expected call of SetHasGUI.
343func (mr *MockPaneInterfaceMockRecorder) SetHasGUI(arg0 interface{}) *gomock.Call {
344 mr.mock.ctrl.T.Helper()
345 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHasGUI", reflect.TypeOf((*MockPaneInterface)(nil).SetHasGUI), arg0)
346}
347
348// SetID mocks base method.
349func (m *MockPaneInterface) SetID(arg0 string) {
350 m.ctrl.T.Helper()
351 m.ctrl.Call(m, "SetID", arg0)
352}
353
354// SetID indicates an expected call of SetID.
355func (mr *MockPaneInterfaceMockRecorder) SetID(arg0 interface{}) *gomock.Call {
356 mr.mock.ctrl.T.Helper()
357 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetID", reflect.TypeOf((*MockPaneInterface)(nil).SetID), arg0)
358}
359
360// ShortcutHandler mocks base method.
361func (m *MockPaneInterface) ShortcutHandler() browser.ShortcutHandlerInterface {
362 m.ctrl.T.Helper()
363 ret := m.ctrl.Call(m, "ShortcutHandler")
364 ret0, _ := ret[0].(browser.ShortcutHandlerInterface)
365 return ret0
366}
367
368// ShortcutHandler indicates an expected call of ShortcutHandler.
369func (mr *MockPaneInterfaceMockRecorder) ShortcutHandler() *gomock.Call {
370 mr.mock.ctrl.T.Helper()
371 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShortcutHandler", reflect.TypeOf((*MockPaneInterface)(nil).ShortcutHandler))
372}
373
374// UpdateLastFocus mocks base method.
375func (m *MockPaneInterface) UpdateLastFocus() {
376 m.ctrl.T.Helper()
377 m.ctrl.Call(m, "UpdateLastFocus")
378}
379
380// UpdateLastFocus indicates an expected call of UpdateLastFocus.
381func (mr *MockPaneInterfaceMockRecorder) UpdateLastFocus() *gomock.Call {
382 mr.mock.ctrl.T.Helper()
383 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLastFocus", reflect.TypeOf((*MockPaneInterface)(nil).UpdateLastFocus))
384}
385
386// WebView mocks base method.
387func (m *MockPaneInterface) WebView() browser.WebViewInterface {
388 m.ctrl.T.Helper()
389 ret := m.ctrl.Call(m, "WebView")
390 ret0, _ := ret[0].(browser.WebViewInterface)
391 return ret0
392}
393
394// WebView indicates an expected call of WebView.
395func (mr *MockPaneInterfaceMockRecorder) WebView() *gomock.Call {
396 mr.mock.ctrl.T.Helper()
397 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WebView", reflect.TypeOf((*MockPaneInterface)(nil).WebView))
398}
399
400// ZoomController mocks base method.
401func (m *MockPaneInterface) ZoomController() browser.ZoomControllerInterface {
402 m.ctrl.T.Helper()
403 ret := m.ctrl.Call(m, "ZoomController")
404 ret0, _ := ret[0].(browser.ZoomControllerInterface)
405 return ret0
406}
407
408// ZoomController indicates an expected call of ZoomController.
409func (mr *MockPaneInterfaceMockRecorder) ZoomController() *gomock.Call {
410 mr.mock.ctrl.T.Helper()
411 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZoomController", reflect.TypeOf((*MockPaneInterface)(nil).ZoomController))
412}
413
414// MockMessageHandlerInterface is a mock of MessageHandlerInterface interface.
415type MockMessageHandlerInterface struct {
416 ctrl *gomock.Controller
417 recorder *MockMessageHandlerInterfaceMockRecorder
418}
419
420// MockMessageHandlerInterfaceMockRecorder is the mock recorder for MockMessageHandlerInterface.
421type MockMessageHandlerInterfaceMockRecorder struct {
422 mock *MockMessageHandlerInterface
423}
424
425// NewMockMessageHandlerInterface creates a new mock instance.
426func NewMockMessageHandlerInterface(ctrl *gomock.Controller) *MockMessageHandlerInterface {
427 mock := &MockMessageHandlerInterface{ctrl: ctrl}
428 mock.recorder = &MockMessageHandlerInterfaceMockRecorder{mock}
429 return mock
430}
431
432// EXPECT returns an object that allows the caller to indicate expected use.
433func (m *MockMessageHandlerInterface) EXPECT() *MockMessageHandlerInterfaceMockRecorder {
434 return m.recorder
435}
436
437// SetWorkspaceObserver mocks base method.
438func (m *MockMessageHandlerInterface) SetWorkspaceObserver(observer messaging.WorkspaceObserver) {
439 m.ctrl.T.Helper()
440 m.ctrl.Call(m, "SetWorkspaceObserver", observer)
441}
442
443// SetWorkspaceObserver indicates an expected call of SetWorkspaceObserver.
444func (mr *MockMessageHandlerInterfaceMockRecorder) SetWorkspaceObserver(observer interface{}) *gomock.Call {
445 mr.mock.ctrl.T.Helper()
446 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWorkspaceObserver", reflect.TypeOf((*MockMessageHandlerInterface)(nil).SetWorkspaceObserver), observer)
447}
448
449// MockNavigationControllerInterface is a mock of NavigationControllerInterface interface.
450type MockNavigationControllerInterface struct {
451 ctrl *gomock.Controller
452 recorder *MockNavigationControllerInterfaceMockRecorder
453}
454
455// MockNavigationControllerInterfaceMockRecorder is the mock recorder for MockNavigationControllerInterface.
456type MockNavigationControllerInterfaceMockRecorder struct {
457 mock *MockNavigationControllerInterface
458}
459
460// NewMockNavigationControllerInterface creates a new mock instance.
461func NewMockNavigationControllerInterface(ctrl *gomock.Controller) *MockNavigationControllerInterface {
462 mock := &MockNavigationControllerInterface{ctrl: ctrl}
463 mock.recorder = &MockNavigationControllerInterfaceMockRecorder{mock}
464 return mock
465}
466
467// EXPECT returns an object that allows the caller to indicate expected use.
468func (m *MockNavigationControllerInterface) EXPECT() *MockNavigationControllerInterfaceMockRecorder {
469 return m.recorder
470}
471
472// NavigateToURL mocks base method.
473func (m *MockNavigationControllerInterface) NavigateToURL(url string) error {
474 m.ctrl.T.Helper()
475 ret := m.ctrl.Call(m, "NavigateToURL", url)
476 ret0, _ := ret[0].(error)
477 return ret0
478}
479
480// NavigateToURL indicates an expected call of NavigateToURL.
481func (mr *MockNavigationControllerInterfaceMockRecorder) NavigateToURL(url interface{}) *gomock.Call {
482 mr.mock.ctrl.T.Helper()
483 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NavigateToURL", reflect.TypeOf((*MockNavigationControllerInterface)(nil).NavigateToURL), url)
484}
485
486// MockZoomControllerInterface is a mock of ZoomControllerInterface interface.
487type MockZoomControllerInterface struct {
488 ctrl *gomock.Controller
489 recorder *MockZoomControllerInterfaceMockRecorder
490}
491
492// MockZoomControllerInterfaceMockRecorder is the mock recorder for MockZoomControllerInterface.
493type MockZoomControllerInterfaceMockRecorder struct {
494 mock *MockZoomControllerInterface
495}
496
497// NewMockZoomControllerInterface creates a new mock instance.
498func NewMockZoomControllerInterface(ctrl *gomock.Controller) *MockZoomControllerInterface {
499 mock := &MockZoomControllerInterface{ctrl: ctrl}
500 mock.recorder = &MockZoomControllerInterfaceMockRecorder{mock}
501 return mock
502}
503
504// EXPECT returns an object that allows the caller to indicate expected use.
505func (m *MockZoomControllerInterface) EXPECT() *MockZoomControllerInterfaceMockRecorder {
506 return m.recorder
507}
508
509// ApplyInitialZoom mocks base method.
510func (m *MockZoomControllerInterface) ApplyInitialZoom() {
511 m.ctrl.T.Helper()
512 m.ctrl.Call(m, "ApplyInitialZoom")
513}
514
515// ApplyInitialZoom indicates an expected call of ApplyInitialZoom.
516func (mr *MockZoomControllerInterfaceMockRecorder) ApplyInitialZoom() *gomock.Call {
517 mr.mock.ctrl.T.Helper()
518 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyInitialZoom", reflect.TypeOf((*MockZoomControllerInterface)(nil).ApplyInitialZoom))
519}
520
521// MockClipboardControllerInterface is a mock of ClipboardControllerInterface interface.
522type MockClipboardControllerInterface struct {
523 ctrl *gomock.Controller
524 recorder *MockClipboardControllerInterfaceMockRecorder
525}
526
527// MockClipboardControllerInterfaceMockRecorder is the mock recorder for MockClipboardControllerInterface.
528type MockClipboardControllerInterfaceMockRecorder struct {
529 mock *MockClipboardControllerInterface
530}
531
532// NewMockClipboardControllerInterface creates a new mock instance.
533func NewMockClipboardControllerInterface(ctrl *gomock.Controller) *MockClipboardControllerInterface {
534 mock := &MockClipboardControllerInterface{ctrl: ctrl}
535 mock.recorder = &MockClipboardControllerInterfaceMockRecorder{mock}
536 return mock
537}
538
539// EXPECT returns an object that allows the caller to indicate expected use.
540func (m *MockClipboardControllerInterface) EXPECT() *MockClipboardControllerInterfaceMockRecorder {
541 return m.recorder
542}
543
544// MockShortcutHandlerInterface is a mock of ShortcutHandlerInterface interface.
545type MockShortcutHandlerInterface struct {
546 ctrl *gomock.Controller
547 recorder *MockShortcutHandlerInterfaceMockRecorder
548}
549
550// MockShortcutHandlerInterfaceMockRecorder is the mock recorder for MockShortcutHandlerInterface.
551type MockShortcutHandlerInterfaceMockRecorder struct {
552 mock *MockShortcutHandlerInterface
553}
554
555// NewMockShortcutHandlerInterface creates a new mock instance.
556func NewMockShortcutHandlerInterface(ctrl *gomock.Controller) *MockShortcutHandlerInterface {
557 mock := &MockShortcutHandlerInterface{ctrl: ctrl}
558 mock.recorder = &MockShortcutHandlerInterfaceMockRecorder{mock}
559 return mock
560}
561
562// EXPECT returns an object that allows the caller to indicate expected use.
563func (m *MockShortcutHandlerInterface) EXPECT() *MockShortcutHandlerInterfaceMockRecorder {
564 return m.recorder
565}
566
567// MockBrowserAppInterface is a mock of BrowserAppInterface interface.
568type MockBrowserAppInterface struct {
569 ctrl *gomock.Controller
570 recorder *MockBrowserAppInterfaceMockRecorder
571}
572
573// MockBrowserAppInterfaceMockRecorder is the mock recorder for MockBrowserAppInterface.
574type MockBrowserAppInterfaceMockRecorder struct {
575 mock *MockBrowserAppInterface
576}
577
578// NewMockBrowserAppInterface creates a new mock instance.
579func NewMockBrowserAppInterface(ctrl *gomock.Controller) *MockBrowserAppInterface {
580 mock := &MockBrowserAppInterface{ctrl: ctrl}
581 mock.recorder = &MockBrowserAppInterfaceMockRecorder{mock}
582 return mock
583}
584
585// EXPECT returns an object that allows the caller to indicate expected use.
586func (m *MockBrowserAppInterface) EXPECT() *MockBrowserAppInterfaceMockRecorder {
587 return m.recorder
588}
589
590// AppendPane mocks base method.
591func (m *MockBrowserAppInterface) AppendPane(pane *browser.BrowserPane) {
592 m.ctrl.T.Helper()
593 m.ctrl.Call(m, "AppendPane", pane)
594}
595
596// AppendPane indicates an expected call of AppendPane.
597func (mr *MockBrowserAppInterfaceMockRecorder) AppendPane(pane interface{}) *gomock.Call {
598 mr.mock.ctrl.T.Helper()
599 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendPane", reflect.TypeOf((*MockBrowserAppInterface)(nil).AppendPane), pane)
600}
601
602// BuildWebkitConfig mocks base method.
603func (m *MockBrowserAppInterface) BuildWebkitConfig() (*webkit.Config, error) {
604 m.ctrl.T.Helper()
605 ret := m.ctrl.Call(m, "BuildWebkitConfig")
606 ret0, _ := ret[0].(*webkit.Config)
607 ret1, _ := ret[1].(error)
608 return ret0, ret1
609}
610
611// BuildWebkitConfig indicates an expected call of BuildWebkitConfig.
612func (mr *MockBrowserAppInterfaceMockRecorder) BuildWebkitConfig() *gomock.Call {
613 mr.mock.ctrl.T.Helper()
614 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildWebkitConfig", reflect.TypeOf((*MockBrowserAppInterface)(nil).BuildWebkitConfig))
615}
616
617// CreatePaneForView mocks base method.
618func (m *MockBrowserAppInterface) CreatePaneForView(view *webkit.WebView) (*browser.BrowserPane, error) {
619 m.ctrl.T.Helper()
620 ret := m.ctrl.Call(m, "CreatePaneForView", view)
621 ret0, _ := ret[0].(*browser.BrowserPane)
622 ret1, _ := ret[1].(error)
623 return ret0, ret1
624}
625
626// CreatePaneForView indicates an expected call of CreatePaneForView.
627func (mr *MockBrowserAppInterfaceMockRecorder) CreatePaneForView(view interface{}) *gomock.Call {
628 mr.mock.ctrl.T.Helper()
629 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePaneForView", reflect.TypeOf((*MockBrowserAppInterface)(nil).CreatePaneForView), view)
630}
631
632// GetActivePane mocks base method.
633func (m *MockBrowserAppInterface) GetActivePane() *browser.BrowserPane {
634 m.ctrl.T.Helper()
635 ret := m.ctrl.Call(m, "GetActivePane")
636 ret0, _ := ret[0].(*browser.BrowserPane)
637 return ret0
638}
639
640// GetActivePane indicates an expected call of GetActivePane.
641func (mr *MockBrowserAppInterfaceMockRecorder) GetActivePane() *gomock.Call {
642 mr.mock.ctrl.T.Helper()
643 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActivePane", reflect.TypeOf((*MockBrowserAppInterface)(nil).GetActivePane))
644}
645
646// GetPanes mocks base method.
647func (m *MockBrowserAppInterface) GetPanes() []*browser.BrowserPane {
648 m.ctrl.T.Helper()
649 ret := m.ctrl.Call(m, "GetPanes")
650 ret0, _ := ret[0].([]*browser.BrowserPane)
651 return ret0
652}
653
654// GetPanes indicates an expected call of GetPanes.
655func (mr *MockBrowserAppInterfaceMockRecorder) GetPanes() *gomock.Call {
656 mr.mock.ctrl.T.Helper()
657 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPanes", reflect.TypeOf((*MockBrowserAppInterface)(nil).GetPanes))
658}
659
660// RemovePane mocks base method.
661func (m *MockBrowserAppInterface) RemovePane(pane *browser.BrowserPane) {
662 m.ctrl.T.Helper()
663 m.ctrl.Call(m, "RemovePane", pane)
664}
665
666// RemovePane indicates an expected call of RemovePane.
667func (mr *MockBrowserAppInterfaceMockRecorder) RemovePane(pane interface{}) *gomock.Call {
668 mr.mock.ctrl.T.Helper()
669 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePane", reflect.TypeOf((*MockBrowserAppInterface)(nil).RemovePane), pane)
670}
671
672// SetActivePane mocks base method.
673func (m *MockBrowserAppInterface) SetActivePane(pane *browser.BrowserPane) {
674 m.ctrl.T.Helper()
675 m.ctrl.Call(m, "SetActivePane", pane)
676}
677
678// SetActivePane indicates an expected call of SetActivePane.
679func (mr *MockBrowserAppInterfaceMockRecorder) SetActivePane(pane interface{}) *gomock.Call {
680 mr.mock.ctrl.T.Helper()
681 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetActivePane", reflect.TypeOf((*MockBrowserAppInterface)(nil).SetActivePane), pane)
682}
683
684// MockWindowInterface is a mock of WindowInterface interface.
685type MockWindowInterface struct {
686 ctrl *gomock.Controller
687 recorder *MockWindowInterfaceMockRecorder
688}
689
690// MockWindowInterfaceMockRecorder is the mock recorder for MockWindowInterface.
691type MockWindowInterfaceMockRecorder struct {
692 mock *MockWindowInterface
693}
694
695// NewMockWindowInterface creates a new mock instance.
696func NewMockWindowInterface(ctrl *gomock.Controller) *MockWindowInterface {
697 mock := &MockWindowInterface{ctrl: ctrl}
698 mock.recorder = &MockWindowInterfaceMockRecorder{mock}
699 return mock
700}
701
702// EXPECT returns an object that allows the caller to indicate expected use.
703func (m *MockWindowInterface) EXPECT() *MockWindowInterfaceMockRecorder {
704 return m.recorder
705}
706
707// SetChild mocks base method.
708func (m *MockWindowInterface) SetChild(widget uintptr) {
709 m.ctrl.T.Helper()
710 m.ctrl.Call(m, "SetChild", widget)
711}
712
713// SetChild indicates an expected call of SetChild.
714func (mr *MockWindowInterfaceMockRecorder) SetChild(widget interface{}) *gomock.Call {
715 mr.mock.ctrl.T.Helper()
716 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetChild", reflect.TypeOf((*MockWindowInterface)(nil).SetChild), widget)
717}
718
719// MockWindowShortcutHandlerInterface is a mock of WindowShortcutHandlerInterface interface.
720type MockWindowShortcutHandlerInterface struct {
721 ctrl *gomock.Controller
722 recorder *MockWindowShortcutHandlerInterfaceMockRecorder
723}
724
725// MockWindowShortcutHandlerInterfaceMockRecorder is the mock recorder for MockWindowShortcutHandlerInterface.
726type MockWindowShortcutHandlerInterfaceMockRecorder struct {
727 mock *MockWindowShortcutHandlerInterface
728}
729
730// NewMockWindowShortcutHandlerInterface creates a new mock instance.
731func NewMockWindowShortcutHandlerInterface(ctrl *gomock.Controller) *MockWindowShortcutHandlerInterface {
732 mock := &MockWindowShortcutHandlerInterface{ctrl: ctrl}
733 mock.recorder = &MockWindowShortcutHandlerInterfaceMockRecorder{mock}
734 return mock
735}
736
737// EXPECT returns an object that allows the caller to indicate expected use.
738func (m *MockWindowShortcutHandlerInterface) EXPECT() *MockWindowShortcutHandlerInterfaceMockRecorder {
739 return m.recorder
740}
741
742// Cleanup mocks base method.
743func (m *MockWindowShortcutHandlerInterface) Cleanup() {
744 m.ctrl.T.Helper()
745 m.ctrl.Call(m, "Cleanup")
746}
747
748// Cleanup indicates an expected call of Cleanup.
749func (mr *MockWindowShortcutHandlerInterfaceMockRecorder) Cleanup() *gomock.Call {
750 mr.mock.ctrl.T.Helper()
751 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cleanup", reflect.TypeOf((*MockWindowShortcutHandlerInterface)(nil).Cleanup))
752}