1 // Copyright 2014 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/service_worker/embedded_worker_test_helper.h" 6 7 #include <map> 8 #include <string> 9 10 #include "base/bind.h" 11 #include "content/browser/service_worker/embedded_worker_instance.h" 12 #include "content/browser/service_worker/embedded_worker_registry.h" 13 #include "content/browser/service_worker/service_worker_context_core.h" 14 #include "content/browser/service_worker/service_worker_context_wrapper.h" 15 #include "content/common/service_worker/embedded_worker_messages.h" 16 #include "content/common/service_worker/service_worker_messages.h" 17 #include "testing/gtest/include/gtest/gtest.h" 18 19 namespace content { 20 21 EmbeddedWorkerTestHelper::EmbeddedWorkerTestHelper(int mock_render_process_id) 22 : wrapper_(new ServiceWorkerContextWrapper(NULL)), 23 next_thread_id_(0), 24 mock_render_process_id_(mock_render_process_id), 25 weak_factory_(this) { 26 wrapper_->InitInternal(base::FilePath(), 27 base::MessageLoopProxy::current(), 28 base::MessageLoopProxy::current(), 29 base::MessageLoopProxy::current(), 30 NULL); 31 wrapper_->process_manager()->SetProcessIdForTest(mock_render_process_id); 32 registry()->AddChildProcessSender(mock_render_process_id, this); 33 } 34 35 EmbeddedWorkerTestHelper::~EmbeddedWorkerTestHelper() { 36 if (wrapper_.get()) 37 wrapper_->Shutdown(); 38 } 39 40 void EmbeddedWorkerTestHelper::SimulateAddProcessToPattern( 41 const GURL& pattern, 42 int process_id) { 43 registry()->AddChildProcessSender(process_id, this); 44 wrapper_->process_manager()->AddProcessReferenceToPattern( 45 pattern, process_id); 46 } 47 48 bool EmbeddedWorkerTestHelper::Send(IPC::Message* message) { 49 OnMessageReceived(*message); 50 delete message; 51 return true; 52 } 53 54 bool EmbeddedWorkerTestHelper::OnMessageReceived(const IPC::Message& message) { 55 bool handled = true; 56 IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerTestHelper, message) 57 IPC_MESSAGE_HANDLER(EmbeddedWorkerMsg_StartWorker, OnStartWorkerStub) 58 IPC_MESSAGE_HANDLER(EmbeddedWorkerMsg_StopWorker, OnStopWorkerStub) 59 IPC_MESSAGE_HANDLER(EmbeddedWorkerContextMsg_MessageToWorker, 60 OnMessageToWorkerStub) 61 IPC_MESSAGE_HANDLER(EmbeddedWorkerMsg_ResumeAfterDownload, 62 OnResumeAfterDownloadStub) 63 IPC_MESSAGE_UNHANDLED(handled = false) 64 IPC_END_MESSAGE_MAP() 65 66 // IPC::TestSink only records messages that are not handled by filters, 67 // so we just forward all messages to the separate sink. 68 sink_.OnMessageReceived(message); 69 70 return handled; 71 } 72 73 ServiceWorkerContextCore* EmbeddedWorkerTestHelper::context() { 74 return wrapper_->context(); 75 } 76 77 void EmbeddedWorkerTestHelper::ShutdownContext() { 78 wrapper_->Shutdown(); 79 wrapper_ = NULL; 80 } 81 82 void EmbeddedWorkerTestHelper::OnStartWorker( 83 int embedded_worker_id, 84 int64 service_worker_version_id, 85 const GURL& scope, 86 const GURL& script_url, 87 bool pause_after_download) { 88 if (pause_after_download) { 89 SimulatePausedAfterDownload(embedded_worker_id); 90 return; 91 } 92 SimulateWorkerReadyForInspection(embedded_worker_id); 93 SimulateWorkerScriptLoaded(next_thread_id_++, embedded_worker_id); 94 SimulateWorkerStarted(embedded_worker_id); 95 } 96 97 void EmbeddedWorkerTestHelper::OnResumeAfterDownload(int embedded_worker_id) { 98 SimulateWorkerReadyForInspection(embedded_worker_id); 99 SimulateWorkerScriptLoaded(next_thread_id_++, embedded_worker_id); 100 SimulateWorkerStarted(embedded_worker_id); 101 } 102 103 void EmbeddedWorkerTestHelper::OnStopWorker(int embedded_worker_id) { 104 // By default just notify the sender that the worker is stopped. 105 SimulateWorkerStopped(embedded_worker_id); 106 } 107 108 bool EmbeddedWorkerTestHelper::OnMessageToWorker( 109 int thread_id, 110 int embedded_worker_id, 111 const IPC::Message& message) { 112 bool handled = true; 113 current_embedded_worker_id_ = embedded_worker_id; 114 IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerTestHelper, message) 115 IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ActivateEvent, OnActivateEventStub) 116 IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEventStub) 117 IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FetchEvent, OnFetchEventStub) 118 IPC_MESSAGE_UNHANDLED(handled = false) 119 IPC_END_MESSAGE_MAP() 120 // Record all messages directed to inner script context. 121 inner_sink_.OnMessageReceived(message); 122 return handled; 123 } 124 125 void EmbeddedWorkerTestHelper::OnActivateEvent(int embedded_worker_id, 126 int request_id) { 127 SimulateSend( 128 new ServiceWorkerHostMsg_ActivateEventFinished( 129 embedded_worker_id, request_id, 130 blink::WebServiceWorkerEventResultCompleted)); 131 } 132 133 void EmbeddedWorkerTestHelper::OnInstallEvent(int embedded_worker_id, 134 int request_id, 135 int active_version_id) { 136 SimulateSend( 137 new ServiceWorkerHostMsg_InstallEventFinished( 138 embedded_worker_id, request_id, 139 blink::WebServiceWorkerEventResultCompleted)); 140 } 141 142 void EmbeddedWorkerTestHelper::OnFetchEvent( 143 int embedded_worker_id, 144 int request_id, 145 const ServiceWorkerFetchRequest& request) { 146 SimulateSend(new ServiceWorkerHostMsg_FetchEventFinished( 147 embedded_worker_id, 148 request_id, 149 SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, 150 ServiceWorkerResponse( 151 GURL(""), 200, "OK", ServiceWorkerHeaderMap(), std::string()))); 152 } 153 154 void EmbeddedWorkerTestHelper::SimulatePausedAfterDownload( 155 int embedded_worker_id) { 156 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); 157 ASSERT_TRUE(worker != NULL); 158 registry()->OnPausedAfterDownload(worker->process_id(), embedded_worker_id); 159 } 160 161 void EmbeddedWorkerTestHelper::SimulateWorkerReadyForInspection( 162 int embedded_worker_id) { 163 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); 164 ASSERT_TRUE(worker != NULL); 165 registry()->OnWorkerReadyForInspection(worker->process_id(), 166 embedded_worker_id); 167 } 168 169 void EmbeddedWorkerTestHelper::SimulateWorkerScriptLoaded( 170 int thread_id, int embedded_worker_id) { 171 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); 172 ASSERT_TRUE(worker != NULL); 173 registry()->OnWorkerScriptLoaded( 174 worker->process_id(), thread_id, embedded_worker_id); 175 } 176 177 void EmbeddedWorkerTestHelper::SimulateWorkerStarted( 178 int embedded_worker_id) { 179 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); 180 ASSERT_TRUE(worker != NULL); 181 registry()->OnWorkerStarted( 182 worker->process_id(), 183 embedded_worker_id); 184 } 185 186 void EmbeddedWorkerTestHelper::SimulateWorkerStopped( 187 int embedded_worker_id) { 188 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); 189 if (worker != NULL) 190 registry()->OnWorkerStopped(worker->process_id(), embedded_worker_id); 191 } 192 193 void EmbeddedWorkerTestHelper::SimulateSend( 194 IPC::Message* message) { 195 registry()->OnMessageReceived(*message); 196 delete message; 197 } 198 199 void EmbeddedWorkerTestHelper::OnStartWorkerStub( 200 const EmbeddedWorkerMsg_StartWorker_Params& params) { 201 EmbeddedWorkerInstance* worker = 202 registry()->GetWorker(params.embedded_worker_id); 203 ASSERT_TRUE(worker != NULL); 204 EXPECT_EQ(EmbeddedWorkerInstance::STARTING, worker->status()); 205 base::MessageLoopProxy::current()->PostTask( 206 FROM_HERE, 207 base::Bind(&EmbeddedWorkerTestHelper::OnStartWorker, 208 weak_factory_.GetWeakPtr(), 209 params.embedded_worker_id, 210 params.service_worker_version_id, 211 params.scope, 212 params.script_url, 213 params.pause_after_download)); 214 } 215 216 void EmbeddedWorkerTestHelper::OnResumeAfterDownloadStub( 217 int embedded_worker_id) { 218 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); 219 ASSERT_TRUE(worker != NULL); 220 base::MessageLoopProxy::current()->PostTask( 221 FROM_HERE, 222 base::Bind(&EmbeddedWorkerTestHelper::OnResumeAfterDownload, 223 weak_factory_.GetWeakPtr(), 224 embedded_worker_id)); 225 } 226 227 void EmbeddedWorkerTestHelper::OnStopWorkerStub(int embedded_worker_id) { 228 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); 229 ASSERT_TRUE(worker != NULL); 230 base::MessageLoopProxy::current()->PostTask( 231 FROM_HERE, 232 base::Bind(&EmbeddedWorkerTestHelper::OnStopWorker, 233 weak_factory_.GetWeakPtr(), 234 embedded_worker_id)); 235 } 236 237 void EmbeddedWorkerTestHelper::OnMessageToWorkerStub( 238 int thread_id, 239 int embedded_worker_id, 240 const IPC::Message& message) { 241 EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id); 242 ASSERT_TRUE(worker != NULL); 243 EXPECT_EQ(worker->thread_id(), thread_id); 244 base::MessageLoopProxy::current()->PostTask( 245 FROM_HERE, 246 base::Bind( 247 base::IgnoreResult(&EmbeddedWorkerTestHelper::OnMessageToWorker), 248 weak_factory_.GetWeakPtr(), 249 thread_id, 250 embedded_worker_id, 251 message)); 252 } 253 254 void EmbeddedWorkerTestHelper::OnActivateEventStub(int request_id) { 255 base::MessageLoopProxy::current()->PostTask( 256 FROM_HERE, 257 base::Bind(&EmbeddedWorkerTestHelper::OnActivateEvent, 258 weak_factory_.GetWeakPtr(), 259 current_embedded_worker_id_, 260 request_id)); 261 } 262 263 void EmbeddedWorkerTestHelper::OnInstallEventStub(int request_id, 264 int active_version_id) { 265 base::MessageLoopProxy::current()->PostTask( 266 FROM_HERE, 267 base::Bind(&EmbeddedWorkerTestHelper::OnInstallEvent, 268 weak_factory_.GetWeakPtr(), 269 current_embedded_worker_id_, 270 request_id, 271 active_version_id)); 272 } 273 274 void EmbeddedWorkerTestHelper::OnFetchEventStub( 275 int request_id, 276 const ServiceWorkerFetchRequest& request) { 277 base::MessageLoopProxy::current()->PostTask( 278 FROM_HERE, 279 base::Bind(&EmbeddedWorkerTestHelper::OnFetchEvent, 280 weak_factory_.GetWeakPtr(), 281 current_embedded_worker_id_, 282 request_id, 283 request)); 284 } 285 286 EmbeddedWorkerRegistry* EmbeddedWorkerTestHelper::registry() { 287 DCHECK(context()); 288 return context()->embedded_worker_registry(); 289 } 290 291 } // namespace content 292
