Add a Restore() method to ValueStore and make StorageAPI use it

chrome/browser/extensions/api/storage/settings_storage_quota_enforcer.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/api/storage/settings_storage_quota_enforcer.h"
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
+#include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/value_store/value_store_util.h"
 #include "extensions/common/extension_api.h"
 
 namespace util = value_store_util;
 
 namespace extensions {
 
 namespace {
 
@@ skipping 58 matching lines @@
       ValueStore::QUOTA_EXCEEDED,
       base::StringPrintf("%s quota exceeded", name),
       key.Pass()));
 }
 
 }  // namespace
 
 SettingsStorageQuotaEnforcer::SettingsStorageQuotaEnforcer(
     const Limits& limits, ValueStore* delegate)
     : limits_(limits), delegate_(delegate), used_total_(0) {
-  ReadResult maybe_settings = delegate_->Get();
-  if (maybe_settings->HasError()) {
-    LOG(WARNING) << "Failed to get initial settings for quota: " <<
-        maybe_settings->error().message;
-    return;
-  }
-
-  for (base::DictionaryValue::Iterator it(maybe_settings->settings());
-       !it.IsAtEnd(); it.Advance()) {
-    Allocate(it.key(), it.value(), &used_total_, &used_per_setting_);
-  }
+  CalculateUsage();
 }
 
 SettingsStorageQuotaEnforcer::~SettingsStorageQuotaEnforcer() {}
 
 size_t SettingsStorageQuotaEnforcer::GetBytesInUse(const std::string& key) {
   std::map<std::string, size_t>::iterator maybe_used =
       used_per_setting_.find(key);
   return maybe_used == used_per_setting_.end() ? 0u : maybe_used->second;
 }
 
@@ skipping 111 matching lines @@
   }
   return result.Pass();
 }
 
 ValueStore::WriteResult SettingsStorageQuotaEnforcer::Clear() {
   WriteResult result = delegate_->Clear();
   if (result->HasError()) {
     return result.Pass();
   }
 
-  while (!used_per_setting_.empty()) {
-    Free(&used_total_, &used_per_setting_, used_per_setting_.begin()->first);
-  }
+  used_per_setting_.clear();
+  used_total_ = 0;
   return result.Pass();
 }
 
+bool SettingsStorageQuotaEnforcer::Restore() {
+  if (!delegate_->Restore()) {
+    // If we failed, we can't calculate the usage - that's okay, though, because
+    // next time we Restore() (if it succeeds) we will recalculate usage anyway.
+    // So reset storage counters now to free up resources.
+    used_per_setting_.clear();
+    used_total_ = 0u;
+    return false;
+  }
+  CalculateUsage();
+  return true;
+}
+
+bool SettingsStorageQuotaEnforcer::RestoreKey(const std::string& key) {
+  if (!delegate_->RestoreKey(key))
+    return false;
+
+  ReadResult result = Get(key);
+  // If the key was deleted as a result of the Restore() call, free it.
+  if (!result->settings().HasKey(key) && ContainsKey(used_per_setting_, key))
+    Free(&used_total_, &used_per_setting_, key);
+  return true;
+}
+
+void SettingsStorageQuotaEnforcer::CalculateUsage() {

[not at google - send to devlin, 2014/02/19 21:25:29]

yeah, this is all complex enough to warrant testing

[Devlin, 2014/02/19 23:12:28]

Will do in follow-up, if that's okay.

+  ReadResult maybe_settings = delegate_->Get();
+  if (maybe_settings->HasError()) {
+    // Try to restore the database if it's corrupt.
+    if (maybe_settings->error().code == ValueStore::CORRUPTION &&
+        delegate_->Restore()) {
+      maybe_settings = delegate_->Get();
+    } else {
+      LOG(WARNING) << "Failed to get settings for quota:"
+                   << maybe_settings->error().message;
+      return;
+    }
+  }
+
+  for (base::DictionaryValue::Iterator it(maybe_settings->settings());
+       !it.IsAtEnd();
+       it.Advance()) {
+    Allocate(it.key(), it.value(), &used_total_, &used_per_setting_);
+  }
+}
+
 }  // namespace extensions