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
|
// Copyright 2014 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.
#include "content/browser/push_messaging/push_messaging_router.h"
#include "base/bind.h"
#include "content/browser/service_worker/service_worker_context_wrapper.h"
#include "content/browser/service_worker/service_worker_registration.h"
#include "content/browser/service_worker/service_worker_storage.h"
#include "content/common/service_worker/service_worker_status_code.h"
#include "content/public/browser/browser_context.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/storage_partition.h"
namespace content {
// static
void PushMessagingRouter::DeliverMessage(
BrowserContext* browser_context,
const GURL& origin,
int64 service_worker_registration_id,
const std::string& data,
const DeliverMessageCallback& deliver_message_callback) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
StoragePartition* partition =
BrowserContext::GetStoragePartitionForSite(browser_context, origin);
scoped_refptr<ServiceWorkerContextWrapper> service_worker_context =
static_cast<ServiceWorkerContextWrapper*>(
partition->GetServiceWorkerContext());
BrowserThread::PostTask(
BrowserThread::IO,
FROM_HERE,
base::Bind(&PushMessagingRouter::FindServiceWorkerRegistration,
origin,
service_worker_registration_id,
data,
deliver_message_callback,
service_worker_context));
}
// static
void PushMessagingRouter::FindServiceWorkerRegistration(
const GURL& origin,
int64 service_worker_registration_id,
const std::string& data,
const DeliverMessageCallback& deliver_message_callback,
scoped_refptr<ServiceWorkerContextWrapper> service_worker_context) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
// Try to acquire the registration from storage. If it's already live we'll
// receive it right away. If not, it will be revived from storage.
service_worker_context->context()->storage()->FindRegistrationForId(
service_worker_registration_id,
origin,
base::Bind(&PushMessagingRouter::FindServiceWorkerRegistrationCallback,
data,
deliver_message_callback));
}
// static
void PushMessagingRouter::FindServiceWorkerRegistrationCallback(
const std::string& data,
const DeliverMessageCallback& deliver_message_callback,
ServiceWorkerStatusCode service_worker_status,
const scoped_refptr<ServiceWorkerRegistration>&
service_worker_registration) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
if (service_worker_status == SERVICE_WORKER_OK) {
// Hold on to the service worker registration in the callback to keep it
// alive until the callback dies. Otherwise the registration could be
// released when this method returns - before the event is delivered to the
// service worker.
base::Callback<void(ServiceWorkerStatusCode)> dispatch_event_callback =
base::Bind(&PushMessagingRouter::DeliverMessageEnd,
deliver_message_callback,
service_worker_registration);
service_worker_registration->active_version()->DispatchPushEvent(
dispatch_event_callback, data);
} else {
// TODO(mvanouwerkerk): UMA logging.
BrowserThread::PostTask(BrowserThread::UI,
FROM_HERE,
base::Bind(deliver_message_callback,
PUSH_DELIVERY_STATUS_NO_SERVICE_WORKER));
}
}
// static
void PushMessagingRouter::DeliverMessageEnd(
const DeliverMessageCallback& deliver_message_callback,
const scoped_refptr<ServiceWorkerRegistration>& service_worker_registration,
ServiceWorkerStatusCode service_worker_status) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
// TODO(mvanouwerkerk): UMA logging.
PushDeliveryStatus delivery_status;
switch (service_worker_status) {
case SERVICE_WORKER_OK:
delivery_status = PUSH_DELIVERY_STATUS_SUCCESS;
break;
case SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED:
delivery_status = PUSH_DELIVERY_STATUS_EVENT_WAITUNTIL_REJECTED;
break;
case SERVICE_WORKER_ERROR_FAILED:
case SERVICE_WORKER_ERROR_ABORT:
case SERVICE_WORKER_ERROR_START_WORKER_FAILED:
case SERVICE_WORKER_ERROR_PROCESS_NOT_FOUND:
case SERVICE_WORKER_ERROR_NOT_FOUND:
case SERVICE_WORKER_ERROR_IPC_FAILED:
delivery_status = PUSH_DELIVERY_STATUS_SERVICE_WORKER_ERROR;
break;
case SERVICE_WORKER_ERROR_EXISTS:
case SERVICE_WORKER_ERROR_INSTALL_WORKER_FAILED:
case SERVICE_WORKER_ERROR_ACTIVATE_WORKER_FAILED:
case SERVICE_WORKER_ERROR_NETWORK:
case SERVICE_WORKER_ERROR_SECURITY:
NOTREACHED() << "Got unexpected error code: " << service_worker_status
<< " " << ServiceWorkerStatusToString(service_worker_status);
delivery_status = PUSH_DELIVERY_STATUS_SERVICE_WORKER_ERROR;
break;
}
BrowserThread::PostTask(
BrowserThread::UI,
FROM_HERE,
base::Bind(deliver_message_callback, delivery_status));
}
} // namespace content
|
