OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 2012 Apple Inc. All rights reserved. | 2 * Copyright (C) 2012 Apple Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions | 5 * modification, are permitted provided that the following conditions |
6 * are met: | 6 * are met: |
7 * 1. Redistributions of source code must retain the above copyright | 7 * 1. Redistributions of source code must retain the above copyright |
8 * notice, this list of conditions and the following disclaimer. | 8 * notice, this list of conditions and the following disclaimer. |
9 * 2. Redistributions in binary form must reproduce the above copyright | 9 * 2. Redistributions in binary form must reproduce the above copyright |
10 * notice, this list of conditions and the following disclaimer in the | 10 * notice, this list of conditions and the following disclaimer in the |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
62 | 62 |
63 // This is just for ignoring DatabaseCallback::handleEvent()'s return value. | 63 // This is just for ignoring DatabaseCallback::handleEvent()'s return value. |
64 static void DatabaseCallbackHandleEvent(DatabaseCallback* callback, | 64 static void DatabaseCallbackHandleEvent(DatabaseCallback* callback, |
65 Database* database) { | 65 Database* database) { |
66 probe::AsyncTask async_task(database->GetExecutionContext(), callback); | 66 probe::AsyncTask async_task(database->GetExecutionContext(), callback); |
67 callback->handleEvent(database); | 67 callback->handleEvent(database); |
68 } | 68 } |
69 | 69 |
70 DatabaseContext* DatabaseManager::ExistingDatabaseContextFor( | 70 DatabaseContext* DatabaseManager::ExistingDatabaseContextFor( |
71 ExecutionContext* context) { | 71 ExecutionContext* context) { |
72 ASSERT(database_context_registered_count_ >= 0); | 72 #if DCHECK_IS_ON() |
73 ASSERT(database_context_instance_count_ >= 0); | 73 DCHECK_GE(database_context_registered_count_, 0); |
74 ASSERT(database_context_registered_count_ <= | 74 DCHECK_GE(database_context_instance_count_, 0); |
75 database_context_instance_count_); | 75 DCHECK_LE(database_context_registered_count_, |
| 76 database_context_instance_count_); |
| 77 #endif |
76 return context_map_.at(context); | 78 return context_map_.at(context); |
77 } | 79 } |
78 | 80 |
79 DatabaseContext* DatabaseManager::DatabaseContextFor( | 81 DatabaseContext* DatabaseManager::DatabaseContextFor( |
80 ExecutionContext* context) { | 82 ExecutionContext* context) { |
81 if (DatabaseContext* database_context = ExistingDatabaseContextFor(context)) | 83 if (DatabaseContext* database_context = ExistingDatabaseContextFor(context)) |
82 return database_context; | 84 return database_context; |
83 return DatabaseContext::Create(context); | 85 return DatabaseContext::Create(context); |
84 } | 86 } |
85 | 87 |
86 void DatabaseManager::RegisterDatabaseContext( | 88 void DatabaseManager::RegisterDatabaseContext( |
87 DatabaseContext* database_context) { | 89 DatabaseContext* database_context) { |
88 ExecutionContext* context = database_context->GetExecutionContext(); | 90 ExecutionContext* context = database_context->GetExecutionContext(); |
89 context_map_.Set(context, database_context); | 91 context_map_.Set(context, database_context); |
90 #if DCHECK_IS_ON() | 92 #if DCHECK_IS_ON() |
91 database_context_registered_count_++; | 93 database_context_registered_count_++; |
92 #endif | 94 #endif |
93 } | 95 } |
94 | 96 |
95 void DatabaseManager::UnregisterDatabaseContext( | 97 void DatabaseManager::UnregisterDatabaseContext( |
96 DatabaseContext* database_context) { | 98 DatabaseContext* database_context) { |
97 ExecutionContext* context = database_context->GetExecutionContext(); | 99 ExecutionContext* context = database_context->GetExecutionContext(); |
98 ASSERT(context_map_.at(context)); | 100 DCHECK(context_map_.at(context)); |
99 #if DCHECK_IS_ON() | 101 #if DCHECK_IS_ON() |
100 database_context_registered_count_--; | 102 database_context_registered_count_--; |
101 #endif | 103 #endif |
102 context_map_.erase(context); | 104 context_map_.erase(context); |
103 } | 105 } |
104 | 106 |
105 #if DCHECK_IS_ON() | 107 #if DCHECK_IS_ON() |
106 void DatabaseManager::DidConstructDatabaseContext() { | 108 void DatabaseManager::DidConstructDatabaseContext() { |
107 database_context_instance_count_++; | 109 database_context_instance_count_++; |
108 } | 110 } |
109 | 111 |
110 void DatabaseManager::DidDestructDatabaseContext() { | 112 void DatabaseManager::DidDestructDatabaseContext() { |
111 database_context_instance_count_--; | 113 database_context_instance_count_--; |
112 ASSERT(database_context_registered_count_ <= | 114 DCHECK_LE(database_context_registered_count_, |
113 database_context_instance_count_); | 115 database_context_instance_count_); |
114 } | 116 } |
115 #endif | 117 #endif |
116 | 118 |
117 void DatabaseManager::ThrowExceptionForDatabaseError( | 119 void DatabaseManager::ThrowExceptionForDatabaseError( |
118 DatabaseError error, | 120 DatabaseError error, |
119 const String& error_message, | 121 const String& error_message, |
120 ExceptionState& exception_state) { | 122 ExceptionState& exception_state) { |
121 switch (error) { | 123 switch (error) { |
122 case DatabaseError::kNone: | 124 case DatabaseError::kNone: |
123 return; | 125 return; |
124 case DatabaseError::kGenericSecurityError: | 126 case DatabaseError::kGenericSecurityError: |
125 exception_state.ThrowSecurityError(error_message); | 127 exception_state.ThrowSecurityError(error_message); |
126 return; | 128 return; |
127 case DatabaseError::kInvalidDatabaseState: | 129 case DatabaseError::kInvalidDatabaseState: |
128 exception_state.ThrowDOMException(kInvalidStateError, error_message); | 130 exception_state.ThrowDOMException(kInvalidStateError, error_message); |
129 return; | 131 return; |
130 default: | 132 default: |
131 ASSERT_NOT_REACHED(); | 133 NOTREACHED(); |
132 } | 134 } |
133 } | 135 } |
134 | 136 |
135 static void LogOpenDatabaseError(ExecutionContext* context, | 137 static void LogOpenDatabaseError(ExecutionContext* context, |
136 const String& name) { | 138 const String& name) { |
137 STORAGE_DVLOG(1) << "Database " << name << " for origin " | 139 STORAGE_DVLOG(1) << "Database " << name << " for origin " |
138 << context->GetSecurityOrigin()->ToString() | 140 << context->GetSecurityOrigin()->ToString() |
139 << " not allowed to be established"; | 141 << " not allowed to be established"; |
140 } | 142 } |
141 | 143 |
142 Database* DatabaseManager::OpenDatabaseInternal( | 144 Database* DatabaseManager::OpenDatabaseInternal( |
143 ExecutionContext* context, | 145 ExecutionContext* context, |
144 const String& name, | 146 const String& name, |
145 const String& expected_version, | 147 const String& expected_version, |
146 const String& display_name, | 148 const String& display_name, |
147 unsigned estimated_size, | 149 unsigned estimated_size, |
148 bool set_version_in_new_database, | 150 bool set_version_in_new_database, |
149 DatabaseError& error, | 151 DatabaseError& error, |
150 String& error_message) { | 152 String& error_message) { |
151 ASSERT(error == DatabaseError::kNone); | 153 DCHECK_EQ(error, DatabaseError::kNone); |
152 | 154 |
153 DatabaseContext* backend_context = DatabaseContextFor(context)->Backend(); | 155 DatabaseContext* backend_context = DatabaseContextFor(context)->Backend(); |
154 if (DatabaseTracker::Tracker().CanEstablishDatabase( | 156 if (DatabaseTracker::Tracker().CanEstablishDatabase( |
155 backend_context, name, display_name, estimated_size, error)) { | 157 backend_context, name, display_name, estimated_size, error)) { |
156 Database* backend = new Database(backend_context, name, expected_version, | 158 Database* backend = new Database(backend_context, name, expected_version, |
157 display_name, estimated_size); | 159 display_name, estimated_size); |
158 if (backend->OpenAndVerifyVersion(set_version_in_new_database, error, | 160 if (backend->OpenAndVerifyVersion(set_version_in_new_database, error, |
159 error_message)) | 161 error_message)) |
160 return backend; | 162 return backend; |
161 } | 163 } |
162 | 164 |
163 ASSERT(error != DatabaseError::kNone); | 165 DCHECK_NE(error, DatabaseError::kNone); |
164 switch (error) { | 166 switch (error) { |
165 case DatabaseError::kGenericSecurityError: | 167 case DatabaseError::kGenericSecurityError: |
166 LogOpenDatabaseError(context, name); | 168 LogOpenDatabaseError(context, name); |
167 return nullptr; | 169 return nullptr; |
168 | 170 |
169 case DatabaseError::kInvalidDatabaseState: | 171 case DatabaseError::kInvalidDatabaseState: |
170 LogErrorMessage(context, error_message); | 172 LogErrorMessage(context, error_message); |
171 return nullptr; | 173 return nullptr; |
172 | 174 |
173 default: | 175 default: |
174 ASSERT_NOT_REACHED(); | 176 NOTREACHED(); |
175 } | 177 } |
176 return nullptr; | 178 return nullptr; |
177 } | 179 } |
178 | 180 |
179 Database* DatabaseManager::OpenDatabase(ExecutionContext* context, | 181 Database* DatabaseManager::OpenDatabase(ExecutionContext* context, |
180 const String& name, | 182 const String& name, |
181 const String& expected_version, | 183 const String& expected_version, |
182 const String& display_name, | 184 const String& display_name, |
183 unsigned estimated_size, | 185 unsigned estimated_size, |
184 DatabaseCallback* creation_callback, | 186 DatabaseCallback* creation_callback, |
185 DatabaseError& error, | 187 DatabaseError& error, |
186 String& error_message) { | 188 String& error_message) { |
187 ASSERT(error == DatabaseError::kNone); | 189 DCHECK_EQ(error, DatabaseError::kNone); |
188 | 190 |
189 bool set_version_in_new_database = !creation_callback; | 191 bool set_version_in_new_database = !creation_callback; |
190 Database* database = OpenDatabaseInternal( | 192 Database* database = OpenDatabaseInternal( |
191 context, name, expected_version, display_name, estimated_size, | 193 context, name, expected_version, display_name, estimated_size, |
192 set_version_in_new_database, error, error_message); | 194 set_version_in_new_database, error, error_message); |
193 if (!database) | 195 if (!database) |
194 return nullptr; | 196 return nullptr; |
195 | 197 |
196 DatabaseContextFor(context)->SetHasOpenDatabases(); | 198 DatabaseContextFor(context)->SetHasOpenDatabases(); |
197 DatabaseClient::From(context)->DidOpenDatabase( | 199 DatabaseClient::From(context)->DidOpenDatabase( |
198 database, context->GetSecurityOrigin()->Host(), name, expected_version); | 200 database, context->GetSecurityOrigin()->Host(), name, expected_version); |
199 | 201 |
200 if (database->IsNew() && creation_callback) { | 202 if (database->IsNew() && creation_callback) { |
201 STORAGE_DVLOG(1) << "Scheduling DatabaseCreationCallbackTask for database " | 203 STORAGE_DVLOG(1) << "Scheduling DatabaseCreationCallbackTask for database " |
202 << database; | 204 << database; |
203 probe::AsyncTaskScheduled(database->GetExecutionContext(), "openDatabase", | 205 probe::AsyncTaskScheduled(database->GetExecutionContext(), "openDatabase", |
204 creation_callback); | 206 creation_callback); |
205 TaskRunnerHelper::Get(TaskType::kDatabaseAccess, | 207 TaskRunnerHelper::Get(TaskType::kDatabaseAccess, |
206 database->GetExecutionContext()) | 208 database->GetExecutionContext()) |
207 ->PostTask(BLINK_FROM_HERE, WTF::Bind(&DatabaseCallbackHandleEvent, | 209 ->PostTask(BLINK_FROM_HERE, WTF::Bind(&DatabaseCallbackHandleEvent, |
208 WrapPersistent(creation_callback), | 210 WrapPersistent(creation_callback), |
209 WrapPersistent(database))); | 211 WrapPersistent(database))); |
210 } | 212 } |
211 | 213 |
212 ASSERT(database); | 214 DCHECK(database); |
213 return database; | 215 return database; |
214 } | 216 } |
215 | 217 |
216 String DatabaseManager::FullPathForDatabase(SecurityOrigin* origin, | 218 String DatabaseManager::FullPathForDatabase(SecurityOrigin* origin, |
217 const String& name, | 219 const String& name, |
218 bool create_if_does_not_exist) { | 220 bool create_if_does_not_exist) { |
219 return DatabaseTracker::Tracker().FullPathForDatabase( | 221 return DatabaseTracker::Tracker().FullPathForDatabase( |
220 origin, name, create_if_does_not_exist); | 222 origin, name, create_if_does_not_exist); |
221 } | 223 } |
222 | 224 |
223 void DatabaseManager::LogErrorMessage(ExecutionContext* context, | 225 void DatabaseManager::LogErrorMessage(ExecutionContext* context, |
224 const String& message) { | 226 const String& message) { |
225 context->AddConsoleMessage(ConsoleMessage::Create( | 227 context->AddConsoleMessage(ConsoleMessage::Create( |
226 kStorageMessageSource, kErrorMessageLevel, message)); | 228 kStorageMessageSource, kErrorMessageLevel, message)); |
227 } | 229 } |
228 | 230 |
229 } // namespace blink | 231 } // namespace blink |
OLD | NEW |