Add HostCachePersistenceManager for Cronet

components/cronet/host_cache_persistence_manager.cc

+// Copyright 2017 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/cronet/host_cache_persistence_manager.h"
+
+#include <memory>
+
+#include "base/memory/ptr_util.h"
+#include "base/time/time.h"
+#include "base/timer/timer.h"
+#include "base/values.h"
+#include "components/prefs/pref_change_registrar.h"
+#include "components/prefs/pref_service.h"
+
+namespace cronet {
+
+HostCachePersistenceManager::HostCachePersistenceManager(
+    net::HostCache* cache,
+    PrefService* pref_service,
+    std::string pref_name,
+    base::TimeDelta delay)
+    : cache_(cache),
+      registrar_(base::MakeUnique<PrefChangeRegistrar>()),
+      pref_service_(pref_service),
+      pref_name_(pref_name),
+      delay_(delay),
+      timer_(base::MakeUnique<base::OneShotTimer>()),
+      weak_factory_(this) {
+  DCHECK(cache_);
+  DCHECK(pref_service_);
+
+  // Get the initial value of the pref if it's already initialized.
+  if (pref_service_->HasPrefPath(pref_name_))
+    OnRead();
+
+  registrar_->Init(pref_service_);
+  registrar_->Add(pref_name_, base::Bind(&HostCachePersistenceManager::OnRead,
+                                         weak_factory_.GetWeakPtr()));
+  cache_->set_persistence_delegate(this);
+}
+
+HostCachePersistenceManager::~HostCachePersistenceManager() {
+  DCHECK(cache_);
+  DCHECK(pref_service_);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  timer_->Stop();
+  registrar_->RemoveAll();
+  cache_->set_persistence_delegate(nullptr);

[pauljensen, 2017/06/22 19:03:50]

I feel like either there should be a DCHECK_EQ(cache_->persistence_delectate(),
this) here, or in set_persistence_delegate() there should be a
DCHECK_NE(delegate == nullptr, delegate_ == nullptr), to prevent inadvertent
overwriting of the persistence delegate.
  

[mgersh, 2017/06/22 21:27:32]

Done. Picked the second because it'll give a more useful stack trace if
something tries to add a second PersistenceDelegate.

+}
+
+void HostCachePersistenceManager::OnRead() {

[pauljensen, 2017/06/22 19:03:50]

It looks like this is the counterpart to DoWrite() as DoWrite() copies from
cache_ to prefs, and this function copies from prefs to cache_.  Can we name it
DoRead()?  or perhaps we could rename both functions to Save() and Restore(), or
Save() and Reload(), or WriteToDisk() and ReadFromDisk()?

[mgersh, 2017/06/22 21:27:32]

Done.

+  DCHECK(cache_);
+  DCHECK(pref_service_);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  if (writing_pref_)
+    return;
+
+  const base::ListValue* pref_value = pref_service_->GetList(pref_name_);
+  cache_->RestoreFromListValue(*pref_value);
+}
+
+void HostCachePersistenceManager::ScheduleWrite() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  if (timer_->IsRunning())
+    return;
+
+  timer_->Start(FROM_HERE, delay_,
+                base::Bind(&HostCachePersistenceManager::DoWrite,
+                           weak_factory_.GetWeakPtr()));
+}
+
+void HostCachePersistenceManager::DoWrite() {
+  DCHECK(cache_);
+  DCHECK(pref_service_);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  std::unique_ptr<base::ListValue> value = cache_->GetAsListValue(false);
+  writing_pref_ = true;
+  pref_service_->Set(pref_name_, *value);
+  writing_pref_ = false;
+}
+
+}  // namespace cronet