Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(102)

Side by Side Diff: webkit/browser/appcache/appcache_update_job.cc

Issue 344493002: Move all remaining appcache-related code to content namespace (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: rebase Created 6 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
(Empty)
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "webkit/browser/appcache/appcache_update_job.h"
6
7 #include "base/bind.h"
8 #include "base/bind_helpers.h"
9 #include "base/compiler_specific.h"
10 #include "base/message_loop/message_loop.h"
11 #include "base/strings/string_util.h"
12 #include "base/strings/stringprintf.h"
13 #include "net/base/io_buffer.h"
14 #include "net/base/load_flags.h"
15 #include "net/base/net_errors.h"
16 #include "net/base/request_priority.h"
17 #include "net/http/http_request_headers.h"
18 #include "net/http/http_response_headers.h"
19 #include "net/url_request/url_request_context.h"
20 #include "webkit/browser/appcache/appcache_group.h"
21 #include "webkit/browser/appcache/appcache_histograms.h"
22
23 namespace appcache {
24
25 static const int kBufferSize = 32768;
26 static const size_t kMaxConcurrentUrlFetches = 2;
27 static const int kMax503Retries = 3;
28
29 static std::string FormatUrlErrorMessage(
30 const char* format, const GURL& url,
31 AppCacheUpdateJob::ResultType error,
32 int response_code) {
33 // Show the net response code if we have one.
34 int code = response_code;
35 if (error != AppCacheUpdateJob::SERVER_ERROR)
36 code = static_cast<int>(error);
37 return base::StringPrintf(format, code, url.spec().c_str());
38 }
39
40 // Helper class for collecting hosts per frontend when sending notifications
41 // so that only one notification is sent for all hosts using the same frontend.
42 class HostNotifier {
43 public:
44 typedef std::vector<int> HostIds;
45 typedef std::map<AppCacheFrontend*, HostIds> NotifyHostMap;
46
47 // Caller is responsible for ensuring there will be no duplicate hosts.
48 void AddHost(AppCacheHost* host) {
49 std::pair<NotifyHostMap::iterator , bool> ret = hosts_to_notify.insert(
50 NotifyHostMap::value_type(host->frontend(), HostIds()));
51 ret.first->second.push_back(host->host_id());
52 }
53
54 void AddHosts(const std::set<AppCacheHost*>& hosts) {
55 for (std::set<AppCacheHost*>::const_iterator it = hosts.begin();
56 it != hosts.end(); ++it) {
57 AddHost(*it);
58 }
59 }
60
61 void SendNotifications(AppCacheEventID event_id) {
62 for (NotifyHostMap::iterator it = hosts_to_notify.begin();
63 it != hosts_to_notify.end(); ++it) {
64 AppCacheFrontend* frontend = it->first;
65 frontend->OnEventRaised(it->second, event_id);
66 }
67 }
68
69 void SendProgressNotifications(
70 const GURL& url, int num_total, int num_complete) {
71 for (NotifyHostMap::iterator it = hosts_to_notify.begin();
72 it != hosts_to_notify.end(); ++it) {
73 AppCacheFrontend* frontend = it->first;
74 frontend->OnProgressEventRaised(it->second, url,
75 num_total, num_complete);
76 }
77 }
78
79 void SendErrorNotifications(const AppCacheErrorDetails& details) {
80 DCHECK(!details.message.empty());
81 for (NotifyHostMap::iterator it = hosts_to_notify.begin();
82 it != hosts_to_notify.end(); ++it) {
83 AppCacheFrontend* frontend = it->first;
84 frontend->OnErrorEventRaised(it->second, details);
85 }
86 }
87
88 void SendLogMessage(const std::string& message) {
89 for (NotifyHostMap::iterator it = hosts_to_notify.begin();
90 it != hosts_to_notify.end(); ++it) {
91 AppCacheFrontend* frontend = it->first;
92 for (HostIds::iterator id = it->second.begin();
93 id != it->second.end(); ++id) {
94 frontend->OnLogMessage(*id, APPCACHE_LOG_WARNING, message);
95 }
96 }
97 }
98
99 private:
100 NotifyHostMap hosts_to_notify;
101 };
102
103 AppCacheUpdateJob::UrlToFetch::UrlToFetch(const GURL& url,
104 bool checked,
105 AppCacheResponseInfo* info)
106 : url(url),
107 storage_checked(checked),
108 existing_response_info(info) {
109 }
110
111 AppCacheUpdateJob::UrlToFetch::~UrlToFetch() {
112 }
113
114 // Helper class to fetch resources. Depending on the fetch type,
115 // can either fetch to an in-memory string or write the response
116 // data out to the disk cache.
117 AppCacheUpdateJob::URLFetcher::URLFetcher(const GURL& url,
118 FetchType fetch_type,
119 AppCacheUpdateJob* job)
120 : url_(url),
121 job_(job),
122 fetch_type_(fetch_type),
123 retry_503_attempts_(0),
124 buffer_(new net::IOBuffer(kBufferSize)),
125 request_(job->service_->request_context()
126 ->CreateRequest(url, net::DEFAULT_PRIORITY, this, NULL)),
127 result_(UPDATE_OK),
128 redirect_response_code_(-1) {}
129
130 AppCacheUpdateJob::URLFetcher::~URLFetcher() {
131 }
132
133 void AppCacheUpdateJob::URLFetcher::Start() {
134 request_->set_first_party_for_cookies(job_->manifest_url_);
135 request_->SetLoadFlags(request_->load_flags() |
136 net::LOAD_DISABLE_INTERCEPT);
137 if (existing_response_headers_.get())
138 AddConditionalHeaders(existing_response_headers_.get());
139 request_->Start();
140 }
141
142 void AppCacheUpdateJob::URLFetcher::OnReceivedRedirect(
143 net::URLRequest* request, const GURL& new_url, bool* defer_redirect) {
144 DCHECK(request_ == request);
145 // Redirect is not allowed by the update process.
146 job_->MadeProgress();
147 redirect_response_code_ = request->GetResponseCode();
148 request->Cancel();
149 result_ = REDIRECT_ERROR;
150 OnResponseCompleted();
151 }
152
153 void AppCacheUpdateJob::URLFetcher::OnResponseStarted(
154 net::URLRequest *request) {
155 DCHECK(request == request_);
156 int response_code = -1;
157 if (request->status().is_success()) {
158 response_code = request->GetResponseCode();
159 job_->MadeProgress();
160 }
161 if ((response_code / 100) == 2) {
162
163 // See http://code.google.com/p/chromium/issues/detail?id=69594
164 // We willfully violate the HTML5 spec at this point in order
165 // to support the appcaching of cross-origin HTTPS resources.
166 // We've opted for a milder constraint and allow caching unless
167 // the resource has a "no-store" header. A spec change has been
168 // requested on the whatwg list.
169 // TODO(michaeln): Consider doing this for cross-origin HTTP resources too.
170 if (url_.SchemeIsSecure() &&
171 url_.GetOrigin() != job_->manifest_url_.GetOrigin()) {
172 if (request->response_headers()->
173 HasHeaderValue("cache-control", "no-store")) {
174 DCHECK_EQ(-1, redirect_response_code_);
175 request->Cancel();
176 result_ = SERVER_ERROR; // Not the best match?
177 OnResponseCompleted();
178 return;
179 }
180 }
181
182 // Write response info to storage for URL fetches. Wait for async write
183 // completion before reading any response data.
184 if (fetch_type_ == URL_FETCH || fetch_type_ == MASTER_ENTRY_FETCH) {
185 response_writer_.reset(job_->CreateResponseWriter());
186 scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
187 new HttpResponseInfoIOBuffer(
188 new net::HttpResponseInfo(request->response_info())));
189 response_writer_->WriteInfo(
190 io_buffer.get(),
191 base::Bind(&URLFetcher::OnWriteComplete, base::Unretained(this)));
192 } else {
193 ReadResponseData();
194 }
195 } else {
196 if (response_code > 0)
197 result_ = SERVER_ERROR;
198 else
199 result_ = NETWORK_ERROR;
200 OnResponseCompleted();
201 }
202 }
203
204 void AppCacheUpdateJob::URLFetcher::OnReadCompleted(
205 net::URLRequest* request, int bytes_read) {
206 DCHECK(request_ == request);
207 bool data_consumed = true;
208 if (request->status().is_success() && bytes_read > 0) {
209 job_->MadeProgress();
210 data_consumed = ConsumeResponseData(bytes_read);
211 if (data_consumed) {
212 bytes_read = 0;
213 while (request->Read(buffer_.get(), kBufferSize, &bytes_read)) {
214 if (bytes_read > 0) {
215 data_consumed = ConsumeResponseData(bytes_read);
216 if (!data_consumed)
217 break; // wait for async data processing, then read more
218 } else {
219 break;
220 }
221 }
222 }
223 }
224 if (data_consumed && !request->status().is_io_pending()) {
225 DCHECK_EQ(UPDATE_OK, result_);
226 OnResponseCompleted();
227 }
228 }
229
230 void AppCacheUpdateJob::URLFetcher::AddConditionalHeaders(
231 const net::HttpResponseHeaders* headers) {
232 DCHECK(request_.get() && headers);
233 net::HttpRequestHeaders extra_headers;
234
235 // Add If-Modified-Since header if response info has Last-Modified header.
236 const std::string last_modified = "Last-Modified";
237 std::string last_modified_value;
238 headers->EnumerateHeader(NULL, last_modified, &last_modified_value);
239 if (!last_modified_value.empty()) {
240 extra_headers.SetHeader(net::HttpRequestHeaders::kIfModifiedSince,
241 last_modified_value);
242 }
243
244 // Add If-None-Match header if response info has ETag header.
245 const std::string etag = "ETag";
246 std::string etag_value;
247 headers->EnumerateHeader(NULL, etag, &etag_value);
248 if (!etag_value.empty()) {
249 extra_headers.SetHeader(net::HttpRequestHeaders::kIfNoneMatch,
250 etag_value);
251 }
252 if (!extra_headers.IsEmpty())
253 request_->SetExtraRequestHeaders(extra_headers);
254 }
255
256 void AppCacheUpdateJob::URLFetcher::OnWriteComplete(int result) {
257 if (result < 0) {
258 request_->Cancel();
259 result_ = DISKCACHE_ERROR;
260 OnResponseCompleted();
261 return;
262 }
263 ReadResponseData();
264 }
265
266 void AppCacheUpdateJob::URLFetcher::ReadResponseData() {
267 InternalUpdateState state = job_->internal_state_;
268 if (state == CACHE_FAILURE || state == CANCELLED || state == COMPLETED)
269 return;
270 int bytes_read = 0;
271 request_->Read(buffer_.get(), kBufferSize, &bytes_read);
272 OnReadCompleted(request_.get(), bytes_read);
273 }
274
275 // Returns false if response data is processed asynchronously, in which
276 // case ReadResponseData will be invoked when it is safe to continue
277 // reading more response data from the request.
278 bool AppCacheUpdateJob::URLFetcher::ConsumeResponseData(int bytes_read) {
279 DCHECK_GT(bytes_read, 0);
280 switch (fetch_type_) {
281 case MANIFEST_FETCH:
282 case MANIFEST_REFETCH:
283 manifest_data_.append(buffer_->data(), bytes_read);
284 break;
285 case URL_FETCH:
286 case MASTER_ENTRY_FETCH:
287 DCHECK(response_writer_.get());
288 response_writer_->WriteData(
289 buffer_.get(),
290 bytes_read,
291 base::Bind(&URLFetcher::OnWriteComplete, base::Unretained(this)));
292 return false; // wait for async write completion to continue reading
293 default:
294 NOTREACHED();
295 }
296 return true;
297 }
298
299 void AppCacheUpdateJob::URLFetcher::OnResponseCompleted() {
300 if (request_->status().is_success())
301 job_->MadeProgress();
302
303 // Retry for 503s where retry-after is 0.
304 if (request_->status().is_success() &&
305 request_->GetResponseCode() == 503 &&
306 MaybeRetryRequest()) {
307 return;
308 }
309
310 switch (fetch_type_) {
311 case MANIFEST_FETCH:
312 job_->HandleManifestFetchCompleted(this);
313 break;
314 case URL_FETCH:
315 job_->HandleUrlFetchCompleted(this);
316 break;
317 case MASTER_ENTRY_FETCH:
318 job_->HandleMasterEntryFetchCompleted(this);
319 break;
320 case MANIFEST_REFETCH:
321 job_->HandleManifestRefetchCompleted(this);
322 break;
323 default:
324 NOTREACHED();
325 }
326
327 delete this;
328 }
329
330 bool AppCacheUpdateJob::URLFetcher::MaybeRetryRequest() {
331 if (retry_503_attempts_ >= kMax503Retries ||
332 !request_->response_headers()->HasHeaderValue("retry-after", "0")) {
333 return false;
334 }
335 ++retry_503_attempts_;
336 result_ = UPDATE_OK;
337 request_ = job_->service_->request_context()->CreateRequest(
338 url_, net::DEFAULT_PRIORITY, this, NULL);
339 Start();
340 return true;
341 }
342
343 AppCacheUpdateJob::AppCacheUpdateJob(AppCacheServiceImpl* service,
344 AppCacheGroup* group)
345 : service_(service),
346 manifest_url_(group->manifest_url()),
347 group_(group),
348 update_type_(UNKNOWN_TYPE),
349 internal_state_(FETCH_MANIFEST),
350 master_entries_completed_(0),
351 url_fetches_completed_(0),
352 manifest_fetcher_(NULL),
353 manifest_has_valid_mime_type_(false),
354 stored_state_(UNSTORED),
355 storage_(service->storage()) {
356 service_->AddObserver(this);
357 }
358
359 AppCacheUpdateJob::~AppCacheUpdateJob() {
360 if (service_)
361 service_->RemoveObserver(this);
362 if (internal_state_ != COMPLETED)
363 Cancel();
364
365 DCHECK(!manifest_fetcher_);
366 DCHECK(pending_url_fetches_.empty());
367 DCHECK(!inprogress_cache_.get());
368 DCHECK(pending_master_entries_.empty());
369 DCHECK(master_entry_fetches_.empty());
370
371 if (group_)
372 group_->SetUpdateAppCacheStatus(AppCacheGroup::IDLE);
373 }
374
375 void AppCacheUpdateJob::StartUpdate(AppCacheHost* host,
376 const GURL& new_master_resource) {
377 DCHECK(group_->update_job() == this);
378 DCHECK(!group_->is_obsolete());
379
380 bool is_new_pending_master_entry = false;
381 if (!new_master_resource.is_empty()) {
382 DCHECK(new_master_resource == host->pending_master_entry_url());
383 DCHECK(!new_master_resource.has_ref());
384 DCHECK(new_master_resource.GetOrigin() == manifest_url_.GetOrigin());
385
386 // Cannot add more to this update if already terminating.
387 if (IsTerminating()) {
388 group_->QueueUpdate(host, new_master_resource);
389 return;
390 }
391
392 std::pair<PendingMasters::iterator, bool> ret =
393 pending_master_entries_.insert(
394 PendingMasters::value_type(new_master_resource, PendingHosts()));
395 is_new_pending_master_entry = ret.second;
396 ret.first->second.push_back(host);
397 host->AddObserver(this);
398 }
399
400 // Notify host (if any) if already checking or downloading.
401 AppCacheGroup::UpdateAppCacheStatus update_status = group_->update_status();
402 if (update_status == AppCacheGroup::CHECKING ||
403 update_status == AppCacheGroup::DOWNLOADING) {
404 if (host) {
405 NotifySingleHost(host, APPCACHE_CHECKING_EVENT);
406 if (update_status == AppCacheGroup::DOWNLOADING)
407 NotifySingleHost(host, APPCACHE_DOWNLOADING_EVENT);
408
409 // Add to fetch list or an existing entry if already fetched.
410 if (!new_master_resource.is_empty()) {
411 AddMasterEntryToFetchList(host, new_master_resource,
412 is_new_pending_master_entry);
413 }
414 }
415 return;
416 }
417
418 // Begin update process for the group.
419 MadeProgress();
420 group_->SetUpdateAppCacheStatus(AppCacheGroup::CHECKING);
421 if (group_->HasCache()) {
422 update_type_ = UPGRADE_ATTEMPT;
423 NotifyAllAssociatedHosts(APPCACHE_CHECKING_EVENT);
424 } else {
425 update_type_ = CACHE_ATTEMPT;
426 DCHECK(host);
427 NotifySingleHost(host, APPCACHE_CHECKING_EVENT);
428 }
429
430 if (!new_master_resource.is_empty()) {
431 AddMasterEntryToFetchList(host, new_master_resource,
432 is_new_pending_master_entry);
433 }
434
435 FetchManifest(true);
436 }
437
438 AppCacheResponseWriter* AppCacheUpdateJob::CreateResponseWriter() {
439 AppCacheResponseWriter* writer =
440 storage_->CreateResponseWriter(manifest_url_,
441 group_->group_id());
442 stored_response_ids_.push_back(writer->response_id());
443 return writer;
444 }
445
446 void AppCacheUpdateJob::HandleCacheFailure(
447 const AppCacheErrorDetails& error_details,
448 ResultType result,
449 const GURL& failed_resource_url) {
450 // 6.9.4 cache failure steps 2-8.
451 DCHECK(internal_state_ != CACHE_FAILURE);
452 DCHECK(!error_details.message.empty());
453 DCHECK(result != UPDATE_OK);
454 internal_state_ = CACHE_FAILURE;
455 LogHistogramStats(result, failed_resource_url);
456 CancelAllUrlFetches();
457 CancelAllMasterEntryFetches(error_details);
458 NotifyAllError(error_details);
459 DiscardInprogressCache();
460 internal_state_ = COMPLETED;
461 DeleteSoon(); // To unwind the stack prior to deletion.
462 }
463
464 void AppCacheUpdateJob::FetchManifest(bool is_first_fetch) {
465 DCHECK(!manifest_fetcher_);
466 manifest_fetcher_ = new URLFetcher(
467 manifest_url_,
468 is_first_fetch ? URLFetcher::MANIFEST_FETCH :
469 URLFetcher::MANIFEST_REFETCH,
470 this);
471
472 // Add any necessary Http headers before sending fetch request.
473 if (is_first_fetch) {
474 AppCacheEntry* entry = (update_type_ == UPGRADE_ATTEMPT) ?
475 group_->newest_complete_cache()->GetEntry(manifest_url_) : NULL;
476 if (entry) {
477 // Asynchronously load response info for manifest from newest cache.
478 storage_->LoadResponseInfo(manifest_url_, group_->group_id(),
479 entry->response_id(), this);
480 } else {
481 manifest_fetcher_->Start();
482 }
483 } else {
484 DCHECK(internal_state_ == REFETCH_MANIFEST);
485 DCHECK(manifest_response_info_.get());
486 manifest_fetcher_->set_existing_response_headers(
487 manifest_response_info_->headers.get());
488 manifest_fetcher_->Start();
489 }
490 }
491
492
493 void AppCacheUpdateJob::HandleManifestFetchCompleted(
494 URLFetcher* fetcher) {
495 DCHECK_EQ(internal_state_, FETCH_MANIFEST);
496 DCHECK_EQ(manifest_fetcher_, fetcher);
497 manifest_fetcher_ = NULL;
498
499 net::URLRequest* request = fetcher->request();
500 int response_code = -1;
501 bool is_valid_response_code = false;
502 if (request->status().is_success()) {
503 response_code = request->GetResponseCode();
504 is_valid_response_code = (response_code / 100 == 2);
505
506 std::string mime_type;
507 request->GetMimeType(&mime_type);
508 manifest_has_valid_mime_type_ = (mime_type == "text/cache-manifest");
509 }
510
511 if (is_valid_response_code) {
512 manifest_data_ = fetcher->manifest_data();
513 manifest_response_info_.reset(
514 new net::HttpResponseInfo(request->response_info()));
515 if (update_type_ == UPGRADE_ATTEMPT)
516 CheckIfManifestChanged(); // continues asynchronously
517 else
518 ContinueHandleManifestFetchCompleted(true);
519 } else if (response_code == 304 && update_type_ == UPGRADE_ATTEMPT) {
520 ContinueHandleManifestFetchCompleted(false);
521 } else if ((response_code == 404 || response_code == 410) &&
522 update_type_ == UPGRADE_ATTEMPT) {
523 storage_->MakeGroupObsolete(group_, this, response_code); // async
524 } else {
525 const char* kFormatString = "Manifest fetch failed (%d) %s";
526 std::string message = FormatUrlErrorMessage(
527 kFormatString, manifest_url_, fetcher->result(), response_code);
528 HandleCacheFailure(AppCacheErrorDetails(message,
529 appcache::APPCACHE_MANIFEST_ERROR,
530 manifest_url_,
531 response_code,
532 false /*is_cross_origin*/),
533 fetcher->result(),
534 GURL());
535 }
536 }
537
538 void AppCacheUpdateJob::OnGroupMadeObsolete(AppCacheGroup* group,
539 bool success,
540 int response_code) {
541 DCHECK(master_entry_fetches_.empty());
542 CancelAllMasterEntryFetches(AppCacheErrorDetails(
543 "The cache has been made obsolete, "
544 "the manifest file returned 404 or 410",
545 appcache::APPCACHE_MANIFEST_ERROR,
546 GURL(),
547 response_code,
548 false /*is_cross_origin*/));
549 if (success) {
550 DCHECK(group->is_obsolete());
551 NotifyAllAssociatedHosts(APPCACHE_OBSOLETE_EVENT);
552 internal_state_ = COMPLETED;
553 MaybeCompleteUpdate();
554 } else {
555 // Treat failure to mark group obsolete as a cache failure.
556 HandleCacheFailure(AppCacheErrorDetails(
557 "Failed to mark the cache as obsolete",
558 APPCACHE_UNKNOWN_ERROR,
559 GURL(),
560 0,
561 false /*is_cross_origin*/),
562 DB_ERROR,
563 GURL());
564 }
565 }
566
567 void AppCacheUpdateJob::ContinueHandleManifestFetchCompleted(bool changed) {
568 DCHECK(internal_state_ == FETCH_MANIFEST);
569
570 if (!changed) {
571 DCHECK(update_type_ == UPGRADE_ATTEMPT);
572 internal_state_ = NO_UPDATE;
573
574 // Wait for pending master entries to download.
575 FetchMasterEntries();
576 MaybeCompleteUpdate(); // if not done, run async 6.9.4 step 7 substeps
577 return;
578 }
579
580 Manifest manifest;
581 if (!ParseManifest(manifest_url_, manifest_data_.data(),
582 manifest_data_.length(),
583 manifest_has_valid_mime_type_ ?
584 PARSE_MANIFEST_ALLOWING_INTERCEPTS :
585 PARSE_MANIFEST_PER_STANDARD,
586 manifest)) {
587 const char* kFormatString = "Failed to parse manifest %s";
588 const std::string message = base::StringPrintf(kFormatString,
589 manifest_url_.spec().c_str());
590 HandleCacheFailure(
591 AppCacheErrorDetails(
592 message, APPCACHE_SIGNATURE_ERROR, GURL(), 0,
593 false /*is_cross_origin*/),
594 APPCACHE_MANIFEST_ERROR,
595 GURL());
596 VLOG(1) << message;
597 return;
598 }
599
600 // Proceed with update process. Section 6.9.4 steps 8-20.
601 internal_state_ = DOWNLOADING;
602 inprogress_cache_ = new AppCache(storage_, storage_->NewCacheId());
603 BuildUrlFileList(manifest);
604 inprogress_cache_->InitializeWithManifest(&manifest);
605
606 // Associate all pending master hosts with the newly created cache.
607 for (PendingMasters::iterator it = pending_master_entries_.begin();
608 it != pending_master_entries_.end(); ++it) {
609 PendingHosts& hosts = it->second;
610 for (PendingHosts::iterator host_it = hosts.begin();
611 host_it != hosts.end(); ++host_it) {
612 (*host_it)
613 ->AssociateIncompleteCache(inprogress_cache_.get(), manifest_url_);
614 }
615 }
616
617 if (manifest.did_ignore_intercept_namespaces) {
618 // Must be done after associating all pending master hosts.
619 std::string message(
620 "Ignoring the INTERCEPT section of the application cache manifest "
621 "because the content type is not text/cache-manifest");
622 LogConsoleMessageToAll(message);
623 }
624
625 group_->SetUpdateAppCacheStatus(AppCacheGroup::DOWNLOADING);
626 NotifyAllAssociatedHosts(APPCACHE_DOWNLOADING_EVENT);
627 FetchUrls();
628 FetchMasterEntries();
629 MaybeCompleteUpdate(); // if not done, continues when async fetches complete
630 }
631
632 void AppCacheUpdateJob::HandleUrlFetchCompleted(URLFetcher* fetcher) {
633 DCHECK(internal_state_ == DOWNLOADING);
634
635 net::URLRequest* request = fetcher->request();
636 const GURL& url = request->original_url();
637 pending_url_fetches_.erase(url);
638 NotifyAllProgress(url);
639 ++url_fetches_completed_;
640
641 int response_code = request->status().is_success()
642 ? request->GetResponseCode()
643 : fetcher->redirect_response_code();
644
645 AppCacheEntry& entry = url_file_list_.find(url)->second;
646
647 if (response_code / 100 == 2) {
648 // Associate storage with the new entry.
649 DCHECK(fetcher->response_writer());
650 entry.set_response_id(fetcher->response_writer()->response_id());
651 entry.set_response_size(fetcher->response_writer()->amount_written());
652 if (!inprogress_cache_->AddOrModifyEntry(url, entry))
653 duplicate_response_ids_.push_back(entry.response_id());
654
655 // TODO(michaeln): Check for <html manifest=xxx>
656 // See http://code.google.com/p/chromium/issues/detail?id=97930
657 // if (entry.IsMaster() && !(entry.IsExplicit() || fallback || intercept))
658 // if (!manifestAttribute) skip it
659
660 // Foreign entries will be detected during cache selection.
661 // Note: 6.9.4, step 17.9 possible optimization: if resource is HTML or XML
662 // file whose root element is an html element with a manifest attribute
663 // whose value doesn't match the manifest url of the application cache
664 // being processed, mark the entry as being foreign.
665 } else {
666 VLOG(1) << "Request status: " << request->status().status()
667 << " error: " << request->status().error()
668 << " response code: " << response_code;
669 if (entry.IsExplicit() || entry.IsFallback() || entry.IsIntercept()) {
670 if (response_code == 304 && fetcher->existing_entry().has_response_id()) {
671 // Keep the existing response.
672 entry.set_response_id(fetcher->existing_entry().response_id());
673 entry.set_response_size(fetcher->existing_entry().response_size());
674 inprogress_cache_->AddOrModifyEntry(url, entry);
675 } else {
676 const char* kFormatString = "Resource fetch failed (%d) %s";
677 std::string message = FormatUrlErrorMessage(
678 kFormatString, url, fetcher->result(), response_code);
679 ResultType result = fetcher->result();
680 bool is_cross_origin = url.GetOrigin() != manifest_url_.GetOrigin();
681 switch (result) {
682 case DISKCACHE_ERROR:
683 HandleCacheFailure(
684 AppCacheErrorDetails(
685 message, APPCACHE_UNKNOWN_ERROR, GURL(), 0,
686 is_cross_origin),
687 result,
688 url);
689 break;
690 case NETWORK_ERROR:
691 HandleCacheFailure(
692 AppCacheErrorDetails(message, APPCACHE_RESOURCE_ERROR, url, 0,
693 is_cross_origin),
694 result,
695 url);
696 break;
697 default:
698 HandleCacheFailure(AppCacheErrorDetails(message,
699 APPCACHE_RESOURCE_ERROR,
700 url,
701 response_code,
702 is_cross_origin),
703 result,
704 url);
705 break;
706 }
707 return;
708 }
709 } else if (response_code == 404 || response_code == 410) {
710 // Entry is skipped. They are dropped from the cache.
711 } else if (update_type_ == UPGRADE_ATTEMPT &&
712 fetcher->existing_entry().has_response_id()) {
713 // Keep the existing response.
714 // TODO(michaeln): Not sure this is a good idea. This is spec compliant
715 // but the old resource may or may not be compatible with the new contents
716 // of the cache. Impossible to know one way or the other.
717 entry.set_response_id(fetcher->existing_entry().response_id());
718 entry.set_response_size(fetcher->existing_entry().response_size());
719 inprogress_cache_->AddOrModifyEntry(url, entry);
720 }
721 }
722
723 // Fetch another URL now that one request has completed.
724 DCHECK(internal_state_ != CACHE_FAILURE);
725 FetchUrls();
726 MaybeCompleteUpdate();
727 }
728
729 void AppCacheUpdateJob::HandleMasterEntryFetchCompleted(
730 URLFetcher* fetcher) {
731 DCHECK(internal_state_ == NO_UPDATE || internal_state_ == DOWNLOADING);
732
733 // TODO(jennb): Handle downloads completing during cache failure when update
734 // no longer fetches master entries directly. For now, we cancel all pending
735 // master entry fetches when entering cache failure state so this will never
736 // be called in CACHE_FAILURE state.
737
738 net::URLRequest* request = fetcher->request();
739 const GURL& url = request->original_url();
740 master_entry_fetches_.erase(url);
741 ++master_entries_completed_;
742
743 int response_code = request->status().is_success()
744 ? request->GetResponseCode() : -1;
745
746 PendingMasters::iterator found = pending_master_entries_.find(url);
747 DCHECK(found != pending_master_entries_.end());
748 PendingHosts& hosts = found->second;
749
750 // Section 6.9.4. No update case: step 7.3, else step 22.
751 if (response_code / 100 == 2) {
752 // Add fetched master entry to the appropriate cache.
753 AppCache* cache = inprogress_cache_.get() ? inprogress_cache_.get()
754 : group_->newest_complete_cache();
755 DCHECK(fetcher->response_writer());
756 AppCacheEntry master_entry(AppCacheEntry::MASTER,
757 fetcher->response_writer()->response_id(),
758 fetcher->response_writer()->amount_written());
759 if (cache->AddOrModifyEntry(url, master_entry))
760 added_master_entries_.push_back(url);
761 else
762 duplicate_response_ids_.push_back(master_entry.response_id());
763
764 // In no-update case, associate host with the newest cache.
765 if (!inprogress_cache_.get()) {
766 // TODO(michaeln): defer until the updated cache has been stored
767 DCHECK(cache == group_->newest_complete_cache());
768 for (PendingHosts::iterator host_it = hosts.begin();
769 host_it != hosts.end(); ++host_it) {
770 (*host_it)->AssociateCompleteCache(cache);
771 }
772 }
773 } else {
774 HostNotifier host_notifier;
775 for (PendingHosts::iterator host_it = hosts.begin();
776 host_it != hosts.end(); ++host_it) {
777 AppCacheHost* host = *host_it;
778 host_notifier.AddHost(host);
779
780 // In downloading case, disassociate host from inprogress cache.
781 if (inprogress_cache_.get())
782 host->AssociateNoCache(GURL());
783
784 host->RemoveObserver(this);
785 }
786 hosts.clear();
787
788 const char* kFormatString = "Manifest fetch failed (%d) %s";
789 std::string message = FormatUrlErrorMessage(
790 kFormatString, request->url(), fetcher->result(), response_code);
791 host_notifier.SendErrorNotifications(
792 AppCacheErrorDetails(message,
793 appcache::APPCACHE_MANIFEST_ERROR,
794 request->url(),
795 response_code,
796 false /*is_cross_origin*/));
797
798 // In downloading case, update result is different if all master entries
799 // failed vs. only some failing.
800 if (inprogress_cache_.get()) {
801 // Only count successful downloads to know if all master entries failed.
802 pending_master_entries_.erase(found);
803 --master_entries_completed_;
804
805 // Section 6.9.4, step 22.3.
806 if (update_type_ == CACHE_ATTEMPT && pending_master_entries_.empty()) {
807 HandleCacheFailure(AppCacheErrorDetails(message,
808 appcache::APPCACHE_MANIFEST_ERROR,
809 request->url(),
810 response_code,
811 false /*is_cross_origin*/),
812 fetcher->result(),
813 GURL());
814 return;
815 }
816 }
817 }
818
819 DCHECK(internal_state_ != CACHE_FAILURE);
820 FetchMasterEntries();
821 MaybeCompleteUpdate();
822 }
823
824 void AppCacheUpdateJob::HandleManifestRefetchCompleted(
825 URLFetcher* fetcher) {
826 DCHECK(internal_state_ == REFETCH_MANIFEST);
827 DCHECK(manifest_fetcher_ == fetcher);
828 manifest_fetcher_ = NULL;
829
830 net::URLRequest* request = fetcher->request();
831 int response_code = request->status().is_success()
832 ? request->GetResponseCode() : -1;
833 if (response_code == 304 || manifest_data_ == fetcher->manifest_data()) {
834 // Only need to store response in storage if manifest is not already
835 // an entry in the cache.
836 AppCacheEntry* entry = inprogress_cache_->GetEntry(manifest_url_);
837 if (entry) {
838 entry->add_types(AppCacheEntry::MANIFEST);
839 StoreGroupAndCache();
840 } else {
841 manifest_response_writer_.reset(CreateResponseWriter());
842 scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
843 new HttpResponseInfoIOBuffer(manifest_response_info_.release()));
844 manifest_response_writer_->WriteInfo(
845 io_buffer.get(),
846 base::Bind(&AppCacheUpdateJob::OnManifestInfoWriteComplete,
847 base::Unretained(this)));
848 }
849 } else {
850 VLOG(1) << "Request status: " << request->status().status()
851 << " error: " << request->status().error()
852 << " response code: " << response_code;
853 ScheduleUpdateRetry(kRerunDelayMs);
854 if (response_code == 200) {
855 HandleCacheFailure(AppCacheErrorDetails("Manifest changed during update",
856 APPCACHE_CHANGED_ERROR,
857 GURL(),
858 0,
859 false /*is_cross_origin*/),
860 APPCACHE_MANIFEST_ERROR,
861 GURL());
862 } else {
863 const char* kFormatString = "Manifest re-fetch failed (%d) %s";
864 std::string message = FormatUrlErrorMessage(
865 kFormatString, manifest_url_, fetcher->result(), response_code);
866 HandleCacheFailure(AppCacheErrorDetails(message,
867 appcache::APPCACHE_MANIFEST_ERROR,
868 GURL(),
869 response_code,
870 false /*is_cross_origin*/),
871 fetcher->result(),
872 GURL());
873 }
874 }
875 }
876
877 void AppCacheUpdateJob::OnManifestInfoWriteComplete(int result) {
878 if (result > 0) {
879 scoped_refptr<net::StringIOBuffer> io_buffer(
880 new net::StringIOBuffer(manifest_data_));
881 manifest_response_writer_->WriteData(
882 io_buffer.get(),
883 manifest_data_.length(),
884 base::Bind(&AppCacheUpdateJob::OnManifestDataWriteComplete,
885 base::Unretained(this)));
886 } else {
887 HandleCacheFailure(
888 AppCacheErrorDetails("Failed to write the manifest headers to storage",
889 APPCACHE_UNKNOWN_ERROR,
890 GURL(),
891 0,
892 false /*is_cross_origin*/),
893 DISKCACHE_ERROR,
894 GURL());
895 }
896 }
897
898 void AppCacheUpdateJob::OnManifestDataWriteComplete(int result) {
899 if (result > 0) {
900 AppCacheEntry entry(AppCacheEntry::MANIFEST,
901 manifest_response_writer_->response_id(),
902 manifest_response_writer_->amount_written());
903 if (!inprogress_cache_->AddOrModifyEntry(manifest_url_, entry))
904 duplicate_response_ids_.push_back(entry.response_id());
905 StoreGroupAndCache();
906 } else {
907 HandleCacheFailure(
908 AppCacheErrorDetails("Failed to write the manifest data to storage",
909 APPCACHE_UNKNOWN_ERROR,
910 GURL(),
911 0,
912 false /*is_cross_origin*/),
913 DISKCACHE_ERROR,
914 GURL());
915 }
916 }
917
918 void AppCacheUpdateJob::StoreGroupAndCache() {
919 DCHECK(stored_state_ == UNSTORED);
920 stored_state_ = STORING;
921 scoped_refptr<AppCache> newest_cache;
922 if (inprogress_cache_.get())
923 newest_cache.swap(inprogress_cache_);
924 else
925 newest_cache = group_->newest_complete_cache();
926 newest_cache->set_update_time(base::Time::Now());
927
928 // TODO(michaeln): dcheck is fishing for clues to crbug/95101
929 DCHECK_EQ(manifest_url_, group_->manifest_url());
930 storage_->StoreGroupAndNewestCache(group_, newest_cache.get(), this);
931 }
932
933 void AppCacheUpdateJob::OnGroupAndNewestCacheStored(AppCacheGroup* group,
934 AppCache* newest_cache,
935 bool success,
936 bool would_exceed_quota) {
937 DCHECK(stored_state_ == STORING);
938 if (success) {
939 stored_state_ = STORED;
940 MaybeCompleteUpdate(); // will definitely complete
941 } else {
942 stored_state_ = UNSTORED;
943
944 // Restore inprogress_cache_ to get the proper events delivered
945 // and the proper cleanup to occur.
946 if (newest_cache != group->newest_complete_cache())
947 inprogress_cache_ = newest_cache;
948
949 ResultType result = DB_ERROR;
950 AppCacheErrorReason reason = APPCACHE_UNKNOWN_ERROR;
951 std::string message("Failed to commit new cache to storage");
952 if (would_exceed_quota) {
953 message.append(", would exceed quota");
954 result = APPCACHE_QUOTA_ERROR;
955 reason = appcache::APPCACHE_QUOTA_ERROR;
956 }
957 HandleCacheFailure(
958 AppCacheErrorDetails(message, reason, GURL(), 0,
959 false /*is_cross_origin*/),
960 result,
961 GURL());
962 }
963 }
964
965 void AppCacheUpdateJob::NotifySingleHost(AppCacheHost* host,
966 AppCacheEventID event_id) {
967 std::vector<int> ids(1, host->host_id());
968 host->frontend()->OnEventRaised(ids, event_id);
969 }
970
971 void AppCacheUpdateJob::NotifyAllAssociatedHosts(AppCacheEventID event_id) {
972 HostNotifier host_notifier;
973 AddAllAssociatedHostsToNotifier(&host_notifier);
974 host_notifier.SendNotifications(event_id);
975 }
976
977 void AppCacheUpdateJob::NotifyAllProgress(const GURL& url) {
978 HostNotifier host_notifier;
979 AddAllAssociatedHostsToNotifier(&host_notifier);
980 host_notifier.SendProgressNotifications(
981 url, url_file_list_.size(), url_fetches_completed_);
982 }
983
984 void AppCacheUpdateJob::NotifyAllFinalProgress() {
985 DCHECK(url_file_list_.size() == url_fetches_completed_);
986 NotifyAllProgress(GURL());
987 }
988
989 void AppCacheUpdateJob::NotifyAllError(const AppCacheErrorDetails& details) {
990 HostNotifier host_notifier;
991 AddAllAssociatedHostsToNotifier(&host_notifier);
992 host_notifier.SendErrorNotifications(details);
993 }
994
995 void AppCacheUpdateJob::LogConsoleMessageToAll(const std::string& message) {
996 HostNotifier host_notifier;
997 AddAllAssociatedHostsToNotifier(&host_notifier);
998 host_notifier.SendLogMessage(message);
999 }
1000
1001 void AppCacheUpdateJob::AddAllAssociatedHostsToNotifier(
1002 HostNotifier* host_notifier) {
1003 // Collect hosts so we only send one notification per frontend.
1004 // A host can only be associated with a single cache so no need to worry
1005 // about duplicate hosts being added to the notifier.
1006 if (inprogress_cache_.get()) {
1007 DCHECK(internal_state_ == DOWNLOADING || internal_state_ == CACHE_FAILURE);
1008 host_notifier->AddHosts(inprogress_cache_->associated_hosts());
1009 }
1010
1011 AppCacheGroup::Caches old_caches = group_->old_caches();
1012 for (AppCacheGroup::Caches::const_iterator it = old_caches.begin();
1013 it != old_caches.end(); ++it) {
1014 host_notifier->AddHosts((*it)->associated_hosts());
1015 }
1016
1017 AppCache* newest_cache = group_->newest_complete_cache();
1018 if (newest_cache)
1019 host_notifier->AddHosts(newest_cache->associated_hosts());
1020 }
1021
1022 void AppCacheUpdateJob::OnDestructionImminent(AppCacheHost* host) {
1023 // The host is about to be deleted; remove from our collection.
1024 PendingMasters::iterator found =
1025 pending_master_entries_.find(host->pending_master_entry_url());
1026 DCHECK(found != pending_master_entries_.end());
1027 PendingHosts& hosts = found->second;
1028 PendingHosts::iterator it = std::find(hosts.begin(), hosts.end(), host);
1029 DCHECK(it != hosts.end());
1030 hosts.erase(it);
1031 }
1032
1033 void AppCacheUpdateJob::OnServiceReinitialized(
1034 AppCacheStorageReference* old_storage_ref) {
1035 // We continue to use the disabled instance, but arrange for its
1036 // deletion when its no longer needed.
1037 if (old_storage_ref->storage() == storage_)
1038 disabled_storage_reference_ = old_storage_ref;
1039 }
1040
1041 void AppCacheUpdateJob::CheckIfManifestChanged() {
1042 DCHECK(update_type_ == UPGRADE_ATTEMPT);
1043 AppCacheEntry* entry = NULL;
1044 if (group_->newest_complete_cache())
1045 entry = group_->newest_complete_cache()->GetEntry(manifest_url_);
1046 if (!entry) {
1047 // TODO(michaeln): This is just a bandaid to avoid a crash.
1048 // http://code.google.com/p/chromium/issues/detail?id=95101
1049 if (service_->storage() == storage_) {
1050 // Use a local variable because service_ is reset in HandleCacheFailure.
1051 AppCacheServiceImpl* service = service_;
1052 HandleCacheFailure(
1053 AppCacheErrorDetails("Manifest entry not found in existing cache",
1054 APPCACHE_UNKNOWN_ERROR,
1055 GURL(),
1056 0,
1057 false /*is_cross_origin*/),
1058 DB_ERROR,
1059 GURL());
1060 AppCacheHistograms::AddMissingManifestEntrySample();
1061 service->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
1062 }
1063 return;
1064 }
1065
1066 // Load manifest data from storage to compare against fetched manifest.
1067 manifest_response_reader_.reset(
1068 storage_->CreateResponseReader(manifest_url_,
1069 group_->group_id(),
1070 entry->response_id()));
1071 read_manifest_buffer_ = new net::IOBuffer(kBufferSize);
1072 manifest_response_reader_->ReadData(
1073 read_manifest_buffer_.get(),
1074 kBufferSize,
1075 base::Bind(&AppCacheUpdateJob::OnManifestDataReadComplete,
1076 base::Unretained(this))); // async read
1077 }
1078
1079 void AppCacheUpdateJob::OnManifestDataReadComplete(int result) {
1080 if (result > 0) {
1081 loaded_manifest_data_.append(read_manifest_buffer_->data(), result);
1082 manifest_response_reader_->ReadData(
1083 read_manifest_buffer_.get(),
1084 kBufferSize,
1085 base::Bind(&AppCacheUpdateJob::OnManifestDataReadComplete,
1086 base::Unretained(this))); // read more
1087 } else {
1088 read_manifest_buffer_ = NULL;
1089 manifest_response_reader_.reset();
1090 ContinueHandleManifestFetchCompleted(
1091 result < 0 || manifest_data_ != loaded_manifest_data_);
1092 }
1093 }
1094
1095 void AppCacheUpdateJob::BuildUrlFileList(const Manifest& manifest) {
1096 for (base::hash_set<std::string>::const_iterator it =
1097 manifest.explicit_urls.begin();
1098 it != manifest.explicit_urls.end(); ++it) {
1099 AddUrlToFileList(GURL(*it), AppCacheEntry::EXPLICIT);
1100 }
1101
1102 const std::vector<Namespace>& intercepts =
1103 manifest.intercept_namespaces;
1104 for (std::vector<Namespace>::const_iterator it = intercepts.begin();
1105 it != intercepts.end(); ++it) {
1106 int flags = AppCacheEntry::INTERCEPT;
1107 if (it->is_executable)
1108 flags |= AppCacheEntry::EXECUTABLE;
1109 AddUrlToFileList(it->target_url, flags);
1110 }
1111
1112 const std::vector<Namespace>& fallbacks =
1113 manifest.fallback_namespaces;
1114 for (std::vector<Namespace>::const_iterator it = fallbacks.begin();
1115 it != fallbacks.end(); ++it) {
1116 AddUrlToFileList(it->target_url, AppCacheEntry::FALLBACK);
1117 }
1118
1119 // Add all master entries from newest complete cache.
1120 if (update_type_ == UPGRADE_ATTEMPT) {
1121 const AppCache::EntryMap& entries =
1122 group_->newest_complete_cache()->entries();
1123 for (AppCache::EntryMap::const_iterator it = entries.begin();
1124 it != entries.end(); ++it) {
1125 const AppCacheEntry& entry = it->second;
1126 if (entry.IsMaster())
1127 AddUrlToFileList(it->first, AppCacheEntry::MASTER);
1128 }
1129 }
1130 }
1131
1132 void AppCacheUpdateJob::AddUrlToFileList(const GURL& url, int type) {
1133 std::pair<AppCache::EntryMap::iterator, bool> ret = url_file_list_.insert(
1134 AppCache::EntryMap::value_type(url, AppCacheEntry(type)));
1135
1136 if (ret.second)
1137 urls_to_fetch_.push_back(UrlToFetch(url, false, NULL));
1138 else
1139 ret.first->second.add_types(type); // URL already exists. Merge types.
1140 }
1141
1142 void AppCacheUpdateJob::FetchUrls() {
1143 DCHECK(internal_state_ == DOWNLOADING);
1144
1145 // Fetch each URL in the list according to section 6.9.4 step 17.1-17.3.
1146 // Fetch up to the concurrent limit. Other fetches will be triggered as each
1147 // each fetch completes.
1148 while (pending_url_fetches_.size() < kMaxConcurrentUrlFetches &&
1149 !urls_to_fetch_.empty()) {
1150 UrlToFetch url_to_fetch = urls_to_fetch_.front();
1151 urls_to_fetch_.pop_front();
1152
1153 AppCache::EntryMap::iterator it = url_file_list_.find(url_to_fetch.url);
1154 DCHECK(it != url_file_list_.end());
1155 AppCacheEntry& entry = it->second;
1156 if (ShouldSkipUrlFetch(entry)) {
1157 NotifyAllProgress(url_to_fetch.url);
1158 ++url_fetches_completed_;
1159 } else if (AlreadyFetchedEntry(url_to_fetch.url, entry.types())) {
1160 NotifyAllProgress(url_to_fetch.url);
1161 ++url_fetches_completed_; // saved a URL request
1162 } else if (!url_to_fetch.storage_checked &&
1163 MaybeLoadFromNewestCache(url_to_fetch.url, entry)) {
1164 // Continues asynchronously after data is loaded from newest cache.
1165 } else {
1166 URLFetcher* fetcher = new URLFetcher(
1167 url_to_fetch.url, URLFetcher::URL_FETCH, this);
1168 if (url_to_fetch.existing_response_info.get()) {
1169 DCHECK(group_->newest_complete_cache());
1170 AppCacheEntry* existing_entry =
1171 group_->newest_complete_cache()->GetEntry(url_to_fetch.url);
1172 DCHECK(existing_entry);
1173 DCHECK(existing_entry->response_id() ==
1174 url_to_fetch.existing_response_info->response_id());
1175 fetcher->set_existing_response_headers(
1176 url_to_fetch.existing_response_info->http_response_info()->headers
1177 .get());
1178 fetcher->set_existing_entry(*existing_entry);
1179 }
1180 fetcher->Start();
1181 pending_url_fetches_.insert(
1182 PendingUrlFetches::value_type(url_to_fetch.url, fetcher));
1183 }
1184 }
1185 }
1186
1187 void AppCacheUpdateJob::CancelAllUrlFetches() {
1188 // Cancel any pending URL requests.
1189 for (PendingUrlFetches::iterator it = pending_url_fetches_.begin();
1190 it != pending_url_fetches_.end(); ++it) {
1191 delete it->second;
1192 }
1193
1194 url_fetches_completed_ +=
1195 pending_url_fetches_.size() + urls_to_fetch_.size();
1196 pending_url_fetches_.clear();
1197 urls_to_fetch_.clear();
1198 }
1199
1200 bool AppCacheUpdateJob::ShouldSkipUrlFetch(const AppCacheEntry& entry) {
1201 // 6.6.4 Step 17
1202 // If the resource URL being processed was flagged as neither an
1203 // "explicit entry" nor or a "fallback entry", then the user agent
1204 // may skip this URL.
1205 if (entry.IsExplicit() || entry.IsFallback() || entry.IsIntercept())
1206 return false;
1207
1208 // TODO(jennb): decide if entry should be skipped to expire it from cache
1209 return false;
1210 }
1211
1212 bool AppCacheUpdateJob::AlreadyFetchedEntry(const GURL& url,
1213 int entry_type) {
1214 DCHECK(internal_state_ == DOWNLOADING || internal_state_ == NO_UPDATE);
1215 AppCacheEntry* existing =
1216 inprogress_cache_.get() ? inprogress_cache_->GetEntry(url)
1217 : group_->newest_complete_cache()->GetEntry(url);
1218 if (existing) {
1219 existing->add_types(entry_type);
1220 return true;
1221 }
1222 return false;
1223 }
1224
1225 void AppCacheUpdateJob::AddMasterEntryToFetchList(AppCacheHost* host,
1226 const GURL& url,
1227 bool is_new) {
1228 DCHECK(!IsTerminating());
1229
1230 if (internal_state_ == DOWNLOADING || internal_state_ == NO_UPDATE) {
1231 AppCache* cache;
1232 if (inprogress_cache_.get()) {
1233 // always associate
1234 host->AssociateIncompleteCache(inprogress_cache_.get(), manifest_url_);
1235 cache = inprogress_cache_.get();
1236 } else {
1237 cache = group_->newest_complete_cache();
1238 }
1239
1240 // Update existing entry if it has already been fetched.
1241 AppCacheEntry* entry = cache->GetEntry(url);
1242 if (entry) {
1243 entry->add_types(AppCacheEntry::MASTER);
1244 if (internal_state_ == NO_UPDATE && !inprogress_cache_.get()) {
1245 // only associate if have entry
1246 host->AssociateCompleteCache(cache);
1247 }
1248 if (is_new)
1249 ++master_entries_completed_; // pretend fetching completed
1250 return;
1251 }
1252 }
1253
1254 // Add to fetch list if not already fetching.
1255 if (master_entry_fetches_.find(url) == master_entry_fetches_.end()) {
1256 master_entries_to_fetch_.insert(url);
1257 if (internal_state_ == DOWNLOADING || internal_state_ == NO_UPDATE)
1258 FetchMasterEntries();
1259 }
1260 }
1261
1262 void AppCacheUpdateJob::FetchMasterEntries() {
1263 DCHECK(internal_state_ == NO_UPDATE || internal_state_ == DOWNLOADING);
1264
1265 // Fetch each master entry in the list, up to the concurrent limit.
1266 // Additional fetches will be triggered as each fetch completes.
1267 while (master_entry_fetches_.size() < kMaxConcurrentUrlFetches &&
1268 !master_entries_to_fetch_.empty()) {
1269 const GURL& url = *master_entries_to_fetch_.begin();
1270
1271 if (AlreadyFetchedEntry(url, AppCacheEntry::MASTER)) {
1272 ++master_entries_completed_; // saved a URL request
1273
1274 // In no update case, associate hosts to newest cache in group
1275 // now that master entry has been "successfully downloaded".
1276 if (internal_state_ == NO_UPDATE) {
1277 // TODO(michaeln): defer until the updated cache has been stored.
1278 DCHECK(!inprogress_cache_.get());
1279 AppCache* cache = group_->newest_complete_cache();
1280 PendingMasters::iterator found = pending_master_entries_.find(url);
1281 DCHECK(found != pending_master_entries_.end());
1282 PendingHosts& hosts = found->second;
1283 for (PendingHosts::iterator host_it = hosts.begin();
1284 host_it != hosts.end(); ++host_it) {
1285 (*host_it)->AssociateCompleteCache(cache);
1286 }
1287 }
1288 } else {
1289 URLFetcher* fetcher = new URLFetcher(
1290 url, URLFetcher::MASTER_ENTRY_FETCH, this);
1291 fetcher->Start();
1292 master_entry_fetches_.insert(PendingUrlFetches::value_type(url, fetcher));
1293 }
1294
1295 master_entries_to_fetch_.erase(master_entries_to_fetch_.begin());
1296 }
1297 }
1298
1299 void AppCacheUpdateJob::CancelAllMasterEntryFetches(
1300 const AppCacheErrorDetails& error_details) {
1301 // For now, cancel all in-progress fetches for master entries and pretend
1302 // all master entries fetches have completed.
1303 // TODO(jennb): Delete this when update no longer fetches master entries
1304 // directly.
1305
1306 // Cancel all in-progress fetches.
1307 for (PendingUrlFetches::iterator it = master_entry_fetches_.begin();
1308 it != master_entry_fetches_.end(); ++it) {
1309 delete it->second;
1310 master_entries_to_fetch_.insert(it->first); // back in unfetched list
1311 }
1312 master_entry_fetches_.clear();
1313
1314 master_entries_completed_ += master_entries_to_fetch_.size();
1315
1316 // Cache failure steps, step 2.
1317 // Pretend all master entries that have not yet been fetched have completed
1318 // downloading. Unassociate hosts from any appcache and send ERROR event.
1319 HostNotifier host_notifier;
1320 while (!master_entries_to_fetch_.empty()) {
1321 const GURL& url = *master_entries_to_fetch_.begin();
1322 PendingMasters::iterator found = pending_master_entries_.find(url);
1323 DCHECK(found != pending_master_entries_.end());
1324 PendingHosts& hosts = found->second;
1325 for (PendingHosts::iterator host_it = hosts.begin();
1326 host_it != hosts.end(); ++host_it) {
1327 AppCacheHost* host = *host_it;
1328 host->AssociateNoCache(GURL());
1329 host_notifier.AddHost(host);
1330 host->RemoveObserver(this);
1331 }
1332 hosts.clear();
1333
1334 master_entries_to_fetch_.erase(master_entries_to_fetch_.begin());
1335 }
1336 host_notifier.SendErrorNotifications(error_details);
1337 }
1338
1339 bool AppCacheUpdateJob::MaybeLoadFromNewestCache(const GURL& url,
1340 AppCacheEntry& entry) {
1341 if (update_type_ != UPGRADE_ATTEMPT)
1342 return false;
1343
1344 AppCache* newest = group_->newest_complete_cache();
1345 AppCacheEntry* copy_me = newest->GetEntry(url);
1346 if (!copy_me || !copy_me->has_response_id())
1347 return false;
1348
1349 // Load HTTP headers for entry from newest cache.
1350 loading_responses_.insert(
1351 LoadingResponses::value_type(copy_me->response_id(), url));
1352 storage_->LoadResponseInfo(manifest_url_, group_->group_id(),
1353 copy_me->response_id(),
1354 this);
1355 // Async: wait for OnResponseInfoLoaded to complete.
1356 return true;
1357 }
1358
1359 void AppCacheUpdateJob::OnResponseInfoLoaded(
1360 AppCacheResponseInfo* response_info, int64 response_id) {
1361 const net::HttpResponseInfo* http_info = response_info ?
1362 response_info->http_response_info() : NULL;
1363
1364 // Needed response info for a manifest fetch request.
1365 if (internal_state_ == FETCH_MANIFEST) {
1366 if (http_info)
1367 manifest_fetcher_->set_existing_response_headers(
1368 http_info->headers.get());
1369 manifest_fetcher_->Start();
1370 return;
1371 }
1372
1373 LoadingResponses::iterator found = loading_responses_.find(response_id);
1374 DCHECK(found != loading_responses_.end());
1375 const GURL& url = found->second;
1376
1377 if (!http_info) {
1378 LoadFromNewestCacheFailed(url, NULL); // no response found
1379 } else {
1380 // Check if response can be re-used according to HTTP caching semantics.
1381 // Responses with a "vary" header get treated as expired.
1382 const std::string name = "vary";
1383 std::string value;
1384 void* iter = NULL;
1385 if (!http_info->headers.get() ||
1386 http_info->headers->RequiresValidation(http_info->request_time,
1387 http_info->response_time,
1388 base::Time::Now()) ||
1389 http_info->headers->EnumerateHeader(&iter, name, &value)) {
1390 LoadFromNewestCacheFailed(url, response_info);
1391 } else {
1392 DCHECK(group_->newest_complete_cache());
1393 AppCacheEntry* copy_me = group_->newest_complete_cache()->GetEntry(url);
1394 DCHECK(copy_me);
1395 DCHECK(copy_me->response_id() == response_id);
1396
1397 AppCache::EntryMap::iterator it = url_file_list_.find(url);
1398 DCHECK(it != url_file_list_.end());
1399 AppCacheEntry& entry = it->second;
1400 entry.set_response_id(response_id);
1401 entry.set_response_size(copy_me->response_size());
1402 inprogress_cache_->AddOrModifyEntry(url, entry);
1403 NotifyAllProgress(url);
1404 ++url_fetches_completed_;
1405 }
1406 }
1407 loading_responses_.erase(found);
1408
1409 MaybeCompleteUpdate();
1410 }
1411
1412 void AppCacheUpdateJob::LoadFromNewestCacheFailed(
1413 const GURL& url, AppCacheResponseInfo* response_info) {
1414 if (internal_state_ == CACHE_FAILURE)
1415 return;
1416
1417 // Re-insert url at front of fetch list. Indicate storage has been checked.
1418 urls_to_fetch_.push_front(UrlToFetch(url, true, response_info));
1419 FetchUrls();
1420 }
1421
1422 void AppCacheUpdateJob::MaybeCompleteUpdate() {
1423 DCHECK(internal_state_ != CACHE_FAILURE);
1424
1425 // Must wait for any pending master entries or url fetches to complete.
1426 if (master_entries_completed_ != pending_master_entries_.size() ||
1427 url_fetches_completed_ != url_file_list_.size()) {
1428 DCHECK(internal_state_ != COMPLETED);
1429 return;
1430 }
1431
1432 switch (internal_state_) {
1433 case NO_UPDATE:
1434 if (master_entries_completed_ > 0) {
1435 switch (stored_state_) {
1436 case UNSTORED:
1437 StoreGroupAndCache();
1438 return;
1439 case STORING:
1440 return;
1441 case STORED:
1442 break;
1443 }
1444 }
1445 // 6.9.4 steps 7.3-7.7.
1446 NotifyAllAssociatedHosts(APPCACHE_NO_UPDATE_EVENT);
1447 DiscardDuplicateResponses();
1448 internal_state_ = COMPLETED;
1449 break;
1450 case DOWNLOADING:
1451 internal_state_ = REFETCH_MANIFEST;
1452 FetchManifest(false);
1453 break;
1454 case REFETCH_MANIFEST:
1455 DCHECK(stored_state_ == STORED);
1456 NotifyAllFinalProgress();
1457 if (update_type_ == CACHE_ATTEMPT)
1458 NotifyAllAssociatedHosts(APPCACHE_CACHED_EVENT);
1459 else
1460 NotifyAllAssociatedHosts(APPCACHE_UPDATE_READY_EVENT);
1461 DiscardDuplicateResponses();
1462 internal_state_ = COMPLETED;
1463 LogHistogramStats(UPDATE_OK, GURL());
1464 break;
1465 case CACHE_FAILURE:
1466 NOTREACHED(); // See HandleCacheFailure
1467 break;
1468 default:
1469 break;
1470 }
1471
1472 // Let the stack unwind before deletion to make it less risky as this
1473 // method is called from multiple places in this file.
1474 if (internal_state_ == COMPLETED)
1475 DeleteSoon();
1476 }
1477
1478 void AppCacheUpdateJob::ScheduleUpdateRetry(int delay_ms) {
1479 // TODO(jennb): post a delayed task with the "same parameters" as this job
1480 // to retry the update at a later time. Need group, URLs of pending master
1481 // entries and their hosts.
1482 }
1483
1484 void AppCacheUpdateJob::Cancel() {
1485 internal_state_ = CANCELLED;
1486
1487 LogHistogramStats(CANCELLED_ERROR, GURL());
1488
1489 if (manifest_fetcher_) {
1490 delete manifest_fetcher_;
1491 manifest_fetcher_ = NULL;
1492 }
1493
1494 for (PendingUrlFetches::iterator it = pending_url_fetches_.begin();
1495 it != pending_url_fetches_.end(); ++it) {
1496 delete it->second;
1497 }
1498 pending_url_fetches_.clear();
1499
1500 for (PendingUrlFetches::iterator it = master_entry_fetches_.begin();
1501 it != master_entry_fetches_.end(); ++it) {
1502 delete it->second;
1503 }
1504 master_entry_fetches_.clear();
1505
1506 ClearPendingMasterEntries();
1507 DiscardInprogressCache();
1508
1509 // Delete response writer to avoid any callbacks.
1510 if (manifest_response_writer_)
1511 manifest_response_writer_.reset();
1512
1513 storage_->CancelDelegateCallbacks(this);
1514 }
1515
1516 void AppCacheUpdateJob::ClearPendingMasterEntries() {
1517 for (PendingMasters::iterator it = pending_master_entries_.begin();
1518 it != pending_master_entries_.end(); ++it) {
1519 PendingHosts& hosts = it->second;
1520 for (PendingHosts::iterator host_it = hosts.begin();
1521 host_it != hosts.end(); ++host_it) {
1522 (*host_it)->RemoveObserver(this);
1523 }
1524 }
1525
1526 pending_master_entries_.clear();
1527 }
1528
1529 void AppCacheUpdateJob::DiscardInprogressCache() {
1530 if (stored_state_ == STORING) {
1531 // We can make no assumptions about whether the StoreGroupAndCacheTask
1532 // actually completed or not. This condition should only be reachable
1533 // during shutdown. Free things up and return to do no harm.
1534 inprogress_cache_ = NULL;
1535 added_master_entries_.clear();
1536 return;
1537 }
1538
1539 storage_->DoomResponses(manifest_url_, stored_response_ids_);
1540
1541 if (!inprogress_cache_.get()) {
1542 // We have to undo the changes we made, if any, to the existing cache.
1543 if (group_ && group_->newest_complete_cache()) {
1544 for (std::vector<GURL>::iterator iter = added_master_entries_.begin();
1545 iter != added_master_entries_.end(); ++iter) {
1546 group_->newest_complete_cache()->RemoveEntry(*iter);
1547 }
1548 }
1549 added_master_entries_.clear();
1550 return;
1551 }
1552
1553 AppCache::AppCacheHosts& hosts = inprogress_cache_->associated_hosts();
1554 while (!hosts.empty())
1555 (*hosts.begin())->AssociateNoCache(GURL());
1556
1557 inprogress_cache_ = NULL;
1558 added_master_entries_.clear();
1559 }
1560
1561 void AppCacheUpdateJob::DiscardDuplicateResponses() {
1562 storage_->DoomResponses(manifest_url_, duplicate_response_ids_);
1563 }
1564
1565 void AppCacheUpdateJob::LogHistogramStats(
1566 ResultType result, const GURL& failed_resource_url) {
1567 AppCacheHistograms::CountUpdateJobResult(result, manifest_url_.GetOrigin());
1568 if (result == UPDATE_OK)
1569 return;
1570
1571 int percent_complete = 0;
1572 if (url_file_list_.size() > 0) {
1573 size_t actual_fetches_completed = url_fetches_completed_;
1574 if (!failed_resource_url.is_empty() && actual_fetches_completed)
1575 --actual_fetches_completed;
1576 percent_complete = (static_cast<double>(actual_fetches_completed) /
1577 static_cast<double>(url_file_list_.size())) * 100.0;
1578 percent_complete = std::min(percent_complete, 99);
1579 }
1580
1581 bool was_making_progress =
1582 base::Time::Now() - last_progress_time_ <
1583 base::TimeDelta::FromMinutes(5);
1584
1585 bool off_origin_resource_failure =
1586 !failed_resource_url.is_empty() &&
1587 (failed_resource_url.GetOrigin() != manifest_url_.GetOrigin());
1588
1589 AppCacheHistograms::LogUpdateFailureStats(
1590 manifest_url_.GetOrigin(),
1591 percent_complete,
1592 was_making_progress,
1593 off_origin_resource_failure);
1594 }
1595
1596 void AppCacheUpdateJob::DeleteSoon() {
1597 ClearPendingMasterEntries();
1598 manifest_response_writer_.reset();
1599 storage_->CancelDelegateCallbacks(this);
1600 service_->RemoveObserver(this);
1601 service_ = NULL;
1602
1603 // Break the connection with the group so the group cannot call delete
1604 // on this object after we've posted a task to delete ourselves.
1605 group_->SetUpdateAppCacheStatus(AppCacheGroup::IDLE);
1606 group_ = NULL;
1607
1608 base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
1609 }
1610
1611 } // namespace appcache
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698