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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
// 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_SERVICE_WORKER_REGISTER_JOB_H_
#define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_REGISTER_JOB_H_
#include <vector>
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "content/browser/service_worker/embedded_worker_instance.h"
#include "content/browser/service_worker/service_worker_register_job_base.h"
#include "content/browser/service_worker/service_worker_registration.h"
#include "content/common/service_worker/service_worker_status_code.h"
#include "url/gurl.h"
namespace content {
class ServiceWorkerJobCoordinator;
class ServiceWorkerStorage;
// Handles the initial registration of a Service Worker and the
// subsequent update of existing registrations.
//
// The control flow includes most or all of the following,
// depending on what is already registered:
// - creating a ServiceWorkerRegistration instance if there isn't
// already something registered
// - creating a ServiceWorkerVersion for the new version.
// - starting a worker for the ServiceWorkerVersion
// - firing the 'install' event at the ServiceWorkerVersion
// - firing the 'activate' event at the ServiceWorkerVersion
// - waiting for older ServiceWorkerVersions to deactivate
// - designating the new version to be the 'active' version
// - updating storage
class ServiceWorkerRegisterJob : public ServiceWorkerRegisterJobBase {
public:
typedef base::Callback<void(ServiceWorkerStatusCode status,
const std::string& status_message,
ServiceWorkerRegistration* registration)>
RegistrationCallback;
// For registration jobs.
CONTENT_EXPORT ServiceWorkerRegisterJob(
base::WeakPtr<ServiceWorkerContextCore> context,
const GURL& pattern,
const GURL& script_url);
// For update jobs.
CONTENT_EXPORT ServiceWorkerRegisterJob(
base::WeakPtr<ServiceWorkerContextCore> context,
ServiceWorkerRegistration* registration,
bool force_bypass_cache,
bool skip_script_comparison);
~ServiceWorkerRegisterJob() override;
// Registers a callback to be called when the promise would resolve (whether
// successfully or not). Multiple callbacks may be registered.
// If |provider_host| is not NULL, its process will be regarded as a candidate
// process to run the worker.
void AddCallback(const RegistrationCallback& callback,
ServiceWorkerProviderHost* provider_host);
// ServiceWorkerRegisterJobBase implementation:
void Start() override;
void Abort() override;
bool Equals(ServiceWorkerRegisterJobBase* job) const override;
RegistrationJobType GetType() const override;
void DoomInstallingWorker();
private:
enum Phase {
INITIAL,
START,
REGISTER,
UPDATE,
INSTALL,
STORE,
COMPLETE,
ABORT,
};
// Holds internal state of ServiceWorkerRegistrationJob, to compel use of the
// getter/setter functions.
struct Internal {
Internal();
~Internal();
scoped_refptr<ServiceWorkerRegistration> registration;
// Holds the version created by this job. It can be the 'installing',
// 'waiting', or 'active' version depending on the phase.
scoped_refptr<ServiceWorkerVersion> new_version;
};
void set_registration(
const scoped_refptr<ServiceWorkerRegistration>& registration);
ServiceWorkerRegistration* registration();
void set_new_version(ServiceWorkerVersion* version);
ServiceWorkerVersion* new_version();
void SetPhase(Phase phase);
void StartImpl();
void ContinueWithRegistration(
ServiceWorkerStatusCode status,
const scoped_refptr<ServiceWorkerRegistration>& registration);
void ContinueWithUpdate(
ServiceWorkerStatusCode status,
const scoped_refptr<ServiceWorkerRegistration>& registration);
void RegisterAndContinue();
void ContinueWithUninstallingRegistration(
const scoped_refptr<ServiceWorkerRegistration>& existing_registration,
ServiceWorkerStatusCode status);
void ContinueWithRegistrationForSameScriptUrl(
const scoped_refptr<ServiceWorkerRegistration>& existing_registration,
ServiceWorkerStatusCode status);
void UpdateAndContinue();
void OnStartWorkerFinished(ServiceWorkerStatusCode status);
void OnStoreRegistrationComplete(ServiceWorkerStatusCode status);
void InstallAndContinue();
void OnInstallFinished(ServiceWorkerStatusCode status);
void Complete(ServiceWorkerStatusCode status);
void Complete(ServiceWorkerStatusCode status,
const std::string& status_message);
void CompleteInternal(ServiceWorkerStatusCode status,
const std::string& status_message);
void ResolvePromise(ServiceWorkerStatusCode status,
const std::string& status_message,
ServiceWorkerRegistration* registration);
void AddRegistrationToMatchingProviderHosts(
ServiceWorkerRegistration* registration);
// The ServiceWorkerContextCore object should always outlive this.
base::WeakPtr<ServiceWorkerContextCore> context_;
RegistrationJobType job_type_;
const GURL pattern_;
const GURL script_url_;
std::vector<RegistrationCallback> callbacks_;
Phase phase_;
Internal internal_;
bool doom_installing_worker_;
bool is_promise_resolved_;
bool should_uninstall_on_failure_;
bool force_bypass_cache_;
bool skip_script_comparison_;
ServiceWorkerStatusCode promise_resolved_status_;
std::string promise_resolved_status_message_;
scoped_refptr<ServiceWorkerRegistration> promise_resolved_registration_;
base::WeakPtrFactory<ServiceWorkerRegisterJob> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(ServiceWorkerRegisterJob);
};
} // namespace content
#endif // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_REGISTER_JOB_H_
|
