Add setting to isolate zoom changes by default.

chrome/browser/ui/webui/settings/site_settings_handler.cc

 // Copyright 2016 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 "chrome/browser/ui/webui/settings/site_settings_handler.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/i18n/number_formatting.h"
 #include "base/macros.h"
 #include "base/values.h"
 #include "chrome/browser/browsing_data/browsing_data_local_storage_helper.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/permissions/chooser_context_base.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/site_settings_helper.h"
+#include "chrome/browser/ui/zoom/chrome_zoom_level_prefs.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings_types.h"
 #include "components/crx_file/id_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/common/url_constants.h"
@@ skipping 117 matching lines @@
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "isPatternValid",
       base::Bind(&SiteSettingsHandler::HandleIsPatternValid,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "updateIncognitoStatus",
       base::Bind(&SiteSettingsHandler::HandleUpdateIncognitoStatus,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
+      "fetchZoomScope", base::Bind(&SiteSettingsHandler::HandleFetchZoomScope,
+                                   base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
       "fetchZoomLevels",
       base::Bind(&SiteSettingsHandler::HandleFetchZoomLevels,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
+      "setZoomScopeIsPerOrigin",
+      base::Bind(&SiteSettingsHandler::HandleSetZoomScopeIsPerOrigin,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
       "removeZoomLevel",
       base::Bind(&SiteSettingsHandler::HandleRemoveZoomLevel,
                  base::Unretained(this)));
 }
 
 void SiteSettingsHandler::OnJavascriptAllowed() {
   observer_.Add(HostContentSettingsMapFactory::GetForProfile(profile_));
   if (profile_->HasOffTheRecordProfile()) {
     auto* map = HostContentSettingsMapFactory::GetForProfile(
         profile_->GetOffTheRecordProfile());
@@ skipping 10 matching lines @@
 
   // Here we only subscribe to the HostZoomMap for the default storage partition
   // since we don't allow the user to manage the zoom levels for apps.
   // We're only interested in zoom-levels that are persisted, since the user
   // is given the opportunity to view/delete these in the content-settings page.
   host_zoom_map_subscription_ =
       content::HostZoomMap::GetDefaultForBrowserContext(profile_)
           ->AddZoomLevelChangedCallback(
               base::Bind(&SiteSettingsHandler::OnZoomLevelChanged,
                          base::Unretained(this)));
+  // We subscribe to the ChromeZoomLevelPrefs to get updates to the default
+  // zoom scope. As with the HostZoomMap, we only allow the user to modify
+  // the default zoom scope for the default storage partition.
+  ChromeZoomLevelPrefs* zoom_level_prefs = profile_->GetZoomLevelPrefs();
+  // Only regular profiles can change the default zoom scope, so only require
+  // a |zoom_level_prefs| in this case.
+  DCHECK(zoom_level_prefs ||
+         profile_->GetProfileType() != Profile::REGULAR_PROFILE);
+  if (zoom_level_prefs)
+    default_zoom_scope_subscription_ =
+        zoom_level_prefs->RegisterDefaultZoomScopeCallback(base::Bind(
+            &SiteSettingsHandler::OnZoomScopeChanged, base::Unretained(this)));
 }
 
 void SiteSettingsHandler::OnJavascriptDisallowed() {
   observer_.RemoveAll();
   notification_registrar_.RemoveAll();
   host_zoom_map_subscription_.reset();
+  default_zoom_scope_subscription_.reset();
 }
 
 void SiteSettingsHandler::OnGetUsageInfo(
     const storage::UsageInfoEntries& entries) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   for (const auto& entry : entries) {
     if (entry.usage <= 0) continue;
     if (entry.host == usage_host_) {
       CallJavascriptFunction("settings.WebsiteUsagePrivateApi.returnUsageTotal",
@@ skipping 65 matching lines @@
       if (!profile_->IsSameProfile(profile))
         break;
       SendIncognitoStatus(profile, /*was_destroyed=*/ false);
 
       observer_.Add(HostContentSettingsMapFactory::GetForProfile(profile));
       break;
     }
   }
 }
 
+void SiteSettingsHandler::OnZoomScopeChanged() {
+  SendZoomScope();
+}
+
 void SiteSettingsHandler::OnZoomLevelChanged(
     const content::HostZoomMap::ZoomLevelChange& change) {
   SendZoomLevels();
 }
 
 void SiteSettingsHandler::HandleFetchUsageTotal(
     const base::ListValue* args) {
   AllowJavascript();
 
   CHECK_EQ(1U, args->GetSize());
@@ skipping 321 matching lines @@
   // message before destroying, so HasOffTheRecordProfile for profile_ won't
   // return false until after the profile actually been destroyed.
   bool incognito_enabled = profile_->HasOffTheRecordProfile() &&
       !(was_destroyed && profile == profile_->GetOffTheRecordProfile());
 
   CallJavascriptFunction("cr.webUIListenerCallback",
                          base::StringValue("onIncognitoStatusChanged"),
                          base::FundamentalValue(incognito_enabled));
 }
 
+void SiteSettingsHandler::HandleFetchZoomScope(const base::ListValue* args) {
+  AllowJavascript();
+  SendZoomScope();
+}
+
 void SiteSettingsHandler::HandleFetchZoomLevels(const base::ListValue* args) {
   AllowJavascript();
   SendZoomLevels();
 }
 
+void SiteSettingsHandler::SendZoomScope() {
+  if (!IsJavascriptAllowed())
+    return;
+
+  ChromeZoomLevelPrefs* zoom_level_prefs = profile_->GetZoomLevelPrefs();
+  bool is_per_origin = zoom_level_prefs
+                           ? zoom_level_prefs->GetZoomScopeIsPerOriginPref()
+                           : ChromeZoomLevelPrefs::kZoomScopeSettingDefault;
+  CallJavascriptFunction("cr.webUIListenerCallback",
+                         base::StringValue("onZoomScopeChanged"),
+                         base::FundamentalValue(is_per_origin));
+}
+
 void SiteSettingsHandler::SendZoomLevels() {
   if (!IsJavascriptAllowed())
     return;
 
   base::ListValue zoom_levels_exceptions;
 
   content::HostZoomMap* host_zoom_map =
       content::HostZoomMap::GetDefaultForBrowserContext(profile_);
   content::HostZoomMap::ZoomLevelVector zoom_levels(
       host_zoom_map->GetAllZoomLevels());
@@ skipping 61 matching lines @@
         site_settings::kSource, site_settings::kPreferencesSource);
     // Append the new entry to the list and map.
     zoom_levels_exceptions.Append(std::move(exception));
   }
 
   CallJavascriptFunction("cr.webUIListenerCallback",
                          base::StringValue("onZoomLevelsChanged"),
                          zoom_levels_exceptions);
 }
 
+void SiteSettingsHandler::HandleSetZoomScopeIsPerOrigin(
+    const base::ListValue* args) {
+  CHECK_EQ(1U, args->GetSize());
+
+  bool is_per_origin;
+  CHECK(args->GetBoolean(0, &is_per_origin));
+
+  ChromeZoomLevelPrefs* zoom_level_prefs = profile_->GetZoomLevelPrefs();
+  DCHECK(zoom_level_prefs);
+  zoom_level_prefs->SetZoomScopeIsPerOriginPref(is_per_origin);
+}
+
 void SiteSettingsHandler::HandleRemoveZoomLevel(const base::ListValue* args) {
   CHECK_EQ(1U, args->GetSize());
 
   std::string origin;
   CHECK(args->GetString(0, &origin));
 
   if (origin ==
           l10n_util::GetStringUTF8(IDS_ZOOMLEVELS_CHROME_ERROR_PAGES_LABEL)) {
     origin = content::kUnreachableWebDataURL;
   }
 
   content::HostZoomMap* host_zoom_map;
   host_zoom_map = content::HostZoomMap::GetDefaultForBrowserContext(profile_);
   double default_level = host_zoom_map->GetDefaultZoomLevel();
   host_zoom_map->SetZoomLevelForHost(origin, default_level);
 }
 
 }  // namespace settings