| OLD | NEW |
|---|
| (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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 344493002:
Move all remaining appcache-related code to content namespace (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src