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
3 // found in the LICENSE file.
4
5 #include "content/browser/host_zoom_map_impl.h"
6
7 #include <algorithm>
8 #include <cmath>
9
10 #include "base/strings/string_piece.h"
11 #include "base/strings/utf_string_conversions.h"
12 #include "base/values.h"
13 #include "content/browser/frame_host/navigation_entry_impl.h"
14 #include "content/browser/renderer_host/render_process_host_impl.h"
15 #include "content/browser/renderer_host/render_view_host_impl.h"
16 #include "content/browser/web_contents/web_contents_impl.h"
17 #include "content/common/view_messages.h"
18 #include "content/public/browser/browser_context.h"
19 #include "content/public/browser/browser_thread.h"
20 #include "content/public/browser/notification_service.h"
21 #include "content/public/browser/notification_types.h"
22 #include "content/public/browser/resource_context.h"
23 #include "content/public/common/page_zoom.h"
24 #include "net/base/net_util.h"
25
26 static const char* kHostZoomMapKeyName = "content_host_zoom_map";
27
28 namespace content {
29
30 namespace {
31
GetHostFromProcessView(int render_process_id,int render_view_id)32 std::string GetHostFromProcessView(int render_process_id, int render_view_id) {
33 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
34 RenderViewHost* render_view_host =
35 RenderViewHost::FromID(render_process_id, render_view_id);
36 if (!render_view_host)
37 return std::string();
38
39 WebContents* web_contents = WebContents::FromRenderViewHost(render_view_host);
40
41 NavigationEntry* entry =
42 web_contents->GetController().GetLastCommittedEntry();
43 if (!entry)
44 return std::string();
45
46 return net::GetHostOrSpecFromURL(entry->GetURL());
47 }
48
49 } // namespace
50
GetForBrowserContext(BrowserContext * context)51 HostZoomMap* HostZoomMap::GetForBrowserContext(BrowserContext* context) {
52 HostZoomMapImpl* rv = static_cast<HostZoomMapImpl*>(
53 context->GetUserData(kHostZoomMapKeyName));
54 if (!rv) {
55 rv = new HostZoomMapImpl();
56 context->SetUserData(kHostZoomMapKeyName, rv);
57 }
58 return rv;
59 }
60
61 // Helper function for setting/getting zoom levels for WebContents without
62 // having to import HostZoomMapImpl everywhere.
GetZoomLevel(const WebContents * web_contents)63 double HostZoomMap::GetZoomLevel(const WebContents* web_contents) {
64 HostZoomMapImpl* host_zoom_map = static_cast<HostZoomMapImpl*>(
65 HostZoomMap::GetForBrowserContext(web_contents->GetBrowserContext()));
66 return host_zoom_map->GetZoomLevelForWebContents(
67 *static_cast<const WebContentsImpl*>(web_contents));
68 }
69
SetZoomLevel(const WebContents * web_contents,double level)70 void HostZoomMap::SetZoomLevel(const WebContents* web_contents, double level) {
71 HostZoomMapImpl* host_zoom_map = static_cast<HostZoomMapImpl*>(
72 HostZoomMap::GetForBrowserContext(web_contents->GetBrowserContext()));
73 host_zoom_map->SetZoomLevelForWebContents(
74 *static_cast<const WebContentsImpl*>(web_contents), level);
75 }
76
HostZoomMapImpl()77 HostZoomMapImpl::HostZoomMapImpl()
78 : default_zoom_level_(0.0) {
79 registrar_.Add(
80 this, NOTIFICATION_RENDER_VIEW_HOST_WILL_CLOSE_RENDER_VIEW,
81 NotificationService::AllSources());
82 }
83
CopyFrom(HostZoomMap * copy_interface)84 void HostZoomMapImpl::CopyFrom(HostZoomMap* copy_interface) {
85 // This can only be called on the UI thread to avoid deadlocks, otherwise
86 // UI: a.CopyFrom(b);
87 // IO: b.CopyFrom(a);
88 // can deadlock.
89 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
90 HostZoomMapImpl* copy = static_cast<HostZoomMapImpl*>(copy_interface);
91 base::AutoLock auto_lock(lock_);
92 base::AutoLock copy_auto_lock(copy->lock_);
93 host_zoom_levels_.
94 insert(copy->host_zoom_levels_.begin(), copy->host_zoom_levels_.end());
95 for (SchemeHostZoomLevels::const_iterator i(copy->
96 scheme_host_zoom_levels_.begin());
97 i != copy->scheme_host_zoom_levels_.end(); ++i) {
98 scheme_host_zoom_levels_[i->first] = HostZoomLevels();
99 scheme_host_zoom_levels_[i->first].
100 insert(i->second.begin(), i->second.end());
101 }
102 default_zoom_level_ = copy->default_zoom_level_;
103 }
104
GetZoomLevelForHost(const std::string & host) const105 double HostZoomMapImpl::GetZoomLevelForHost(const std::string& host) const {
106 base::AutoLock auto_lock(lock_);
107 HostZoomLevels::const_iterator i(host_zoom_levels_.find(host));
108 return (i == host_zoom_levels_.end()) ? default_zoom_level_ : i->second;
109 }
110
HasZoomLevel(const std::string & scheme,const std::string & host) const111 bool HostZoomMapImpl::HasZoomLevel(const std::string& scheme,
112 const std::string& host) const {
113 base::AutoLock auto_lock(lock_);
114
115 SchemeHostZoomLevels::const_iterator scheme_iterator(
116 scheme_host_zoom_levels_.find(scheme));
117
118 const HostZoomLevels& zoom_levels =
119 (scheme_iterator != scheme_host_zoom_levels_.end())
120 ? scheme_iterator->second
121 : host_zoom_levels_;
122
123 HostZoomLevels::const_iterator i(zoom_levels.find(host));
124 return i != zoom_levels.end();
125 }
126
GetZoomLevelForHostAndScheme(const std::string & scheme,const std::string & host) const127 double HostZoomMapImpl::GetZoomLevelForHostAndScheme(
128 const std::string& scheme,
129 const std::string& host) const {
130 {
131 base::AutoLock auto_lock(lock_);
132 SchemeHostZoomLevels::const_iterator scheme_iterator(
133 scheme_host_zoom_levels_.find(scheme));
134 if (scheme_iterator != scheme_host_zoom_levels_.end()) {
135 HostZoomLevels::const_iterator i(scheme_iterator->second.find(host));
136 if (i != scheme_iterator->second.end())
137 return i->second;
138 }
139 }
140 return GetZoomLevelForHost(host);
141 }
142
GetAllZoomLevels() const143 HostZoomMap::ZoomLevelVector HostZoomMapImpl::GetAllZoomLevels() const {
144 HostZoomMap::ZoomLevelVector result;
145 {
146 base::AutoLock auto_lock(lock_);
147 result.reserve(host_zoom_levels_.size() + scheme_host_zoom_levels_.size());
148 for (HostZoomLevels::const_iterator i = host_zoom_levels_.begin();
149 i != host_zoom_levels_.end();
150 ++i) {
151 ZoomLevelChange change = {HostZoomMap::ZOOM_CHANGED_FOR_HOST,
152 i->first, // host
153 std::string(), // scheme
154 i->second // zoom level
155 };
156 result.push_back(change);
157 }
158 for (SchemeHostZoomLevels::const_iterator i =
159 scheme_host_zoom_levels_.begin();
160 i != scheme_host_zoom_levels_.end();
161 ++i) {
162 const std::string& scheme = i->first;
163 const HostZoomLevels& host_zoom_levels = i->second;
164 for (HostZoomLevels::const_iterator j = host_zoom_levels.begin();
165 j != host_zoom_levels.end();
166 ++j) {
167 ZoomLevelChange change = {HostZoomMap::ZOOM_CHANGED_FOR_SCHEME_AND_HOST,
168 j->first, // host
169 scheme, // scheme
170 j->second // zoom level
171 };
172 result.push_back(change);
173 }
174 }
175 }
176 return result;
177 }
178
SetZoomLevelForHost(const std::string & host,double level)179 void HostZoomMapImpl::SetZoomLevelForHost(const std::string& host,
180 double level) {
181 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
182
183 {
184 base::AutoLock auto_lock(lock_);
185
186 if (ZoomValuesEqual(level, default_zoom_level_))
187 host_zoom_levels_.erase(host);
188 else
189 host_zoom_levels_[host] = level;
190 }
191
192 // TODO(wjmaclean) Should we use a GURL here? crbug.com/384486
193 SendZoomLevelChange(std::string(), host, level);
194
195 HostZoomMap::ZoomLevelChange change;
196 change.mode = HostZoomMap::ZOOM_CHANGED_FOR_HOST;
197 change.host = host;
198 change.zoom_level = level;
199
200 zoom_level_changed_callbacks_.Notify(change);
201 }
202
SetZoomLevelForHostAndScheme(const std::string & scheme,const std::string & host,double level)203 void HostZoomMapImpl::SetZoomLevelForHostAndScheme(const std::string& scheme,
204 const std::string& host,
205 double level) {
206 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
207 {
208 base::AutoLock auto_lock(lock_);
209 scheme_host_zoom_levels_[scheme][host] = level;
210 }
211
212 SendZoomLevelChange(scheme, host, level);
213
214 HostZoomMap::ZoomLevelChange change;
215 change.mode = HostZoomMap::ZOOM_CHANGED_FOR_SCHEME_AND_HOST;
216 change.host = host;
217 change.scheme = scheme;
218 change.zoom_level = level;
219
220 zoom_level_changed_callbacks_.Notify(change);
221 }
222
GetDefaultZoomLevel() const223 double HostZoomMapImpl::GetDefaultZoomLevel() const {
224 return default_zoom_level_;
225 }
226
SetDefaultZoomLevel(double level)227 void HostZoomMapImpl::SetDefaultZoomLevel(double level) {
228 default_zoom_level_ = level;
229 }
230
231 scoped_ptr<HostZoomMap::Subscription>
AddZoomLevelChangedCallback(const ZoomLevelChangedCallback & callback)232 HostZoomMapImpl::AddZoomLevelChangedCallback(
233 const ZoomLevelChangedCallback& callback) {
234 return zoom_level_changed_callbacks_.Add(callback);
235 }
236
GetZoomLevelForWebContents(const WebContentsImpl & web_contents_impl) const237 double HostZoomMapImpl::GetZoomLevelForWebContents(
238 const WebContentsImpl& web_contents_impl) const {
239 int render_process_id = web_contents_impl.GetRenderProcessHost()->GetID();
240 int routing_id = web_contents_impl.GetRenderViewHost()->GetRoutingID();
241
242 if (UsesTemporaryZoomLevel(render_process_id, routing_id))
243 return GetTemporaryZoomLevel(render_process_id, routing_id);
244
245 // Get the url from the navigation controller directly, as calling
246 // WebContentsImpl::GetLastCommittedURL() may give us a virtual url that
247 // is different than is stored in the map.
248 GURL url;
249 NavigationEntry* entry =
250 web_contents_impl.GetController().GetLastCommittedEntry();
251 // It is possible for a WebContent's zoom level to be queried before
252 // a navigation has occurred.
253 if (entry)
254 url = entry->GetURL();
255 return GetZoomLevelForHostAndScheme(url.scheme(),
256 net::GetHostOrSpecFromURL(url));
257 }
258
SetZoomLevelForWebContents(const WebContentsImpl & web_contents_impl,double level)259 void HostZoomMapImpl::SetZoomLevelForWebContents(
260 const WebContentsImpl& web_contents_impl,
261 double level) {
262 int render_process_id = web_contents_impl.GetRenderProcessHost()->GetID();
263 int render_view_id = web_contents_impl.GetRenderViewHost()->GetRoutingID();
264 if (UsesTemporaryZoomLevel(render_process_id, render_view_id)) {
265 SetTemporaryZoomLevel(render_process_id, render_view_id, level);
266 } else {
267 // Get the url from the navigation controller directly, as calling
268 // WebContentsImpl::GetLastCommittedURL() may give us a virtual url that
269 // is different than what the render view is using. If the two don't match,
270 // the attempt to set the zoom will fail.
271 NavigationEntry* entry =
272 web_contents_impl.GetController().GetLastCommittedEntry();
273 // Tests may invoke this function with a null entry, but we don't
274 // want to save zoom levels in this case.
275 if (!entry)
276 return;
277
278 GURL url = entry->GetURL();
279 SetZoomLevelForHost(net::GetHostOrSpecFromURL(url), level);
280 }
281 }
282
SetZoomLevelForView(int render_process_id,int render_view_id,double level,const std::string & host)283 void HostZoomMapImpl::SetZoomLevelForView(int render_process_id,
284 int render_view_id,
285 double level,
286 const std::string& host) {
287 if (UsesTemporaryZoomLevel(render_process_id, render_view_id))
288 SetTemporaryZoomLevel(render_process_id, render_view_id, level);
289 else
290 SetZoomLevelForHost(host, level);
291 }
292
UsesTemporaryZoomLevel(int render_process_id,int render_view_id) const293 bool HostZoomMapImpl::UsesTemporaryZoomLevel(int render_process_id,
294 int render_view_id) const {
295 RenderViewKey key(render_process_id, render_view_id);
296
297 base::AutoLock auto_lock(lock_);
298 return ContainsKey(temporary_zoom_levels_, key);
299 }
300
GetTemporaryZoomLevel(int render_process_id,int render_view_id) const301 double HostZoomMapImpl::GetTemporaryZoomLevel(int render_process_id,
302 int render_view_id) const {
303 base::AutoLock auto_lock(lock_);
304 RenderViewKey key(render_process_id, render_view_id);
305 if (!ContainsKey(temporary_zoom_levels_, key))
306 return 0;
307
308 return temporary_zoom_levels_.find(key)->second;
309 }
310
SetTemporaryZoomLevel(int render_process_id,int render_view_id,double level)311 void HostZoomMapImpl::SetTemporaryZoomLevel(int render_process_id,
312 int render_view_id,
313 double level) {
314 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
315
316 {
317 RenderViewKey key(render_process_id, render_view_id);
318 base::AutoLock auto_lock(lock_);
319 temporary_zoom_levels_[key] = level;
320 }
321
322 RenderViewHost* host =
323 RenderViewHost::FromID(render_process_id, render_view_id);
324 host->Send(new ViewMsg_SetZoomLevelForView(render_view_id, true, level));
325
326 HostZoomMap::ZoomLevelChange change;
327 change.mode = HostZoomMap::ZOOM_CHANGED_TEMPORARY_ZOOM;
328 change.host = GetHostFromProcessView(render_process_id, render_view_id);
329 change.zoom_level = level;
330
331 zoom_level_changed_callbacks_.Notify(change);
332 }
333
Observe(int type,const NotificationSource & source,const NotificationDetails & details)334 void HostZoomMapImpl::Observe(int type,
335 const NotificationSource& source,
336 const NotificationDetails& details) {
337 switch (type) {
338 case NOTIFICATION_RENDER_VIEW_HOST_WILL_CLOSE_RENDER_VIEW: {
339 int render_view_id = Source<RenderViewHost>(source)->GetRoutingID();
340 int render_process_id =
341 Source<RenderViewHost>(source)->GetProcess()->GetID();
342 ClearTemporaryZoomLevel(render_process_id, render_view_id);
343 break;
344 }
345 default:
346 NOTREACHED() << "Unexpected preference observed.";
347 }
348 }
349
ClearTemporaryZoomLevel(int render_process_id,int render_view_id)350 void HostZoomMapImpl::ClearTemporaryZoomLevel(int render_process_id,
351 int render_view_id) {
352 {
353 base::AutoLock auto_lock(lock_);
354 RenderViewKey key(render_process_id, render_view_id);
355 TemporaryZoomLevels::iterator it = temporary_zoom_levels_.find(key);
356 if (it == temporary_zoom_levels_.end())
357 return;
358 temporary_zoom_levels_.erase(it);
359 }
360 RenderViewHost* host =
361 RenderViewHost::FromID(render_process_id, render_view_id);
362 DCHECK(host);
363 // Send a new zoom level, host-specific if one exists.
364 host->Send(new ViewMsg_SetZoomLevelForView(
365 render_view_id,
366 false,
367 GetZoomLevelForHost(
368 GetHostFromProcessView(render_process_id, render_view_id))));
369 }
370
SendZoomLevelChange(const std::string & scheme,const std::string & host,double level)371 void HostZoomMapImpl::SendZoomLevelChange(const std::string& scheme,
372 const std::string& host,
373 double level) {
374 for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
375 !i.IsAtEnd(); i.Advance()) {
376 RenderProcessHost* render_process_host = i.GetCurrentValue();
377 if (HostZoomMap::GetForBrowserContext(
378 render_process_host->GetBrowserContext()) == this) {
379 render_process_host->Send(
380 new ViewMsg_SetZoomLevelForCurrentURL(scheme, host, level));
381 }
382 }
383 }
384
~HostZoomMapImpl()385 HostZoomMapImpl::~HostZoomMapImpl() {
386 }
387
388 } // namespace content
389