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/renderer/cache_storage/cache_storage_dispatcher.h" | 5 #include "content/renderer/cache_storage/cache_storage_dispatcher.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <map> | 9 #include <map> |
| 10 #include <memory> |
10 #include <string> | 11 #include <string> |
11 #include <utility> | 12 #include <utility> |
12 | 13 |
13 #include "base/lazy_instance.h" | 14 #include "base/lazy_instance.h" |
14 #include "base/logging.h" | 15 #include "base/logging.h" |
15 #include "base/metrics/histogram_macros.h" | 16 #include "base/metrics/histogram_macros.h" |
16 #include "base/strings/utf_string_conversions.h" | 17 #include "base/strings/utf_string_conversions.h" |
17 #include "base/threading/thread_local.h" | 18 #include "base/threading/thread_local.h" |
18 #include "content/child/thread_safe_sender.h" | 19 #include "content/child/thread_safe_sender.h" |
19 #include "content/common/cache_storage/cache_storage_messages.h" | 20 #include "content/common/cache_storage/cache_storage_messages.h" |
(...skipping 131 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
151 public: | 152 public: |
152 WebCache(base::WeakPtr<CacheStorageDispatcher> dispatcher, int cache_id) | 153 WebCache(base::WeakPtr<CacheStorageDispatcher> dispatcher, int cache_id) |
153 : dispatcher_(dispatcher), cache_id_(cache_id) {} | 154 : dispatcher_(dispatcher), cache_id_(cache_id) {} |
154 | 155 |
155 ~WebCache() override { | 156 ~WebCache() override { |
156 if (dispatcher_) | 157 if (dispatcher_) |
157 dispatcher_->OnWebCacheDestruction(cache_id_); | 158 dispatcher_->OnWebCacheDestruction(cache_id_); |
158 } | 159 } |
159 | 160 |
160 // From blink::WebServiceWorkerCache: | 161 // From blink::WebServiceWorkerCache: |
161 void dispatchMatch(CacheMatchCallbacks* callbacks, | 162 void dispatchMatch(std::unique_ptr<CacheMatchCallbacks> callbacks, |
162 const blink::WebServiceWorkerRequest& request, | 163 const blink::WebServiceWorkerRequest& request, |
163 const QueryParams& query_params) override { | 164 const QueryParams& query_params) override { |
164 if (!dispatcher_) | 165 if (!dispatcher_) |
165 return; | 166 return; |
166 dispatcher_->dispatchMatchForCache(cache_id_, callbacks, request, | 167 dispatcher_->dispatchMatchForCache(cache_id_, std::move(callbacks), request, |
167 query_params); | 168 query_params); |
168 } | 169 } |
169 void dispatchMatchAll(CacheWithResponsesCallbacks* callbacks, | 170 void dispatchMatchAll(std::unique_ptr<CacheWithResponsesCallbacks> callbacks, |
170 const blink::WebServiceWorkerRequest& request, | 171 const blink::WebServiceWorkerRequest& request, |
171 const QueryParams& query_params) override { | 172 const QueryParams& query_params) override { |
172 if (!dispatcher_) | 173 if (!dispatcher_) |
173 return; | 174 return; |
174 dispatcher_->dispatchMatchAllForCache(cache_id_, callbacks, request, | 175 dispatcher_->dispatchMatchAllForCache(cache_id_, std::move(callbacks), |
175 query_params); | 176 request, query_params); |
176 } | 177 } |
177 void dispatchKeys(CacheWithRequestsCallbacks* callbacks, | 178 void dispatchKeys(std::unique_ptr<CacheWithRequestsCallbacks> callbacks, |
178 const blink::WebServiceWorkerRequest& request, | 179 const blink::WebServiceWorkerRequest& request, |
179 const QueryParams& query_params) override { | 180 const QueryParams& query_params) override { |
180 if (!dispatcher_) | 181 if (!dispatcher_) |
181 return; | 182 return; |
182 dispatcher_->dispatchKeysForCache(cache_id_, callbacks, request, | 183 dispatcher_->dispatchKeysForCache(cache_id_, std::move(callbacks), request, |
183 query_params); | 184 query_params); |
184 } | 185 } |
185 void dispatchBatch( | 186 void dispatchBatch( |
186 CacheBatchCallbacks* callbacks, | 187 std::unique_ptr<CacheBatchCallbacks> callbacks, |
187 const blink::WebVector<BatchOperation>& batch_operations) override { | 188 const blink::WebVector<BatchOperation>& batch_operations) override { |
188 if (!dispatcher_) | 189 if (!dispatcher_) |
189 return; | 190 return; |
190 dispatcher_->dispatchBatchForCache(cache_id_, callbacks, batch_operations); | 191 dispatcher_->dispatchBatchForCache(cache_id_, std::move(callbacks), |
| 192 batch_operations); |
191 } | 193 } |
192 | 194 |
193 private: | 195 private: |
194 const base::WeakPtr<CacheStorageDispatcher> dispatcher_; | 196 const base::WeakPtr<CacheStorageDispatcher> dispatcher_; |
195 const int cache_id_; | 197 const int cache_id_; |
196 }; | 198 }; |
197 | 199 |
198 CacheStorageDispatcher::CacheStorageDispatcher( | 200 CacheStorageDispatcher::CacheStorageDispatcher( |
199 ThreadSafeSender* thread_safe_sender) | 201 ThreadSafeSender* thread_safe_sender) |
200 : thread_safe_sender_(thread_safe_sender), weak_factory_(this) { | 202 : thread_safe_sender_(thread_safe_sender), weak_factory_(this) { |
(...skipping 304 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
505 blink::WebServiceWorkerCacheError reason) { | 507 blink::WebServiceWorkerCacheError reason) { |
506 DCHECK_EQ(thread_id, CurrentWorkerId()); | 508 DCHECK_EQ(thread_id, CurrentWorkerId()); |
507 blink::WebServiceWorkerCache::CacheBatchCallbacks* callbacks = | 509 blink::WebServiceWorkerCache::CacheBatchCallbacks* callbacks = |
508 cache_batch_callbacks_.Lookup(request_id); | 510 cache_batch_callbacks_.Lookup(request_id); |
509 callbacks->onError(blink::WebServiceWorkerCacheError(reason)); | 511 callbacks->onError(blink::WebServiceWorkerCacheError(reason)); |
510 cache_batch_callbacks_.Remove(request_id); | 512 cache_batch_callbacks_.Remove(request_id); |
511 cache_batch_times_.erase(request_id); | 513 cache_batch_times_.erase(request_id); |
512 } | 514 } |
513 | 515 |
514 void CacheStorageDispatcher::dispatchHas( | 516 void CacheStorageDispatcher::dispatchHas( |
515 WebServiceWorkerCacheStorage::CacheStorageCallbacks* callbacks, | 517 std::unique_ptr<WebServiceWorkerCacheStorage::CacheStorageCallbacks> |
| 518 callbacks, |
516 const url::Origin& origin, | 519 const url::Origin& origin, |
517 const blink::WebString& cacheName) { | 520 const blink::WebString& cacheName) { |
518 int request_id = has_callbacks_.Add(callbacks); | 521 int request_id = has_callbacks_.Add(std::move(callbacks)); |
519 has_times_[request_id] = base::TimeTicks::Now(); | 522 has_times_[request_id] = base::TimeTicks::Now(); |
520 Send(new CacheStorageHostMsg_CacheStorageHas(CurrentWorkerId(), request_id, | 523 Send(new CacheStorageHostMsg_CacheStorageHas(CurrentWorkerId(), request_id, |
521 origin, cacheName)); | 524 origin, cacheName)); |
522 } | 525 } |
523 | 526 |
524 void CacheStorageDispatcher::dispatchOpen( | 527 void CacheStorageDispatcher::dispatchOpen( |
525 WebServiceWorkerCacheStorage::CacheStorageWithCacheCallbacks* callbacks, | 528 std::unique_ptr< |
| 529 WebServiceWorkerCacheStorage::CacheStorageWithCacheCallbacks> callbacks, |
526 const url::Origin& origin, | 530 const url::Origin& origin, |
527 const blink::WebString& cacheName) { | 531 const blink::WebString& cacheName) { |
528 int request_id = open_callbacks_.Add(callbacks); | 532 int request_id = open_callbacks_.Add(std::move(callbacks)); |
529 open_times_[request_id] = base::TimeTicks::Now(); | 533 open_times_[request_id] = base::TimeTicks::Now(); |
530 Send(new CacheStorageHostMsg_CacheStorageOpen(CurrentWorkerId(), request_id, | 534 Send(new CacheStorageHostMsg_CacheStorageOpen(CurrentWorkerId(), request_id, |
531 origin, cacheName)); | 535 origin, cacheName)); |
532 } | 536 } |
533 | 537 |
534 void CacheStorageDispatcher::dispatchDelete( | 538 void CacheStorageDispatcher::dispatchDelete( |
535 WebServiceWorkerCacheStorage::CacheStorageCallbacks* callbacks, | 539 std::unique_ptr<WebServiceWorkerCacheStorage::CacheStorageCallbacks> |
| 540 callbacks, |
536 const url::Origin& origin, | 541 const url::Origin& origin, |
537 const blink::WebString& cacheName) { | 542 const blink::WebString& cacheName) { |
538 int request_id = delete_callbacks_.Add(callbacks); | 543 int request_id = delete_callbacks_.Add(std::move(callbacks)); |
539 delete_times_[request_id] = base::TimeTicks::Now(); | 544 delete_times_[request_id] = base::TimeTicks::Now(); |
540 Send(new CacheStorageHostMsg_CacheStorageDelete(CurrentWorkerId(), request_id, | 545 Send(new CacheStorageHostMsg_CacheStorageDelete(CurrentWorkerId(), request_id, |
541 origin, cacheName)); | 546 origin, cacheName)); |
542 } | 547 } |
543 | 548 |
544 void CacheStorageDispatcher::dispatchKeys( | 549 void CacheStorageDispatcher::dispatchKeys( |
545 WebServiceWorkerCacheStorage::CacheStorageKeysCallbacks* callbacks, | 550 std::unique_ptr<WebServiceWorkerCacheStorage::CacheStorageKeysCallbacks> |
| 551 callbacks, |
546 const url::Origin& origin) { | 552 const url::Origin& origin) { |
547 int request_id = keys_callbacks_.Add(callbacks); | 553 int request_id = keys_callbacks_.Add(std::move(callbacks)); |
548 keys_times_[request_id] = base::TimeTicks::Now(); | 554 keys_times_[request_id] = base::TimeTicks::Now(); |
549 Send(new CacheStorageHostMsg_CacheStorageKeys(CurrentWorkerId(), request_id, | 555 Send(new CacheStorageHostMsg_CacheStorageKeys(CurrentWorkerId(), request_id, |
550 origin)); | 556 origin)); |
551 } | 557 } |
552 | 558 |
553 void CacheStorageDispatcher::dispatchMatch( | 559 void CacheStorageDispatcher::dispatchMatch( |
554 WebServiceWorkerCacheStorage::CacheStorageMatchCallbacks* callbacks, | 560 std::unique_ptr<WebServiceWorkerCacheStorage::CacheStorageMatchCallbacks> |
| 561 callbacks, |
555 const url::Origin& origin, | 562 const url::Origin& origin, |
556 const blink::WebServiceWorkerRequest& request, | 563 const blink::WebServiceWorkerRequest& request, |
557 const blink::WebServiceWorkerCache::QueryParams& query_params) { | 564 const blink::WebServiceWorkerCache::QueryParams& query_params) { |
558 int request_id = match_callbacks_.Add(callbacks); | 565 int request_id = match_callbacks_.Add(std::move(callbacks)); |
559 match_times_[request_id] = base::TimeTicks::Now(); | 566 match_times_[request_id] = base::TimeTicks::Now(); |
560 Send(new CacheStorageHostMsg_CacheStorageMatch( | 567 Send(new CacheStorageHostMsg_CacheStorageMatch( |
561 CurrentWorkerId(), request_id, origin, | 568 CurrentWorkerId(), request_id, origin, |
562 FetchRequestFromWebRequest(request), | 569 FetchRequestFromWebRequest(request), |
563 QueryParamsFromWebQueryParams(query_params))); | 570 QueryParamsFromWebQueryParams(query_params))); |
564 } | 571 } |
565 | 572 |
566 void CacheStorageDispatcher::dispatchMatchForCache( | 573 void CacheStorageDispatcher::dispatchMatchForCache( |
567 int cache_id, | 574 int cache_id, |
568 blink::WebServiceWorkerCache::CacheMatchCallbacks* callbacks, | 575 std::unique_ptr<blink::WebServiceWorkerCache::CacheMatchCallbacks> |
| 576 callbacks, |
569 const blink::WebServiceWorkerRequest& request, | 577 const blink::WebServiceWorkerRequest& request, |
570 const blink::WebServiceWorkerCache::QueryParams& query_params) { | 578 const blink::WebServiceWorkerCache::QueryParams& query_params) { |
571 int request_id = cache_match_callbacks_.Add(callbacks); | 579 int request_id = cache_match_callbacks_.Add(std::move(callbacks)); |
572 cache_match_times_[request_id] = base::TimeTicks::Now(); | 580 cache_match_times_[request_id] = base::TimeTicks::Now(); |
573 | 581 |
574 Send(new CacheStorageHostMsg_CacheMatch( | 582 Send(new CacheStorageHostMsg_CacheMatch( |
575 CurrentWorkerId(), request_id, cache_id, | 583 CurrentWorkerId(), request_id, cache_id, |
576 FetchRequestFromWebRequest(request), | 584 FetchRequestFromWebRequest(request), |
577 QueryParamsFromWebQueryParams(query_params))); | 585 QueryParamsFromWebQueryParams(query_params))); |
578 } | 586 } |
579 | 587 |
580 void CacheStorageDispatcher::dispatchMatchAllForCache( | 588 void CacheStorageDispatcher::dispatchMatchAllForCache( |
581 int cache_id, | 589 int cache_id, |
582 blink::WebServiceWorkerCache::CacheWithResponsesCallbacks* callbacks, | 590 std::unique_ptr<blink::WebServiceWorkerCache::CacheWithResponsesCallbacks> |
| 591 callbacks, |
583 const blink::WebServiceWorkerRequest& request, | 592 const blink::WebServiceWorkerRequest& request, |
584 const blink::WebServiceWorkerCache::QueryParams& query_params) { | 593 const blink::WebServiceWorkerCache::QueryParams& query_params) { |
585 int request_id = cache_match_all_callbacks_.Add(callbacks); | 594 int request_id = cache_match_all_callbacks_.Add(std::move(callbacks)); |
586 cache_match_all_times_[request_id] = base::TimeTicks::Now(); | 595 cache_match_all_times_[request_id] = base::TimeTicks::Now(); |
587 | 596 |
588 Send(new CacheStorageHostMsg_CacheMatchAll( | 597 Send(new CacheStorageHostMsg_CacheMatchAll( |
589 CurrentWorkerId(), request_id, cache_id, | 598 CurrentWorkerId(), request_id, cache_id, |
590 FetchRequestFromWebRequest(request), | 599 FetchRequestFromWebRequest(request), |
591 QueryParamsFromWebQueryParams(query_params))); | 600 QueryParamsFromWebQueryParams(query_params))); |
592 } | 601 } |
593 | 602 |
594 void CacheStorageDispatcher::dispatchKeysForCache( | 603 void CacheStorageDispatcher::dispatchKeysForCache( |
595 int cache_id, | 604 int cache_id, |
596 blink::WebServiceWorkerCache::CacheWithRequestsCallbacks* callbacks, | 605 std::unique_ptr<blink::WebServiceWorkerCache::CacheWithRequestsCallbacks> |
| 606 callbacks, |
597 const blink::WebServiceWorkerRequest& request, | 607 const blink::WebServiceWorkerRequest& request, |
598 const blink::WebServiceWorkerCache::QueryParams& query_params) { | 608 const blink::WebServiceWorkerCache::QueryParams& query_params) { |
599 int request_id = cache_keys_callbacks_.Add(callbacks); | 609 int request_id = cache_keys_callbacks_.Add(std::move(callbacks)); |
600 cache_keys_times_[request_id] = base::TimeTicks::Now(); | 610 cache_keys_times_[request_id] = base::TimeTicks::Now(); |
601 | 611 |
602 Send(new CacheStorageHostMsg_CacheKeys( | 612 Send(new CacheStorageHostMsg_CacheKeys( |
603 CurrentWorkerId(), request_id, cache_id, | 613 CurrentWorkerId(), request_id, cache_id, |
604 FetchRequestFromWebRequest(request), | 614 FetchRequestFromWebRequest(request), |
605 QueryParamsFromWebQueryParams(query_params))); | 615 QueryParamsFromWebQueryParams(query_params))); |
606 } | 616 } |
607 | 617 |
608 void CacheStorageDispatcher::dispatchBatchForCache( | 618 void CacheStorageDispatcher::dispatchBatchForCache( |
609 int cache_id, | 619 int cache_id, |
610 blink::WebServiceWorkerCache::CacheBatchCallbacks* callbacks, | 620 std::unique_ptr<blink::WebServiceWorkerCache::CacheBatchCallbacks> |
| 621 callbacks, |
611 const blink::WebVector<blink::WebServiceWorkerCache::BatchOperation>& | 622 const blink::WebVector<blink::WebServiceWorkerCache::BatchOperation>& |
612 web_operations) { | 623 web_operations) { |
613 int request_id = cache_batch_callbacks_.Add(callbacks); | 624 int request_id = cache_batch_callbacks_.Add(std::move(callbacks)); |
614 cache_batch_times_[request_id] = base::TimeTicks::Now(); | 625 cache_batch_times_[request_id] = base::TimeTicks::Now(); |
615 | 626 |
616 std::vector<CacheStorageBatchOperation> operations; | 627 std::vector<CacheStorageBatchOperation> operations; |
617 operations.reserve(web_operations.size()); | 628 operations.reserve(web_operations.size()); |
618 for (size_t i = 0; i < web_operations.size(); ++i) { | 629 for (size_t i = 0; i < web_operations.size(); ++i) { |
619 operations.push_back( | 630 operations.push_back( |
620 BatchOperationFromWebBatchOperation(web_operations[i])); | 631 BatchOperationFromWebBatchOperation(web_operations[i])); |
621 } | 632 } |
622 | 633 |
623 Send(new CacheStorageHostMsg_CacheBatch(CurrentWorkerId(), request_id, | 634 Send(new CacheStorageHostMsg_CacheBatch(CurrentWorkerId(), request_id, |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
666 CacheStorageDispatcher::WebResponsesFromResponses( | 677 CacheStorageDispatcher::WebResponsesFromResponses( |
667 const std::vector<ServiceWorkerResponse>& responses) { | 678 const std::vector<ServiceWorkerResponse>& responses) { |
668 blink::WebVector<blink::WebServiceWorkerResponse> web_responses( | 679 blink::WebVector<blink::WebServiceWorkerResponse> web_responses( |
669 responses.size()); | 680 responses.size()); |
670 for (size_t i = 0; i < responses.size(); ++i) | 681 for (size_t i = 0; i < responses.size(); ++i) |
671 PopulateWebResponseFromResponse(responses[i], &(web_responses[i])); | 682 PopulateWebResponseFromResponse(responses[i], &(web_responses[i])); |
672 return web_responses; | 683 return web_responses; |
673 } | 684 } |
674 | 685 |
675 } // namespace content | 686 } // namespace content |
OLD | NEW |