Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(527)

Side by Side Diff: content/browser/service_worker/embedded_worker_instance_unittest.cc

Issue 2227593002: ServiceWorker: Implement StartWorker by using mojo (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Added argument check and updated comment and BUILD.gn Created 4 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2013 The Chromium Authors. All rights reserved. 1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "content/browser/service_worker/embedded_worker_instance.h" 5 #include "content/browser/service_worker/embedded_worker_instance.h"
6 6
7 #include <stdint.h> 7 #include <stdint.h>
8 #include <utility> 8 #include <utility>
9 #include <vector> 9 #include <vector>
10 10
11 #include "base/command_line.h"
11 #include "base/macros.h" 12 #include "base/macros.h"
12 #include "base/run_loop.h" 13 #include "base/run_loop.h"
13 #include "base/stl_util.h" 14 #include "base/stl_util.h"
14 #include "content/browser/service_worker/embedded_worker_registry.h" 15 #include "content/browser/service_worker/embedded_worker_registry.h"
15 #include "content/browser/service_worker/embedded_worker_status.h" 16 #include "content/browser/service_worker/embedded_worker_status.h"
16 #include "content/browser/service_worker/embedded_worker_test_helper.h" 17 #include "content/browser/service_worker/embedded_worker_test_helper.h"
17 #include "content/browser/service_worker/service_worker_context_core.h" 18 #include "content/browser/service_worker/service_worker_context_core.h"
18 #include "content/browser/service_worker/service_worker_context_wrapper.h" 19 #include "content/browser/service_worker/service_worker_context_wrapper.h"
20 #include "content/common/service_worker/embedded_worker.mojom.h"
19 #include "content/common/service_worker/embedded_worker_messages.h" 21 #include "content/common/service_worker/embedded_worker_messages.h"
20 #include "content/public/common/child_process_host.h" 22 #include "content/public/common/child_process_host.h"
23 #include "content/public/common/content_switches.h"
21 #include "content/public/test/test_browser_thread_bundle.h" 24 #include "content/public/test/test_browser_thread_bundle.h"
25 #include "mojo/public/cpp/bindings/strong_binding.h"
22 #include "testing/gmock/include/gmock/gmock.h" 26 #include "testing/gmock/include/gmock/gmock.h"
23 #include "testing/gtest/include/gtest/gtest.h" 27 #include "testing/gtest/include/gtest/gtest.h"
24 28
29 using ::testing::Eq;
30 using ::testing::Field;
31 using ::testing::Pointee;
32
25 namespace content { 33 namespace content {
26 34
27 namespace { 35 namespace {
28 36
29 void SaveStatusAndCall(ServiceWorkerStatusCode* out, 37 void SaveStatusAndCall(ServiceWorkerStatusCode* out,
30 const base::Closure& callback, 38 const base::Closure& callback,
31 ServiceWorkerStatusCode status) { 39 ServiceWorkerStatusCode status) {
32 *out = status; 40 *out = status;
33 callback.Run(); 41 callback.Run();
34 } 42 }
35 43
36 std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> 44 std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params>
37 CreateStartParams(int version_id, const GURL& scope, const GURL& script_url) { 45 CreateStartParams(int version_id, const GURL& scope, const GURL& script_url) {
38 std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params( 46 std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params(
39 new EmbeddedWorkerMsg_StartWorker_Params); 47 new EmbeddedWorkerMsg_StartWorker_Params);
40 params->service_worker_version_id = version_id; 48 params->service_worker_version_id = version_id;
41 params->scope = scope; 49 params->scope = scope;
42 params->script_url = script_url; 50 params->script_url = script_url;
43 params->pause_after_download = false; 51 params->pause_after_download = false;
44 return params; 52 return params;
45 } 53 }
46 54
55 bool IsMojoForServiceWorkerEnabled() {
56 return base::CommandLine::ForCurrentProcess()->HasSwitch(
57 switches::kMojoServiceWorker);
58 }
59
47 } // namespace 60 } // namespace
48 61
49 class EmbeddedWorkerInstanceTest : public testing::Test, 62 class EmbeddedWorkerInstanceTest : public testing::Test,
50 public EmbeddedWorkerInstance::Listener { 63 public EmbeddedWorkerInstance::Listener {
51 protected: 64 protected:
52 EmbeddedWorkerInstanceTest() 65 EmbeddedWorkerInstanceTest()
53 : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {} 66 : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {}
54 67
55 enum EventType { 68 enum EventType {
56 PROCESS_ALLOCATED, 69 PROCESS_ALLOCATED,
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after
115 IPC::TestSink* ipc_sink() { return helper_->ipc_sink(); } 128 IPC::TestSink* ipc_sink() { return helper_->ipc_sink(); }
116 129
117 TestBrowserThreadBundle thread_bundle_; 130 TestBrowserThreadBundle thread_bundle_;
118 std::unique_ptr<EmbeddedWorkerTestHelper> helper_; 131 std::unique_ptr<EmbeddedWorkerTestHelper> helper_;
119 std::vector<EventLog> events_; 132 std::vector<EventLog> events_;
120 133
121 private: 134 private:
122 DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerInstanceTest); 135 DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerInstanceTest);
123 }; 136 };
124 137
138 class MojoEmbeddedWorkerInstanceTest : public EmbeddedWorkerInstanceTest {
139 protected:
140 void SetUp() override {
141 base::CommandLine::ForCurrentProcess()->AppendSwitch(
142 switches::kMojoServiceWorker);
143 EmbeddedWorkerInstanceTest::SetUp();
144 }
145
146 std::vector<std::unique_ptr<
147 EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient>>*
148 mock_instance_clients() {
149 return helper_->mock_instance_clients();
150 }
151 };
152
125 // A helper to simulate the start worker sequence is stalled in a worker 153 // A helper to simulate the start worker sequence is stalled in a worker
126 // process. 154 // process.
127 class StalledInStartWorkerHelper : public EmbeddedWorkerTestHelper { 155 class StalledInStartWorkerHelper : public EmbeddedWorkerTestHelper {
128 public: 156 public:
129 StalledInStartWorkerHelper() : EmbeddedWorkerTestHelper(base::FilePath()) {} 157 StalledInStartWorkerHelper() : EmbeddedWorkerTestHelper(base::FilePath()) {}
130 ~StalledInStartWorkerHelper() override{}; 158 ~StalledInStartWorkerHelper() override{};
131 159
132 void OnStartWorker(int embedded_worker_id, 160 void OnStartWorker(int embedded_worker_id,
133 int64_t service_worker_version_id, 161 int64_t service_worker_version_id,
134 const GURL& scope, 162 const GURL& scope,
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after
200 // EmbeddedWorkerTestHelper. 228 // EmbeddedWorkerTestHelper.
201 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); 229 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status());
202 230
203 // Verify that we've sent two messages to start and terminate the worker. 231 // Verify that we've sent two messages to start and terminate the worker.
204 ASSERT_TRUE( 232 ASSERT_TRUE(
205 ipc_sink()->GetUniqueMessageMatching(EmbeddedWorkerMsg_StartWorker::ID)); 233 ipc_sink()->GetUniqueMessageMatching(EmbeddedWorkerMsg_StartWorker::ID));
206 ASSERT_TRUE(ipc_sink()->GetUniqueMessageMatching( 234 ASSERT_TRUE(ipc_sink()->GetUniqueMessageMatching(
207 EmbeddedWorkerMsg_StopWorker::ID)); 235 EmbeddedWorkerMsg_StopWorker::ID));
208 } 236 }
209 237
238 TEST_F(MojoEmbeddedWorkerInstanceTest, StartAndStop) {
239 using mojom::EmbeddedWorkerStartWorkerParams;
240
241 ASSERT_TRUE(IsMojoForServiceWorkerEnabled());
242
243 std::unique_ptr<EmbeddedWorkerInstance> worker =
244 embedded_worker_registry()->CreateWorker();
245 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status());
246
247 const int64_t service_worker_version_id = 55L;
248 const GURL pattern("http://example.com/");
249 const GURL url("http://example.com/worker.js");
250
251 // Simulate adding one process to the pattern.
252 helper_->SimulateAddProcessToPattern(pattern,
253 helper_->mock_render_process_id());
254
255 // Check if StartWorker will be called via mojo IPC.
256 helper_->PrepareMockInstanceClients(1);
257 ASSERT_EQ(mock_instance_clients()->size(), 1UL);
258 EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient* instance_client =
259 mock_instance_clients()->at(0).get();
260 EXPECT_CALL(
261 *instance_client,
262 MockStartWorker(AllOf(
263 Pointee(
264 Field(&EmbeddedWorkerStartWorkerParams::service_worker_version_id,
265 Eq(service_worker_version_id))),
266 Pointee(Field(&EmbeddedWorkerStartWorkerParams::scope, Eq(pattern))),
267 Pointee(
268 Field(&EmbeddedWorkerStartWorkerParams::script_url, Eq(url))))))
269 .Times(1);
falken 2016/09/07 05:01:42 Sorry I got to this late. gmock is fairly discoura
shimazu 2016/09/12 06:28:19 Oops, I didn't know that... The only use case of g
270
271 // Start should succeed.
272 ServiceWorkerStatusCode status;
273 base::RunLoop run_loop;
274 std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params =
275 CreateStartParams(service_worker_version_id, pattern, url);
276 worker->Start(std::move(params), base::Bind(&SaveStatusAndCall, &status,
277 run_loop.QuitClosure()));
278 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, worker->status());
279 run_loop.Run();
280 EXPECT_EQ(SERVICE_WORKER_OK, status);
281
282 // The 'WorkerStarted' message should have been sent by
283 // EmbeddedWorkerTestHelper.
284 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, worker->status());
285 EXPECT_EQ(helper_->mock_render_process_id(), worker->process_id());
286
287 // Stop the worker.
288 EXPECT_EQ(SERVICE_WORKER_OK, worker->Stop());
289 EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, worker->status());
290 base::RunLoop().RunUntilIdle();
291
292 // The 'WorkerStopped' message should have been sent by
293 // EmbeddedWorkerTestHelper.
294 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status());
295
296 // Ckeck if StopWorker has been sent via chromium IPC.
297 ASSERT_TRUE(
298 ipc_sink()->GetUniqueMessageMatching(EmbeddedWorkerMsg_StopWorker::ID));
299 }
300
210 // Test that a worker that failed twice will use a new render process 301 // Test that a worker that failed twice will use a new render process
211 // on the next attempt. 302 // on the next attempt.
212 TEST_F(EmbeddedWorkerInstanceTest, ForceNewProcess) { 303 TEST_F(EmbeddedWorkerInstanceTest, ForceNewProcess) {
213 std::unique_ptr<EmbeddedWorkerInstance> worker = 304 std::unique_ptr<EmbeddedWorkerInstance> worker =
214 embedded_worker_registry()->CreateWorker(); 305 embedded_worker_registry()->CreateWorker();
215 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status()); 306 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status());
216 307
217 const int64_t service_worker_version_id = 55L; 308 const int64_t service_worker_version_id = 55L;
218 const GURL pattern("http://example.com/"); 309 const GURL pattern("http://example.com/");
219 const GURL url("http://example.com/worker.js"); 310 const GURL url("http://example.com/worker.js");
(...skipping 423 matching lines...) Expand 10 before | Expand all | Expand 10 after
643 734
644 // The callback should have run, and we should have got an OnStopped message. 735 // The callback should have run, and we should have got an OnStopped message.
645 EXPECT_EQ(SERVICE_WORKER_ERROR_IPC_FAILED, status); 736 EXPECT_EQ(SERVICE_WORKER_ERROR_IPC_FAILED, status);
646 ASSERT_EQ(2u, events_.size()); 737 ASSERT_EQ(2u, events_.size());
647 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type); 738 EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type);
648 EXPECT_EQ(STOPPED, events_[1].type); 739 EXPECT_EQ(STOPPED, events_[1].type);
649 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, events_[1].status); 740 EXPECT_EQ(EmbeddedWorkerStatus::STARTING, events_[1].status);
650 } 741 }
651 742
652 } // namespace content 743 } // namespace content
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698