Add setting to isolate zoom changes by default.

components/zoom/zoom_controller.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/zoom/zoom_controller.h"
 
 #include "components/zoom/zoom_event_manager.h"
 #include "components/zoom/zoom_observer.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/host_zoom_map.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/page_type.h"
 #include "content/public/common/page_zoom.h"
 #include "net/base/url_util.h"
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(zoom::ZoomController);
 
 namespace zoom {
 
 double ZoomController::GetZoomLevelForWebContents(
     const content::WebContents* web_contents) {
   if (!web_contents)
     return 0.0;
 
   auto* zoom_controller = FromWebContents(web_contents);
   if (zoom_controller)
     return zoom_controller->GetZoomLevel();
 
   return content::HostZoomMap::GetZoomLevel(web_contents);
 }
 
 ZoomController::ZoomController(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       can_show_bubble_(true),
-      zoom_mode_(ZOOM_MODE_DEFAULT),
+      default_per_origin_(true),
       zoom_level_(1.0),
       browser_context_(web_contents->GetBrowserContext()) {
   host_zoom_map_ = content::HostZoomMap::GetForWebContents(web_contents);
   zoom_level_ = host_zoom_map_->GetDefaultZoomLevel();
 
+  // TODO Should we use GetStoragePartition with the SiteInstance?

[wjmaclean, 2017/01/19 21:09:05]

If we have the SiteInstance, then it's preferable to get the StoragePartition
using it.

[Kevin McNee, 2017/02/03 20:11:54]

Done.

+  content::ZoomLevelDelegate* zoom_level_delegate =
+      content::BrowserContext::GetDefaultStoragePartition(browser_context_)
+          ->GetZoomLevelDelegate();
+  if (zoom_level_delegate) {
+    default_per_origin_ = zoom_level_delegate->GetIsOriginScopePref();
+    default_zoom_scope_subscription_ =
+        zoom_level_delegate->RegisterDefaultZoomScopeCallback(
+            base::Bind(&ZoomController::OnDefaultZoomScopeChanged,
+                       base::Unretained(this)));

[wjmaclean, 2017/01/19 21:09:05]

Is this safe? What if the WebContents that owns us goes away while the
prefs-delegate is in the process of sending notifications? (Can that happen?)

[Kevin McNee, 2017/02/01 20:29:40]

Good point. Once this ZoomController is destroyed our subscription will be
destroyed, so we don't have to worry about notifications after that even if it's
in the process of sending notifications.

However, if the WebContents's destructor is interrupted and a notification
occurs before the ZoomController is destroyed, then we'll be in trouble when we
access the WebContents (although our existing HostZoomMap subscription would
have the same issue).

To be safe, we could manually destroy our subscription during
WebContentsDestroyed. The WebContents still appears to be valid at that point.

[Kevin McNee, 2017/02/03 20:11:54]

Done.

+  }
+  zoom_mode_ = default_per_origin_ ? ZOOM_MODE_DEFAULT : ZOOM_MODE_ISOLATED;
+
+  // When in isolated zoom, a temporary zoom level needs to be set to override
+  // any existing per-host zoom levels.
+  // If this WebContents is a clone of another, don't overwrite the temporary
+  // level we've inherited.
+  int render_process_id = web_contents->GetRenderProcessHost()->GetID();
+  int render_view_id = web_contents->GetRenderViewHost()->GetRoutingID();
+  if (zoom_mode_ == ZOOM_MODE_ISOLATED &&
+      !host_zoom_map_->UsesTemporaryZoomLevel(render_process_id,
+                                              render_view_id)) {
+    host_zoom_map_->SetTemporaryZoomLevel(render_process_id, render_view_id,
+                                          zoom_level_);
+  }
+
   zoom_subscription_ = host_zoom_map_->AddZoomLevelChangedCallback(
       base::Bind(&ZoomController::OnZoomLevelChanged, base::Unretained(this)));
 
   UpdateState(std::string());
 }
 
 ZoomController::~ZoomController() {}
 
 bool ZoomController::IsAtDefaultZoom() const {
   return content::ZoomValuesEqual(GetZoomLevel(), GetDefaultZoomLevel());
@@ skipping 118 matching lines @@
   content::HostZoomMap* zoom_map =
       content::HostZoomMap::GetForWebContents(web_contents());
   DCHECK(zoom_map);
   int render_process_id = web_contents()->GetRenderProcessHost()->GetID();
   int render_view_id = web_contents()->GetRenderViewHost()->GetRoutingID();
   double original_zoom_level = GetZoomLevel();
 
   DCHECK(!event_data_);
   event_data_.reset(new ZoomChangedEventData(
       web_contents(), original_zoom_level, original_zoom_level, new_mode,
-      new_mode != ZOOM_MODE_DEFAULT));
+      new_mode !=
+          (default_per_origin_ ? ZOOM_MODE_DEFAULT : ZOOM_MODE_ISOLATED)));
 
   switch (new_mode) {
     case ZOOM_MODE_DEFAULT: {
       content::NavigationEntry* entry =
           web_contents()->GetController().GetLastCommittedEntry();
 
       if (entry) {
         GURL url = content::HostZoomMap::GetURLFromEntry(entry);
         std::string host = net::GetHostOrSpecFromURL(url);
 
@@ skipping 60 matching lines @@
       break;
     }
   }
   // Any event data we've stored should have been consumed by this point.
   DCHECK(!event_data_);
 
   zoom_mode_ = new_mode;
 }
 
 void ZoomController::ResetZoomModeOnNavigationIfNeeded(const GURL& url) {
-  if (zoom_mode_ != ZOOM_MODE_ISOLATED && zoom_mode_ != ZOOM_MODE_MANUAL)
+  if ((!default_per_origin_ || zoom_mode_ != ZOOM_MODE_ISOLATED) &&
+      zoom_mode_ != ZOOM_MODE_MANUAL)
     return;
 
   int render_process_id = web_contents()->GetRenderProcessHost()->GetID();
   int render_view_id = web_contents()->GetRenderViewHost()->GetRoutingID();
   content::HostZoomMap* zoom_map =
       content::HostZoomMap::GetForWebContents(web_contents());
+  double old_zoom_level = GetZoomLevel();
+  // Set |zoom_level_| after calling GetZoomLevel() so we get the correct old
+  // zoom level if we're resetting from manual.
   zoom_level_ = zoom_map->GetDefaultZoomLevel();
-  double old_zoom_level = zoom_map->GetZoomLevel(web_contents());
-  double new_zoom_level = zoom_map->GetZoomLevelForHostAndScheme(
-      url.scheme(), net::GetHostOrSpecFromURL(url));
+  ZoomMode new_mode;
+  double new_zoom_level;
+  if (default_per_origin_) {
+    new_mode = ZOOM_MODE_DEFAULT;
+    new_zoom_level = zoom_map->GetZoomLevelForHostAndScheme(
+        url.scheme(), net::GetHostOrSpecFromURL(url));
+  } else {
+    new_mode = ZOOM_MODE_ISOLATED;
+    new_zoom_level = zoom_level_;
+  }
   event_data_.reset(new ZoomChangedEventData(web_contents(), old_zoom_level,
-                                             new_zoom_level, ZOOM_MODE_DEFAULT,
+                                             new_zoom_level, new_mode,
                                              false /* can_show_bubble */));
-  // The call to ClearTemporaryZoomLevel() doesn't generate any events from
-  // HostZoomMap, but the call to UpdateState() at the end of this function
-  // will notify our observers.
-  // Note: it's possible the render_process/view ids have disappeared (e.g.
-  // if we navigated to a new origin), but this won't cause a problem in the
-  // call below.
-  zoom_map->ClearTemporaryZoomLevel(render_process_id, render_view_id);
-  zoom_mode_ = ZOOM_MODE_DEFAULT;
+  if (default_per_origin_) {
+    // The call to ClearTemporaryZoomLevel() doesn't generate any events from
+    // HostZoomMap, but the call to UpdateState() at the end of this function
+    // will notify our observers.
+    // Note: it's possible the render_process/view ids have disappeared (e.g.
+    // if we navigated to a new origin), but this won't cause a problem in the
+    // call below.
+    zoom_map->ClearTemporaryZoomLevel(render_process_id, render_view_id);
+  } else {
+    // If we're resetting to isolated zoom, a temporary zoom level needs to
+    // be set to override any existing per-host zoom levels.
+    zoom_map->SetTemporaryZoomLevel(render_process_id, render_view_id,
+                                    new_zoom_level);
+  }
+  zoom_mode_ = new_mode;
+}
+
+void ZoomController::UpdateZoomModeOnScopeChangeIfNeeded() {
+  if (zoom_mode_ != ZOOM_MODE_DEFAULT && zoom_mode_ != ZOOM_MODE_ISOLATED)
+    return;
+
+  // When going from per-tab to per-host, if there isn't an existing per-host
+  // zoom level set, the first ZoomController (that has set a non-default
+  // temporary zoom level) to be notified of the scope change will set the
+  // per-host zoom level.
+  // TODO Is this acceptable behaviour?
+  SetZoomMode(default_per_origin_ ? ZOOM_MODE_DEFAULT : ZOOM_MODE_ISOLATED);
 }
 
 void ZoomController::DidNavigateMainFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   if (details.entry && details.entry->GetPageType() == content::PAGE_TYPE_ERROR)
     content::HostZoomMap::SendErrorPageZoomLevelRefresh(web_contents());
 
   if (!details.is_in_page)
     ResetZoomModeOnNavigationIfNeeded(params.url);
 
   // If the main frame's content has changed, the new page may have a different
   // zoom level from the old one.
   UpdateState(std::string());
   DCHECK(!event_data_);
 }
 
 void ZoomController::WebContentsDestroyed() {
   // At this point we should no longer be sending any zoom events with this
   // WebContents.
   observers_.Clear();
 }
 
 void ZoomController::RenderFrameHostChanged(
     content::RenderFrameHost* old_host,
     content::RenderFrameHost* new_host) {
-  // If our associated HostZoomMap changes, update our event subscription.
   content::HostZoomMap* new_host_zoom_map =
       content::HostZoomMap::GetForWebContents(web_contents());
+
+  // The HostZoomMap records temporary zoom levels per RenderView. When zooming
+  // is per-tab and our RenderView changes, we need to copy the level for our
+  // new RenderView so that the tab's zoom level is preserved.
+  if (old_host && !default_per_origin_ && zoom_mode_ == ZOOM_MODE_ISOLATED) {
+    new_host_zoom_map->PreserveTemporaryZoomLevelFrom(
+        host_zoom_map_, old_host, new_host);
+  }
+
+  // If our associated HostZoomMap changes, update our event subscription.
   if (new_host_zoom_map == host_zoom_map_)
     return;
 
   host_zoom_map_ = new_host_zoom_map;
   zoom_subscription_ = host_zoom_map_->AddZoomLevelChangedCallback(
       base::Bind(&ZoomController::OnZoomLevelChanged, base::Unretained(this)));
 }
 
