Add pause/resume functionality to precache

components/precache/core/precache_database.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/precache/core/precache_database.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/history/core/browser/history_constants.h"
 #include "sql/connection.h"
 #include "sql/transaction.h"
 #include "url/gurl.h"
 
 namespace {
 
 // The number of days old that an entry in the precache URL table can be before
 // it is considered "old" and is removed from the table.
 const int kPrecacheHistoryExpiryPeriodDays = 60;
 
 }  // namespace
 
 namespace precache {
 
+UnfinishedWork::UnfinishedWork(
+    const std::list<GURL>& manifest_urls_to_fetch,
+    const std::list<GURL>& resource_urls_to_fetch,
+    int64_t total_response_bytes,
+    int64_t network_response_bytes,
+    int64_t num_manifest_urls_to_fetch,
+    const base::TimeTicks& start_time_of_session)
+    : manifests(manifest_urls_to_fetch),
+      resources(resource_urls_to_fetch),
+      total_bytes(total_response_bytes),
+      network_bytes(network_response_bytes),
+      num_manifest_urls(num_manifest_urls_to_fetch),
+      start_time(start_time_of_session) {}
+
+UnfinishedWork::UnfinishedWork(
+    const base::TimeTicks& earliest_start_time_of_session)
+    : total_bytes(0), network_bytes(0), num_manifest_urls(0),
+      start_time(earliest_start_time_of_session) {}
+
+UnfinishedWork::~UnfinishedWork() {}
+
 PrecacheDatabase::PrecacheDatabase()
     : is_flush_posted_(false), weak_factory_(this) {
   // A PrecacheDatabase can be constructed on any thread.
   thread_checker_.DetachFromThread();
 }
 
 PrecacheDatabase::~PrecacheDatabase() {
   // The destructor must not run on the UI thread, as it may trigger IO
   // operations via sql::Connection's destructor.
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 bool PrecacheDatabase::Init(const base::FilePath& db_path) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!db_);  // Init must only be called once.
 
   db_.reset(new sql::Connection());
   db_->set_histogram_tag("Precache");
 
   if (!db_->Open(db_path)) {
     // Don't initialize the URL table if unable to access
     // the database.
     return false;
   }
 
-  if (!precache_url_table_.Init(db_.get())) {
+  if (!precache_url_table_.Init(db_.get()) ||
+      !precache_session_tables_.Init(db_.get())) {
     // Raze and close the database connection to indicate that it's not usable,
     // and so that the database will be created anew next time, in case it's
     // corrupted.
     db_->RazeAndClose();
     return false;
   }
   return true;
 }
 
 void PrecacheDatabase::DeleteExpiredPrecacheHistory(
@@ skipping 187 matching lines @@
   // Post a delayed task to flush the buffer in 1 second, so that multiple
   // database writes can be buffered up and flushed together in the same
   // transaction.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&PrecacheDatabase::PostedFlush,
                             weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(1));
   is_flush_posted_ = true;
 }
 
+void PrecacheDatabase::GetUnfinishedWork(
+    scoped_refptr<UnfinishedWork> unfinished_work) {
+  base::TimeTicks earliest_start_time = unfinished_work->start_time;
+  precache_session_tables_.GetStatistics(
+      &unfinished_work->total_bytes,
+      &unfinished_work->network_bytes,
+      &unfinished_work->num_manifest_urls,
+      &unfinished_work->start_time);
+  if (unfinished_work->start_time >= earliest_start_time) {
+    precache_session_tables_.GetURLs(&unfinished_work->manifests,
+                                     &unfinished_work->resources);
+  }
+}
+
+void PrecacheDatabase::SaveUnfinishedWork(
+    scoped_refptr<UnfinishedWork> unfinished_work) {
+  precache_session_tables_.StoreURLs(unfinished_work->manifests,
+                                     unfinished_work->resources);
+  precache_session_tables_.StoreStatistics(
+      unfinished_work->total_bytes, unfinished_work->network_bytes,
+      unfinished_work->num_manifest_urls,
+      unfinished_work->start_time);
+}
+
+void PrecacheDatabase::ClearPrecacheSessionState() {
+  precache_session_tables_.ClearURLs();
+  precache_session_tables_.ClearStatistics();
+}
+
+base::WeakPtr<PrecacheDatabase> PrecacheDatabase::GetWeakPtr() {
+  return weak_factory_.GetWeakPtr();
+}
+
 }  // namespace precache