1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef CONTENT_BROWSER_DOM_STORAGE_SESSION_STORAGE_DATABASE_H_
6 #define CONTENT_BROWSER_DOM_STORAGE_SESSION_STORAGE_DATABASE_H_
11 #include "base/files/file_path.h"
12 #include "base/memory/ref_counted.h"
13 #include "base/memory/scoped_ptr.h"
14 #include "base/synchronization/lock.h"
15 #include "content/common/content_export.h"
16 #include "content/common/dom_storage/dom_storage_types.h"
17 #include "third_party/leveldatabase/src/include/leveldb/status.h"
25 } // namespace leveldb
29 // SessionStorageDatabase holds the data from multiple namespaces and multiple
30 // origins. All DOMStorageAreas for session storage share the same
31 // SessionStorageDatabase.
33 // Only one thread is allowed to call the public functions other than
34 // ReadAreaValues and ReadNamespacesAndOrigins. Other threads are allowed to
35 // call ReadAreaValues and ReadNamespacesAndOrigins.
36 class CONTENT_EXPORT SessionStorageDatabase :
37 public base::RefCountedThreadSafe<SessionStorageDatabase> {
39 explicit SessionStorageDatabase(const base::FilePath& file_path);
41 // Reads the (key, value) pairs for |namespace_id| and |origin|. |result| is
42 // assumed to be empty and any duplicate keys will be overwritten. If the
43 // database exists on disk then it will be opened. If it does not exist then
44 // it will not be created and |result| will be unmodified.
45 void ReadAreaValues(const std::string& namespace_id,
47 DOMStorageValuesMap* result);
49 // Updates the data for |namespace_id| and |origin|. Will remove all keys
50 // before updating the database if |clear_all_first| is set. Then all entries
51 // in |changes| will be examined - keys mapped to a null NullableString16 will
52 // be removed and all others will be inserted/updated as appropriate. It is
53 // allowed to write data into a shallow copy created by CloneNamespace, and in
54 // that case the copy will be made deep before writing the values.
55 bool CommitAreaChanges(const std::string& namespace_id,
58 const DOMStorageValuesMap& changes);
60 // Creates shallow copies of the areas for |namespace_id| and associates them
61 // with |new_namespace_id|.
62 bool CloneNamespace(const std::string& namespace_id,
63 const std::string& new_namespace_id);
65 // Deletes the data for |namespace_id| and |origin|.
66 bool DeleteArea(const std::string& namespace_id, const GURL& origin);
68 // Deletes the data for |namespace_id|.
69 bool DeleteNamespace(const std::string& namespace_id);
71 // Reads the namespace IDs and origins present in the database.
72 bool ReadNamespacesAndOrigins(
73 std::map<std::string, std::vector<GURL> >* namespaces_and_origins);
76 friend class base::RefCountedThreadSafe<SessionStorageDatabase>;
77 friend class SessionStorageDatabaseTest;
79 ~SessionStorageDatabase();
81 // Opens the database at file_path_ if it exists already and creates it if
82 // |create_if_needed| is true. Returns true if the database was opened, false
83 // if the opening failed or was not necessary (the database doesn't exist and
84 // |create_if_needed| is false). The possible failures are:
85 // - leveldb cannot open the database.
86 // - The database is in an inconsistent or errored state.
87 bool LazyOpen(bool create_if_needed);
89 // Tries to open the database at file_path_, assigns |db| to point to the
90 // opened leveldb::DB instance.
91 leveldb::Status TryToOpen(leveldb::DB** db);
93 // Returns true if the database is already open, false otherwise.
96 // Helpers for checking caller erros, invariants and database errors. All
97 // these return |ok|, for chaining.
98 bool CallerErrorCheck(bool ok) const;
99 bool ConsistencyCheck(bool ok);
100 bool DatabaseErrorCheck(bool ok);
102 // Helper functions. All return true if the operation succeeded, and false if
103 // it failed (a database error or a consistency error). If the return type is
104 // void, the operation cannot fail. If they return false, ConsistencyCheck or
105 // DatabaseErrorCheck have already been called.
107 // Creates a namespace for |namespace_id| and updates the next namespace id if
108 // needed. If |ok_if_exists| is false, checks that the namespace didn't exist
110 bool CreateNamespace(const std::string& namespace_id,
112 leveldb::WriteBatch* batch);
114 // Reads the areas assoiated with |namespace_id| and puts the (origin, map_id)
115 // pairs into |areas|.
116 bool GetAreasInNamespace(const std::string& namespace_id,
117 std::map<std::string, std::string>* areas);
119 // Adds an association between |origin| and |map_id| into the namespace
121 void AddAreaToNamespace(const std::string& namespace_id,
122 const std::string& origin,
123 const std::string& map_id,
124 leveldb::WriteBatch* batch);
126 // Helpers for deleting data for |namespace_id| and |origin|.
127 bool DeleteAreaHelper(const std::string& namespace_id,
128 const std::string& origin,
129 leveldb::WriteBatch* batch);
131 // Retrieves the map id for |namespace_id| and |origin|. It's not an error if
132 // the map doesn't exist.
133 bool GetMapForArea(const std::string& namespace_id,
134 const std::string& origin,
135 const leveldb::ReadOptions& options,
137 std::string* map_id);
139 // Creates a new map for |namespace_id| and |origin|. |map_id| will hold the
140 // id of the created map. If there is a map for |namespace_id| and |origin|,
141 // this just overwrites the map id. The caller is responsible for decreasing
143 bool CreateMapForArea(const std::string& namespace_id,
146 leveldb::WriteBatch* batch);
147 // Reads the contents of the map |map_id| into |result|. If |only_keys| is
148 // true, only keys are aread from the database and the values in |result| will
150 bool ReadMap(const std::string& map_id,
151 const leveldb::ReadOptions& options,
152 DOMStorageValuesMap* result,
154 // Writes |values| into the map |map_id|.
155 void WriteValuesToMap(const std::string& map_id,
156 const DOMStorageValuesMap& values,
157 leveldb::WriteBatch* batch);
159 bool GetMapRefCount(const std::string& map_id, int64* ref_count);
160 bool IncreaseMapRefCount(const std::string& map_id,
161 leveldb::WriteBatch* batch);
162 // Decreases the ref count of a map by |decrease|. If the ref count goes to 0,
164 bool DecreaseMapRefCount(const std::string& map_id,
166 leveldb::WriteBatch* batch);
168 // Deletes all values in |map_id|.
169 bool ClearMap(const std::string& map_id, leveldb::WriteBatch* batch);
171 // Breaks the association between (|namespace_id|, |origin|) and |map_id| and
172 // creates a new map for (|namespace_id|, |origin|). Copies the data from the
173 // old map if |copy_data| is true.
174 bool DeepCopyArea(const std::string& namespace_id,
178 leveldb::WriteBatch* batch);
180 // Helper functions for creating the keys needed for the schema.
181 static std::string NamespaceStartKey(const std::string& namespace_id);
182 static std::string NamespaceKey(const std::string& namespace_id,
183 const std::string& origin);
184 static const char* NamespacePrefix();
185 static std::string MapRefCountKey(const std::string& map_id);
186 static std::string MapKey(const std::string& map_id, const std::string& key);
187 static const char* NextMapIdKey();
189 scoped_ptr<leveldb::DB> db_;
190 base::FilePath file_path_;
192 // For protecting the database opening code.
195 // True if a database error has occurred (e.g., cannot read data).
197 // True if the database is in an inconsistent state.
198 bool is_inconsistent_;
200 DISALLOW_COPY_AND_ASSIGN(SessionStorageDatabase);
203 } // namespace content
205 #endif // CONTENT_BROWSER_DOM_STORAGE_SESSION_STORAGE_DATABASE_H_