OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "webkit/database/database_connections.h" | 5 #include "webkit/database/database_connections.h" |
6 | 6 |
7 #include "base/auto_reset.h" | 7 #include "base/auto_reset.h" |
8 #include "base/bind.h" | 8 #include "base/bind.h" |
9 #include "base/logging.h" | 9 #include "base/logging.h" |
10 #include "base/message_loop.h" | 10 #include "base/message_loop.h" |
11 #include "base/message_loop_proxy.h" | 11 #include "base/message_loop_proxy.h" |
12 | 12 |
13 namespace webkit_database { | 13 namespace webkit_database { |
14 | 14 |
15 DatabaseConnections::DatabaseConnections() { | 15 DatabaseConnections::DatabaseConnections() { |
16 } | 16 } |
17 | 17 |
18 DatabaseConnections::~DatabaseConnections() { | 18 DatabaseConnections::~DatabaseConnections() { |
19 DCHECK(connections_.empty()); | 19 DCHECK(connections_.empty()); |
20 } | 20 } |
21 | 21 |
22 bool DatabaseConnections::IsEmpty() const { | 22 bool DatabaseConnections::IsEmpty() const { |
23 return connections_.empty(); | 23 return connections_.empty(); |
24 } | 24 } |
25 | 25 |
26 bool DatabaseConnections::IsDatabaseOpened( | 26 bool DatabaseConnections::IsDatabaseOpened( |
27 const string16& origin_identifier, | 27 const base::string16& origin_identifier, |
28 const string16& database_name) const { | 28 const base::string16& database_name) const { |
29 OriginConnections::const_iterator origin_it = | 29 OriginConnections::const_iterator origin_it = |
30 connections_.find(origin_identifier); | 30 connections_.find(origin_identifier); |
31 if (origin_it == connections_.end()) | 31 if (origin_it == connections_.end()) |
32 return false; | 32 return false; |
33 const DBConnections& origin_connections = origin_it->second; | 33 const DBConnections& origin_connections = origin_it->second; |
34 return (origin_connections.find(database_name) != origin_connections.end()); | 34 return (origin_connections.find(database_name) != origin_connections.end()); |
35 } | 35 } |
36 | 36 |
37 bool DatabaseConnections::IsOriginUsed( | 37 bool DatabaseConnections::IsOriginUsed( |
38 const string16& origin_identifier) const { | 38 const base::string16& origin_identifier) const { |
39 return (connections_.find(origin_identifier) != connections_.end()); | 39 return (connections_.find(origin_identifier) != connections_.end()); |
40 } | 40 } |
41 | 41 |
42 bool DatabaseConnections::AddConnection(const string16& origin_identifier, | 42 bool DatabaseConnections::AddConnection( |
43 const string16& database_name) { | 43 const base::string16& origin_identifier, |
| 44 const base::string16& database_name) { |
44 int& count = connections_[origin_identifier][database_name].first; | 45 int& count = connections_[origin_identifier][database_name].first; |
45 return ++count == 1; | 46 return ++count == 1; |
46 } | 47 } |
47 | 48 |
48 bool DatabaseConnections::RemoveConnection(const string16& origin_identifier, | 49 bool DatabaseConnections::RemoveConnection( |
49 const string16& database_name) { | 50 const base::string16& origin_identifier, |
| 51 const base::string16& database_name) { |
50 return RemoveConnectionsHelper(origin_identifier, database_name, 1); | 52 return RemoveConnectionsHelper(origin_identifier, database_name, 1); |
51 } | 53 } |
52 | 54 |
53 void DatabaseConnections::RemoveAllConnections() { | 55 void DatabaseConnections::RemoveAllConnections() { |
54 connections_.clear(); | 56 connections_.clear(); |
55 } | 57 } |
56 | 58 |
57 void DatabaseConnections::RemoveConnections( | 59 void DatabaseConnections::RemoveConnections( |
58 const DatabaseConnections& connections, | 60 const DatabaseConnections& connections, |
59 std::vector<std::pair<string16, string16> >* closed_dbs) { | 61 std::vector<std::pair<base::string16, base::string16> >* closed_dbs) { |
60 for (OriginConnections::const_iterator origin_it = | 62 for (OriginConnections::const_iterator origin_it = |
61 connections.connections_.begin(); | 63 connections.connections_.begin(); |
62 origin_it != connections.connections_.end(); | 64 origin_it != connections.connections_.end(); |
63 origin_it++) { | 65 origin_it++) { |
64 const DBConnections& db_connections = origin_it->second; | 66 const DBConnections& db_connections = origin_it->second; |
65 for (DBConnections::const_iterator db_it = db_connections.begin(); | 67 for (DBConnections::const_iterator db_it = db_connections.begin(); |
66 db_it != db_connections.end(); db_it++) { | 68 db_it != db_connections.end(); db_it++) { |
67 if (RemoveConnectionsHelper(origin_it->first, db_it->first, | 69 if (RemoveConnectionsHelper(origin_it->first, db_it->first, |
68 db_it->second.first)) | 70 db_it->second.first)) |
69 closed_dbs->push_back(std::make_pair(origin_it->first, db_it->first)); | 71 closed_dbs->push_back(std::make_pair(origin_it->first, db_it->first)); |
70 } | 72 } |
71 } | 73 } |
72 } | 74 } |
73 | 75 |
74 int64 DatabaseConnections::GetOpenDatabaseSize( | 76 int64 DatabaseConnections::GetOpenDatabaseSize( |
75 const string16& origin_identifier, | 77 const base::string16& origin_identifier, |
76 const string16& database_name) const { | 78 const base::string16& database_name) const { |
77 DCHECK(IsDatabaseOpened(origin_identifier, database_name)); | 79 DCHECK(IsDatabaseOpened(origin_identifier, database_name)); |
78 return connections_[origin_identifier][database_name].second; | 80 return connections_[origin_identifier][database_name].second; |
79 } | 81 } |
80 | 82 |
81 void DatabaseConnections::SetOpenDatabaseSize( | 83 void DatabaseConnections::SetOpenDatabaseSize( |
82 const string16& origin_identifier, | 84 const base::string16& origin_identifier, |
83 const string16& database_name, | 85 const base::string16& database_name, |
84 int64 size) { | 86 int64 size) { |
85 DCHECK(IsDatabaseOpened(origin_identifier, database_name)); | 87 DCHECK(IsDatabaseOpened(origin_identifier, database_name)); |
86 connections_[origin_identifier][database_name].second = size; | 88 connections_[origin_identifier][database_name].second = size; |
87 } | 89 } |
88 | 90 |
89 void DatabaseConnections::ListConnections( | 91 void DatabaseConnections::ListConnections( |
90 std::vector<std::pair<string16, string16> > *list) const { | 92 std::vector<std::pair<base::string16, base::string16> > *list) const { |
91 for (OriginConnections::const_iterator origin_it = | 93 for (OriginConnections::const_iterator origin_it = |
92 connections_.begin(); | 94 connections_.begin(); |
93 origin_it != connections_.end(); | 95 origin_it != connections_.end(); |
94 origin_it++) { | 96 origin_it++) { |
95 const DBConnections& db_connections = origin_it->second; | 97 const DBConnections& db_connections = origin_it->second; |
96 for (DBConnections::const_iterator db_it = db_connections.begin(); | 98 for (DBConnections::const_iterator db_it = db_connections.begin(); |
97 db_it != db_connections.end(); db_it++) { | 99 db_it != db_connections.end(); db_it++) { |
98 list->push_back(std::make_pair(origin_it->first, db_it->first)); | 100 list->push_back(std::make_pair(origin_it->first, db_it->first)); |
99 } | 101 } |
100 } | 102 } |
101 } | 103 } |
102 | 104 |
103 bool DatabaseConnections::RemoveConnectionsHelper( | 105 bool DatabaseConnections::RemoveConnectionsHelper( |
104 const string16& origin_identifier, | 106 const base::string16& origin_identifier, |
105 const string16& database_name, | 107 const base::string16& database_name, |
106 int num_connections) { | 108 int num_connections) { |
107 OriginConnections::iterator origin_iterator = | 109 OriginConnections::iterator origin_iterator = |
108 connections_.find(origin_identifier); | 110 connections_.find(origin_identifier); |
109 DCHECK(origin_iterator != connections_.end()); | 111 DCHECK(origin_iterator != connections_.end()); |
110 DBConnections& db_connections = origin_iterator->second; | 112 DBConnections& db_connections = origin_iterator->second; |
111 int& count = db_connections[database_name].first; | 113 int& count = db_connections[database_name].first; |
112 DCHECK(count >= num_connections); | 114 DCHECK(count >= num_connections); |
113 count -= num_connections; | 115 count -= num_connections; |
114 if (count) | 116 if (count) |
115 return false; | 117 return false; |
(...skipping 21 matching lines...) Expand all Loading... |
137 } | 139 } |
138 } | 140 } |
139 | 141 |
140 bool DatabaseConnectionsWrapper::HasOpenConnections() { | 142 bool DatabaseConnectionsWrapper::HasOpenConnections() { |
141 DCHECK(main_thread_->BelongsToCurrentThread()); | 143 DCHECK(main_thread_->BelongsToCurrentThread()); |
142 base::AutoLock auto_lock(open_connections_lock_); | 144 base::AutoLock auto_lock(open_connections_lock_); |
143 return !open_connections_.IsEmpty(); | 145 return !open_connections_.IsEmpty(); |
144 } | 146 } |
145 | 147 |
146 void DatabaseConnectionsWrapper::AddOpenConnection( | 148 void DatabaseConnectionsWrapper::AddOpenConnection( |
147 const string16& origin_identifier, | 149 const base::string16& origin_identifier, |
148 const string16& database_name) { | 150 const base::string16& database_name) { |
149 // We add to the collection immediately on any thread. | 151 // We add to the collection immediately on any thread. |
150 base::AutoLock auto_lock(open_connections_lock_); | 152 base::AutoLock auto_lock(open_connections_lock_); |
151 open_connections_.AddConnection(origin_identifier, database_name); | 153 open_connections_.AddConnection(origin_identifier, database_name); |
152 } | 154 } |
153 | 155 |
154 void DatabaseConnectionsWrapper::RemoveOpenConnection( | 156 void DatabaseConnectionsWrapper::RemoveOpenConnection( |
155 const string16& origin_identifier, | 157 const base::string16& origin_identifier, |
156 const string16& database_name) { | 158 const base::string16& database_name) { |
157 // But only remove from the collection on the main thread | 159 // But only remove from the collection on the main thread |
158 // so we can handle the waiting_for_dbs_to_close_ case. | 160 // so we can handle the waiting_for_dbs_to_close_ case. |
159 if (!main_thread_->BelongsToCurrentThread()) { | 161 if (!main_thread_->BelongsToCurrentThread()) { |
160 main_thread_->PostTask( | 162 main_thread_->PostTask( |
161 FROM_HERE, | 163 FROM_HERE, |
162 base::Bind(&DatabaseConnectionsWrapper::RemoveOpenConnection, this, | 164 base::Bind(&DatabaseConnectionsWrapper::RemoveOpenConnection, this, |
163 origin_identifier, database_name)); | 165 origin_identifier, database_name)); |
164 return; | 166 return; |
165 } | 167 } |
166 base::AutoLock auto_lock(open_connections_lock_); | 168 base::AutoLock auto_lock(open_connections_lock_); |
167 open_connections_.RemoveConnection(origin_identifier, database_name); | 169 open_connections_.RemoveConnection(origin_identifier, database_name); |
168 if (waiting_for_dbs_to_close_ && open_connections_.IsEmpty()) | 170 if (waiting_for_dbs_to_close_ && open_connections_.IsEmpty()) |
169 MessageLoop::current()->Quit(); | 171 MessageLoop::current()->Quit(); |
170 } | 172 } |
171 | 173 |
172 } // namespace webkit_database | 174 } // namespace webkit_database |
OLD | NEW |