components/offline_pages/offline_page_model.cc

   1 // Copyright 2015 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 "components/offline_pages/offline_page_model.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/bind.h"
  10 #include "base/files/file_util.h"
  11 #include "base/location.h"
  12 #include "base/logging.h"
  13 #include "base/sequenced_task_runner.h"
  14 #include "components/offline_pages/offline_page_item.h"
  15 #include "components/offline_pages/offline_page_metadata_store.h"
  16 #include "url/gurl.h"
  17
  18 using ArchiverResult = offline_pages::OfflinePageArchiver::ArchiverResult;
  19 using SavePageResult = offline_pages::OfflinePageModel::SavePageResult;
  20
  21 namespace offline_pages {
  22
  23 namespace {
  24
  25 SavePageResult ToSavePageResult(ArchiverResult archiver_result) {
  26   SavePageResult result;
  27   switch (archiver_result) {
  28     case ArchiverResult::SUCCESSFULLY_CREATED:
  29       result = SavePageResult::SUCCESS;
  30       break;
  31     case ArchiverResult::ERROR_DEVICE_FULL:
  32       result = SavePageResult::DEVICE_FULL;
  33       break;
  34     case ArchiverResult::ERROR_CONTENT_UNAVAILABLE:
  35       result = SavePageResult::CONTENT_UNAVAILABLE;
  36       break;
  37     case ArchiverResult::ERROR_ARCHIVE_CREATION_FAILED:
  38       result = SavePageResult::ARCHIVE_CREATION_FAILED;
  39       break;
  40     case ArchiverResult::ERROR_CANCELED:
  41       result = SavePageResult::CANCELLED;
  42       break;
  43     default:
  44       NOTREACHED();
  45       result = SavePageResult::CONTENT_UNAVAILABLE;
  46   }
  47   return result;
  48 }
  49
  50 void DeleteArchiveFile(const base::FilePath& file_path, bool* success) {
  51   DCHECK(success);
  52   *success = base::DeleteFile(file_path, false);
  53 }
  54
  55 }  // namespace
  56
  57 OfflinePageModel::OfflinePageModel(
  58     scoped_ptr<OfflinePageMetadataStore> store,
  59     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
  60     : store_(store.Pass()),
  61       is_loaded_(false),
  62       task_runner_(task_runner),
  63       weak_ptr_factory_(this) {
  64   store_->Load(base::Bind(&OfflinePageModel::OnLoadDone,
  65                           weak_ptr_factory_.GetWeakPtr()));
  66 }
  67
  68 OfflinePageModel::~OfflinePageModel() {
  69 }
  70
  71 void OfflinePageModel::Shutdown() {
  72 }
  73
  74 void OfflinePageModel::AddObserver(Observer* observer) {
  75   observers_.AddObserver(observer);
  76 }
  77
  78 void OfflinePageModel::RemoveObserver(Observer* observer) {
  79   observers_.RemoveObserver(observer);
  80 }
  81
  82 void OfflinePageModel::SavePage(const GURL& url,
  83                                 int64 bookmark_id,
  84                                 scoped_ptr<OfflinePageArchiver> archiver,
  85                                 const SavePageCallback& callback) {
  86   DCHECK(is_loaded_);
  87   DCHECK(archiver.get());
  88   archiver->CreateArchive(base::Bind(&OfflinePageModel::OnCreateArchiveDone,
  89                                      weak_ptr_factory_.GetWeakPtr(), url,
  90                                      bookmark_id, callback));
  91   pending_archivers_.push_back(archiver.Pass());
  92 }
  93
  94 void OfflinePageModel::DeletePageByBookmarkId(
  95     int64 bookmark_id,
  96     const DeletePageCallback& callback) {
  97   DCHECK(is_loaded_);
  98
  99   for (const auto& page : offline_pages_) {
 100     if (page.bookmark_id == bookmark_id) {
 101       DeletePage(page, callback);
 102       return;
 103     }
 104   }
 105
 106   callback.Run(DeletePageResult::NOT_FOUND);
 107 }
 108
 109 void OfflinePageModel::DeletePage(const OfflinePageItem& offline_page,
 110                                   const DeletePageCallback& callback) {
 111   DCHECK(is_loaded_);
 112
 113   bool* success = new bool(false);
 114   task_runner_->PostTaskAndReply(
 115       FROM_HERE,
 116       base::Bind(&DeleteArchiveFile,
 117                  offline_page.file_path,
 118                  success),
 119       base::Bind(&OfflinePageModel::OnDeleteArchiverFileDone,
 120                  weak_ptr_factory_.GetWeakPtr(),
 121                  offline_page.url,
 122                  callback,
 123                  base::Owned(success)));
 124 }
 125
 126 const std::vector<OfflinePageItem>& OfflinePageModel::GetAllPages() const {
 127   DCHECK(is_loaded_);
 128   return offline_pages_;
 129 }
 130
 131 bool OfflinePageModel::GetPageByBookmarkId(
 132     int64 bookmark_id,
 133     OfflinePageItem* offline_page) const {
 134   DCHECK(offline_page);
 135
 136   for (const auto& page : offline_pages_) {
 137     if (page.bookmark_id == bookmark_id) {
 138       *offline_page = page;
 139       return true;
 140     }
 141   }
 142   return false;
 143 }
 144
 145 OfflinePageMetadataStore* OfflinePageModel::GetStoreForTesting() {
 146   return store_.get();
 147 }
 148
 149 void OfflinePageModel::OnCreateArchiveDone(const GURL& requested_url,
 150                                            int64 bookmark_id,
 151                                            const SavePageCallback& callback,
 152                                            OfflinePageArchiver* archiver,
 153                                            ArchiverResult archiver_result,
 154                                            const GURL& url,
 155                                            const base::FilePath& file_path,
 156                                            int64 file_size) {
 157   if (requested_url != url) {
 158     DVLOG(1) << "Saved URL does not match requested URL.";
 159     // TODO(fgorski): We have created an archive for a wrong URL. It should be
 160     // deleted from here, once archiver has the right functionality.
 161     InformSavePageDone(callback, SavePageResult::ARCHIVE_CREATION_FAILED);
 162     DeletePendingArchiver(archiver);
 163     return;
 164   }
 165
 166   if (archiver_result != ArchiverResult::SUCCESSFULLY_CREATED) {
 167     SavePageResult result = ToSavePageResult(archiver_result);
 168     InformSavePageDone(callback, result);
 169     DeletePendingArchiver(archiver);
 170     return;
 171   }
 172
 173   OfflinePageItem offline_page_item(url, bookmark_id, file_path, file_size,
 174                                     base::Time::Now());
 175   store_->AddOfflinePage(
 176       offline_page_item,
 177       base::Bind(&OfflinePageModel::OnAddOfflinePageDone,
 178                  weak_ptr_factory_.GetWeakPtr(), archiver, callback,
 179                  offline_page_item));
 180 }
 181
 182 void OfflinePageModel::OnAddOfflinePageDone(OfflinePageArchiver* archiver,
 183                                             const SavePageCallback& callback,
 184                                             const OfflinePageItem& offline_page,
 185                                             bool success) {
 186   SavePageResult result;
 187   if (success) {
 188     offline_pages_.push_back(offline_page);
 189     result = SavePageResult::SUCCESS;
 190   } else {
 191     result = SavePageResult::STORE_FAILURE;
 192   }
 193   InformSavePageDone(callback, result);
 194   DeletePendingArchiver(archiver);
 195 }
 196
 197 void OfflinePageModel::OnLoadDone(
 198     bool success,
 199     const std::vector<OfflinePageItem>& offline_pages) {
 200   DCHECK(!is_loaded_);
 201   is_loaded_ = true;
 202
 203   // TODO(fgorski): Report the UMA upon failure. Cache should probably start
 204   // empty. See if we can do something about it.
 205   if (success)
 206     offline_pages_ = offline_pages;
 207
 208   FOR_EACH_OBSERVER(Observer, observers_, OfflinePageModelLoaded(this));
 209 }
 210
 211 void OfflinePageModel::InformSavePageDone(const SavePageCallback& callback,
 212                                           SavePageResult result) {
 213   callback.Run(result);
 214 }
 215
 216 void OfflinePageModel::DeletePendingArchiver(OfflinePageArchiver* archiver) {
 217   pending_archivers_.erase(std::find(
 218       pending_archivers_.begin(), pending_archivers_.end(), archiver));
 219 }
 220
 221 void OfflinePageModel::OnDeleteArchiverFileDone(
 222     const GURL& url,
 223     const DeletePageCallback& callback,
 224     const bool* success) {
 225   DCHECK(success);
 226
 227   if (!*success) {
 228     callback.Run(DeletePageResult::DEVICE_FAILURE);
 229     return;
 230   }
 231
 232   store_->RemoveOfflinePage(
 233       url,
 234       base::Bind(&OfflinePageModel::OnRemoveOfflinePageDone,
 235                  weak_ptr_factory_.GetWeakPtr(), url, callback));
 236 }
 237
 238 void OfflinePageModel::OnRemoveOfflinePageDone(
 239     const GURL& url,
 240     const DeletePageCallback& callback,
 241     bool success) {
 242   // Delete the offline page from the in memory cache regardless of success in
 243   // store.
 244   for (auto iter = offline_pages_.begin();
 245        iter != offline_pages_.end();
 246        ++iter) {
 247     if (iter->url == url) {
 248       offline_pages_.erase(iter);
 249       break;
 250     }
 251   }
 252
 253   callback.Run(
 254       success ? DeletePageResult::SUCCESS : DeletePageResult::STORE_FAILURE);
 255 }
 256
 257 }  // namespace offline_pages