embedded_worker_test_helper.cc revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7 
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 "base/bind.h"
8#include "content/browser/service_worker/embedded_worker_instance.h"
9#include "content/browser/service_worker/embedded_worker_registry.h"
10#include "content/browser/service_worker/service_worker_context_core.h"
11#include "content/common/service_worker/embedded_worker_messages.h"
12#include "testing/gtest/include/gtest/gtest.h"
13
14namespace content {
15
16EmbeddedWorkerTestHelper::EmbeddedWorkerTestHelper(
17    ServiceWorkerContextCore* context,
18    int mock_render_process_id)
19    : context_(context->AsWeakPtr()),
20      next_thread_id_(0),
21      weak_factory_(this) {
22  registry()->AddChildProcessSender(mock_render_process_id, this);
23}
24
25EmbeddedWorkerTestHelper::~EmbeddedWorkerTestHelper() {
26}
27
28void EmbeddedWorkerTestHelper::SimulateAddProcessToWorker(
29    int embedded_worker_id,
30    int process_id) {
31  EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
32  ASSERT_TRUE(worker);
33  registry()->AddChildProcessSender(process_id, this);
34  worker->AddProcessReference(process_id);
35}
36
37bool EmbeddedWorkerTestHelper::Send(IPC::Message* message) {
38  OnMessageReceived(*message);
39  delete message;
40  return true;
41}
42
43bool EmbeddedWorkerTestHelper::OnMessageReceived(const IPC::Message& message) {
44  bool handled = true;
45  IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerTestHelper, message)
46    IPC_MESSAGE_HANDLER(EmbeddedWorkerMsg_StartWorker, OnStartWorkerStub)
47    IPC_MESSAGE_HANDLER(EmbeddedWorkerMsg_StopWorker, OnStopWorkerStub)
48    IPC_MESSAGE_HANDLER(EmbeddedWorkerContextMsg_SendMessageToWorker,
49                        OnSendMessageToWorkerStub)
50    IPC_MESSAGE_UNHANDLED(handled = false)
51  IPC_END_MESSAGE_MAP()
52
53  // IPC::TestSink only records messages that are not handled by filters,
54  // so we just forward all messages to the separate sink.
55  sink_.OnMessageReceived(message);
56
57  return handled;
58}
59
60void EmbeddedWorkerTestHelper::OnStartWorker(
61    int embedded_worker_id,
62    int64 service_worker_version_id,
63    const GURL& script_url) {
64  // By default just notify the sender that the worker is started.
65  SimulateWorkerStarted(next_thread_id_++, embedded_worker_id);
66}
67
68void EmbeddedWorkerTestHelper::OnStopWorker(int embedded_worker_id) {
69  // By default just notify the sender that the worker is stopped.
70  SimulateWorkerStopped(embedded_worker_id);
71}
72
73void EmbeddedWorkerTestHelper::OnSendMessageToWorker(
74    int thread_id,
75    int embedded_worker_id,
76    int request_id,
77    const IPC::Message& message) {
78  // Do nothing on the message by default.
79}
80
81void EmbeddedWorkerTestHelper::SimulateWorkerStarted(
82    int thread_id, int embedded_worker_id) {
83  EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
84  ASSERT_TRUE(worker != NULL);
85  registry()->OnWorkerStarted(
86      worker->process_id(),
87      thread_id,
88      embedded_worker_id);
89}
90
91void EmbeddedWorkerTestHelper::SimulateWorkerStopped(
92    int embedded_worker_id) {
93  EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
94  ASSERT_TRUE(worker != NULL);
95  registry()->OnWorkerStopped(worker->process_id(), embedded_worker_id);
96}
97
98void EmbeddedWorkerTestHelper::SimulateSendMessageToBrowser(
99    int embedded_worker_id, int request_id, const IPC::Message& message) {
100  registry()->OnSendMessageToBrowser(embedded_worker_id, request_id, message);
101}
102
103void EmbeddedWorkerTestHelper::OnStartWorkerStub(
104    int embedded_worker_id,
105    int64 service_worker_version_id,
106    const GURL& script_url) {
107  EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
108  ASSERT_TRUE(worker != NULL);
109  EXPECT_EQ(EmbeddedWorkerInstance::STARTING, worker->status());
110  base::MessageLoopProxy::current()->PostTask(
111      FROM_HERE,
112      base::Bind(&EmbeddedWorkerTestHelper::OnStartWorker,
113                 weak_factory_.GetWeakPtr(),
114                 embedded_worker_id,
115                 service_worker_version_id,
116                 script_url));
117}
118
119void EmbeddedWorkerTestHelper::OnStopWorkerStub(int embedded_worker_id) {
120  EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
121  ASSERT_TRUE(worker != NULL);
122  base::MessageLoopProxy::current()->PostTask(
123      FROM_HERE,
124      base::Bind(&EmbeddedWorkerTestHelper::OnStopWorker,
125                 weak_factory_.GetWeakPtr(),
126                 embedded_worker_id));
127}
128
129void EmbeddedWorkerTestHelper::OnSendMessageToWorkerStub(
130    int thread_id,
131    int embedded_worker_id,
132    int request_id,
133    const IPC::Message& message) {
134  EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
135  ASSERT_TRUE(worker != NULL);
136  EXPECT_EQ(worker->thread_id(), thread_id);
137  base::MessageLoopProxy::current()->PostTask(
138      FROM_HERE,
139      base::Bind(&EmbeddedWorkerTestHelper::OnSendMessageToWorker,
140                 weak_factory_.GetWeakPtr(),
141                 thread_id,
142                 embedded_worker_id,
143                 request_id,
144                 message));
145}
146
147EmbeddedWorkerRegistry* EmbeddedWorkerTestHelper::registry() {
148  DCHECK(context_);
149  return context_->embedded_worker_registry();
150}
151
152}  // namespace content
153