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
|
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_BROWSER_SERVICE_WORKER_EMBEDDED_WORKER_INSTANCE_H_
#define CONTENT_BROWSER_SERVICE_WORKER_EMBEDDED_WORKER_INSTANCE_H_
#include <map>
#include "base/basictypes.h"
#include "base/callback_forward.h"
#include "base/gtest_prod_util.h"
#include "base/logging.h"
#include "base/memory/ref_counted.h"
#include "base/observer_list.h"
#include "content/common/content_export.h"
#include "content/common/service_worker/service_worker_status_code.h"
class GURL;
namespace IPC {
class Message;
}
namespace content {
class EmbeddedWorkerRegistry;
struct ServiceWorkerFetchRequest;
// This gives an interface to control one EmbeddedWorker instance, which
// may be 'in-waiting' or running in one of the child processes added by
// AddProcessReference().
class CONTENT_EXPORT EmbeddedWorkerInstance {
public:
enum Status {
STOPPED,
STARTING,
RUNNING,
STOPPING,
};
class Observer {
public:
virtual ~Observer() {}
virtual void OnStarted() = 0;
virtual void OnStopped() = 0;
virtual void OnMessageReceived(int request_id,
const IPC::Message& message) = 0;
};
~EmbeddedWorkerInstance();
// Starts the worker. It is invalid to call this when the worker is
// not in STOPPED status.
ServiceWorkerStatusCode Start(int64 service_worker_version_id,
const GURL& script_url);
// Stops the worker. It is invalid to call this when the worker is
// not in STARTING or RUNNING status.
// This returns false if stopping a worker fails immediately, e.g. when
// IPC couldn't be sent to the worker.
ServiceWorkerStatusCode Stop();
// Sends |message| to the embedded worker running in the child process.
// It is invalid to call this while the worker is not in RUNNING status.
// |request_id| can be optionally used to establish 2-way request-response
// messaging (e.g. the receiver can send back a response using the same
// request_id).
ServiceWorkerStatusCode SendMessage(
int request_id, const IPC::Message& message);
// Add or remove |process_id| to the internal process set where this
// worker can be started.
void AddProcessReference(int process_id);
void ReleaseProcessReference(int process_id);
int embedded_worker_id() const { return embedded_worker_id_; }
Status status() const { return status_; }
int process_id() const { return process_id_; }
int thread_id() const { return thread_id_; }
void AddObserver(Observer* observer);
void RemoveObserver(Observer* observer);
private:
friend class EmbeddedWorkerRegistry;
FRIEND_TEST_ALL_PREFIXES(EmbeddedWorkerInstanceTest, StartAndStop);
typedef std::map<int, int> ProcessRefMap;
// Constructor is called via EmbeddedWorkerRegistry::CreateWorker().
// This instance holds a ref of |registry|.
EmbeddedWorkerInstance(EmbeddedWorkerRegistry* registry,
int embedded_worker_id);
// Called back from Registry when the worker instance has ack'ed that
// its WorkerGlobalScope is actually started on |thread_id| in the
// child process.
// This will change the internal status from STARTING to RUNNING.
void OnStarted(int thread_id);
// Called back from Registry when the worker instance has ack'ed that
// its WorkerGlobalScope is actually stopped in the child process.
// This will change the internal status from STARTING or RUNNING to
// STOPPED.
void OnStopped();
// Called back from Registry when the worker instance sends message
// to the browser (i.e. EmbeddedWorker observers).
void OnMessageReceived(int request_id, const IPC::Message& message);
// Chooses a process to start this worker and populate process_id_.
// Returns false when no process is available.
bool ChooseProcess();
scoped_refptr<EmbeddedWorkerRegistry> registry_;
const int embedded_worker_id_;
Status status_;
// Current running information. -1 indicates the worker is not running.
int process_id_;
int thread_id_;
ProcessRefMap process_refs_;
ObserverList<Observer> observer_list_;
DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerInstance);
};
} // namespace content
#endif // CONTENT_BROWSER_SERVICE_WORKER_EMBEDDED_WORKER_INSTANCE_H_
|
