Home | History | Annotate | Download | only in appcache 
      1 // Copyright 2014 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_service_impl.h"
      6 
      7 #include <functional>
      8 
      9 #include "base/bind.h"
     10 #include "base/bind_helpers.h"
     11 #include "base/logging.h"
     12 #include "base/message_loop/message_loop.h"
     13 #include "base/stl_util.h"
     14 #include "net/base/completion_callback.h"
     15 #include "net/base/io_buffer.h"
     16 #include "webkit/browser/appcache/appcache.h"
     17 #include "webkit/browser/appcache/appcache_backend_impl.h"
     18 #include "webkit/browser/appcache/appcache_entry.h"
     19 #include "webkit/browser/appcache/appcache_executable_handler.h"
     20 #include "webkit/browser/appcache/appcache_histograms.h"
     21 #include "webkit/browser/appcache/appcache_policy.h"
     22 #include "webkit/browser/appcache/appcache_quota_client.h"
     23 #include "webkit/browser/appcache/appcache_response.h"
     24 #include "webkit/browser/appcache/appcache_service_impl.h"
     25 #include "webkit/browser/appcache/appcache_storage_impl.h"
     26 #include "webkit/browser/quota/special_storage_policy.h"
     27 
     28 namespace appcache {
     29 
     30 namespace {
     31 
     32 void DeferredCallback(const net::CompletionCallback& callback, int rv) {
     33   callback.Run(rv);
     34 }
     35 
     36 }  // namespace
     37 
     38 AppCacheInfoCollection::AppCacheInfoCollection() {}
     39 
     40 AppCacheInfoCollection::~AppCacheInfoCollection() {}
     41 
     42 // AsyncHelper -------
     43 
     44 class AppCacheServiceImpl::AsyncHelper
     45     : public AppCacheStorage::Delegate {
     46  public:
     47   AsyncHelper(AppCacheServiceImpl* service,
     48               const net::CompletionCallback& callback)
     49       : service_(service), callback_(callback) {
     50     service_->pending_helpers_.insert(this);
     51   }
     52 
     53   virtual ~AsyncHelper() {
     54     if (service_)
     55       service_->pending_helpers_.erase(this);
     56   }
     57 
     58   virtual void Start() = 0;
     59   virtual void Cancel();
     60 
     61  protected:
     62   void CallCallback(int rv) {
     63     if (!callback_.is_null()) {
     64       // Defer to guarantee async completion.
     65       base::MessageLoop::current()->PostTask(
     66           FROM_HERE, base::Bind(&DeferredCallback, callback_, rv));
     67     }
     68     callback_.Reset();
     69   }
     70 
     71   AppCacheServiceImpl* service_;
     72   net::CompletionCallback callback_;
     73 };
     74 
     75 void AppCacheServiceImpl::AsyncHelper::Cancel() {
     76   if (!callback_.is_null()) {
     77     callback_.Run(net::ERR_ABORTED);
     78     callback_.Reset();
     79   }
     80   service_->storage()->CancelDelegateCallbacks(this);
     81   service_ = NULL;
     82 }
     83 
     84 // CanHandleOfflineHelper -------
     85 
     86 class AppCacheServiceImpl::CanHandleOfflineHelper : AsyncHelper {
     87  public:
     88   CanHandleOfflineHelper(
     89       AppCacheServiceImpl* service, const GURL& url,
     90       const GURL& first_party, const net::CompletionCallback& callback)
     91       : AsyncHelper(service, callback),
     92         url_(url),
     93         first_party_(first_party) {
     94   }
     95 
     96   virtual void Start() OVERRIDE {
     97     AppCachePolicy* policy = service_->appcache_policy();
     98     if (policy && !policy->CanLoadAppCache(url_, first_party_)) {
     99       CallCallback(net::ERR_FAILED);
    100       delete this;
    101       return;
    102     }
    103 
    104     service_->storage()->FindResponseForMainRequest(url_, GURL(), this);
    105   }
    106 
    107  private:
    108   // AppCacheStorage::Delegate implementation.
    109   virtual void OnMainResponseFound(
    110       const GURL& url, const AppCacheEntry& entry,
    111       const GURL& fallback_url, const AppCacheEntry& fallback_entry,
    112       int64 cache_id, int64 group_id, const GURL& mainfest_url) OVERRIDE;
    113 
    114   GURL url_;
    115   GURL first_party_;
    116 
    117   DISALLOW_COPY_AND_ASSIGN(CanHandleOfflineHelper);
    118 };
    119 
    120 void AppCacheServiceImpl::CanHandleOfflineHelper::OnMainResponseFound(
    121       const GURL& url, const AppCacheEntry& entry,
    122       const GURL& fallback_url, const AppCacheEntry& fallback_entry,
    123       int64 cache_id, int64 group_id, const GURL& manifest_url) {
    124   bool can = (entry.has_response_id() || fallback_entry.has_response_id());
    125   CallCallback(can ? net::OK : net::ERR_FAILED);
    126   delete this;
    127 }
    128 
    129 // DeleteHelper -------
    130 
    131 class AppCacheServiceImpl::DeleteHelper : public AsyncHelper {
    132  public:
    133   DeleteHelper(
    134       AppCacheServiceImpl* service, const GURL& manifest_url,
    135       const net::CompletionCallback& callback)
    136       : AsyncHelper(service, callback), manifest_url_(manifest_url) {
    137   }
    138 
    139   virtual void Start() OVERRIDE {
    140     service_->storage()->LoadOrCreateGroup(manifest_url_, this);
    141   }
    142 
    143  private:
    144   // AppCacheStorage::Delegate implementation.
    145   virtual void OnGroupLoaded(
    146       appcache::AppCacheGroup* group, const GURL& manifest_url) OVERRIDE;
    147   virtual void OnGroupMadeObsolete(appcache::AppCacheGroup* group,
    148                                    bool success,
    149                                    int response_code) OVERRIDE;
    150 
    151   GURL manifest_url_;
    152   DISALLOW_COPY_AND_ASSIGN(DeleteHelper);
    153 };
    154 
    155 void AppCacheServiceImpl::DeleteHelper::OnGroupLoaded(
    156       appcache::AppCacheGroup* group, const GURL& manifest_url) {
    157   if (group) {
    158     group->set_being_deleted(true);
    159     group->CancelUpdate();
    160     service_->storage()->MakeGroupObsolete(group, this, 0);
    161   } else {
    162     CallCallback(net::ERR_FAILED);
    163     delete this;
    164   }
    165 }
    166 
    167 void AppCacheServiceImpl::DeleteHelper::OnGroupMadeObsolete(
    168     appcache::AppCacheGroup* group,
    169     bool success,
    170     int response_code) {
    171   CallCallback(success ? net::OK : net::ERR_FAILED);
    172   delete this;
    173 }
    174 
    175 // DeleteOriginHelper -------
    176 
    177 class AppCacheServiceImpl::DeleteOriginHelper : public AsyncHelper {
    178  public:
    179   DeleteOriginHelper(
    180       AppCacheServiceImpl* service, const GURL& origin,
    181       const net::CompletionCallback& callback)
    182       : AsyncHelper(service, callback), origin_(origin),
    183         num_caches_to_delete_(0), successes_(0), failures_(0) {
    184   }
    185 
    186   virtual void Start() OVERRIDE {
    187     // We start by listing all caches, continues in OnAllInfo().
    188     service_->storage()->GetAllInfo(this);
    189   }
    190 
    191  private:
    192   // AppCacheStorage::Delegate implementation.
    193   virtual void OnAllInfo(AppCacheInfoCollection* collection) OVERRIDE;
    194   virtual void OnGroupLoaded(
    195       appcache::AppCacheGroup* group, const GURL& manifest_url) OVERRIDE;
    196   virtual void OnGroupMadeObsolete(appcache::AppCacheGroup* group,
    197                                    bool success,
    198                                    int response_code) OVERRIDE;
    199 
    200   void CacheCompleted(bool success);
    201 
    202   GURL origin_;
    203   int num_caches_to_delete_;
    204   int successes_;
    205   int failures_;
    206 
    207   DISALLOW_COPY_AND_ASSIGN(DeleteOriginHelper);
    208 };
    209 
    210 void AppCacheServiceImpl::DeleteOriginHelper::OnAllInfo(
    211     AppCacheInfoCollection* collection) {
    212   if (!collection) {
    213     // Failed to get a listing.
    214     CallCallback(net::ERR_FAILED);
    215     delete this;
    216     return;
    217   }
    218 
    219   std::map<GURL, AppCacheInfoVector>::iterator found =
    220       collection->infos_by_origin.find(origin_);
    221   if (found == collection->infos_by_origin.end() || found->second.empty()) {
    222     // No caches for this origin.
    223     CallCallback(net::OK);
    224     delete this;
    225     return;
    226   }
    227 
    228   // We have some caches to delete.
    229   const AppCacheInfoVector& caches_to_delete = found->second;
    230   successes_ = 0;
    231   failures_ = 0;
    232   num_caches_to_delete_ = static_cast<int>(caches_to_delete.size());
    233   for (AppCacheInfoVector::const_iterator iter = caches_to_delete.begin();
    234        iter != caches_to_delete.end(); ++iter) {
    235     service_->storage()->LoadOrCreateGroup(iter->manifest_url, this);
    236   }
    237 }
    238 
    239 void AppCacheServiceImpl::DeleteOriginHelper::OnGroupLoaded(
    240       appcache::AppCacheGroup* group, const GURL& manifest_url) {
    241   if (group) {
    242     group->set_being_deleted(true);
    243     group->CancelUpdate();
    244     service_->storage()->MakeGroupObsolete(group, this, 0);
    245   } else {
    246     CacheCompleted(false);
    247   }
    248 }
    249 
    250 void AppCacheServiceImpl::DeleteOriginHelper::OnGroupMadeObsolete(
    251     appcache::AppCacheGroup* group,
    252     bool success,
    253     int response_code) {
    254   CacheCompleted(success);
    255 }
    256 
    257 void AppCacheServiceImpl::DeleteOriginHelper::CacheCompleted(bool success) {
    258   if (success)
    259     ++successes_;
    260   else
    261     ++failures_;
    262   if ((successes_ + failures_) < num_caches_to_delete_)
    263     return;
    264 
    265   CallCallback(!failures_ ? net::OK : net::ERR_FAILED);
    266   delete this;
    267 }
    268 
    269 
    270 // GetInfoHelper -------
    271 
    272 class AppCacheServiceImpl::GetInfoHelper : AsyncHelper {
    273  public:
    274   GetInfoHelper(
    275       AppCacheServiceImpl* service, AppCacheInfoCollection* collection,
    276       const net::CompletionCallback& callback)
    277       : AsyncHelper(service, callback), collection_(collection) {
    278   }
    279 
    280   virtual void Start() OVERRIDE {
    281     service_->storage()->GetAllInfo(this);
    282   }
    283 
    284  private:
    285   // AppCacheStorage::Delegate implementation.
    286   virtual void OnAllInfo(AppCacheInfoCollection* collection) OVERRIDE;
    287 
    288   scoped_refptr<AppCacheInfoCollection> collection_;
    289 
    290   DISALLOW_COPY_AND_ASSIGN(GetInfoHelper);
    291 };
    292 
    293 void AppCacheServiceImpl::GetInfoHelper::OnAllInfo(
    294       AppCacheInfoCollection* collection) {
    295   if (collection)
    296     collection->infos_by_origin.swap(collection_->infos_by_origin);
    297   CallCallback(collection ? net::OK : net::ERR_FAILED);
    298   delete this;
    299 }
    300 
    301 // CheckResponseHelper -------
    302 
    303 class AppCacheServiceImpl::CheckResponseHelper : AsyncHelper {
    304  public:
    305   CheckResponseHelper(
    306       AppCacheServiceImpl* service, const GURL& manifest_url, int64 cache_id,
    307       int64 response_id)
    308       : AsyncHelper(service, net::CompletionCallback()),
    309         manifest_url_(manifest_url),
    310         cache_id_(cache_id),
    311         response_id_(response_id),
    312         kIOBufferSize(32 * 1024),
    313         expected_total_size_(0),
    314         amount_headers_read_(0),
    315         amount_data_read_(0) {
    316   }
    317 
    318   virtual void Start() OVERRIDE {
    319     service_->storage()->LoadOrCreateGroup(manifest_url_, this);
    320   }
    321 
    322   virtual void Cancel() OVERRIDE {
    323     AppCacheHistograms::CountCheckResponseResult(
    324         AppCacheHistograms::CHECK_CANCELED);
    325     response_reader_.reset();
    326     AsyncHelper::Cancel();
    327   }
    328 
    329  private:
    330   virtual void OnGroupLoaded(AppCacheGroup* group,
    331                              const GURL& manifest_url) OVERRIDE;
    332   void OnReadInfoComplete(int result);
    333   void OnReadDataComplete(int result);
    334 
    335   // Inputs describing what to check.
    336   GURL manifest_url_;
    337   int64 cache_id_;
    338   int64 response_id_;
    339 
    340   // Internals used to perform the checks.
    341   const int kIOBufferSize;
    342   scoped_refptr<AppCache> cache_;
    343   scoped_ptr<AppCacheResponseReader> response_reader_;
    344   scoped_refptr<HttpResponseInfoIOBuffer> info_buffer_;
    345   scoped_refptr<net::IOBuffer> data_buffer_;
    346   int64 expected_total_size_;
    347   int amount_headers_read_;
    348   int amount_data_read_;
    349   DISALLOW_COPY_AND_ASSIGN(CheckResponseHelper);
    350 };
    351 
    352 void AppCacheServiceImpl::CheckResponseHelper::OnGroupLoaded(
    353     AppCacheGroup* group, const GURL& manifest_url) {
    354   DCHECK_EQ(manifest_url_, manifest_url);
    355   if (!group || !group->newest_complete_cache() || group->is_being_deleted() ||
    356       group->is_obsolete()) {
    357     AppCacheHistograms::CountCheckResponseResult(
    358         AppCacheHistograms::MANIFEST_OUT_OF_DATE);
    359     delete this;
    360     return;
    361   }
    362 
    363   cache_ = group->newest_complete_cache();
    364   const AppCacheEntry* entry = cache_->GetEntryWithResponseId(response_id_);
    365   if (!entry) {
    366     if (cache_->cache_id() == cache_id_) {
    367       AppCacheHistograms::CountCheckResponseResult(
    368           AppCacheHistograms::ENTRY_NOT_FOUND);
    369       service_->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
    370     } else {
    371       AppCacheHistograms::CountCheckResponseResult(
    372           AppCacheHistograms::RESPONSE_OUT_OF_DATE);
    373     }
    374     delete this;
    375     return;
    376   }
    377 
    378   // Verify that we can read the response info and data.
    379   expected_total_size_ = entry->response_size();
    380   response_reader_.reset(service_->storage()->CreateResponseReader(
    381       manifest_url_, group->group_id(), response_id_));
    382   info_buffer_ = new HttpResponseInfoIOBuffer();
    383   response_reader_->ReadInfo(
    384       info_buffer_.get(),
    385       base::Bind(&CheckResponseHelper::OnReadInfoComplete,
    386                  base::Unretained(this)));
    387 }
    388 
    389 void AppCacheServiceImpl::CheckResponseHelper::OnReadInfoComplete(int result) {
    390   if (result < 0) {
    391     AppCacheHistograms::CountCheckResponseResult(
    392         AppCacheHistograms::READ_HEADERS_ERROR);
    393     service_->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
    394     delete this;
    395     return;
    396   }
    397   amount_headers_read_ = result;
    398 
    399   // Start reading the data.
    400   data_buffer_ = new net::IOBuffer(kIOBufferSize);
    401   response_reader_->ReadData(
    402       data_buffer_.get(),
    403       kIOBufferSize,
    404       base::Bind(&CheckResponseHelper::OnReadDataComplete,
    405                  base::Unretained(this)));
    406 }
    407 
    408 void AppCacheServiceImpl::CheckResponseHelper::OnReadDataComplete(int result) {
    409   if (result > 0) {
    410     // Keep reading until we've read thru everything or failed to read.
    411     amount_data_read_ += result;
    412     response_reader_->ReadData(
    413         data_buffer_.get(),
    414         kIOBufferSize,
    415         base::Bind(&CheckResponseHelper::OnReadDataComplete,
    416                    base::Unretained(this)));
    417     return;
    418   }
    419 
    420   AppCacheHistograms::CheckResponseResultType check_result;
    421   if (result < 0)
    422     check_result = AppCacheHistograms::READ_DATA_ERROR;
    423   else if (info_buffer_->response_data_size != amount_data_read_ ||
    424            expected_total_size_ != amount_data_read_ + amount_headers_read_)
    425     check_result = AppCacheHistograms::UNEXPECTED_DATA_SIZE;
    426   else
    427     check_result = AppCacheHistograms::RESPONSE_OK;
    428   AppCacheHistograms::CountCheckResponseResult(check_result);
    429 
    430   if (check_result != AppCacheHistograms::RESPONSE_OK)
    431     service_->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
    432   delete this;
    433 }
    434 
    435 // AppCacheStorageReference ------
    436 
    437 AppCacheStorageReference::AppCacheStorageReference(
    438     scoped_ptr<AppCacheStorage> storage)
    439     : storage_(storage.Pass()) {}
    440 AppCacheStorageReference::~AppCacheStorageReference() {}
    441 
    442 // AppCacheServiceImpl -------
    443 
    444 AppCacheServiceImpl::AppCacheServiceImpl(quota::QuotaManagerProxy*
    445     quota_manager_proxy)
    446     : appcache_policy_(NULL), quota_client_(NULL), handler_factory_(NULL),
    447       quota_manager_proxy_(quota_manager_proxy),
    448       request_context_(NULL),
    449       force_keep_session_state_(false) {
    450   if (quota_manager_proxy_.get()) {
    451     quota_client_ = new AppCacheQuotaClient(this);
    452     quota_manager_proxy_->RegisterClient(quota_client_);
    453   }
    454 }
    455 
    456 AppCacheServiceImpl::~AppCacheServiceImpl() {
    457   DCHECK(backends_.empty());
    458   std::for_each(pending_helpers_.begin(),
    459                 pending_helpers_.end(),
    460                 std::mem_fun(&AsyncHelper::Cancel));
    461   STLDeleteElements(&pending_helpers_);
    462   if (quota_client_)
    463     quota_client_->NotifyAppCacheDestroyed();
    464 
    465   // Destroy storage_ first; ~AppCacheStorageImpl accesses other data members
    466   // (special_storage_policy_).
    467   storage_.reset();
    468 }
    469 
    470 void AppCacheServiceImpl::Initialize(const base::FilePath& cache_directory,
    471                                  base::MessageLoopProxy* db_thread,
    472                                  base::MessageLoopProxy* cache_thread) {
    473   DCHECK(!storage_.get());
    474   cache_directory_ = cache_directory;
    475   db_thread_ = db_thread;
    476   cache_thread_ = cache_thread;
    477   AppCacheStorageImpl* storage = new AppCacheStorageImpl(this);
    478   storage->Initialize(cache_directory, db_thread, cache_thread);
    479   storage_.reset(storage);
    480 }
    481 
    482 void AppCacheServiceImpl::ScheduleReinitialize() {
    483   if (reinit_timer_.IsRunning())
    484     return;
    485 
    486   // Reinitialization only happens when corruption has been noticed.
    487   // We don't want to thrash the disk but we also don't want to
    488   // leave the appcache disabled for an indefinite period of time. Some
    489   // users never shutdown the browser.
    490 
    491   const base::TimeDelta kZeroDelta;
    492   const base::TimeDelta kOneHour(base::TimeDelta::FromHours(1));
    493   const base::TimeDelta k30Seconds(base::TimeDelta::FromSeconds(30));
    494 
    495   // If the system managed to stay up for long enough, reset the
    496   // delay so a new failure won't incur a long wait to get going again.
    497   base::TimeDelta up_time = base::Time::Now() - last_reinit_time_;
    498   if (next_reinit_delay_ != kZeroDelta && up_time > kOneHour)
    499     next_reinit_delay_ = kZeroDelta;
    500 
    501   reinit_timer_.Start(FROM_HERE, next_reinit_delay_,
    502                       this, &AppCacheServiceImpl::Reinitialize);
    503 
    504   // Adjust the delay for next time.
    505   base::TimeDelta increment = std::max(k30Seconds, next_reinit_delay_);
    506   next_reinit_delay_ = std::min(next_reinit_delay_ + increment,  kOneHour);
    507 }
    508 
    509 void AppCacheServiceImpl::Reinitialize() {
    510   AppCacheHistograms::CountReinitAttempt(!last_reinit_time_.is_null());
    511   last_reinit_time_ = base::Time::Now();
    512 
    513   // Inform observers of about this and give them a chance to
    514   // defer deletion of the old storage object.
    515   scoped_refptr<AppCacheStorageReference>
    516       old_storage_ref(new AppCacheStorageReference(storage_.Pass()));
    517   FOR_EACH_OBSERVER(Observer, observers_,
    518                     OnServiceReinitialized(old_storage_ref.get()));
    519 
    520   Initialize(cache_directory_, db_thread_, cache_thread_);
    521 }
    522 
    523 void AppCacheServiceImpl::CanHandleMainResourceOffline(
    524     const GURL& url,
    525     const GURL& first_party,
    526     const net::CompletionCallback& callback) {
    527   CanHandleOfflineHelper* helper =
    528       new CanHandleOfflineHelper(this, url, first_party, callback);
    529   helper->Start();
    530 }
    531 
    532 void AppCacheServiceImpl::GetAllAppCacheInfo(
    533     AppCacheInfoCollection* collection,
    534     const net::CompletionCallback& callback) {
    535   DCHECK(collection);
    536   GetInfoHelper* helper = new GetInfoHelper(this, collection, callback);
    537   helper->Start();
    538 }
    539 
    540 void AppCacheServiceImpl::DeleteAppCacheGroup(
    541     const GURL& manifest_url,
    542     const net::CompletionCallback& callback) {
    543   DeleteHelper* helper = new DeleteHelper(this, manifest_url, callback);
    544   helper->Start();
    545 }
    546 
    547 void AppCacheServiceImpl::DeleteAppCachesForOrigin(
    548     const GURL& origin,  const net::CompletionCallback& callback) {
    549   DeleteOriginHelper* helper = new DeleteOriginHelper(this, origin, callback);
    550   helper->Start();
    551 }
    552 
    553 void AppCacheServiceImpl::CheckAppCacheResponse(const GURL& manifest_url,
    554                                             int64 cache_id,
    555                                             int64 response_id) {
    556   CheckResponseHelper* helper = new CheckResponseHelper(
    557       this, manifest_url, cache_id, response_id);
    558   helper->Start();
    559 }
    560 
    561 void AppCacheServiceImpl::set_special_storage_policy(
    562     quota::SpecialStoragePolicy* policy) {
    563   special_storage_policy_ = policy;
    564 }
    565 
    566 void AppCacheServiceImpl::RegisterBackend(
    567     AppCacheBackendImpl* backend_impl) {
    568   DCHECK(backends_.find(backend_impl->process_id()) == backends_.end());
    569   backends_.insert(
    570       BackendMap::value_type(backend_impl->process_id(), backend_impl));
    571 }
    572 
    573 void AppCacheServiceImpl::UnregisterBackend(
    574     AppCacheBackendImpl* backend_impl) {
    575   backends_.erase(backend_impl->process_id());
    576 }
    577 
    578 }  // namespace appcache
    579