| // Copyright 2016 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 "content/renderer/dom_storage/local_storage_cached_area.h" |
| |
| #include "base/bind.h" |
| #include "base/memory/ptr_util.h" |
| #include "base/metrics/histogram_macros.h" |
| #include "base/rand_util.h" |
| #include "base/strings/string16.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "base/strings/string_split.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "base/time/time.h" |
| #include "components/services/leveldb/public/cpp/util.h" |
| #include "content/common/dom_storage/dom_storage_map.h" |
| #include "content/renderer/dom_storage/local_storage_area.h" |
| #include "content/renderer/dom_storage/local_storage_cached_areas.h" |
| #include "content/renderer/dom_storage/session_web_storage_namespace_impl.h" |
| #include "content/renderer/render_thread_impl.h" |
| #include "mojo/public/cpp/bindings/strong_associated_binding.h" |
| #include "third_party/blink/public/mojom/dom_storage/session_storage_namespace.mojom.h" |
| #include "third_party/blink/public/mojom/dom_storage/storage_partition_service.mojom.h" |
| #include "third_party/blink/public/platform/scheduler/web_thread_scheduler.h" |
| #include "third_party/blink/public/platform/web_url.h" |
| #include "third_party/blink/public/web/web_storage_event_dispatcher.h" |
| |
| namespace content { |
| |
| namespace { |
| |
| // Don't change or reorder any of the values in this enum, as these values |
| // are serialized on disk. |
| enum class StorageFormat : uint8_t { UTF16 = 0, Latin1 = 1 }; |
| |
| class GetAllCallback : public blink::mojom::StorageAreaGetAllCallback { |
| public: |
| static blink::mojom::StorageAreaGetAllCallbackAssociatedPtrInfo CreateAndBind( |
| base::OnceCallback<void(bool)> callback) { |
| blink::mojom::StorageAreaGetAllCallbackAssociatedPtrInfo ptr_info; |
| auto request = mojo::MakeRequest(&ptr_info); |
| mojo::MakeStrongAssociatedBinding( |
| base::WrapUnique(new GetAllCallback(std::move(callback))), |
| std::move(request)); |
| return ptr_info; |
| } |
| |
| private: |
| explicit GetAllCallback(base::OnceCallback<void(bool)> callback) |
| : m_callback(std::move(callback)) {} |
| void Complete(bool success) override { std::move(m_callback).Run(success); } |
| |
| base::OnceCallback<void(bool)> m_callback; |
| }; |
| |
| } // namespace |
| |
| // These methods are used to pack and unpack the page_url/storage_area_id into |
| // source strings to/from the browser. |
| std::string PackSource(const GURL& page_url, |
| const std::string& storage_area_id) { |
| return page_url.spec() + "\n" + storage_area_id; |
| } |
| |
| void UnpackSource(const std::string& source, |
| GURL* page_url, |
| std::string* storage_area_id) { |
| std::vector<std::string> result = base::SplitString( |
| source, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL); |
| DCHECK_EQ(result.size(), 2u); |
| *page_url = GURL(result[0]); |
| *storage_area_id = result[1]; |
| } |
| |
| LocalStorageCachedArea::LocalStorageCachedArea( |
| const std::string& namespace_id, |
| const url::Origin& origin, |
| blink::mojom::SessionStorageNamespace* session_namespace, |
| LocalStorageCachedAreas* cached_areas, |
| blink::scheduler::WebThreadScheduler* main_thread_scheduler) |
| : namespace_id_(namespace_id), |
| origin_(origin), |
| binding_(this), |
| cached_areas_(cached_areas), |
| main_thread_scheduler_(main_thread_scheduler), |
| weak_factory_(this) { |
| DCHECK(!namespace_id_.empty()); |
| blink::mojom::StorageAreaAssociatedPtrInfo wrapper_ptr_info; |
| session_namespace->OpenArea(origin_, mojo::MakeRequest(&wrapper_ptr_info)); |
| leveldb_.Bind(std::move(wrapper_ptr_info), |
| main_thread_scheduler->IPCTaskRunner()); |
| blink::mojom::StorageAreaObserverAssociatedPtrInfo ptr_info; |
| binding_.Bind(mojo::MakeRequest(&ptr_info), |
| main_thread_scheduler->IPCTaskRunner()); |
| leveldb_->AddObserver(std::move(ptr_info)); |
| } |
| |
| LocalStorageCachedArea::LocalStorageCachedArea( |
| const url::Origin& origin, |
| blink::mojom::StoragePartitionService* storage_partition_service, |
| LocalStorageCachedAreas* cached_areas, |
| blink::scheduler::WebThreadScheduler* main_thread_scheduler) |
| : origin_(origin), |
| binding_(this), |
| cached_areas_(cached_areas), |
| main_thread_scheduler_(main_thread_scheduler), |
| weak_factory_(this) { |
| DCHECK(namespace_id_.empty()); |
| blink::mojom::StorageAreaPtrInfo wrapper_ptr_info; |
| storage_partition_service->OpenLocalStorage( |
| origin_, mojo::MakeRequest(&wrapper_ptr_info)); |
| leveldb_.Bind(std::move(wrapper_ptr_info), |
| main_thread_scheduler->IPCTaskRunner()); |
| blink::mojom::StorageAreaObserverAssociatedPtrInfo ptr_info; |
| binding_.Bind(mojo::MakeRequest(&ptr_info), |
| main_thread_scheduler->IPCTaskRunner()); |
| leveldb_->AddObserver(std::move(ptr_info)); |
| } |
| |
| LocalStorageCachedArea::~LocalStorageCachedArea() {} |
| |
| unsigned LocalStorageCachedArea::GetLength() { |
| EnsureLoaded(); |
| return map_->Length(); |
| } |
| |
| base::NullableString16 LocalStorageCachedArea::GetKey( |
| unsigned index, |
| bool* did_decrease_iterator) { |
| EnsureLoaded(); |
| return map_->Key(index, did_decrease_iterator); |
| } |
| |
| base::NullableString16 LocalStorageCachedArea::GetItem( |
| const base::string16& key) { |
| EnsureLoaded(); |
| return map_->GetItem(key); |
| } |
| |
| bool LocalStorageCachedArea::SetItem(const base::string16& key, |
| const base::string16& value, |
| const GURL& page_url, |
| const std::string& storage_area_id) { |
| // A quick check to reject obviously overbudget items to avoid priming the |
| // cache. |
| if ((key.length() + value.length()) * sizeof(base::char16) > |
| kPerStorageAreaQuota) |
| return false; |
| |
| EnsureLoaded(); |
| bool result = false; |
| base::NullableString16 old_nullable_value; |
| if (should_send_old_value_on_mutations_) |
| result = map_->SetItem(key, value, &old_nullable_value); |
| else |
| result = map_->SetItem(key, value, nullptr); |
| if (!result) |
| return false; |
| |
| // Determine data formats. |
| bool is_session_storage = IsSessionStorage(); |
| FormatOption key_format = is_session_storage |
| ? FormatOption::kSessionStorageForceUTF8 |
| : FormatOption::kLocalStorageDetectFormat; |
| FormatOption value_format = is_session_storage |
| ? FormatOption::kSessionStorageForceUTF16 |
| : FormatOption::kLocalStorageDetectFormat; |
| |
| // Ignore mutations to |key| until OnSetItemComplete. |
| ignore_key_mutations_[key]++; |
| base::Optional<std::vector<uint8_t>> optional_old_value; |
| if (!old_nullable_value.is_null()) |
| optional_old_value = |
| String16ToUint8Vector(old_nullable_value.string(), value_format); |
| |
| blink::WebScopedVirtualTimePauser virtual_time_pauser = |
| main_thread_scheduler_->CreateWebScopedVirtualTimePauser( |
| "LocalStorageCachedArea"); |
| virtual_time_pauser.PauseVirtualTime(); |
| leveldb_->Put(String16ToUint8Vector(key, key_format), |
| String16ToUint8Vector(value, value_format), optional_old_value, |
| PackSource(page_url, storage_area_id), |
| base::BindOnce(&LocalStorageCachedArea::OnSetItemComplete, |
| weak_factory_.GetWeakPtr(), key, |
| std::move(virtual_time_pauser))); |
| if (IsSessionStorage() && |
| (old_nullable_value.is_null() || old_nullable_value.string() != value)) { |
| blink::WebStorageArea* originating_area = areas_[storage_area_id]; |
| DCHECK_NE(nullptr, originating_area); |
| SessionWebStorageNamespaceImpl session_namespace_for_event_dispatch( |
| namespace_id_, nullptr); |
| blink::WebStorageEventDispatcher::DispatchSessionStorageEvent( |
| blink::WebString::FromUTF16(key), |
| blink::WebString::FromUTF16(old_nullable_value), |
| blink::WebString::FromUTF16(value), origin_.GetURL(), page_url, |
| session_namespace_for_event_dispatch, originating_area); |
| } |
| return true; |
| } |
| |
| void LocalStorageCachedArea::RemoveItem(const base::string16& key, |
| const GURL& page_url, |
| const std::string& storage_area_id) { |
| EnsureLoaded(); |
| bool result = false; |
| base::string16 old_value; |
| if (should_send_old_value_on_mutations_) |
| result = map_->RemoveItem(key, &old_value); |
| else |
| result = map_->RemoveItem(key, nullptr); |
| if (!result) |
| return; |
| |
| // Determine data formats. |
| bool is_session_storage = IsSessionStorage(); |
| FormatOption key_format = is_session_storage |
| ? FormatOption::kSessionStorageForceUTF8 |
| : FormatOption::kLocalStorageDetectFormat; |
| FormatOption value_format = is_session_storage |
| ? FormatOption::kSessionStorageForceUTF16 |
| : FormatOption::kLocalStorageDetectFormat; |
| |
| // Ignore mutations to |key| until OnRemoveItemComplete. |
| ignore_key_mutations_[key]++; |
| base::Optional<std::vector<uint8_t>> optional_old_value; |
| if (should_send_old_value_on_mutations_) |
| optional_old_value = String16ToUint8Vector(old_value, value_format); |
| |
| blink::WebScopedVirtualTimePauser virtual_time_pauser = |
| main_thread_scheduler_->CreateWebScopedVirtualTimePauser( |
| "LocalStorageCachedArea"); |
| virtual_time_pauser.PauseVirtualTime(); |
| leveldb_->Delete(String16ToUint8Vector(key, key_format), optional_old_value, |
| PackSource(page_url, storage_area_id), |
| base::BindOnce(&LocalStorageCachedArea::OnRemoveItemComplete, |
| weak_factory_.GetWeakPtr(), key, |
| std::move(virtual_time_pauser))); |
| if (IsSessionStorage() && old_value != base::string16()) { |
| blink::WebStorageArea* originating_area = areas_[storage_area_id]; |
| DCHECK_NE(nullptr, originating_area); |
| SessionWebStorageNamespaceImpl session_namespace_for_event_dispatch( |
| namespace_id_, nullptr); |
| blink::WebStorageEventDispatcher::DispatchSessionStorageEvent( |
| blink::WebString::FromUTF16(key), |
| blink::WebString::FromUTF16(old_value), blink::WebString(), |
| origin_.GetURL(), page_url, session_namespace_for_event_dispatch, |
| originating_area); |
| } |
| } |
| |
| void LocalStorageCachedArea::Clear(const GURL& page_url, |
| const std::string& storage_area_id) { |
| bool already_empty = false; |
| if (IsSessionStorage()) { |
| EnsureLoaded(); |
| already_empty = map_->Length() == 0u; |
| } |
| // No need to prime the cache in this case. |
| Reset(); |
| map_ = new DOMStorageMap(kPerStorageAreaQuota); |
| ignore_all_mutations_ = true; |
| |
| blink::WebScopedVirtualTimePauser virtual_time_pauser = |
| main_thread_scheduler_->CreateWebScopedVirtualTimePauser( |
| "LocalStorageCachedArea"); |
| virtual_time_pauser.PauseVirtualTime(); |
| leveldb_->DeleteAll(PackSource(page_url, storage_area_id), |
| base::BindOnce(&LocalStorageCachedArea::OnClearComplete, |
| weak_factory_.GetWeakPtr(), |
| std::move(virtual_time_pauser))); |
| if (IsSessionStorage() && !already_empty) { |
| blink::WebStorageArea* originating_area = areas_[storage_area_id]; |
| DCHECK_NE(nullptr, originating_area); |
| SessionWebStorageNamespaceImpl session_namespace_for_event_dispatch( |
| namespace_id_, nullptr); |
| blink::WebStorageEventDispatcher::DispatchSessionStorageEvent( |
| blink::WebString(), blink::WebString(), blink::WebString(), |
| origin_.GetURL(), page_url, session_namespace_for_event_dispatch, |
| originating_area); |
| } |
| } |
| |
| void LocalStorageCachedArea::AreaCreated(LocalStorageArea* area) { |
| areas_[area->id()] = area; |
| } |
| |
| void LocalStorageCachedArea::AreaDestroyed(LocalStorageArea* area) { |
| areas_.erase(area->id()); |
| } |
| |
| // static |
| base::string16 LocalStorageCachedArea::Uint8VectorToString16( |
| const std::vector<uint8_t>& input, |
| FormatOption format_option) { |
| if (input.empty()) |
| return base::string16(); |
| size_t input_size = input.size(); |
| base::string16 result; |
| switch (format_option) { |
| case FormatOption::kSessionStorageForceUTF16: |
| if (input_size % sizeof(base::char16) != 0) { |
| // TODO(mek): Better error recovery when corrupt (or otherwise invalid) |
| // data is detected. |
| LOCAL_HISTOGRAM_BOOLEAN("LocalStorageCachedArea.CorruptData", true); |
| LOG(ERROR) << "Corrupt data in domstorage"; |
| return base::string16(); |
| } |
| result.resize(input_size / sizeof(base::char16)); |
| std::memcpy(&result[0], input.data(), input_size); |
| return result; |
| case FormatOption::kSessionStorageForceUTF8: |
| // Encoding / codepoint errors are ignored on purpose. |
| return base::UTF8ToUTF16(leveldb::Uint8VectorToStringPiece(input)); |
| case FormatOption::kLocalStorageDetectFormat: |
| break; |
| } |
| StorageFormat format = static_cast<StorageFormat>(input[0]); |
| const size_t payload_size = input_size - 1; |
| bool corrupt = false; |
| switch (format) { |
| case StorageFormat::UTF16: |
| if (payload_size % sizeof(base::char16) != 0) { |
| corrupt = true; |
| break; |
| } |
| result.resize(payload_size / sizeof(base::char16)); |
| std::memcpy(&result[0], input.data() + 1, payload_size); |
| break; |
| case StorageFormat::Latin1: |
| result.resize(payload_size); |
| std::copy(input.begin() + 1, input.end(), result.begin()); |
| break; |
| default: |
| corrupt = true; |
| } |
| if (corrupt) { |
| // TODO(mek): Better error recovery when corrupt (or otherwise invalid) data |
| // is detected. |
| LOCAL_HISTOGRAM_BOOLEAN("LocalStorageCachedArea.CorruptData", true); |
| LOG(ERROR) << "Corrupt data in localstorage"; |
| return base::string16(); |
| } |
| return result; |
| } |
| |
| // static |
| std::vector<uint8_t> LocalStorageCachedArea::String16ToUint8Vector( |
| const base::string16& input, |
| FormatOption format_option) { |
| switch (format_option) { |
| case FormatOption::kSessionStorageForceUTF16: { |
| std::vector<uint8_t> result; |
| result.reserve(input.size() * sizeof(base::char16)); |
| const uint8_t* data = reinterpret_cast<const uint8_t*>(input.data()); |
| result.insert(result.begin(), data, |
| data + input.size() * sizeof(base::char16)); |
| return result; |
| } |
| case FormatOption::kSessionStorageForceUTF8: { |
| // Encoding / codepoint errors are ignored on purpose. |
| std::string utf8 = base::UTF16ToUTF8(base::StringPiece16(input)); |
| return leveldb::StdStringToUint8Vector(utf8); |
| } |
| case FormatOption::kLocalStorageDetectFormat: |
| break; |
| } |
| bool is_8bit = true; |
| for (const auto& c : input) { |
| if (c & 0xff00) { |
| is_8bit = false; |
| break; |
| } |
| } |
| if (is_8bit) { |
| std::vector<uint8_t> result(input.size() + 1); |
| result[0] = static_cast<uint8_t>(StorageFormat::Latin1); |
| std::copy(input.begin(), input.end(), result.begin() + 1); |
| return result; |
| } |
| const uint8_t* data = reinterpret_cast<const uint8_t*>(input.data()); |
| std::vector<uint8_t> result; |
| result.reserve(input.size() * sizeof(base::char16) + 1); |
| result.push_back(static_cast<uint8_t>(StorageFormat::UTF16)); |
| result.insert(result.end(), data, data + input.size() * sizeof(base::char16)); |
| return result; |
| } |
| |
| void LocalStorageCachedArea::KeyAdded(const std::vector<uint8_t>& key, |
| const std::vector<uint8_t>& value, |
| const std::string& source) { |
| DCHECK(!IsSessionStorage()); |
| base::NullableString16 null_value; |
| KeyAddedOrChanged(key, value, null_value, source); |
| } |
| |
| void LocalStorageCachedArea::KeyChanged(const std::vector<uint8_t>& key, |
| const std::vector<uint8_t>& new_value, |
| const std::vector<uint8_t>& old_value, |
| const std::string& source) { |
| DCHECK(!IsSessionStorage()); |
| base::NullableString16 old_value_str( |
| Uint8VectorToString16(old_value, FormatOption::kLocalStorageDetectFormat), |
| false); |
| KeyAddedOrChanged(key, new_value, old_value_str, source); |
| } |
| |
| void LocalStorageCachedArea::KeyDeleted(const std::vector<uint8_t>& key, |
| const std::vector<uint8_t>& old_value, |
| const std::string& source) { |
| DCHECK(!IsSessionStorage()); |
| GURL page_url; |
| std::string storage_area_id; |
| UnpackSource(source, &page_url, &storage_area_id); |
| |
| base::string16 key_string = |
| Uint8VectorToString16(key, FormatOption::kLocalStorageDetectFormat); |
| |
| blink::WebStorageArea* originating_area = nullptr; |
| if (areas_.find(storage_area_id) != areas_.end()) { |
| // The source storage area is in this process. |
| originating_area = areas_[storage_area_id]; |
| } else if (map_ && !ignore_all_mutations_) { |
| // This was from another process or the storage area is gone. If the former, |
| // remove it from our cache if we haven't already changed it and are waiting |
| // for the confirmation callback. In the latter case, we won't do anything |
| // because ignore_key_mutations_ won't be updated until the callback runs. |
| if (ignore_key_mutations_.find(key_string) == ignore_key_mutations_.end()) |
| map_->RemoveItem(key_string, nullptr); |
| } |
| |
| blink::WebStorageEventDispatcher::DispatchLocalStorageEvent( |
| blink::WebString::FromUTF16(key_string), |
| blink::WebString::FromUTF16(Uint8VectorToString16( |
| old_value, FormatOption::kLocalStorageDetectFormat)), |
| blink::WebString(), origin_.GetURL(), page_url, originating_area); |
| } |
| |
| void LocalStorageCachedArea::AllDeleted(const std::string& source) { |
| GURL page_url; |
| std::string storage_area_id; |
| UnpackSource(source, &page_url, &storage_area_id); |
| |
| blink::WebStorageArea* originating_area = nullptr; |
| if (areas_.find(storage_area_id) != areas_.end()) { |
| // The source storage area is in this process. |
| originating_area = areas_[storage_area_id]; |
| } else if (map_ && !ignore_all_mutations_) { |
| scoped_refptr<DOMStorageMap> old = map_; |
| map_ = new DOMStorageMap(kPerStorageAreaQuota); |
| |
| // We have to retain local additions which happened after this clear |
| // operation from another process. |
| auto iter = ignore_key_mutations_.begin(); |
| while (iter != ignore_key_mutations_.end()) { |
| base::NullableString16 value = old->GetItem(iter->first); |
| if (!value.is_null()) |
| map_->SetItem(iter->first, value.string(), nullptr); |
| ++iter; |
| } |
| } |
| |
| if (IsSessionStorage()) { |
| SessionWebStorageNamespaceImpl session_namespace_for_event_dispatch( |
| namespace_id_, nullptr); |
| blink::WebStorageEventDispatcher::DispatchSessionStorageEvent( |
| blink::WebString(), blink::WebString(), blink::WebString(), |
| origin_.GetURL(), page_url, session_namespace_for_event_dispatch, |
| originating_area); |
| } else { |
| blink::WebStorageEventDispatcher::DispatchLocalStorageEvent( |
| blink::WebString(), blink::WebString(), blink::WebString(), |
| origin_.GetURL(), page_url, originating_area); |
| } |
| } |
| |
| void LocalStorageCachedArea::ShouldSendOldValueOnMutations(bool value) { |
| DCHECK(!IsSessionStorage()); |
| should_send_old_value_on_mutations_ = value; |
| } |
| |
| void LocalStorageCachedArea::KeyAddedOrChanged( |
| const std::vector<uint8_t>& key, |
| const std::vector<uint8_t>& new_value, |
| const base::NullableString16& old_value, |
| const std::string& source) { |
| DCHECK(!IsSessionStorage()); |
| GURL page_url; |
| std::string storage_area_id; |
| UnpackSource(source, &page_url, &storage_area_id); |
| |
| base::string16 key_string = |
| Uint8VectorToString16(key, FormatOption::kLocalStorageDetectFormat); |
| base::string16 new_value_string = |
| Uint8VectorToString16(new_value, FormatOption::kLocalStorageDetectFormat); |
| |
| blink::WebStorageArea* originating_area = nullptr; |
| if (areas_.find(storage_area_id) != areas_.end()) { |
| // The source storage area is in this process. |
| originating_area = areas_[storage_area_id]; |
| } else if (map_ && !ignore_all_mutations_) { |
| // This was from another process or the storage area is gone. If the former, |
| // apply it to our cache if we haven't already changed it and are waiting |
| // for the confirmation callback. In the latter case, we won't do anything |
| // because ignore_key_mutations_ won't be updated until the callback runs. |
| if (ignore_key_mutations_.find(key_string) == ignore_key_mutations_.end()) { |
| // We turn off quota checking here to accomodate the over budget allowance |
| // that's provided in the browser process. |
| map_->set_quota(std::numeric_limits<int32_t>::max()); |
| map_->SetItem(key_string, new_value_string, nullptr); |
| map_->set_quota(kPerStorageAreaQuota); |
| } |
| } |
| |
| blink::WebStorageEventDispatcher::DispatchLocalStorageEvent( |
| blink::WebString::FromUTF16(key_string), |
| blink::WebString::FromUTF16(old_value), |
| blink::WebString::FromUTF16(new_value_string), origin_.GetURL(), page_url, |
| originating_area); |
| } |
| |
| void LocalStorageCachedArea::EnsureLoaded() { |
| if (map_) |
| return; |
| |
| base::TimeTicks before = base::TimeTicks::Now(); |
| ignore_all_mutations_ = true; |
| bool success = false; |
| std::vector<blink::mojom::KeyValuePtr> data; |
| leveldb_->GetAll(GetAllCallback::CreateAndBind( |
| base::BindOnce(&LocalStorageCachedArea::OnGetAllComplete, |
| weak_factory_.GetWeakPtr())), |
| &success, &data); |
| |
| DOMStorageValuesMap values; |
| bool is_session_storage = IsSessionStorage(); |
| FormatOption key_format = is_session_storage |
| ? FormatOption::kSessionStorageForceUTF8 |
| : FormatOption::kLocalStorageDetectFormat; |
| FormatOption value_format = is_session_storage |
| ? FormatOption::kSessionStorageForceUTF16 |
| : FormatOption::kLocalStorageDetectFormat; |
| for (size_t i = 0; i < data.size(); ++i) { |
| values[Uint8VectorToString16(data[i]->key, key_format)] = |
| base::NullableString16( |
| Uint8VectorToString16(data[i]->value, value_format), false); |
| } |
| |
| map_ = new DOMStorageMap(kPerStorageAreaQuota); |
| map_->SwapValues(&values); |
| |
| base::TimeDelta time_to_prime = base::TimeTicks::Now() - before; |
| UMA_HISTOGRAM_TIMES("LocalStorage.MojoTimeToPrime", time_to_prime); |
| |
| size_t local_storage_size_kb = map_->storage_used() / 1024; |
| // Track localStorage size, from 0-6MB. Note that the maximum size should be |
| // 5MB, but we add some slop since we want to make sure the max size is always |
| // above what we see in practice, since histograms can't change. |
| UMA_HISTOGRAM_CUSTOM_COUNTS("LocalStorage.MojoSizeInKB", |
| local_storage_size_kb, |
| 1, 6 * 1024, 50); |
| if (local_storage_size_kb < 100) { |
| UMA_HISTOGRAM_TIMES("LocalStorage.MojoTimeToPrimeForUnder100KB", |
| time_to_prime); |
| } else if (local_storage_size_kb < 1000) { |
| UMA_HISTOGRAM_TIMES("LocalStorage.MojoTimeToPrimeFor100KBTo1MB", |
| time_to_prime); |
| } else { |
| UMA_HISTOGRAM_TIMES("LocalStorage.MojoTimeToPrimeFor1MBTo5MB", |
| time_to_prime); |
| } |
| } |
| |
| void LocalStorageCachedArea::OnSetItemComplete( |
| const base::string16& key, |
| blink::WebScopedVirtualTimePauser, |
| bool success) { |
| if (!success) { |
| Reset(); |
| return; |
| } |
| |
| auto found = ignore_key_mutations_.find(key); |
| DCHECK(found != ignore_key_mutations_.end()); |
| if (--found->second == 0) |
| ignore_key_mutations_.erase(found); |
| } |
| |
| void LocalStorageCachedArea::OnRemoveItemComplete( |
| const base::string16& key, |
| blink::WebScopedVirtualTimePauser, |
| bool success) { |
| DCHECK(success); |
| auto found = ignore_key_mutations_.find(key); |
| DCHECK(found != ignore_key_mutations_.end()); |
| if (--found->second == 0) |
| ignore_key_mutations_.erase(found); |
| } |
| |
| void LocalStorageCachedArea::OnClearComplete(blink::WebScopedVirtualTimePauser, |
| bool success) { |
| DCHECK(success); |
| DCHECK(ignore_all_mutations_); |
| ignore_all_mutations_ = false; |
| } |
| |
| void LocalStorageCachedArea::OnGetAllComplete(bool success) { |
| // Since the GetAll method is synchronous, we need this asynchronously |
| // delivered notification to avoid applying changes to the returned array |
| // that we already have. |
| DCHECK(success); |
| DCHECK(ignore_all_mutations_); |
| ignore_all_mutations_ = false; |
| } |
| |
| void LocalStorageCachedArea::Reset() { |
| map_ = nullptr; |
| ignore_key_mutations_.clear(); |
| ignore_all_mutations_ = false; |
| weak_factory_.InvalidateWeakPtrs(); |
| } |
| |
| } // namespace content |
