webkit/browser/appcache/appcache_update_job.cc

   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