+void ZoomController::PreserveTemporaryZoomLevel(
+    content::WebContents* old_web_contents,
+    content::WebContents* new_web_contents) const {
+  if (default_per_origin_ || zoom_mode_ != ZOOM_MODE_ISOLATED)

[wjmaclean, 2017/01/19 21:09:05]

Again, something like |is_per_origin| or |zoom_is_per_origin| might be clearer
here.

[Kevin McNee, 2017/02/03 22:51:34]

Done.

+    return;
+
+  content::RenderFrameHost* old_host = old_web_contents->GetMainFrame();
+  content::RenderFrameHost* new_host = new_web_contents->GetMainFrame();
+  const content::HostZoomMap* old_host_zoom_map =
+      content::HostZoomMap::GetForWebContents(old_web_contents);
+  content::HostZoomMap* new_host_zoom_map =
+      content::HostZoomMap::GetForWebContents(new_web_contents);
+
+  new_host_zoom_map->PreserveTemporaryZoomLevelFrom(
+      old_host_zoom_map, old_host, new_host);
+}
+
+void ZoomController::DidCloneToNewWebContents(
+    content::WebContents* old_web_contents,
+    content::WebContents* new_web_contents) {
+  // If a WebContents is cloned when zooming is per-tab, have the clone inherit
+  // the original's zoom level.
+  PreserveTemporaryZoomLevel(old_web_contents, new_web_contents);
+}
+
+void ZoomController::WebContentsReplaced(
+    content::WebContents* old_web_contents,
+    content::WebContents* new_web_contents) {
+  // A tab may replace its WebContents with another, but from the user's
+  // perspective, this is still the same tab, so we need to preserve the
+  // per-tab zoom.
+  PreserveTemporaryZoomLevel(old_web_contents, new_web_contents);
+}
+
 void ZoomController::OnZoomLevelChanged(
     const content::HostZoomMap::ZoomLevelChange& change) {
   UpdateState(change.host);
 }
 
+void ZoomController::OnDefaultZoomScopeChanged() {
+  default_per_origin_ = !default_per_origin_;
+  UpdateZoomModeOnScopeChangeIfNeeded();
+}
+
 void ZoomController::UpdateState(const std::string& host) {
   // If |host| is empty, all observers should be updated.
   if (!host.empty()) {
     // Use the navigation entry's URL instead of the WebContents' so virtual
     // URLs work (e.g. chrome://settings). http://crbug.com/153950
     content::NavigationEntry* entry =
         web_contents()->GetController().GetLastCommittedEntry();
     if (!entry ||
         host != net::GetHostOrSpecFromURL(
                     content::HostZoomMap::GetURLFromEntry(entry))) {
@@ skipping 29 matching lines @@
   int render_view_id = web_contents()->GetRenderViewHost()->GetRoutingID();
   host_zoom_map_->SetPageScaleFactorIsOneForView(render_process_id,
                                                  render_view_id, is_one);
 }
 
 bool ZoomController::PageScaleFactorIsOne() const {
   return content::HostZoomMap::PageScaleFactorIsOne(web_contents());
 }
 
 }  // namespace zoom