src/chrome/browser/ui/zoom/zoom_controller.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 "chrome/browser/ui/zoom/zoom_controller.h"
   6
   7 #include "chrome/browser/ui/sad_tab.h"
   8 #include "chrome/browser/ui/zoom/zoom_event_manager.h"
   9 #include "chrome/browser/ui/zoom/zoom_observer.h"
  10 #include "content/public/browser/host_zoom_map.h"
  11 #include "content/public/browser/navigation_details.h"
  12 #include "content/public/browser/navigation_entry.h"
  13 #include "content/public/browser/render_process_host.h"
  14 #include "content/public/browser/render_view_host.h"
  15 #include "content/public/browser/web_contents.h"
  16 #include "content/public/common/page_type.h"
  17 #include "content/public/common/page_zoom.h"
  18 #include "extensions/common/extension.h"
  19 #include "grit/theme_resources.h"
  20 #include "net/base/net_util.h"
  21
  22 DEFINE_WEB_CONTENTS_USER_DATA_KEY(ZoomController);
  23
  24 ZoomController::ZoomController(content::WebContents* web_contents)
  25     : content::WebContentsObserver(web_contents),
  26       can_show_bubble_(true),
  27       zoom_mode_(ZOOM_MODE_DEFAULT),
  28       zoom_level_(1.0),
  29       browser_context_(web_contents->GetBrowserContext()) {
  30   // TODO(wjmaclean) Make calls to HostZoomMap::GetDefaultForBrowserContext()
  31   // refer to the webcontents-specific HostZoomMap when that becomes available.
  32   content::HostZoomMap* host_zoom_map =
  33       content::HostZoomMap::GetDefaultForBrowserContext(browser_context_);
  34   zoom_level_ = host_zoom_map->GetDefaultZoomLevel();
  35
  36   zoom_subscription_ = host_zoom_map->AddZoomLevelChangedCallback(
  37       base::Bind(&ZoomController::OnZoomLevelChanged, base::Unretained(this)));
  38
  39   UpdateState(std::string());
  40 }
  41
  42 ZoomController::~ZoomController() {}
  43
  44 bool ZoomController::IsAtDefaultZoom() const {
  45   return content::ZoomValuesEqual(GetZoomLevel(), GetDefaultZoomLevel());
  46 }
  47
  48 int ZoomController::GetResourceForZoomLevel() const {
  49   if (IsAtDefaultZoom())
  50     return IDR_ZOOM_NORMAL;
  51   return GetZoomLevel() > GetDefaultZoomLevel() ? IDR_ZOOM_PLUS
  52                                                 : IDR_ZOOM_MINUS;
  53 }
  54
  55 void ZoomController::AddObserver(ZoomObserver* observer) {
  56   observers_.AddObserver(observer);
  57 }
  58
  59 void ZoomController::RemoveObserver(ZoomObserver* observer) {
  60   observers_.RemoveObserver(observer);
  61 }
  62
  63 double ZoomController::GetZoomLevel() const {
  64   return zoom_mode_ == ZOOM_MODE_MANUAL ?
  65              zoom_level_:
  66              content::HostZoomMap::GetZoomLevel(web_contents());
  67 }
  68
  69 int ZoomController::GetZoomPercent() const {
  70   double zoom_factor = content::ZoomLevelToZoomFactor(GetZoomLevel());
  71   // Round double for return.
  72   return static_cast<int>(zoom_factor * 100 + 0.5);
  73 }
  74
  75 bool ZoomController::SetZoomLevel(double zoom_level) {
  76   // An extension did not initiate this zoom change.
  77   return SetZoomLevelByExtension(zoom_level, NULL);
  78 }
  79
  80 bool ZoomController::SetZoomLevelByExtension(
  81     double zoom_level,
  82     const scoped_refptr<const extensions::Extension>& extension) {
  83   content::NavigationEntry* entry =
  84       web_contents()->GetController().GetLastCommittedEntry();
  85   // Cannot zoom in disabled mode. Also, don't allow changing zoom level on
  86   // a crashed tab, an error page or an interstitial page.
  87   if (zoom_mode_ == ZOOM_MODE_DISABLED ||
  88       !web_contents()->GetRenderViewHost()->IsRenderViewLive())
  89     return false;
  90
  91   // Store extension data so that |extension| can be attributed when the zoom
  92   // change completes. We expect that by the time this function returns that
  93   // any observers that require this information will have requested it.
  94   last_extension_ = extension;
  95
  96   // Do not actually rescale the page in manual mode.
  97   if (zoom_mode_ == ZOOM_MODE_MANUAL) {
  98     double old_zoom_level = zoom_level_;
  99     zoom_level_ = zoom_level;
 100
 101     // TODO(wjmaclean) Do we care about filling in host/scheme here?
 102     content::HostZoomMap::ZoomLevelChange change;
 103     change.mode = content::HostZoomMap::ZOOM_CHANGED_TEMPORARY_ZOOM;
 104     change.zoom_level = zoom_level;
 105     ZoomEventManager::GetForBrowserContext(browser_context_)->
 106         OnZoomLevelChanged(change);
 107
 108     ZoomChangedEventData zoom_change_data(web_contents(),
 109                                           old_zoom_level,
 110                                           zoom_level_,
 111                                           zoom_mode_,
 112                                           false /* can_show_bubble */);
 113     FOR_EACH_OBSERVER(
 114         ZoomObserver, observers_, OnZoomChanged(zoom_change_data));
 115
 116     last_extension_ = NULL;
 117     return true;
 118   }
 119
 120   content::HostZoomMap* zoom_map =
 121       content::HostZoomMap::GetDefaultForBrowserContext(browser_context_);
 122   DCHECK(zoom_map);
 123   DCHECK(!event_data_);
 124   event_data_.reset(new ZoomChangedEventData(web_contents(),
 125                                              GetZoomLevel(),
 126                                              zoom_level,
 127                                              zoom_mode_,
 128                                              false /* can_show_bubble */));
 129   int render_process_id = web_contents()->GetRenderProcessHost()->GetID();
 130   int render_view_id = web_contents()->GetRenderViewHost()->GetRoutingID();
 131   if (zoom_mode_ == ZOOM_MODE_ISOLATED ||
 132       zoom_map->UsesTemporaryZoomLevel(render_process_id, render_view_id)) {
 133     zoom_map->SetTemporaryZoomLevel(
 134         render_process_id, render_view_id, zoom_level);
 135   } else {
 136     if (!entry) {
 137       last_extension_ = NULL;
 138       return false;
 139     }
 140     std::string host =
 141         net::GetHostOrSpecFromURL(content::HostZoomMap::GetURLFromEntry(entry));
 142     zoom_map->SetZoomLevelForHost(host, zoom_level);
 143   }
 144
 145   DCHECK(!event_data_);
 146   last_extension_ = NULL;
 147   return true;
 148 }
 149
 150 void ZoomController::SetZoomMode(ZoomMode new_mode) {
 151   if (new_mode == zoom_mode_)
 152     return;
 153
 154   content::HostZoomMap* zoom_map =
 155       content::HostZoomMap::GetDefaultForBrowserContext(browser_context_);
 156   DCHECK(zoom_map);
 157   int render_process_id = web_contents()->GetRenderProcessHost()->GetID();
 158   int render_view_id = web_contents()->GetRenderViewHost()->GetRoutingID();
 159   double original_zoom_level = GetZoomLevel();
 160
 161   DCHECK(!event_data_);
 162   event_data_.reset(new ZoomChangedEventData(web_contents(),
 163                                              original_zoom_level,
 164                                              original_zoom_level,
 165                                              new_mode,
 166                                              new_mode != ZOOM_MODE_DEFAULT));
 167
 168   switch (new_mode) {
 169     case ZOOM_MODE_DEFAULT: {
 170       content::NavigationEntry* entry =
 171           web_contents()->GetController().GetLastCommittedEntry();
 172
 173       if (entry) {
 174         GURL url = content::HostZoomMap::GetURLFromEntry(entry);
 175         std::string host = net::GetHostOrSpecFromURL(url);
 176
 177         if (zoom_map->HasZoomLevel(url.scheme(), host)) {
 178           // If there are other tabs with the same origin, then set this tab's
 179           // zoom level to match theirs. The temporary zoom level will be
 180           // cleared below, but this call will make sure this tab re-draws at
 181           // the correct zoom level.
 182           double origin_zoom_level =
 183               zoom_map->GetZoomLevelForHostAndScheme(url.scheme(), host);
 184           event_data_->new_zoom_level = origin_zoom_level;
 185           zoom_map->SetTemporaryZoomLevel(
 186               render_process_id, render_view_id, origin_zoom_level);
 187         } else {
 188           // The host will need a level prior to removing the temporary level.
 189           // We don't want the zoom level to change just because we entered
 190           // default mode.
 191           zoom_map->SetZoomLevelForHost(host, original_zoom_level);
 192         }
 193       }
 194       // Remove per-tab zoom data for this tab. No event callback expected.
 195       zoom_map->ClearTemporaryZoomLevel(render_process_id, render_view_id);
 196       break;
 197     }
 198     case ZOOM_MODE_ISOLATED: {
 199       // Unless the zoom mode was |ZOOM_MODE_DISABLED| before this call, the
 200       // page needs an initial isolated zoom back to the same level it was at
 201       // in the other mode.
 202       if (zoom_mode_ != ZOOM_MODE_DISABLED) {
 203         zoom_map->SetTemporaryZoomLevel(
 204             render_process_id, render_view_id, original_zoom_level);
 205       } else {
 206         // When we don't call any HostZoomMap set functions, we send the event
 207         // manually.
 208         FOR_EACH_OBSERVER(
 209             ZoomObserver, observers_, OnZoomChanged(*event_data_));
 210         event_data_.reset();
 211       }
 212       break;
 213     }
 214     case ZOOM_MODE_MANUAL: {
 215       // Unless the zoom mode was |ZOOM_MODE_DISABLED| before this call, the
 216       // page needs to be resized to the default zoom. While in manual mode,
 217       // the zoom level is handled independently.
 218       if (zoom_mode_ != ZOOM_MODE_DISABLED) {
 219         zoom_map->SetTemporaryZoomLevel(
 220             render_process_id, render_view_id, GetDefaultZoomLevel());
 221         zoom_level_ = original_zoom_level;
 222       } else {
 223         // When we don't call any HostZoomMap set functions, we send the event
 224         // manually.
 225         FOR_EACH_OBSERVER(
 226             ZoomObserver, observers_, OnZoomChanged(*event_data_));
 227         event_data_.reset();
 228       }
 229       break;
 230     }
 231     case ZOOM_MODE_DISABLED: {
 232       // The page needs to be zoomed back to default before disabling the zoom
 233       zoom_map->SetTemporaryZoomLevel(
 234           render_process_id, render_view_id, GetDefaultZoomLevel());
 235       break;
 236     }
 237   }
 238   // Any event data we've stored should have been consumed by this point.
 239   DCHECK(!event_data_);
 240
 241   zoom_mode_ = new_mode;
 242 }
 243
 244 void ZoomController::DidNavigateMainFrame(
 245     const content::LoadCommittedDetails& details,
 246     const content::FrameNavigateParams& params) {
 247   if (details.entry && details.entry->GetPageType() == content::PAGE_TYPE_ERROR)
 248     content::HostZoomMap::SendErrorPageZoomLevelRefresh(web_contents());
 249
 250   // If the main frame's content has changed, the new page may have a different
 251   // zoom level from the old one.
 252   UpdateState(std::string());
 253 }
 254
 255 void ZoomController::WebContentsDestroyed() {
 256   // At this point we should no longer be sending any zoom events with this
 257   // WebContents.
 258   observers_.Clear();
 259 }
 260
 261 void ZoomController::OnZoomLevelChanged(
 262     const content::HostZoomMap::ZoomLevelChange& change) {
 263   UpdateState(change.host);
 264 }
 265
 266 void ZoomController::UpdateState(const std::string& host) {
 267   // If |host| is empty, all observers should be updated.
 268   if (!host.empty()) {
 269     // Use the navigation entry's URL instead of the WebContents' so virtual
 270     // URLs work (e.g. chrome://settings). http://crbug.com/153950
 271     content::NavigationEntry* entry =
 272         web_contents()->GetController().GetLastCommittedEntry();
 273     if (!entry ||
 274         host != net::GetHostOrSpecFromURL(
 275                     content::HostZoomMap::GetURLFromEntry(entry))) {
 276       return;
 277     }
 278   }
 279
 280   // The zoom bubble should not be shown for zoom changes where the host is
 281   // empty.
 282   bool can_show_bubble = can_show_bubble_ && !host.empty();
 283
 284   if (event_data_) {
 285     // For state changes initiated within the ZoomController, information about
 286     // the change should be sent.
 287     ZoomChangedEventData zoom_change_data = *event_data_;
 288     event_data_.reset();
 289     zoom_change_data.can_show_bubble = can_show_bubble;
 290     FOR_EACH_OBSERVER(
 291         ZoomObserver, observers_, OnZoomChanged(zoom_change_data));
 292   } else {
 293     // TODO(wjmaclean) Should we consider having HostZoomMap send both old and
 294     // new zoom levels here?
 295     double zoom_level = GetZoomLevel();
 296     ZoomChangedEventData zoom_change_data(
 297         web_contents(), zoom_level, zoom_level, zoom_mode_, can_show_bubble);
 298     FOR_EACH_OBSERVER(
 299         ZoomObserver, observers_, OnZoomChanged(zoom_change_data));
 300   }
 301 }