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 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 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. 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 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 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 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 105 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 111 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 127 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 143 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 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 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 223 double HostZoomMapImpl::GetDefaultZoomLevel() const { 224 return default_zoom_level_; 225 } 226 227 void HostZoomMapImpl::SetDefaultZoomLevel(double level) { 228 default_zoom_level_ = level; 229 } 230 231 scoped_ptr<HostZoomMap::Subscription> 232 HostZoomMapImpl::AddZoomLevelChangedCallback( 233 const ZoomLevelChangedCallback& callback) { 234 return zoom_level_changed_callbacks_.Add(callback); 235 } 236 237 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 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 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 293 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 301 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 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 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 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 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 385 HostZoomMapImpl::~HostZoomMapImpl() { 386 } 387 388 } // namespace content 389
