content/browser/appcache/appcache_host.cc

   1 // Copyright (c) 2011 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 "content/browser/appcache/appcache_host.h"
   6
   7 #include "base/logging.h"
   8 #include "base/strings/string_util.h"
   9 #include "base/strings/stringprintf.h"
  10 #include "content/browser/appcache/appcache.h"
  11 #include "content/browser/appcache/appcache_backend_impl.h"
  12 #include "content/browser/appcache/appcache_policy.h"
  13 #include "content/browser/appcache/appcache_request_handler.h"
  14 #include "net/url_request/url_request.h"
  15 #include "storage/browser/quota/quota_manager_proxy.h"
  16
  17 namespace content {
  18
  19 namespace {
  20
  21 void FillCacheInfo(const AppCache* cache,
  22                    const GURL& manifest_url,
  23                    AppCacheStatus status, AppCacheInfo* info) {
  24   info->manifest_url = manifest_url;
  25   info->status = status;
  26
  27   if (!cache)
  28     return;
  29
  30   info->cache_id = cache->cache_id();
  31
  32   if (!cache->is_complete())
  33     return;
  34
  35   DCHECK(cache->owning_group());
  36   info->is_complete = true;
  37   info->group_id = cache->owning_group()->group_id();
  38   info->last_update_time = cache->update_time();
  39   info->creation_time = cache->owning_group()->creation_time();
  40   info->size = cache->cache_size();
  41 }
  42
  43 }  // Anonymous namespace
  44
  45 AppCacheHost::AppCacheHost(int host_id, AppCacheFrontend* frontend,
  46                            AppCacheServiceImpl* service)
  47     : host_id_(host_id),
  48       spawning_host_id_(kAppCacheNoHostId), spawning_process_id_(0),
  49       parent_host_id_(kAppCacheNoHostId), parent_process_id_(0),
  50       pending_main_resource_cache_id_(kAppCacheNoCacheId),
  51       pending_selected_cache_id_(kAppCacheNoCacheId),
  52       frontend_(frontend), service_(service),
  53       storage_(service->storage()),
  54       pending_callback_param_(NULL),
  55       main_resource_was_namespace_entry_(false),
  56       main_resource_blocked_(false),
  57       associated_cache_info_pending_(false) {
  58   service_->AddObserver(this);
  59 }
  60
  61 AppCacheHost::~AppCacheHost() {
  62   service_->RemoveObserver(this);
  63   FOR_EACH_OBSERVER(Observer, observers_, OnDestructionImminent(this));
  64   if (associated_cache_.get())
  65     associated_cache_->UnassociateHost(this);
  66   if (group_being_updated_.get())
  67     group_being_updated_->RemoveUpdateObserver(this);
  68   storage()->CancelDelegateCallbacks(this);
  69   if (service()->quota_manager_proxy() && !origin_in_use_.is_empty())
  70     service()->quota_manager_proxy()->NotifyOriginNoLongerInUse(origin_in_use_);
  71 }
  72
  73 void AppCacheHost::AddObserver(Observer* observer) {
  74   observers_.AddObserver(observer);
  75 }
  76
  77 void AppCacheHost::RemoveObserver(Observer* observer) {
  78   observers_.RemoveObserver(observer);
  79 }
  80
  81 void AppCacheHost::SelectCache(const GURL& document_url,
  82                                const int64 cache_document_was_loaded_from,
  83                                const GURL& manifest_url) {
  84   DCHECK(pending_start_update_callback_.is_null() &&
  85          pending_swap_cache_callback_.is_null() &&
  86          pending_get_status_callback_.is_null() &&
  87          !is_selection_pending());
  88
  89   origin_in_use_ = document_url.GetOrigin();
  90   if (service()->quota_manager_proxy() && !origin_in_use_.is_empty())
  91     service()->quota_manager_proxy()->NotifyOriginInUse(origin_in_use_);
  92
  93   if (main_resource_blocked_)
  94     frontend_->OnContentBlocked(host_id_,
  95                                 blocked_manifest_url_);
  96
  97   // 6.9.6 The application cache selection algorithm.
  98   // The algorithm is started here and continues in FinishCacheSelection,
  99   // after cache or group loading is complete.
 100   // Note: Foreign entries are detected on the client side and
 101   // MarkAsForeignEntry is called in that case, so that detection
 102   // step is skipped here. See WebApplicationCacheHostImpl.cc
 103
 104   if (cache_document_was_loaded_from != kAppCacheNoCacheId) {
 105     LoadSelectedCache(cache_document_was_loaded_from);
 106     return;
 107   }
 108
 109   if (!manifest_url.is_empty() &&
 110       (manifest_url.GetOrigin() == document_url.GetOrigin())) {
 111     DCHECK(!first_party_url_.is_empty());
 112     AppCachePolicy* policy = service()->appcache_policy();
 113     if (policy &&
 114         !policy->CanCreateAppCache(manifest_url, first_party_url_)) {
 115       FinishCacheSelection(NULL, NULL);
 116       std::vector<int> host_ids(1, host_id_);
 117       frontend_->OnEventRaised(host_ids, APPCACHE_CHECKING_EVENT);
 118       frontend_->OnErrorEventRaised(
 119           host_ids,
 120           AppCacheErrorDetails(
 121               "Cache creation was blocked by the content policy",
 122               APPCACHE_POLICY_ERROR,
 123               GURL(),
 124               0,
 125               false /*is_cross_origin*/));
 126       frontend_->OnContentBlocked(host_id_, manifest_url);
 127       return;
 128     }
 129
 130     // Note: The client detects if the document was not loaded using HTTP GET
 131     // and invokes SelectCache without a manifest url, so that detection step
 132     // is also skipped here. See WebApplicationCacheHostImpl.cc
 133     set_preferred_manifest_url(manifest_url);
 134     new_master_entry_url_ = document_url;
 135     LoadOrCreateGroup(manifest_url);
 136     return;
 137   }
 138
 139   // TODO(michaeln): If there was a manifest URL, the user agent may report
 140   // to the user that it was ignored, to aid in application development.
 141   FinishCacheSelection(NULL, NULL);
 142 }
 143
 144 void AppCacheHost::SelectCacheForWorker(int parent_process_id,
 145                                         int parent_host_id) {
 146   DCHECK(pending_start_update_callback_.is_null() &&
 147          pending_swap_cache_callback_.is_null() &&
 148          pending_get_status_callback_.is_null() &&
 149          !is_selection_pending());
 150
 151   parent_process_id_ = parent_process_id;
 152   parent_host_id_ = parent_host_id;
 153   FinishCacheSelection(NULL, NULL);
 154 }
 155
 156 void AppCacheHost::SelectCacheForSharedWorker(int64 appcache_id) {
 157   DCHECK(pending_start_update_callback_.is_null() &&
 158          pending_swap_cache_callback_.is_null() &&
 159          pending_get_status_callback_.is_null() &&
 160          !is_selection_pending());
 161
 162   if (appcache_id != kAppCacheNoCacheId) {
 163     LoadSelectedCache(appcache_id);
 164     return;
 165   }
 166   FinishCacheSelection(NULL, NULL);
 167 }
 168
 169 // TODO(michaeln): change method name to MarkEntryAsForeign for consistency
 170 void AppCacheHost::MarkAsForeignEntry(const GURL& document_url,
 171                                       int64 cache_document_was_loaded_from) {
 172   // The document url is not the resource url in the fallback case.
 173   storage()->MarkEntryAsForeign(
 174       main_resource_was_namespace_entry_ ? namespace_entry_url_ : document_url,
 175       cache_document_was_loaded_from);
 176   SelectCache(document_url, kAppCacheNoCacheId, GURL());
 177 }
 178
 179 void AppCacheHost::GetStatusWithCallback(const GetStatusCallback& callback,
 180                                          void* callback_param) {
 181   DCHECK(pending_start_update_callback_.is_null() &&
 182          pending_swap_cache_callback_.is_null() &&
 183          pending_get_status_callback_.is_null());
 184
 185   pending_get_status_callback_ = callback;
 186   pending_callback_param_ = callback_param;
 187   if (is_selection_pending())
 188     return;
 189
 190   DoPendingGetStatus();
 191 }
 192
 193 void AppCacheHost::DoPendingGetStatus() {
 194   DCHECK_EQ(false, pending_get_status_callback_.is_null());
 195
 196   pending_get_status_callback_.Run(GetStatus(), pending_callback_param_);
 197   pending_get_status_callback_.Reset();
 198   pending_callback_param_ = NULL;
 199 }
 200
 201 void AppCacheHost::StartUpdateWithCallback(const StartUpdateCallback& callback,
 202                                            void* callback_param) {
 203   DCHECK(pending_start_update_callback_.is_null() &&
 204          pending_swap_cache_callback_.is_null() &&
 205          pending_get_status_callback_.is_null());
 206
 207   pending_start_update_callback_ = callback;
 208   pending_callback_param_ = callback_param;
 209   if (is_selection_pending())
 210     return;
 211
 212   DoPendingStartUpdate();
 213 }
 214
 215 void AppCacheHost::DoPendingStartUpdate() {
 216   DCHECK_EQ(false, pending_start_update_callback_.is_null());
 217
 218   // 6.9.8 Application cache API
 219   bool success = false;
 220   if (associated_cache_.get() && associated_cache_->owning_group()) {
 221     AppCacheGroup* group = associated_cache_->owning_group();
 222     if (!group->is_obsolete() && !group->is_being_deleted()) {
 223       success = true;
 224       group->StartUpdate();
 225     }
 226   }
 227
 228   pending_start_update_callback_.Run(success, pending_callback_param_);
 229   pending_start_update_callback_.Reset();
 230   pending_callback_param_ = NULL;
 231 }
 232
 233 void AppCacheHost::SwapCacheWithCallback(const SwapCacheCallback& callback,
 234                                          void* callback_param) {
 235   DCHECK(pending_start_update_callback_.is_null() &&
 236          pending_swap_cache_callback_.is_null() &&
 237          pending_get_status_callback_.is_null());
 238
 239   pending_swap_cache_callback_ = callback;
 240   pending_callback_param_ = callback_param;
 241   if (is_selection_pending())
 242     return;
 243
 244   DoPendingSwapCache();
 245 }
 246
 247 void AppCacheHost::DoPendingSwapCache() {
 248   DCHECK_EQ(false, pending_swap_cache_callback_.is_null());
 249
 250   // 6.9.8 Application cache API
 251   bool success = false;
 252   if (associated_cache_.get() && associated_cache_->owning_group()) {
 253     if (associated_cache_->owning_group()->is_obsolete()) {
 254       success = true;
 255       AssociateNoCache(GURL());
 256     } else if (swappable_cache_.get()) {
 257       DCHECK(swappable_cache_.get() ==
 258              swappable_cache_->owning_group()->newest_complete_cache());
 259       success = true;
 260       AssociateCompleteCache(swappable_cache_.get());
 261     }
 262   }
 263
 264   pending_swap_cache_callback_.Run(success, pending_callback_param_);
 265   pending_swap_cache_callback_.Reset();
 266   pending_callback_param_ = NULL;
 267 }
 268
 269 void AppCacheHost::SetSpawningHostId(
 270     int spawning_process_id, int spawning_host_id) {
 271   spawning_process_id_ = spawning_process_id;
 272   spawning_host_id_ = spawning_host_id;
 273 }
 274
 275 const AppCacheHost* AppCacheHost::GetSpawningHost() const {
 276   AppCacheBackendImpl* backend = service_->GetBackend(spawning_process_id_);
 277   return backend ? backend->GetHost(spawning_host_id_) : NULL;
 278 }
 279
 280 AppCacheHost* AppCacheHost::GetParentAppCacheHost() const {
 281   DCHECK(is_for_dedicated_worker());
 282   AppCacheBackendImpl* backend = service_->GetBackend(parent_process_id_);
 283   return backend ? backend->GetHost(parent_host_id_) : NULL;
 284 }
 285
 286 AppCacheRequestHandler* AppCacheHost::CreateRequestHandler(
 287     net::URLRequest* request,
 288     ResourceType resource_type) {
 289   if (is_for_dedicated_worker()) {
 290     AppCacheHost* parent_host = GetParentAppCacheHost();
 291     if (parent_host)
 292       return parent_host->CreateRequestHandler(request, resource_type);
 293     return NULL;
 294   }
 295
 296   if (AppCacheRequestHandler::IsMainResourceType(resource_type)) {
 297     // Store the first party origin so that it can be used later in SelectCache
 298     // for checking whether the creation of the appcache is allowed.
 299     first_party_url_ = request->first_party_for_cookies();
 300     return new AppCacheRequestHandler(this, resource_type);
 301   }
 302
 303   if ((associated_cache() && associated_cache()->is_complete()) ||
 304       is_selection_pending()) {
 305     return new AppCacheRequestHandler(this, resource_type);
 306   }
 307   return NULL;
 308 }
 309
 310 void AppCacheHost::GetResourceList(
 311     AppCacheResourceInfoVector* resource_infos) {
 312   if (associated_cache_.get() && associated_cache_->is_complete())
 313     associated_cache_->ToResourceInfoVector(resource_infos);
 314 }
 315
 316 AppCacheStatus AppCacheHost::GetStatus() {
 317   // 6.9.8 Application cache API
 318   AppCache* cache = associated_cache();
 319   if (!cache)
 320     return APPCACHE_STATUS_UNCACHED;
 321
 322   // A cache without an owning group represents the cache being constructed
 323   // during the application cache update process.
 324   if (!cache->owning_group())
 325     return APPCACHE_STATUS_DOWNLOADING;
 326
 327   if (cache->owning_group()->is_obsolete())
 328     return APPCACHE_STATUS_OBSOLETE;
 329   if (cache->owning_group()->update_status() == AppCacheGroup::CHECKING)
 330     return APPCACHE_STATUS_CHECKING;
 331   if (cache->owning_group()->update_status() == AppCacheGroup::DOWNLOADING)
 332     return APPCACHE_STATUS_DOWNLOADING;
 333   if (swappable_cache_.get())
 334     return APPCACHE_STATUS_UPDATE_READY;
 335   return APPCACHE_STATUS_IDLE;
 336 }
 337
 338 void AppCacheHost::LoadOrCreateGroup(const GURL& manifest_url) {
 339   DCHECK(manifest_url.is_valid());
 340   pending_selected_manifest_url_ = manifest_url;
 341   storage()->LoadOrCreateGroup(manifest_url, this);
 342 }
 343
 344 void AppCacheHost::OnGroupLoaded(AppCacheGroup* group,
 345                                  const GURL& manifest_url) {
 346   DCHECK(manifest_url == pending_selected_manifest_url_);
 347   pending_selected_manifest_url_ = GURL();
 348   FinishCacheSelection(NULL, group);
 349 }
 350
 351 void AppCacheHost::LoadSelectedCache(int64 cache_id) {
 352   DCHECK(cache_id != kAppCacheNoCacheId);
 353   pending_selected_cache_id_ = cache_id;
 354   storage()->LoadCache(cache_id, this);
 355 }
 356
 357 void AppCacheHost::OnCacheLoaded(AppCache* cache, int64 cache_id) {
 358   if (cache_id == pending_main_resource_cache_id_) {
 359     pending_main_resource_cache_id_ = kAppCacheNoCacheId;
 360     main_resource_cache_ = cache;
 361   } else if (cache_id == pending_selected_cache_id_) {
 362     pending_selected_cache_id_ = kAppCacheNoCacheId;
 363     FinishCacheSelection(cache, NULL);
 364   }
 365 }
 366
 367 void AppCacheHost::FinishCacheSelection(
 368     AppCache *cache, AppCacheGroup* group) {
 369   DCHECK(!associated_cache());
 370
 371   // 6.9.6 The application cache selection algorithm
 372   if (cache) {
 373     // If document was loaded from an application cache, Associate document
 374     // with the application cache from which it was loaded. Invoke the
 375     // application cache update process for that cache and with the browsing
 376     // context being navigated.
 377     DCHECK(cache->owning_group());
 378     DCHECK(new_master_entry_url_.is_empty());
 379     DCHECK_EQ(cache->owning_group()->manifest_url(), preferred_manifest_url_);
 380     AppCacheGroup* owing_group = cache->owning_group();
 381     const char* kFormatString =
 382         "Document was loaded from Application Cache with manifest %s";
 383     frontend_->OnLogMessage(
 384         host_id_, APPCACHE_LOG_INFO,
 385         base::StringPrintf(
 386             kFormatString, owing_group->manifest_url().spec().c_str()));
 387     AssociateCompleteCache(cache);
 388     if (!owing_group->is_obsolete() && !owing_group->is_being_deleted()) {
 389       owing_group->StartUpdateWithHost(this);
 390       ObserveGroupBeingUpdated(owing_group);
 391     }
 392   } else if (group && !group->is_being_deleted()) {
 393     // If document was loaded using HTTP GET or equivalent, and, there is a
 394     // manifest URL, and manifest URL has the same origin as document.
 395     // Invoke the application cache update process for manifest URL, with
 396     // the browsing context being navigated, and with document and the
 397     // resource from which document was loaded as the new master resourse.
 398     DCHECK(!group->is_obsolete());
 399     DCHECK(new_master_entry_url_.is_valid());
 400     DCHECK_EQ(group->manifest_url(), preferred_manifest_url_);
 401     const char* kFormatString = group->HasCache() ?
 402         "Adding master entry to Application Cache with manifest %s" :
 403         "Creating Application Cache with manifest %s";
 404     frontend_->OnLogMessage(
 405         host_id_, APPCACHE_LOG_INFO,
 406         base::StringPrintf(kFormatString,
 407                            group->manifest_url().spec().c_str()));
 408     // The UpdateJob may produce one for us later.
 409     AssociateNoCache(preferred_manifest_url_);
 410     group->StartUpdateWithNewMasterEntry(this, new_master_entry_url_);
 411     ObserveGroupBeingUpdated(group);
 412   } else {
 413     // Otherwise, the Document is not associated with any application cache.
 414     new_master_entry_url_ = GURL();
 415     AssociateNoCache(GURL());
 416   }
 417
 418   // Respond to pending callbacks now that we have a selection.
 419   if (!pending_get_status_callback_.is_null())
 420     DoPendingGetStatus();
 421   else if (!pending_start_update_callback_.is_null())
 422     DoPendingStartUpdate();
 423   else if (!pending_swap_cache_callback_.is_null())
 424     DoPendingSwapCache();
 425
 426   FOR_EACH_OBSERVER(Observer, observers_, OnCacheSelectionComplete(this));
 427 }
 428
 429 void AppCacheHost::OnServiceReinitialized(
 430     AppCacheStorageReference* old_storage_ref) {
 431   // We continue to use the disabled instance, but arrange for its
 432   // deletion when its no longer needed.
 433   if (old_storage_ref->storage() == storage())
 434     disabled_storage_reference_ = old_storage_ref;
 435 }
 436
 437 void AppCacheHost::ObserveGroupBeingUpdated(AppCacheGroup* group) {
 438   DCHECK(!group_being_updated_.get());
 439   group_being_updated_ = group;
 440   newest_cache_of_group_being_updated_ = group->newest_complete_cache();
 441   group->AddUpdateObserver(this);
 442 }
 443
 444 void AppCacheHost::OnUpdateComplete(AppCacheGroup* group) {
 445   DCHECK_EQ(group, group_being_updated_.get());
 446   group->RemoveUpdateObserver(this);
 447
 448   // Add a reference to the newest complete cache.
 449   SetSwappableCache(group);
 450
 451   group_being_updated_ = NULL;
 452   newest_cache_of_group_being_updated_ = NULL;
 453
 454   if (associated_cache_info_pending_ && associated_cache_.get() &&
 455       associated_cache_->is_complete()) {
 456     AppCacheInfo info;
 457     FillCacheInfo(
 458         associated_cache_.get(), preferred_manifest_url_, GetStatus(), &info);
 459     associated_cache_info_pending_ = false;
 460     frontend_->OnCacheSelected(host_id_, info);
 461   }
 462 }
 463
 464 void AppCacheHost::SetSwappableCache(AppCacheGroup* group) {
 465   if (!group) {
 466     swappable_cache_ = NULL;
 467   } else {
 468     AppCache* new_cache = group->newest_complete_cache();
 469     if (new_cache != associated_cache_.get())
 470       swappable_cache_ = new_cache;
 471     else
 472       swappable_cache_ = NULL;
 473   }
 474 }
 475
 476 void AppCacheHost::LoadMainResourceCache(int64 cache_id) {
 477   DCHECK(cache_id != kAppCacheNoCacheId);
 478   if (pending_main_resource_cache_id_ == cache_id ||
 479       (main_resource_cache_.get() &&
 480        main_resource_cache_->cache_id() == cache_id)) {
 481     return;
 482   }
 483   pending_main_resource_cache_id_ = cache_id;
 484   storage()->LoadCache(cache_id, this);
 485 }
 486
 487 void AppCacheHost::NotifyMainResourceIsNamespaceEntry(
 488     const GURL& namespace_entry_url) {
 489   main_resource_was_namespace_entry_ = true;
 490   namespace_entry_url_ = namespace_entry_url;
 491 }
 492
 493 void AppCacheHost::NotifyMainResourceBlocked(const GURL& manifest_url) {
 494   main_resource_blocked_ = true;
 495   blocked_manifest_url_ = manifest_url;
 496 }
 497
 498 void AppCacheHost::PrepareForTransfer() {
 499   // This can only happen prior to the document having been loaded.
 500   DCHECK(!associated_cache());
 501   DCHECK(!is_selection_pending());
 502   DCHECK(!group_being_updated_.get());
 503   host_id_ = kAppCacheNoHostId;
 504   frontend_ = NULL;
 505 }
 506
 507 void AppCacheHost::CompleteTransfer(int host_id, AppCacheFrontend* frontend) {
 508   host_id_ = host_id;
 509   frontend_ = frontend;
 510 }
 511
 512 void AppCacheHost::AssociateNoCache(const GURL& manifest_url) {
 513   // manifest url can be empty.
 514   AssociateCacheHelper(NULL, manifest_url);
 515 }
 516
 517 void AppCacheHost::AssociateIncompleteCache(AppCache* cache,
 518                                             const GURL& manifest_url) {
 519   DCHECK(cache && !cache->is_complete());
 520   DCHECK(!manifest_url.is_empty());
 521   AssociateCacheHelper(cache, manifest_url);
 522 }
 523
 524 void AppCacheHost::AssociateCompleteCache(AppCache* cache) {
 525   DCHECK(cache && cache->is_complete());
 526   AssociateCacheHelper(cache, cache->owning_group()->manifest_url());
 527 }
 528
 529 void AppCacheHost::AssociateCacheHelper(AppCache* cache,
 530                                         const GURL& manifest_url) {
 531   if (associated_cache_.get()) {
 532     associated_cache_->UnassociateHost(this);
 533   }
 534
 535   associated_cache_ = cache;
 536   SetSwappableCache(cache ? cache->owning_group() : NULL);
 537   associated_cache_info_pending_ = cache && !cache->is_complete();
 538   AppCacheInfo info;
 539   if (cache)
 540     cache->AssociateHost(this);
 541
 542   FillCacheInfo(cache, manifest_url, GetStatus(), &info);
 543   frontend_->OnCacheSelected(host_id_, info);
 544 }
 545
 546 }  // namespace content