src/content/browser/host_zoom_map_impl.cc

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