1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
content / public / test / mock_render_process_host.h [blame]
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_PUBLIC_TEST_MOCK_RENDER_PROCESS_HOST_H_
#define CONTENT_PUBLIC_TEST_MOCK_RENDER_PROCESS_HOST_H_
#include <stddef.h>
#include <stdint.h>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>
#include "base/containers/flat_set.h"
#include "base/functional/callback_forward.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/metrics/persistent_memory_allocator.h"
#include "base/observer_list.h"
#include "build/build_config.h"
#include "build/chromeos_buildflags.h"
#include "content/public/browser/global_routing_id.h"
#include "content/public/browser/render_process_host.h"
#include "content/public/browser/render_process_host_factory.h"
#include "content/public/browser/storage_partition_config.h"
#include "ipc/ipc_test_sink.h"
#include "media/media_buildflags.h"
#include "mojo/public/cpp/bindings/associated_remote.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "net/base/network_isolation_key.h"
#if BUILDFLAG(IS_ANDROID)
#include "base/android/child_process_binding_types.h"
#include "content/public/browser/android/child_process_importance.h"
#include "services/network/public/mojom/attribution.mojom-forward.h"
#endif
namespace blink {
class StorageKey;
} // namespace blink
namespace content {
class MockRenderProcessHostFactory;
class ProcessLock;
class RenderProcessHostPriorityClient;
class SiteInfo;
class SiteInstance;
class StoragePartition;
// A mock render process host that has no corresponding renderer process. All
// IPC messages are sent into the message sink for inspection by tests.
class MockRenderProcessHost : public RenderProcessHost {
public:
using InterfaceBinder =
base::RepeatingCallback<void(mojo::ScopedMessagePipeHandle)>;
explicit MockRenderProcessHost(BrowserContext* browser_context,
bool is_for_guests_only = false);
MockRenderProcessHost(BrowserContext* browser_context,
const StoragePartitionConfig& storage_partition_config,
bool is_for_guests_only);
MockRenderProcessHost(const MockRenderProcessHost&) = delete;
MockRenderProcessHost& operator=(const MockRenderProcessHost&) = delete;
~MockRenderProcessHost() override;
// Provides access to all IPC messages that would have been sent to the
// renderer via this RenderProcessHost.
IPC::TestSink& sink() { return sink_; }
// Provides test access to how many times a bad message has been received.
int bad_msg_count() const { return bad_msg_count_; }
// Provides tests a way to simulate this render process crashing.
void SimulateCrash();
void SimulateRenderProcessExit(base::TerminationStatus termination_status,
int exit_code);
// Simulates async launch happening.
void SimulateReady();
// RenderProcessHost implementation (public portion).
bool Init() override;
void EnableSendQueue() override;
int GetNextRoutingID() override;
void AddRoute(int32_t routing_id, IPC::Listener* listener) override;
void RemoveRoute(int32_t routing_id) override;
void AddObserver(RenderProcessHostObserver* observer) override;
void RemoveObserver(RenderProcessHostObserver* observer) override;
void ShutdownForBadMessage(CrashReportMode crash_report_mode) override;
void UpdateClientPriority(RenderProcessHostPriorityClient* client) override;
int VisibleClientCount() override;
unsigned int GetFrameDepth() override;
bool GetIntersectsViewport() override;
bool IsForGuestsOnly() override;
bool IsJitDisabled() override;
bool AreV8OptimizationsDisabled() override;
bool IsPdf() override;
void OnMediaStreamAdded() override;
void OnMediaStreamRemoved() override;
void OnForegroundServiceWorkerAdded() override;
void OnForegroundServiceWorkerRemoved() override;
void OnBoostForLoadingAdded() override;
void OnBoostForLoadingRemoved() override;
StoragePartition* GetStoragePartition() override;
virtual void AddWord(const std::u16string& word);
bool Shutdown(int exit_code) override;
bool ShutdownRequested() override;
bool FastShutdownIfPossible(size_t page_count,
bool skip_unload_handlers) override;
bool FastShutdownStarted() override;
const base::Process& GetProcess() override;
bool IsReady() override;
int GetID() const override;
base::SafeRef<RenderProcessHost> GetSafeRef() const override;
bool IsInitializedAndNotDead() override;
bool IsDeletingSoon() override;
void SetBlocked(bool blocked) override;
bool IsBlocked() override;
base::CallbackListSubscription RegisterBlockStateChangedCallback(
const BlockStateChangedCallback& cb) override;
void Cleanup() override;
void AddPendingView() override;
void RemovePendingView() override;
void AddPriorityClient(
RenderProcessHostPriorityClient* priority_client) override;
void RemovePriorityClient(
RenderProcessHostPriorityClient* priority_client) override;
#if !BUILDFLAG(IS_ANDROID)
void SetPriorityOverride(base::Process::Priority priority) override;
bool HasPriorityOverride() override;
void ClearPriorityOverride() override;
#endif
#if BUILDFLAG(IS_ANDROID)
ChildProcessImportance GetEffectiveImportance() override;
base::android::ChildBindingState GetEffectiveChildBindingState() override;
void DumpProcessStack() override;
#endif
void SetSuddenTerminationAllowed(bool allowed) override;
bool SuddenTerminationAllowed() override;
BrowserContext* GetBrowserContext() override;
bool InSameStoragePartition(StoragePartition* partition) override;
IPC::ChannelProxy* GetChannel() override;
#if BUILDFLAG(CONTENT_ENABLE_LEGACY_IPC)
void AddFilter(BrowserMessageFilter* filter) override;
#endif
base::TimeDelta GetChildProcessIdleTime() override;
FilterURLResult FilterURL(bool empty_allowed, GURL* url) override;
void EnableAudioDebugRecordings(const base::FilePath& file) override;
void DisableAudioDebugRecordings() override;
WebRtcStopRtpDumpCallback StartRtpDump(
bool incoming,
bool outgoing,
WebRtcRtpPacketCallback packet_callback) override;
void BindReceiver(mojo::GenericPendingReceiver receiver) override;
std::unique_ptr<base::PersistentMemoryAllocator> TakeMetricsAllocator()
override;
const base::TimeTicks& GetLastInitTime() override;
base::Process::Priority GetPriority() override;
size_t GetWorkerRefCount() const;
std::string GetKeepAliveDurations() const override;
size_t GetShutdownDelayRefCount() const override;
int GetRenderFrameHostCount() const override;
void DisableRefCounts() override;
void ForEachRenderFrameHost(
base::FunctionRef<void(RenderFrameHost*)> on_render_frame_host) override;
void RegisterRenderFrameHost(
const GlobalRenderFrameHostId& render_frame_host_id,
bool is_outermost_main_frame) override;
void UnregisterRenderFrameHost(
const GlobalRenderFrameHostId& render_frame_host_id,
bool is_outermost_main_frame) override;
void IncrementWorkerRefCount() override;
void DecrementWorkerRefCount() override;
void IncrementPendingReuseRefCount() override;
void DecrementPendingReuseRefCount() override;
bool AreRefCountsDisabled() override;
mojom::Renderer* GetRendererInterface() override;
bool MayReuseHost() override;
bool IsUnused() override;
void SetIsUsed() override;
bool HostHasNotBeenUsed() override;
bool IsSpare() const override;
void SetProcessLock(const IsolationContext& isolation_context,
const ProcessLock& process_lock) override;
ProcessLock GetProcessLock() const override;
bool IsProcessLockedToSiteForTesting() override;
void DelayProcessShutdown(const base::TimeDelta& subframe_shutdown_timeout,
const base::TimeDelta& unload_handler_timeout,
const SiteInfo& site_info) override {}
void StopTrackingProcessForShutdownDelay() override {}
void BindCacheStorage(
const network::CrossOriginEmbedderPolicy&,
mojo::PendingRemote<network::mojom::CrossOriginEmbedderPolicyReporter>,
const network::DocumentIsolationPolicy& document_isolation_policy,
const storage::BucketLocator& bucket,
mojo::PendingReceiver<blink::mojom::CacheStorage> receiver) override;
void BindFileSystemManager(
const blink::StorageKey& storage_key,
mojo::PendingReceiver<blink::mojom::FileSystemManager> receiver)
override {}
void BindFileSystemAccessManager(
const blink::StorageKey& storage_key,
mojo::PendingReceiver<blink::mojom::FileSystemAccessManager> receiver)
override {}
void GetSandboxedFileSystemForBucket(
const storage::BucketLocator& bucket,
const std::vector<std::string>& directory_path_components,
blink::mojom::FileSystemAccessManager::GetSandboxedFileSystemCallback
callback) override;
void BindIndexedDB(
const blink::StorageKey& storage_key,
BucketContext& bucket_context,
mojo::PendingReceiver<blink::mojom::IDBFactory> receiver) override;
void BindBucketManagerHost(
base::WeakPtr<BucketContext> bucket_context,
mojo::PendingReceiver<blink::mojom::BucketManagerHost> receiver)
override {}
void BindRestrictedCookieManagerForServiceWorker(
const blink::StorageKey& storage_key,
mojo::PendingReceiver<network::mojom::RestrictedCookieManager> receiver)
override {}
void BindVideoDecodePerfHistory(
mojo::PendingReceiver<media::mojom::VideoDecodePerfHistory> receiver)
override {}
void BindQuotaManagerHost(
const blink::StorageKey& storage_key,
mojo::PendingReceiver<blink::mojom::QuotaManagerHost> receiver) override {
}
#if BUILDFLAG(IS_FUCHSIA)
void BindMediaCodecProvider(
mojo::PendingReceiver<media::mojom::FuchsiaMediaCodecProvider> receiver)
override {}
#endif
void CreateLockManager(
const blink::StorageKey& storage_key,
mojo::PendingReceiver<blink::mojom::LockManager> receiver) override {}
void CreateOneShotSyncService(
const url::Origin& origin,
mojo::PendingReceiver<blink::mojom::OneShotBackgroundSyncService>
receiver) override {}
void CreatePeriodicSyncService(
const url::Origin& origin,
mojo::PendingReceiver<blink::mojom::PeriodicBackgroundSyncService>
receiver) override {}
void CreatePermissionService(
const url::Origin& origin,
mojo::PendingReceiver<blink::mojom::PermissionService> receiver)
override {}
void CreatePaymentManagerForOrigin(
const url::Origin& origin,
mojo::PendingReceiver<payments::mojom::PaymentManager> receiver)
override {}
void CreateNotificationService(
GlobalRenderFrameHostId rfh_id,
RenderProcessHost::NotificationServiceCreatorType creator_type,
const blink::StorageKey& storage_key,
mojo::PendingReceiver<blink::mojom::NotificationService> receiver)
override {}
void CreateWebSocketConnector(
const blink::StorageKey& storage_key,
mojo::PendingReceiver<blink::mojom::WebSocketConnector> receiver)
override {}
#if BUILDFLAG(ALLOW_OOP_VIDEO_DECODER)
void CreateStableVideoDecoder(
mojo::PendingReceiver<media::stable::mojom::StableVideoDecoder> receiver)
override {}
#endif // BUILDFLAG(ALLOW_OOP_VIDEO_DECODER)
std::string GetInfoForBrowserContextDestructionCrashReporting() override;
void WriteIntoTrace(perfetto::TracedProto<TraceProto> proto) const override;
#if BUILDFLAG(IS_CHROMEOS_ASH)
void ReinitializeLogging(uint32_t logging_dest,
base::ScopedFD log_file_descriptor) override;
#endif
void SetBatterySaverMode(bool battery_saver_mode_enabled) override {}
uint64_t GetPrivateMemoryFootprint() override;
void PauseSocketManagerForRenderFrameHost(
const GlobalRenderFrameHostId& render_frame_host_id) override {}
void ResumeSocketManagerForRenderFrameHost(
const GlobalRenderFrameHostId& render_frame_host_id) override {}
// IPC::Sender via RenderProcessHost.
bool Send(IPC::Message* msg) override;
// IPC::Listener via RenderProcessHost.
bool OnMessageReceived(const IPC::Message& msg) override;
void OnChannelConnected(int32_t peer_pid) override;
void set_priority(base::Process::Priority priority) { priority_ = priority; }
void SetProcess(base::Process&& new_process) {
process = std::move(new_process);
}
void OverrideBinderForTesting(const std::string& interface_name,
const InterfaceBinder& binder);
void OverrideRendererInterfaceForTesting(
std::unique_ptr<mojo::AssociatedRemote<mojom::Renderer>>
renderer_interface);
bool is_renderer_locked_to_site() const {
return is_renderer_locked_to_site_;
}
int foreground_service_worker_count() const {
return foreground_service_worker_count_;
}
private:
// Stores IPC messages that would have been sent to the renderer.
IPC::TestSink sink_;
int bad_msg_count_;
int id_;
bool has_connection_;
raw_ptr<BrowserContext, DanglingUntriaged> browser_context_;
base::ObserverList<RenderProcessHostObserver> observers_;
StoragePartitionConfig storage_partition_config_;
base::flat_set<raw_ptr<RenderProcessHostPriorityClient, CtnExperimental>>
priority_clients_;
int prev_routing_id_;
base::IDMap<IPC::Listener*> listeners_;
bool shutdown_requested_;
bool fast_shutdown_started_;
bool within_process_died_observer_ = false;
bool delayed_cleanup_ = false;
bool deletion_callback_called_;
bool is_for_guests_only_;
base::Process::Priority priority_;
bool is_unused_;
bool is_ready_ = false;
base::Process process;
int worker_ref_count_;
int pending_reuse_ref_count_;
int foreground_service_worker_count_;
std::unique_ptr<mojo::AssociatedRemote<mojom::Renderer>> renderer_interface_;
std::map<std::string, InterfaceBinder> binder_overrides_;
bool is_renderer_locked_to_site_ = false;
std::set<GlobalRenderFrameHostId> render_frame_host_id_set_;
mojo::PendingReceiver<blink::mojom::CacheStorage> cache_storage_receiver_;
mojo::PendingReceiver<blink::mojom::IDBFactory> idb_factory_receiver_;
base::WeakPtrFactory<MockRenderProcessHost> weak_ptr_factory_{this};
};
class MockRenderProcessHostFactory : public RenderProcessHostFactory {
public:
MockRenderProcessHostFactory();
MockRenderProcessHostFactory(const MockRenderProcessHostFactory&) = delete;
MockRenderProcessHostFactory& operator=(const MockRenderProcessHostFactory&) =
delete;
~MockRenderProcessHostFactory() override;
RenderProcessHost* CreateRenderProcessHost(
BrowserContext* browser_context,
SiteInstance* site_instance) override;
// Removes the given MockRenderProcessHost from the MockRenderProcessHost
// list.
void Remove(MockRenderProcessHost* host) const;
// Retrieve the current list of mock processes.
std::vector<std::unique_ptr<MockRenderProcessHost>>* GetProcesses() {
return &processes_;
}
private:
// A list of MockRenderProcessHosts created by this object. This list is used
// for deleting all MockRenderProcessHosts that have not deleted by a test in
// the destructor and prevent them from being leaked.
mutable std::vector<std::unique_ptr<MockRenderProcessHost>> processes_;
};
} // namespace content
#endif // CONTENT_PUBLIC_TEST_MOCK_RENDER_PROCESS_HOST_H_