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 "content/browser/host_zoom_map_impl.h" | 5 #include "content/browser/host_zoom_map_impl.h" |
6 | 6 |
7 #include <cmath> | 7 #include <cmath> |
8 | 8 |
9 #include "base/strings/string_piece.h" | 9 #include "base/strings/string_piece.h" |
10 #include "base/strings/utf_string_conversions.h" | 10 #include "base/strings/utf_string_conversions.h" |
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
126 | 126 |
127 { | 127 { |
128 base::AutoLock auto_lock(lock_); | 128 base::AutoLock auto_lock(lock_); |
129 | 129 |
130 if (ZoomValuesEqual(level, default_zoom_level_)) | 130 if (ZoomValuesEqual(level, default_zoom_level_)) |
131 host_zoom_levels_.erase(host); | 131 host_zoom_levels_.erase(host); |
132 else | 132 else |
133 host_zoom_levels_[host] = level; | 133 host_zoom_levels_[host] = level; |
134 } | 134 } |
135 | 135 |
136 // Notify renderers from this browser context. | 136 SendZoomLevelChange(std::string(), host, level); |
137 for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator()); | 137 |
138 !i.IsAtEnd(); i.Advance()) { | |
139 RenderProcessHost* render_process_host = i.GetCurrentValue(); | |
140 if (HostZoomMap::GetForBrowserContext( | |
141 render_process_host->GetBrowserContext()) == this) { | |
142 render_process_host->Send( | |
143 new ViewMsg_SetZoomLevelForCurrentURL(std::string(), host, level)); | |
144 } | |
145 } | |
146 HostZoomMap::ZoomLevelChange change; | 138 HostZoomMap::ZoomLevelChange change; |
147 change.mode = HostZoomMap::ZOOM_CHANGED_FOR_HOST; | 139 change.mode = HostZoomMap::ZOOM_CHANGED_FOR_HOST; |
148 change.host = host; | 140 change.host = host; |
149 change.zoom_level = level; | 141 change.zoom_level = level; |
150 | 142 |
151 zoom_level_changed_callbacks_.Notify(change); | 143 zoom_level_changed_callbacks_.Notify(change); |
152 } | 144 } |
153 | 145 |
154 void HostZoomMapImpl::SetZoomLevelForHostAndScheme(const std::string& scheme, | 146 void HostZoomMapImpl::SetZoomLevelForHostAndScheme(const std::string& scheme, |
155 const std::string& host, | 147 const std::string& host, |
156 double level) { | 148 double level) { |
157 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | 149 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
158 { | 150 { |
159 base::AutoLock auto_lock(lock_); | 151 base::AutoLock auto_lock(lock_); |
160 scheme_host_zoom_levels_[scheme][host] = level; | 152 scheme_host_zoom_levels_[scheme][host] = level; |
161 } | 153 } |
162 | 154 |
163 // Notify renderers from this browser context. | 155 SendZoomLevelChange(scheme, host, level); |
164 for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator()); | |
165 !i.IsAtEnd(); i.Advance()) { | |
166 RenderProcessHost* render_process_host = i.GetCurrentValue(); | |
167 if (HostZoomMap::GetForBrowserContext( | |
168 render_process_host->GetBrowserContext()) == this) { | |
169 render_process_host->Send( | |
170 new ViewMsg_SetZoomLevelForCurrentURL(scheme, host, level)); | |
171 } | |
172 } | |
173 | 156 |
174 HostZoomMap::ZoomLevelChange change; | 157 HostZoomMap::ZoomLevelChange change; |
175 change.mode = HostZoomMap::ZOOM_CHANGED_FOR_SCHEME_AND_HOST; | 158 change.mode = HostZoomMap::ZOOM_CHANGED_FOR_SCHEME_AND_HOST; |
176 change.host = host; | 159 change.host = host; |
177 change.scheme = scheme; | 160 change.scheme = scheme; |
178 change.zoom_level = level; | 161 change.zoom_level = level; |
179 | 162 |
180 zoom_level_changed_callbacks_.Notify(change); | 163 zoom_level_changed_callbacks_.Notify(change); |
181 } | 164 } |
182 | 165 |
(...skipping 18 matching lines...) Expand all Loading... |
201 if (temporary_zoom_levels_[i].render_process_id == render_process_id && | 184 if (temporary_zoom_levels_[i].render_process_id == render_process_id && |
202 temporary_zoom_levels_[i].render_view_id == render_view_id) { | 185 temporary_zoom_levels_[i].render_view_id == render_view_id) { |
203 return temporary_zoom_levels_[i].zoom_level; | 186 return temporary_zoom_levels_[i].zoom_level; |
204 } | 187 } |
205 } | 188 } |
206 return 0; | 189 return 0; |
207 } | 190 } |
208 | 191 |
209 void HostZoomMapImpl::SetTemporaryZoomLevel(int render_process_id, | 192 void HostZoomMapImpl::SetTemporaryZoomLevel(int render_process_id, |
210 int render_view_id, | 193 int render_view_id, |
| 194 const std::string& host, |
211 double level) { | 195 double level) { |
212 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | 196 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
213 | 197 |
214 { | 198 { |
215 base::AutoLock auto_lock(lock_); | 199 base::AutoLock auto_lock(lock_); |
216 size_t i; | 200 size_t i; |
217 for (i = 0; i < temporary_zoom_levels_.size(); ++i) { | 201 for (i = 0; i < temporary_zoom_levels_.size(); ++i) { |
218 if (temporary_zoom_levels_[i].render_process_id == render_process_id && | 202 if (temporary_zoom_levels_[i].render_process_id == render_process_id && |
219 temporary_zoom_levels_[i].render_view_id == render_view_id) { | 203 temporary_zoom_levels_[i].render_view_id == render_view_id) { |
220 if (level) { | 204 temporary_zoom_levels_[i].zoom_level = level; |
221 temporary_zoom_levels_[i].zoom_level = level; | |
222 } else { | |
223 temporary_zoom_levels_.erase(temporary_zoom_levels_.begin() + i); | |
224 } | |
225 break; | 205 break; |
226 } | 206 } |
227 } | 207 } |
228 | 208 |
229 if (level && i == temporary_zoom_levels_.size()) { | 209 if (level && i == temporary_zoom_levels_.size()) { |
230 TemporaryZoomLevel temp; | 210 TemporaryZoomLevel temp; |
231 temp.render_process_id = render_process_id; | 211 temp.render_process_id = render_process_id; |
232 temp.render_view_id = render_view_id; | 212 temp.render_view_id = render_view_id; |
233 temp.zoom_level = level; | 213 temp.zoom_level = level; |
234 temporary_zoom_levels_.push_back(temp); | 214 temporary_zoom_levels_.push_back(temp); |
235 } | 215 } |
236 } | 216 } |
237 | 217 |
238 HostZoomMap::ZoomLevelChange change; | 218 HostZoomMap::ZoomLevelChange change; |
239 change.mode = HostZoomMap::ZOOM_CHANGED_TEMPORARY_ZOOM; | 219 change.mode = HostZoomMap::ZOOM_CHANGED_TEMPORARY_ZOOM; |
| 220 change.host = host; |
240 change.zoom_level = level; | 221 change.zoom_level = level; |
241 | 222 |
242 zoom_level_changed_callbacks_.Notify(change); | 223 zoom_level_changed_callbacks_.Notify(change); |
243 } | 224 } |
244 | 225 |
245 void HostZoomMapImpl::Observe(int type, | 226 void HostZoomMapImpl::Observe(int type, |
246 const NotificationSource& source, | 227 const NotificationSource& source, |
247 const NotificationDetails& details) { | 228 const NotificationDetails& details) { |
248 switch (type) { | 229 switch (type) { |
249 case NOTIFICATION_RENDER_VIEW_HOST_WILL_CLOSE_RENDER_VIEW: { | 230 case NOTIFICATION_RENDER_VIEW_HOST_WILL_CLOSE_RENDER_VIEW: { |
250 base::AutoLock auto_lock(lock_); | 231 base::AutoLock auto_lock(lock_); |
251 int render_view_id = Source<RenderViewHost>(source)->GetRoutingID(); | 232 int render_view_id = Source<RenderViewHost>(source)->GetRoutingID(); |
252 int render_process_id = | 233 int render_process_id = |
253 Source<RenderViewHost>(source)->GetProcess()->GetID(); | 234 Source<RenderViewHost>(source)->GetProcess()->GetID(); |
254 | 235 EraseTemporaryZoomLevel(render_process_id, render_view_id); |
255 for (size_t i = 0; i < temporary_zoom_levels_.size(); ++i) { | |
256 if (temporary_zoom_levels_[i].render_process_id == render_process_id && | |
257 temporary_zoom_levels_[i].render_view_id == render_view_id) { | |
258 temporary_zoom_levels_.erase(temporary_zoom_levels_.begin() + i); | |
259 break; | |
260 } | |
261 } | |
262 break; | 236 break; |
263 } | 237 } |
264 default: | 238 default: |
265 NOTREACHED() << "Unexpected preference observed."; | 239 NOTREACHED() << "Unexpected preference observed."; |
266 } | 240 } |
267 } | 241 } |
268 | 242 |
| 243 void HostZoomMapImpl::EraseTemporaryZoomLevel(int render_process_id, |
| 244 int render_view_id) { |
| 245 base::AutoLock auto_lock(lock_); |
| 246 for (size_t i = 0; i < temporary_zoom_levels_.size(); ++i) { |
| 247 if (temporary_zoom_levels_[i].render_process_id == render_process_id && |
| 248 temporary_zoom_levels_[i].render_view_id == render_view_id) { |
| 249 temporary_zoom_levels_.erase(temporary_zoom_levels_.begin() + i); |
| 250 break; |
| 251 } |
| 252 } |
| 253 } |
| 254 |
| 255 void HostZoomMapImpl::SendZoomLevelChange(const std::string& scheme, |
| 256 const std::string& host, |
| 257 double level) { |
| 258 for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator()); |
| 259 !i.IsAtEnd(); i.Advance()) { |
| 260 RenderProcessHost* render_process_host = i.GetCurrentValue(); |
| 261 if (HostZoomMap::GetForBrowserContext( |
| 262 render_process_host->GetBrowserContext()) == this) { |
| 263 int render_process_id = render_process_host->GetID(); |
| 264 std::set<int> exceptions; |
| 265 for (size_t i = 0; i != temporary_zoom_levels_.size(); ++i) { |
| 266 if (temporary_zoom_levels_[i].render_process_id == render_process_id) |
| 267 exceptions.insert(temporary_zoom_levels_[i].render_view_id); |
| 268 } |
| 269 render_process_host->Send(new ViewMsg_SetZoomLevelForCurrentURL( |
| 270 scheme, host, level, exceptions)); |
| 271 } |
| 272 } |
| 273 } |
| 274 |
269 HostZoomMapImpl::~HostZoomMapImpl() { | 275 HostZoomMapImpl::~HostZoomMapImpl() { |
270 } | 276 } |
271 | 277 |
272 } // namespace content | 278 } // namespace content |
OLD | NEW |