OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/service_worker/service_worker_fetch_dispatcher.h" | 5 #include "content/browser/service_worker/service_worker_fetch_dispatcher.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
| 11 #include "base/time/time.h" |
11 #include "base/trace_event/trace_event.h" | 12 #include "base/trace_event/trace_event.h" |
12 #include "content/browser/service_worker/embedded_worker_status.h" | 13 #include "content/browser/service_worker/embedded_worker_status.h" |
| 14 #include "content/browser/service_worker/service_worker_metrics.h" |
13 #include "content/browser/service_worker/service_worker_version.h" | 15 #include "content/browser/service_worker/service_worker_version.h" |
14 #include "content/common/service_worker/service_worker_messages.h" | 16 #include "content/common/service_worker/service_worker_messages.h" |
15 #include "content/common/service_worker/service_worker_utils.h" | 17 #include "content/common/service_worker/service_worker_utils.h" |
16 | 18 |
17 namespace content { | 19 namespace content { |
18 | 20 |
19 namespace { | 21 namespace { |
20 | 22 |
21 using EventType = ServiceWorkerMetrics::EventType; | 23 using EventType = ServiceWorkerMetrics::EventType; |
22 EventType ResourceTypeToEventType(ResourceType resource_type) { | 24 EventType ResourceTypeToEventType(ResourceType resource_type) { |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
69 return ServiceWorkerMetrics::EventType::FETCH_WAITUNTIL; | 71 return ServiceWorkerMetrics::EventType::FETCH_WAITUNTIL; |
70 } | 72 } |
71 | 73 |
72 } // namespace | 74 } // namespace |
73 | 75 |
74 // Helper to receive the fetch event response even if | 76 // Helper to receive the fetch event response even if |
75 // ServiceWorkerFetchDispatcher has been destroyed. | 77 // ServiceWorkerFetchDispatcher has been destroyed. |
76 class ServiceWorkerFetchDispatcher::ResponseCallback { | 78 class ServiceWorkerFetchDispatcher::ResponseCallback { |
77 public: | 79 public: |
78 ResponseCallback(base::WeakPtr<ServiceWorkerFetchDispatcher> fetch_dispatcher, | 80 ResponseCallback(base::WeakPtr<ServiceWorkerFetchDispatcher> fetch_dispatcher, |
79 ServiceWorkerVersion* version) | 81 ServiceWorkerVersion* version, |
80 : fetch_dispatcher_(fetch_dispatcher), version_(version) {} | 82 const base::Time& start_time) |
| 83 : fetch_dispatcher_(fetch_dispatcher), |
| 84 version_(version), |
| 85 start_time_(start_time) {} |
81 | 86 |
82 void Run(int request_id, | 87 void Run(int request_id, |
83 ServiceWorkerFetchEventResult fetch_result, | 88 ServiceWorkerFetchEventResult fetch_result, |
84 const ServiceWorkerResponse& response) { | 89 const ServiceWorkerResponse& response, |
| 90 base::Time event_dispatch_time) { |
| 91 ServiceWorkerMetrics::RecordFetchEventDispatchingDelay( |
| 92 event_dispatch_time - start_time_, version_->site_for_uma()); |
| 93 |
85 const bool handled = | 94 const bool handled = |
86 (fetch_result == SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE); | 95 (fetch_result == SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE); |
87 if (!version_->FinishRequest(request_id, handled)) | 96 if (!version_->FinishRequest(request_id, handled)) |
88 NOTREACHED() << "Should only receive one reply per event"; | 97 NOTREACHED() << "Should only receive one reply per event"; |
89 | 98 |
90 // |fetch_dispatcher| is null if the URLRequest was killed. | 99 // |fetch_dispatcher| is null if the URLRequest was killed. |
91 if (fetch_dispatcher_) | 100 if (fetch_dispatcher_) |
92 fetch_dispatcher_->DidFinish(request_id, fetch_result, response); | 101 fetch_dispatcher_->DidFinish(request_id, fetch_result, response); |
93 } | 102 } |
94 | 103 |
95 private: | 104 private: |
96 base::WeakPtr<ServiceWorkerFetchDispatcher> fetch_dispatcher_; | 105 base::WeakPtr<ServiceWorkerFetchDispatcher> fetch_dispatcher_; |
97 // Owns |this|. | 106 // Owns |this|. |
98 ServiceWorkerVersion* version_; | 107 ServiceWorkerVersion* version_; |
| 108 base::Time start_time_; |
99 | 109 |
100 DISALLOW_COPY_AND_ASSIGN(ResponseCallback); | 110 DISALLOW_COPY_AND_ASSIGN(ResponseCallback); |
101 }; | 111 }; |
102 | 112 |
103 ServiceWorkerFetchDispatcher::ServiceWorkerFetchDispatcher( | 113 ServiceWorkerFetchDispatcher::ServiceWorkerFetchDispatcher( |
104 std::unique_ptr<ServiceWorkerFetchRequest> request, | 114 std::unique_ptr<ServiceWorkerFetchRequest> request, |
105 ServiceWorkerVersion* version, | 115 ServiceWorkerVersion* version, |
106 ResourceType resource_type, | 116 ResourceType resource_type, |
107 const net::BoundNetLog& net_log, | 117 const net::BoundNetLog& net_log, |
108 const base::Closure& prepare_callback, | 118 const base::Closure& prepare_callback, |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
190 | 200 |
191 net_log_.BeginEvent(net::NetLog::TYPE_SERVICE_WORKER_FETCH_EVENT); | 201 net_log_.BeginEvent(net::NetLog::TYPE_SERVICE_WORKER_FETCH_EVENT); |
192 int response_id = version_->StartRequest( | 202 int response_id = version_->StartRequest( |
193 GetEventType(), | 203 GetEventType(), |
194 base::Bind(&ServiceWorkerFetchDispatcher::DidFailToDispatch, | 204 base::Bind(&ServiceWorkerFetchDispatcher::DidFailToDispatch, |
195 weak_factory_.GetWeakPtr())); | 205 weak_factory_.GetWeakPtr())); |
196 int event_finish_id = version_->StartRequest( | 206 int event_finish_id = version_->StartRequest( |
197 FetchTypeToWaitUntilEventType(request_->fetch_type), | 207 FetchTypeToWaitUntilEventType(request_->fetch_type), |
198 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 208 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
199 | 209 |
200 ResponseCallback* response_callback = | 210 ResponseCallback* response_callback = new ResponseCallback( |
201 new ResponseCallback(weak_factory_.GetWeakPtr(), version_.get()); | 211 weak_factory_.GetWeakPtr(), version_.get(), base::Time::Now()); |
202 version_->RegisterRequestCallback<ServiceWorkerHostMsg_FetchEventResponse>( | 212 version_->RegisterRequestCallback<ServiceWorkerHostMsg_FetchEventResponse>( |
203 response_id, | 213 response_id, |
204 base::Bind(&ServiceWorkerFetchDispatcher::ResponseCallback::Run, | 214 base::Bind(&ServiceWorkerFetchDispatcher::ResponseCallback::Run, |
205 base::Owned(response_callback))); | 215 base::Owned(response_callback))); |
206 version_->RegisterSimpleRequest<ServiceWorkerHostMsg_FetchEventFinished>( | 216 version_->RegisterSimpleRequest<ServiceWorkerHostMsg_FetchEventFinished>( |
207 event_finish_id); | 217 event_finish_id); |
208 version_->DispatchEvent({response_id, event_finish_id}, | 218 version_->DispatchEvent({response_id, event_finish_id}, |
209 ServiceWorkerMsg_FetchEvent( | 219 ServiceWorkerMsg_FetchEvent( |
210 response_id, event_finish_id, *request_.get())); | 220 response_id, event_finish_id, *request_.get())); |
211 } | 221 } |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
248 } | 258 } |
249 | 259 |
250 ServiceWorkerMetrics::EventType ServiceWorkerFetchDispatcher::GetEventType() | 260 ServiceWorkerMetrics::EventType ServiceWorkerFetchDispatcher::GetEventType() |
251 const { | 261 const { |
252 if (request_->fetch_type == ServiceWorkerFetchType::FOREIGN_FETCH) | 262 if (request_->fetch_type == ServiceWorkerFetchType::FOREIGN_FETCH) |
253 return ServiceWorkerMetrics::EventType::FOREIGN_FETCH; | 263 return ServiceWorkerMetrics::EventType::FOREIGN_FETCH; |
254 return ResourceTypeToEventType(resource_type_); | 264 return ResourceTypeToEventType(resource_type_); |
255 } | 265 } |
256 | 266 |
257 } // namespace content | 267 } // namespace content |
OLD | NEW |