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