1 // Copyright 2018 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 #include "content/browser/worker_host/mock_shared_worker.h"
6
7 #include "mojo/public/cpp/test_support/test_utils.h"
8 #include "services/network/public/mojom/content_security_policy.mojom-forward.h"
9 #include "testing/gtest/include/gtest/gtest.h"
10 #include "third_party/blink/public/common/loader/url_loader_factory_bundle.h"
11 #include "third_party/blink/public/mojom/worker/shared_worker_info.mojom.h"
12 #include "url/gurl.h"
13
14 namespace content {
15
16 namespace {
17
18 template <typename T>
CheckEquality(const T & expected,const T & actual)19 bool CheckEquality(const T& expected, const T& actual) {
20 EXPECT_EQ(expected, actual);
21 return expected == actual;
22 }
23
24 } // namespace
25
MockSharedWorker(mojo::PendingReceiver<blink::mojom::SharedWorker> receiver)26 MockSharedWorker::MockSharedWorker(
27 mojo::PendingReceiver<blink::mojom::SharedWorker> receiver)
28 : receiver_(this, std::move(receiver)) {}
29
30 MockSharedWorker::~MockSharedWorker() = default;
31
CheckReceivedConnect(int * connection_request_id,blink::MessagePortChannel * port)32 bool MockSharedWorker::CheckReceivedConnect(int* connection_request_id,
33 blink::MessagePortChannel* port) {
34 if (connect_received_.empty())
35 return false;
36 if (connection_request_id)
37 *connection_request_id = connect_received_.front().first;
38 if (port)
39 *port = connect_received_.front().second;
40 connect_received_.pop();
41 return true;
42 }
43
CheckNotReceivedConnect()44 bool MockSharedWorker::CheckNotReceivedConnect() {
45 return connect_received_.empty();
46 }
47
CheckReceivedTerminate()48 bool MockSharedWorker::CheckReceivedTerminate() {
49 if (!terminate_received_)
50 return false;
51 terminate_received_ = false;
52 return true;
53 }
54
Disconnect()55 void MockSharedWorker::Disconnect() {
56 receiver_.reset();
57 }
58
Connect(int connection_request_id,blink::MessagePortDescriptor port)59 void MockSharedWorker::Connect(int connection_request_id,
60 blink::MessagePortDescriptor port) {
61 connect_received_.emplace(connection_request_id,
62 blink::MessagePortChannel(std::move(port)));
63 }
64
Terminate()65 void MockSharedWorker::Terminate() {
66 // Allow duplicate events.
67 terminate_received_ = true;
68 }
69
MockSharedWorkerFactory(mojo::PendingReceiver<blink::mojom::SharedWorkerFactory> receiver)70 MockSharedWorkerFactory::MockSharedWorkerFactory(
71 mojo::PendingReceiver<blink::mojom::SharedWorkerFactory> receiver)
72 : receiver_(this, std::move(receiver)) {}
73
74 MockSharedWorkerFactory::~MockSharedWorkerFactory() = default;
75
CheckReceivedCreateSharedWorker(const GURL & expected_url,const std::string & expected_name,network::mojom::ContentSecurityPolicyType expected_content_security_policy_type,mojo::Remote<blink::mojom::SharedWorkerHost> * host,mojo::PendingReceiver<blink::mojom::SharedWorker> * receiver)76 bool MockSharedWorkerFactory::CheckReceivedCreateSharedWorker(
77 const GURL& expected_url,
78 const std::string& expected_name,
79 network::mojom::ContentSecurityPolicyType
80 expected_content_security_policy_type,
81 mojo::Remote<blink::mojom::SharedWorkerHost>* host,
82 mojo::PendingReceiver<blink::mojom::SharedWorker>* receiver) {
83 std::unique_ptr<CreateParams> create_params = std::move(create_params_);
84 if (!create_params)
85 return false;
86 if (!CheckEquality(expected_url, create_params->info->url))
87 return false;
88 if (!CheckEquality(expected_name, create_params->info->options->name))
89 return false;
90 if (!CheckEquality(expected_content_security_policy_type,
91 create_params->info->content_security_policy_type))
92 return false;
93 if (!CheckEquality(ukm::SourceIdType::WORKER_ID,
94 ukm::GetSourceIdType(create_params->ukm_source_id))) {
95 return false;
96 }
97 host->Bind(std::move(create_params->host));
98 *receiver = std::move(create_params->receiver);
99 return true;
100 }
101
Disconnect()102 void MockSharedWorkerFactory::Disconnect() {
103 receiver_.reset();
104 }
105
CreateSharedWorker(blink::mojom::SharedWorkerInfoPtr info,const blink::SharedWorkerToken & token,const url::Origin & constructor_origin,const std::string & user_agent,const blink::UserAgentMetadata & ua_metadata,bool pause_on_start,const base::UnguessableToken & devtools_worker_token,const blink::RendererPreferences & renderer_preferences,mojo::PendingReceiver<blink::mojom::RendererPreferenceWatcher> preference_watcher_receiver,mojo::PendingRemote<blink::mojom::WorkerContentSettingsProxy> content_settings,blink::mojom::ServiceWorkerContainerInfoForClientPtr service_worker_container_info,const base::Optional<base::UnguessableToken> & appcache_host_id,blink::mojom::WorkerMainScriptLoadParamsPtr main_script_load_params,std::unique_ptr<blink::PendingURLLoaderFactoryBundle> subresource_loader_factories,blink::mojom::ControllerServiceWorkerInfoPtr controller_info,mojo::PendingRemote<blink::mojom::SharedWorkerHost> host,mojo::PendingReceiver<blink::mojom::SharedWorker> receiver,mojo::PendingRemote<blink::mojom::BrowserInterfaceBroker> browser_interface_broker,ukm::SourceId ukm_source_id)106 void MockSharedWorkerFactory::CreateSharedWorker(
107 blink::mojom::SharedWorkerInfoPtr info,
108 const blink::SharedWorkerToken& token,
109 const url::Origin& constructor_origin,
110 const std::string& user_agent,
111 const blink::UserAgentMetadata& ua_metadata,
112 bool pause_on_start,
113 const base::UnguessableToken& devtools_worker_token,
114 const blink::RendererPreferences& renderer_preferences,
115 mojo::PendingReceiver<blink::mojom::RendererPreferenceWatcher>
116 preference_watcher_receiver,
117 mojo::PendingRemote<blink::mojom::WorkerContentSettingsProxy>
118 content_settings,
119 blink::mojom::ServiceWorkerContainerInfoForClientPtr
120 service_worker_container_info,
121 const base::Optional<base::UnguessableToken>& appcache_host_id,
122 blink::mojom::WorkerMainScriptLoadParamsPtr main_script_load_params,
123 std::unique_ptr<blink::PendingURLLoaderFactoryBundle>
124 subresource_loader_factories,
125 blink::mojom::ControllerServiceWorkerInfoPtr controller_info,
126 mojo::PendingRemote<blink::mojom::SharedWorkerHost> host,
127 mojo::PendingReceiver<blink::mojom::SharedWorker> receiver,
128 mojo::PendingRemote<blink::mojom::BrowserInterfaceBroker>
129 browser_interface_broker,
130 ukm::SourceId ukm_source_id) {
131 DCHECK(!create_params_);
132 create_params_ = std::make_unique<CreateParams>();
133 create_params_->info = std::move(info);
134 create_params_->pause_on_start = pause_on_start;
135 create_params_->content_settings = std::move(content_settings);
136 create_params_->host = std::move(host);
137 create_params_->receiver = std::move(receiver);
138 create_params_->ukm_source_id = ukm_source_id;
139 }
140
141 MockSharedWorkerFactory::CreateParams::CreateParams() = default;
142
143 MockSharedWorkerFactory::CreateParams::~CreateParams() = default;
144
145 MockSharedWorkerClient::MockSharedWorkerClient() = default;
146
147 MockSharedWorkerClient::~MockSharedWorkerClient() = default;
148
Bind(mojo::PendingReceiver<blink::mojom::SharedWorkerClient> receiver)149 void MockSharedWorkerClient::Bind(
150 mojo::PendingReceiver<blink::mojom::SharedWorkerClient> receiver) {
151 receiver_.Bind(std::move(receiver));
152 }
153
Close()154 void MockSharedWorkerClient::Close() {
155 receiver_.reset();
156 }
157
CheckReceivedOnCreated()158 bool MockSharedWorkerClient::CheckReceivedOnCreated() {
159 if (!on_created_received_)
160 return false;
161 on_created_received_ = false;
162 return true;
163 }
164
CheckReceivedOnConnected(std::set<blink::mojom::WebFeature> expected_used_features)165 bool MockSharedWorkerClient::CheckReceivedOnConnected(
166 std::set<blink::mojom::WebFeature> expected_used_features) {
167 if (!on_connected_received_)
168 return false;
169 on_connected_received_ = false;
170 if (!CheckEquality(expected_used_features, on_connected_features_))
171 return false;
172 return true;
173 }
174
CheckReceivedOnFeatureUsed(blink::mojom::WebFeature expected_feature)175 bool MockSharedWorkerClient::CheckReceivedOnFeatureUsed(
176 blink::mojom::WebFeature expected_feature) {
177 if (!on_feature_used_received_)
178 return false;
179 on_feature_used_received_ = false;
180 if (!CheckEquality(expected_feature, on_feature_used_feature_))
181 return false;
182 return true;
183 }
184
CheckNotReceivedOnFeatureUsed()185 bool MockSharedWorkerClient::CheckNotReceivedOnFeatureUsed() {
186 return !on_feature_used_received_;
187 }
188
CheckReceivedOnScriptLoadFailed()189 bool MockSharedWorkerClient::CheckReceivedOnScriptLoadFailed() {
190 if (!on_script_load_failed_)
191 return false;
192 on_script_load_failed_ = false;
193 return true;
194 }
195
ResetReceiver()196 void MockSharedWorkerClient::ResetReceiver() {
197 receiver_.reset();
198 }
199
OnCreated(blink::mojom::SharedWorkerCreationContextType creation_context_type)200 void MockSharedWorkerClient::OnCreated(
201 blink::mojom::SharedWorkerCreationContextType creation_context_type) {
202 DCHECK(!on_created_received_);
203 on_created_received_ = true;
204 }
205
OnConnected(const std::vector<blink::mojom::WebFeature> & features_used)206 void MockSharedWorkerClient::OnConnected(
207 const std::vector<blink::mojom::WebFeature>& features_used) {
208 DCHECK(!on_connected_received_);
209 on_connected_received_ = true;
210 for (auto feature : features_used)
211 on_connected_features_.insert(feature);
212 }
213
OnScriptLoadFailed(const std::string & error_message)214 void MockSharedWorkerClient::OnScriptLoadFailed(
215 const std::string& error_message) {
216 DCHECK(!on_script_load_failed_);
217 on_script_load_failed_ = true;
218 }
219
OnFeatureUsed(blink::mojom::WebFeature feature)220 void MockSharedWorkerClient::OnFeatureUsed(blink::mojom::WebFeature feature) {
221 DCHECK(!on_feature_used_received_);
222 on_feature_used_received_ = true;
223 on_feature_used_feature_ = feature;
224 }
225
226 } // namespace content
227