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/dom_storage/dom_storage_namespace.h" | 5 #include "webkit/dom_storage/dom_storage_namespace.h" |
6 | 6 |
7 #include "base/basictypes.h" | 7 #include "base/basictypes.h" |
8 #include "base/bind.h" | 8 #include "base/bind.h" |
9 #include "base/location.h" | 9 #include "base/location.h" |
10 #include "base/logging.h" | 10 #include "base/logging.h" |
(...skipping 23 matching lines...) Expand all Loading... |
34 session_storage_database_(session_storage_database) { | 34 session_storage_database_(session_storage_database) { |
35 DCHECK_NE(kLocalStorageNamespaceId, namespace_id); | 35 DCHECK_NE(kLocalStorageNamespaceId, namespace_id); |
36 } | 36 } |
37 | 37 |
38 DomStorageNamespace::~DomStorageNamespace() { | 38 DomStorageNamespace::~DomStorageNamespace() { |
39 } | 39 } |
40 | 40 |
41 DomStorageArea* DomStorageNamespace::OpenStorageArea(const GURL& origin) { | 41 DomStorageArea* DomStorageNamespace::OpenStorageArea(const GURL& origin) { |
42 if (AreaHolder* holder = GetAreaHolder(origin)) { | 42 if (AreaHolder* holder = GetAreaHolder(origin)) { |
43 ++(holder->open_count_); | 43 ++(holder->open_count_); |
44 return holder->area_; | 44 return holder->area_.get(); |
45 } | 45 } |
46 DomStorageArea* area; | 46 DomStorageArea* area; |
47 if (namespace_id_ == kLocalStorageNamespaceId) { | 47 if (namespace_id_ == kLocalStorageNamespaceId) { |
48 area = new DomStorageArea(origin, directory_, task_runner_); | 48 area = new DomStorageArea(origin, directory_, task_runner_.get()); |
49 } else { | 49 } else { |
50 area = new DomStorageArea(namespace_id_, persistent_namespace_id_, origin, | 50 area = new DomStorageArea(namespace_id_, |
51 session_storage_database_, task_runner_); | 51 persistent_namespace_id_, |
| 52 origin, |
| 53 session_storage_database_.get(), |
| 54 task_runner_.get()); |
52 } | 55 } |
53 areas_[origin] = AreaHolder(area, 1); | 56 areas_[origin] = AreaHolder(area, 1); |
54 return area; | 57 return area; |
55 } | 58 } |
56 | 59 |
57 void DomStorageNamespace::CloseStorageArea(DomStorageArea* area) { | 60 void DomStorageNamespace::CloseStorageArea(DomStorageArea* area) { |
58 AreaHolder* holder = GetAreaHolder(area->origin()); | 61 AreaHolder* holder = GetAreaHolder(area->origin()); |
59 DCHECK(holder); | 62 DCHECK(holder); |
60 DCHECK_EQ(holder->area_.get(), area); | 63 DCHECK_EQ(holder->area_.get(), area); |
61 --(holder->open_count_); | 64 --(holder->open_count_); |
62 // TODO(michaeln): Clean up areas that aren't needed in memory anymore. | 65 // TODO(michaeln): Clean up areas that aren't needed in memory anymore. |
63 // The in-process-webkit based impl didn't do this either, but would be nice. | 66 // The in-process-webkit based impl didn't do this either, but would be nice. |
64 } | 67 } |
65 | 68 |
66 DomStorageArea* DomStorageNamespace::GetOpenStorageArea(const GURL& origin) { | 69 DomStorageArea* DomStorageNamespace::GetOpenStorageArea(const GURL& origin) { |
67 AreaHolder* holder = GetAreaHolder(origin); | 70 AreaHolder* holder = GetAreaHolder(origin); |
68 if (holder && holder->open_count_) | 71 if (holder && holder->open_count_) |
69 return holder->area_; | 72 return holder->area_.get(); |
70 return NULL; | 73 return NULL; |
71 } | 74 } |
72 | 75 |
73 DomStorageNamespace* DomStorageNamespace::Clone( | 76 DomStorageNamespace* DomStorageNamespace::Clone( |
74 int64 clone_namespace_id, | 77 int64 clone_namespace_id, |
75 const std::string& clone_persistent_namespace_id) { | 78 const std::string& clone_persistent_namespace_id) { |
76 DCHECK_NE(kLocalStorageNamespaceId, namespace_id_); | 79 DCHECK_NE(kLocalStorageNamespaceId, namespace_id_); |
77 DCHECK_NE(kLocalStorageNamespaceId, clone_namespace_id); | 80 DCHECK_NE(kLocalStorageNamespaceId, clone_namespace_id); |
78 DomStorageNamespace* clone = new DomStorageNamespace( | 81 DomStorageNamespace* clone = |
79 clone_namespace_id, clone_persistent_namespace_id, | 82 new DomStorageNamespace(clone_namespace_id, |
80 session_storage_database_, task_runner_); | 83 clone_persistent_namespace_id, |
| 84 session_storage_database_.get(), |
| 85 task_runner_.get()); |
81 AreaMap::const_iterator it = areas_.begin(); | 86 AreaMap::const_iterator it = areas_.begin(); |
82 // Clone the in-memory structures. | 87 // Clone the in-memory structures. |
83 for (; it != areas_.end(); ++it) { | 88 for (; it != areas_.end(); ++it) { |
84 DomStorageArea* area = it->second.area_->ShallowCopy( | 89 DomStorageArea* area = it->second.area_->ShallowCopy( |
85 clone_namespace_id, clone_persistent_namespace_id); | 90 clone_namespace_id, clone_persistent_namespace_id); |
86 clone->areas_[it->first] = AreaHolder(area, 0); | 91 clone->areas_[it->first] = AreaHolder(area, 0); |
87 } | 92 } |
88 // And clone the on-disk structures, too. | 93 // And clone the on-disk structures, too. |
89 if (session_storage_database_) { | 94 if (session_storage_database_.get()) { |
90 task_runner_->PostShutdownBlockingTask( | 95 task_runner_->PostShutdownBlockingTask( |
91 FROM_HERE, | 96 FROM_HERE, |
92 DomStorageTaskRunner::COMMIT_SEQUENCE, | 97 DomStorageTaskRunner::COMMIT_SEQUENCE, |
93 base::Bind(base::IgnoreResult(&SessionStorageDatabase::CloneNamespace), | 98 base::Bind(base::IgnoreResult(&SessionStorageDatabase::CloneNamespace), |
94 session_storage_database_.get(), persistent_namespace_id_, | 99 session_storage_database_.get(), |
| 100 persistent_namespace_id_, |
95 clone_persistent_namespace_id)); | 101 clone_persistent_namespace_id)); |
96 } | 102 } |
97 return clone; | 103 return clone; |
98 } | 104 } |
99 | 105 |
100 void DomStorageNamespace::DeleteLocalStorageOrigin(const GURL& origin) { | 106 void DomStorageNamespace::DeleteLocalStorageOrigin(const GURL& origin) { |
101 DCHECK(!session_storage_database_.get()); | 107 DCHECK(!session_storage_database_.get()); |
102 AreaHolder* holder = GetAreaHolder(origin); | 108 AreaHolder* holder = GetAreaHolder(origin); |
103 if (holder) { | 109 if (holder) { |
104 holder->area_->DeleteOrigin(); | 110 holder->area_->DeleteOrigin(); |
105 return; | 111 return; |
106 } | 112 } |
107 if (!directory_.empty()) { | 113 if (!directory_.empty()) { |
108 scoped_refptr<DomStorageArea> area = | 114 scoped_refptr<DomStorageArea> area = |
109 new DomStorageArea(origin, directory_, task_runner_); | 115 new DomStorageArea(origin, directory_, task_runner_.get()); |
110 area->DeleteOrigin(); | 116 area->DeleteOrigin(); |
111 } | 117 } |
112 } | 118 } |
113 | 119 |
114 void DomStorageNamespace::DeleteSessionStorageOrigin(const GURL& origin) { | 120 void DomStorageNamespace::DeleteSessionStorageOrigin(const GURL& origin) { |
115 DomStorageArea* area = OpenStorageArea(origin); | 121 DomStorageArea* area = OpenStorageArea(origin); |
116 area->FastClear(); | 122 area->FastClear(); |
117 CloseStorageArea(area); | 123 CloseStorageArea(area); |
118 } | 124 } |
119 | 125 |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
177 | 183 |
178 DomStorageNamespace::AreaHolder::AreaHolder( | 184 DomStorageNamespace::AreaHolder::AreaHolder( |
179 DomStorageArea* area, int count) | 185 DomStorageArea* area, int count) |
180 : area_(area), open_count_(count) { | 186 : area_(area), open_count_(count) { |
181 } | 187 } |
182 | 188 |
183 DomStorageNamespace::AreaHolder::~AreaHolder() { | 189 DomStorageNamespace::AreaHolder::~AreaHolder() { |
184 } | 190 } |
185 | 191 |
186 } // namespace dom_storage | 192 } // namespace dom_storage |
OLD | NEW |