Relax strict quota limit checks when reading pre-existing DomStorage database files. The other chec…

webkit/dom_storage/dom_storage_map.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 "webkit/dom_storage/dom_storage_map.h"
 
 #include "base/logging.h"
 
 namespace {
 
@@ skipping 54 matching lines @@
     const string16& key, const string16& value,
     NullableString16* old_value) {
   ValuesMap::const_iterator found = values_.find(key);
   if (found == values_.end())
     *old_value = NullableString16(true);
   else
     *old_value = found->second;
 
   size_t old_item_size = old_value->is_null() ?
       0 : size_of_item(key, old_value->string());
-  size_t new_size = bytes_used_ - old_item_size + size_of_item(key, value);
-  if (new_size > quota_)
+  size_t new_item_size = size_of_item(key, value);
+  size_t new_bytes_used = bytes_used_ - old_item_size + new_item_size;
+
+  // Only check quota if the size is increasing since a descrese is

[benm (inactive), 2012/03/06 11:31:15]

s/descrease/decrease/

[michaeln, 2012/03/06 20:37:51]

Done.

+  // always allowed.
+  if ((new_item_size > old_item_size) && (new_bytes_used > quota_))

[benm (inactive), 2012/03/06 11:31:15]

should this be new_item_size >= old_item_size? That would cover the case that
when we're over quota (due to grandfathering in a legacy DB) we'll only allow
the DB to shrink?

nit: can remove some parantheses

[michaeln, 2012/03/06 20:37:51]

Seems cruel to reject a change where the size is not increasing.
Done.

     return false;
 
   values_[key] = NullableString16(value, false);
   ResetKeyIterator();
-  bytes_used_ -= old_item_size;
-  bytes_used_ += size_of_item(key, value);
+  bytes_used_ = new_bytes_used;
   return true;
 }
 
 bool DomStorageMap::RemoveItem(
     const string16& key,
     string16* old_value) {
   ValuesMap::iterator found = values_.find(key);
   if (found == values_.end())
     return false;
   *old_value = found->second.string();
   values_.erase(found);
   ResetKeyIterator();
   bytes_used_ -= size_of_item(key, *old_value);
   return true;
 }
 
-bool DomStorageMap::SwapValues(ValuesMap* values) {
-  size_t new_size = CountBytes(*values);
-  if (new_size > quota_)
-    return false;
+void DomStorageMap::SwapValues(ValuesMap* values) {
   values_.swap(*values);
-  bytes_used_ = new_size;
+  bytes_used_ = CountBytes(values_);
   ResetKeyIterator();
-  return true;
 }
 
 DomStorageMap* DomStorageMap::DeepCopy() const {
-  DCHECK(CountBytes(values_) <= quota_);
   DomStorageMap* copy = new DomStorageMap(quota_);
   copy->values_ = values_;
   copy->bytes_used_ = bytes_used_;
   copy->ResetKeyIterator();
   return copy;
 }
 
 void DomStorageMap::ResetKeyIterator() {
   key_iterator_ = values_.begin();
   last_key_index_ = 0;
 }
 
 }  // namespace dom_storage