Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(597)

Unified Diff: content/browser/item_store.h

Issue 71153005: Pull implementation of CertStore out to be reused. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Correct gypi file. Created 7 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « content/browser/cert_store_impl.cc ('k') | content/content_browser.gypi » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: content/browser/item_store.h
diff --git a/content/browser/item_store.h b/content/browser/item_store.h
new file mode 100644
index 0000000000000000000000000000000000000000..1ed325e29574bbe9d9286c1ee35a10f5a13a6dc3
--- /dev/null
+++ b/content/browser/item_store.h
@@ -0,0 +1,196 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
agl 2013/11/14 16:20:37 2013
alcutter 2013/11/14 16:51:59 Done.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <map>
+
+#include "base/bind.h"
+#include "base/stl_util.h"
+#include "base/synchronization/lock.h"
+#include "content/browser/renderer_host/render_process_host_impl.h"
+#include "content/browser/renderer_host/render_view_host_impl.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_types.h"
+
+template <typename T>
+struct MatchSecond {
+ explicit MatchSecond(const T& t) : value(t) {}
+
+ template<typename Pair>
+ bool operator()(const Pair& p) const {
+ return (value == p.second);
+ }
+ T value;
+};
+
+namespace content {
+
+template<typename T>
+class ItemStore : public NotificationObserver {
+ protected:
+
+ItemStore() : next_item_id_(1) {
agl 2013/11/14 16:20:37 this should be indented two spaces and then the bo
alcutter 2013/11/14 16:51:59 I think this should've already been done with the
+ if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+ RegisterForNotification();
+ } else {
+ BrowserThread::PostTask(
+ BrowserThread::UI, FROM_HERE,
+ base::Bind(&ItemStore::RegisterForNotification,
+ base::Unretained(this)));
+ }
+}
+
+virtual ~ItemStore() {
+}
+
+void RegisterForNotification() {
+ // We watch for RenderProcess termination, as this is how we clear
+ // items for now.
+ // TODO(jcampan): we should be listening to events such as resource cached/
+ // removed from cache, and remove the item when we know it
+ // is not used anymore.
+
+ registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_TERMINATED,
+ NotificationService::AllBrowserContextsAndSources());
+ registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_CLOSED,
+ NotificationService::AllBrowserContextsAndSources());
+}
+
+int Store(T* item, int process_id) {
+ DCHECK(item);
+ base::AutoLock auto_lock(lock_);
+
+ int item_id;
+
+ // Do we already know this item?
+ typename ReverseItemMap::iterator item_iter = item_to_id_.find(item);
+ if (item_iter == item_to_id_.end()) {
+ item_id = next_item_id_++;
+ // We use 0 as an invalid item_id value. In the unlikely event that
+ // next_item_id_ wraps around, we reset it to 1.
+ if (next_item_id_ == 0)
+ next_item_id_ = 1;
+ item->AddRef();
+ id_to_item_[item_id] = item;
+ item_to_id_[item] = item_id;
+ } else {
+ item_id = item_iter->second;
+ }
+
+ // Let's update process_id_to_item_id_.
+ std::pair<IDMap::iterator, IDMap::iterator> process_ids =
+ process_id_to_item_id_.equal_range(process_id);
+ if (std::find_if(process_ids.first, process_ids.second,
+ MatchSecond<int>(item_id)) == process_ids.second) {
+ process_id_to_item_id_.insert(std::make_pair(process_id, item_id));
+ }
+
+ // And item_id_to_process_id_.
+ std::pair<IDMap::iterator, IDMap::iterator> item_ids =
+ item_id_to_process_id_.equal_range(item_id);
+ if (std::find_if(item_ids.first, item_ids.second,
+ MatchSecond<int>(process_id)) == item_ids.second) {
+ item_id_to_process_id_.insert(std::make_pair(item_id, process_id));
+ }
+
+ return item_id;
+}
+
+bool Retrieve(int item_id, scoped_refptr<T>* item) {
+ base::AutoLock auto_lock(lock_);
+
+ typename ItemMap::iterator iter = id_to_item_.find(item_id);
+ if (iter == id_to_item_.end())
+ return false;
+ if (item)
+ *item = iter->second;
+ return true;
+}
+
+void RemoveInternal(int item_id) {
+ typename ItemMap::iterator item_iter = id_to_item_.find(item_id);
+ DCHECK(item_iter != id_to_item_.end());
+
+ typename ReverseItemMap::iterator id_iter =
+ item_to_id_.find(item_iter->second.get());
+ DCHECK(id_iter != item_to_id_.end());
+ item_to_id_.erase(id_iter);
+
+ item_iter->second->Release();
+ id_to_item_.erase(item_iter);
+}
+
+void RemoveForRenderProcessHost(int process_id) {
+ base::AutoLock auto_lock(lock_);
+
+ // We iterate through all the item ids for that process.
+ std::pair<IDMap::iterator, IDMap::iterator> process_ids =
+ process_id_to_item_id_.equal_range(process_id);
+ for (IDMap::iterator ids_iter = process_ids.first;
+ ids_iter != process_ids.second; ++ids_iter) {
+ int item_id = ids_iter->second;
+ // Find all the processes referring to this item id in
+ // item_id_to_process_id_, then locate the process being removed within
+ // that range.
+ std::pair<IDMap::iterator, IDMap::iterator> item_ids =
+ item_id_to_process_id_.equal_range(item_id);
+ IDMap::iterator proc_iter =
+ std::find_if(item_ids.first, item_ids.second,
+ MatchSecond<int>(process_id));
+ DCHECK(proc_iter != item_ids.second);
+
+ // Before removing, determine if no other processes refer to the current
+ // item id. If |proc_iter| (the current process) is the lower bound of
+ // processes containing the current item id and if |next_proc_iter| is the
+ // upper bound (the first process that does not), then only one process,
+ // the one being removed, refers to the item id.
+ IDMap::iterator next_proc_iter = proc_iter;
+ ++next_proc_iter;
+ bool last_process_for_item_id =
+ (proc_iter == item_ids.first && next_proc_iter == item_ids.second);
+ item_id_to_process_id_.erase(proc_iter);
+
+ if (last_process_for_item_id) {
+ // The current item id is not referenced by any other processes, so
+ // remove it from id_to_item_ and item_to_id_.
+ RemoveInternal(item_id);
+ }
+ }
+ if (process_ids.first != process_ids.second)
+ process_id_to_item_id_.erase(process_ids.first, process_ids.second);
+}
+
+void Observe(int type,
+ const NotificationSource& source,
+ const NotificationDetails& details) {
+ DCHECK(type == NOTIFICATION_RENDERER_PROCESS_TERMINATED ||
+ type == NOTIFICATION_RENDERER_PROCESS_CLOSED);
+ RenderProcessHost* rph = Source<RenderProcessHost>(source).ptr();
+ DCHECK(rph);
+ RemoveForRenderProcessHost(rph->GetID());
+}
+
+ protected:
+ typedef std::multimap<int, int> IDMap;
+ typedef std::map<int, scoped_refptr<T> > ItemMap;
+ typedef std::map<T*, int, typename T::LessThan> ReverseItemMap;
+
+ // Is only used on the UI Thread.
+ NotificationRegistrar registrar_;
+
+ IDMap process_id_to_item_id_;
+ IDMap item_id_to_process_id_;
+ ItemMap id_to_item_;
+ ReverseItemMap item_to_id_;
+
+ int next_item_id_;
+
+ // This lock protects: process_to_item_id_, item_id_to_process_id_,
+ // id_to_item_, and item_to_id_.
+ base::Lock lock_;
+};
+
+} // namespace content
« no previous file with comments | « content/browser/cert_store_impl.cc ('k') | content/content_browser.gypi » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698