Home | History | Annotate | Download | only in appcache 
      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_backend_impl.h"
      6 
      7 #include "base/stl_util.h"
      8 #include "content/browser/appcache/appcache.h"
      9 #include "content/browser/appcache/appcache_group.h"
     10 #include "content/browser/appcache/appcache_service_impl.h"
     11 
     12 namespace content {
     13 
     14 AppCacheBackendImpl::AppCacheBackendImpl()
     15     : service_(NULL),
     16       frontend_(NULL),
     17       process_id_(0) {
     18 }
     19 
     20 AppCacheBackendImpl::~AppCacheBackendImpl() {
     21   STLDeleteValues(&hosts_);
     22   if (service_)
     23     service_->UnregisterBackend(this);
     24 }
     25 
     26 void AppCacheBackendImpl::Initialize(AppCacheServiceImpl* service,
     27                                      AppCacheFrontend* frontend,
     28                                      int process_id) {
     29   DCHECK(!service_ && !frontend_ && frontend && service);
     30   service_ = service;
     31   frontend_ = frontend;
     32   process_id_ = process_id;
     33   service_->RegisterBackend(this);
     34 }
     35 
     36 bool AppCacheBackendImpl::RegisterHost(int id) {
     37   if (GetHost(id))
     38     return false;
     39 
     40   hosts_.insert(
     41       HostMap::value_type(id, new AppCacheHost(id, frontend_, service_)));
     42   return true;
     43 }
     44 
     45 bool AppCacheBackendImpl::UnregisterHost(int id) {
     46   HostMap::iterator found = hosts_.find(id);
     47   if (found == hosts_.end())
     48     return false;
     49 
     50   delete found->second;
     51   hosts_.erase(found);
     52   return true;
     53 }
     54 
     55 bool AppCacheBackendImpl::SetSpawningHostId(
     56     int host_id,
     57     int spawning_host_id) {
     58   AppCacheHost* host = GetHost(host_id);
     59   if (!host)
     60     return false;
     61   host->SetSpawningHostId(process_id_, spawning_host_id);
     62   return true;
     63 }
     64 
     65 bool AppCacheBackendImpl::SelectCache(
     66     int host_id,
     67     const GURL& document_url,
     68     const int64 cache_document_was_loaded_from,
     69     const GURL& manifest_url) {
     70   AppCacheHost* host = GetHost(host_id);
     71   if (!host)
     72     return false;
     73 
     74   host->SelectCache(document_url, cache_document_was_loaded_from,
     75                     manifest_url);
     76   return true;
     77 }
     78 
     79 bool AppCacheBackendImpl::SelectCacheForWorker(
     80     int host_id, int parent_process_id, int parent_host_id) {
     81   AppCacheHost* host = GetHost(host_id);
     82   if (!host)
     83     return false;
     84 
     85   host->SelectCacheForWorker(parent_process_id, parent_host_id);
     86   return true;
     87 }
     88 
     89 bool AppCacheBackendImpl::SelectCacheForSharedWorker(
     90     int host_id, int64 appcache_id) {
     91   AppCacheHost* host = GetHost(host_id);
     92   if (!host)
     93     return false;
     94 
     95   host->SelectCacheForSharedWorker(appcache_id);
     96   return true;
     97 }
     98 
     99 bool AppCacheBackendImpl::MarkAsForeignEntry(
    100     int host_id,
    101     const GURL& document_url,
    102     int64 cache_document_was_loaded_from) {
    103   AppCacheHost* host = GetHost(host_id);
    104   if (!host)
    105     return false;
    106 
    107   host->MarkAsForeignEntry(document_url, cache_document_was_loaded_from);
    108   return true;
    109 }
    110 
    111 bool AppCacheBackendImpl::GetStatusWithCallback(
    112     int host_id, const GetStatusCallback& callback, void* callback_param) {
    113   AppCacheHost* host = GetHost(host_id);
    114   if (!host)
    115     return false;
    116 
    117   host->GetStatusWithCallback(callback, callback_param);
    118   return true;
    119 }
    120 
    121 bool AppCacheBackendImpl::StartUpdateWithCallback(
    122     int host_id, const StartUpdateCallback& callback, void* callback_param) {
    123   AppCacheHost* host = GetHost(host_id);
    124   if (!host)
    125     return false;
    126 
    127   host->StartUpdateWithCallback(callback, callback_param);
    128   return true;
    129 }
    130 
    131 bool AppCacheBackendImpl::SwapCacheWithCallback(
    132     int host_id, const SwapCacheCallback& callback, void* callback_param) {
    133   AppCacheHost* host = GetHost(host_id);
    134   if (!host)
    135     return false;
    136 
    137   host->SwapCacheWithCallback(callback, callback_param);
    138   return true;
    139 }
    140 
    141 void AppCacheBackendImpl::GetResourceList(
    142     int host_id, std::vector<AppCacheResourceInfo>* resource_infos) {
    143   AppCacheHost* host = GetHost(host_id);
    144   if (!host)
    145     return;
    146 
    147   host->GetResourceList(resource_infos);
    148 }
    149 
    150 scoped_ptr<AppCacheHost> AppCacheBackendImpl::TransferHostOut(int host_id) {
    151   HostMap::iterator found = hosts_.find(host_id);
    152   if (found == hosts_.end()) {
    153     NOTREACHED();
    154     return scoped_ptr<AppCacheHost>();
    155   }
    156 
    157   AppCacheHost* transferree = found->second;
    158 
    159   // Put a new empty host in its place.
    160   found->second = new AppCacheHost(host_id, frontend_, service_);
    161 
    162   // We give up ownership.
    163   transferree->PrepareForTransfer();
    164   return scoped_ptr<AppCacheHost>(transferree);
    165 }
    166 
    167 void AppCacheBackendImpl::TransferHostIn(
    168     int new_host_id, scoped_ptr<AppCacheHost> host) {
    169   HostMap::iterator found = hosts_.find(new_host_id);
    170   if (found == hosts_.end()) {
    171     NOTREACHED();
    172     return;
    173   }
    174 
    175   delete found->second;
    176 
    177   // We take onwership.
    178   host->CompleteTransfer(new_host_id, frontend_);
    179   found->second = host.release();
    180 }
    181 
    182 }  // namespace content
    183