Show Zoom Levels as content settings

chrome/browser/ui/webui/options/content_settings_handler.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 "chrome/browser/ui/webui/options/content_settings_handler.h"
 
+#include <algorithm>
 #include <map>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/content_settings_details.h"
 #include "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry_factory.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/notifications/desktop_notification_service.h"
 #include "chrome/browser/notifications/desktop_notification_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/content_settings.h"
 #include "chrome/common/content_settings_pattern.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/common/page_zoom.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/permissions/api_permission.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/user_manager.h"
 #endif
 
@@ skipping 24 matching lines @@
     "https://support.google.com/chrome/?p=settings_manage_exceptions";
 
 const char* kSetting = "setting";
 const char* kOrigin = "origin";
 const char* kSource = "source";
 const char* kAppName = "appName";
 const char* kAppId = "appId";
 const char* kEmbeddingOrigin = "embeddingOrigin";
 const char* kPreferencesSource = "preference";
 const char* kVideoSetting = "video";
+const char* kZoom = "zoom";
 
 const ContentSettingsTypeNameEntry kContentSettingsTypeGroupNames[] = {
   {CONTENT_SETTINGS_TYPE_COOKIES, "cookies"},
   {CONTENT_SETTINGS_TYPE_IMAGES, "images"},
   {CONTENT_SETTINGS_TYPE_JAVASCRIPT, "javascript"},
   {CONTENT_SETTINGS_TYPE_PLUGINS, "plugins"},
   {CONTENT_SETTINGS_TYPE_POPUPS, "popups"},
   {CONTENT_SETTINGS_TYPE_GEOLOCATION, "location"},
   {CONTENT_SETTINGS_TYPE_NOTIFICATIONS, "notifications"},
   {CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE, "auto-select-certificate"},
   {CONTENT_SETTINGS_TYPE_FULLSCREEN, "fullscreen"},
   {CONTENT_SETTINGS_TYPE_MOUSELOCK, "mouselock"},
   {CONTENT_SETTINGS_TYPE_PROTOCOL_HANDLERS, "register-protocol-handler"},
   {CONTENT_SETTINGS_TYPE_MEDIASTREAM, "media-stream"},
   {CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, "media-stream-mic"},
   {CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, "media-stream-camera"},
   {CONTENT_SETTINGS_TYPE_PPAPI_BROKER, "ppapi-broker"},
   {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, "multiple-automatic-downloads"},
   {CONTENT_SETTINGS_TYPE_MIDI_SYSEX, "midi-sysex"},
 #if defined(OS_CHROMEOS)
   {CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER, "protectedContent"},
 #endif
 };
 
+// A pseudo content type. We use it to display data like a content setting even
+// though it is not a real content setting.
+const char* kZoomContentType = "zoomlevels";
+
 ContentSettingsType ContentSettingsTypeFromGroupName(const std::string& name) {
   for (size_t i = 0; i < arraysize(kContentSettingsTypeGroupNames); ++i) {
     if (name == kContentSettingsTypeGroupNames[i].name)
       return kContentSettingsTypeGroupNames[i].type;
   }
 
   NOTREACHED() << name << " is not a recognized content settings type.";
   return CONTENT_SETTINGS_TYPE_DEFAULT;
 }
 
@@ skipping 123 matching lines @@
     // Retrieve the launch URL.
     GURL launch_url =
         extensions::AppLaunchInfo::GetLaunchWebURL(extension->get());
     // Skip adding the launch URL if it is part of the web extent.
     if (web_extent.MatchesURL(launch_url))
       continue;
     AddExceptionForHostedApp(launch_url.spec(), *extension->get(), exceptions);
   }
 }
 
+// Sort ZoomLevelChanges by host and scheme
+// (a.com < http://a.com < https://a.com < b.com)
+bool ZoomLevelChangeLessThan(const content::HostZoomMap::ZoomLevelChange& a,
+                             const content::HostZoomMap::ZoomLevelChange& b) {
+  if (a.host < b.host)
+    return true;
+  if (a.host > b.host)
+    return false;
+  return a.scheme < b.scheme;
+}
+
 }  // namespace
 
 namespace options {
 
 ContentSettingsHandler::MediaSettingsInfo::MediaSettingsInfo()
     : flash_default_setting(CONTENT_SETTING_DEFAULT),
       flash_settings_initialized(false),
       last_flash_refresh_request_id(0),
       show_flash_default_link(false),
       show_flash_exceptions_link(false),
@@ skipping 21 matching lines @@
     { "allowException", IDS_EXCEPTIONS_ALLOW_BUTTON },
     { "blockException", IDS_EXCEPTIONS_BLOCK_BUTTON },
     { "sessionException", IDS_EXCEPTIONS_SESSION_ONLY_BUTTON },
     { "askException", IDS_EXCEPTIONS_ASK_BUTTON },
     { "otr_exceptions_explanation", IDS_EXCEPTIONS_OTR_LABEL },
     { "addNewExceptionInstructions", IDS_EXCEPTIONS_ADD_NEW_INSTRUCTIONS },
     { "manageExceptions", IDS_EXCEPTIONS_MANAGE },
     { "manage_handlers", IDS_HANDLERS_MANAGE },
     { "exceptionPatternHeader", IDS_EXCEPTIONS_PATTERN_HEADER },
     { "exceptionBehaviorHeader", IDS_EXCEPTIONS_ACTION_HEADER },
+    { "exceptionZoomHeader", IDS_EXCEPTIONS_ZOOM_HEADER },
     { "embeddedOnHost", IDS_EXCEPTIONS_GEOLOCATION_EMBEDDED_ON_HOST },
     // Cookies filter.
     { "cookies_tab_label", IDS_COOKIES_TAB_LABEL },
     { "cookies_header", IDS_COOKIES_HEADER },
     { "cookies_allow", IDS_COOKIES_ALLOW_RADIO },
     { "cookies_block", IDS_COOKIES_BLOCK_RADIO },
     { "cookies_session_only", IDS_COOKIES_SESSION_ONLY_RADIO },
     { "cookies_block_3rd_party", IDS_COOKIES_BLOCK_3RDPARTY_CHKBOX },
     { "cookies_clear_when_close", IDS_COOKIES_CLEAR_WHEN_CLOSE_CHKBOX },
     { "cookies_lso_clear_when_close", IDS_COOKIES_LSO_CLEAR_WHEN_CLOSE_CHKBOX },
@@ skipping 89 matching lines @@
       IDS_AUTOMATIC_DOWNLOADS_ALLOW_RADIO },
     { "multiple-automatic-downloads_ask",
       IDS_AUTOMATIC_DOWNLOADS_ASK_RADIO },
     { "multiple-automatic-downloads_block",
       IDS_AUTOMATIC_DOWNLOADS_BLOCK_RADIO },
     // MIDI system exclusive messages
     { "midi-sysex_header", IDS_MIDI_SYSEX_TAB_LABEL },
     { "midiSysExAllow", IDS_MIDI_SYSEX_ALLOW_RADIO },
     { "midiSysExAsk", IDS_MIDI_SYSEX_ASK_RADIO },
     { "midiSysExBlock", IDS_MIDI_SYSEX_BLOCK_RADIO },
+    { "zoomlevels_header", IDS_ZOOMLEVELS_HEADER },
+    { "zoomLevelsManage", IDS_ZOOMLEVELS_MANAGE_BUTTON },
   };
 
   RegisterStrings(localized_strings, resources, arraysize(resources));
   RegisterTitle(localized_strings, "contentSettingsPage",
                 IDS_CONTENT_SETTINGS_TITLE);
 
   // Register titles for each of the individual settings whose exception
   // dialogs will be processed by |ContentSettingsHandler|.
   RegisterTitle(localized_strings, "cookies",
                 IDS_COOKIES_TAB_LABEL);
@@ skipping 18 matching lines @@
                 IDS_PROTECTED_CONTENT_TAB_LABEL);
 #endif
   RegisterTitle(localized_strings, "media-stream",
                 IDS_MEDIA_STREAM_TAB_LABEL);
   RegisterTitle(localized_strings, "ppapi-broker",
                 IDS_PPAPI_BROKER_TAB_LABEL);
   RegisterTitle(localized_strings, "multiple-automatic-downloads",
                 IDS_AUTOMATIC_DOWNLOADS_TAB_LABEL);
   RegisterTitle(localized_strings, "midi-sysex",
                 IDS_MIDI_SYSEX_TAB_LABEL);
+  RegisterTitle(localized_strings, "zoomlevels",
+                IDS_ZOOMLEVELS_TAB_LABEL);
 
   localized_strings->SetBoolean("newContentSettings",
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kContentSettings2));
   localized_strings->SetString(
       "exceptionsLearnMoreUrl",
       google_util::StringAppendGoogleLocaleParam(
           kExceptionsLearnMoreUrl));
 }
 
 void ContentSettingsHandler::InitializeHandler() {
@@ skipping 28 matching lines @@
   pref_change_registrar_.Add(
       prefs::kVideoCaptureAllowed,
       base::Bind(&ContentSettingsHandler::UpdateMediaSettingsView,
                  base::Unretained(this)));
   pref_change_registrar_.Add(
       prefs::kEnableDRM,
       base::Bind(
           &ContentSettingsHandler::UpdateProtectedContentExceptionsButton,
           base::Unretained(this)));
 
+  content::HostZoomMap* host_zoom_map =
+      content::HostZoomMap::GetForBrowserContext(profile);
+  host_zoom_map_subscription_ =
+      host_zoom_map->AddZoomLevelChangedCallback(
+          base::Bind(&ContentSettingsHandler::OnZoomLevelChanged,
+                     base::Unretained(this)));
+
   flash_settings_manager_.reset(new PepperFlashSettingsManager(this, profile));
 }
 
 void ContentSettingsHandler::InitializePage() {
   media_settings_ = MediaSettingsInfo();
   RefreshFlashMediaSettings();
 
   UpdateHandlersEnabledRadios();
   UpdateAllExceptionsViewsFromModel();
   UpdateProtectedContentExceptionsButton();
@@ skipping 171 matching lines @@
   web_ui()->CallJavascriptFunction(
       "ContentSettings.updateHandlersEnabledRadios",
       handlers_enabled);
 }
 
 void ContentSettingsHandler::UpdateAllExceptionsViewsFromModel() {
   for (int type = CONTENT_SETTINGS_TYPE_DEFAULT + 1;
        type < CONTENT_SETTINGS_NUM_TYPES; ++type) {
     UpdateExceptionsViewFromModel(static_cast<ContentSettingsType>(type));
   }
+  UpdateZoomLevelsExceptionsView();
 }
 
 void ContentSettingsHandler::UpdateAllOTRExceptionsViewsFromModel() {
   for (int type = CONTENT_SETTINGS_TYPE_DEFAULT + 1;
        type < CONTENT_SETTINGS_NUM_TYPES; ++type) {
     UpdateOTRExceptionsViewFromModel(static_cast<ContentSettingsType>(type));
   }
 }
 
 void ContentSettingsHandler::UpdateExceptionsViewFromModel(
@@ skipping 261 matching lines @@
     web_ui()->CallJavascriptFunction(
         "ContentSettings.showExperimentalWebMIDISettings",
         base::FundamentalValue(true));
   }
 
   UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
   UpdateExceptionsViewFromHostContentSettingsMap(
       CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
 }
 
+void ContentSettingsHandler::UpdateZoomLevelsExceptionsView() {
+  base::ListValue zoom_levels_exceptions;
+
+  content::HostZoomMap* host_zoom_map =
+      content::HostZoomMap::GetForBrowserContext(Profile::FromWebUI(web_ui()));
+  content::HostZoomMap::ZoomLevelVector zoom_levels(
+      host_zoom_map->GetAllZoomLevels());
+  std::sort(zoom_levels.begin(), zoom_levels.end(), ZoomLevelChangeLessThan);
+
+  for (content::HostZoomMap::ZoomLevelVector::const_iterator i =
+           zoom_levels.begin();
+       i != zoom_levels.end();
+       ++i) {
+    base::DictionaryValue* exception = new base::DictionaryValue();
+    switch (i->mode) {
+      case content::HostZoomMap::ZOOM_CHANGED_FOR_HOST:
+        exception->SetString(kOrigin, i->host);
+        break;
+      case content::HostZoomMap::ZOOM_CHANGED_FOR_SCHEME_AND_HOST:
+        exception->SetString(kOrigin, i->scheme + "://" + i->host);
+        break;
+      case content::HostZoomMap::ZOOM_CHANGED_TEMPORARY_ZOOM:
+        NOTREACHED();
+    }
+    exception->SetString(kSetting,
+                         ContentSettingToString(CONTENT_SETTING_DEFAULT));
+
+    // Calculate the zoom percent from the factor. Round up to the nearest whole
+    // number.
+    int percent = static_cast<int>(
+        content::ZoomLevelToZoomFactor(i->zoom_level) * 100 + 0.5);
+    exception->SetString(kZoom, base::IntToString(percent) + "%");

[markusheintz_, 2014/03/12 16:31:06]

hm ... I guess the string concatenation should work for RTL as well. Maybe we
should try it out.

[battre, 2014/03/13 09:22:14]

Done.

+    exception->SetString(kSource, kPreferencesSource);
+    // Append the new entry to the list and map.
+    zoom_levels_exceptions.Append(exception);
+  }
+
+  base::StringValue type_string(kZoomContentType);
+  web_ui()->CallJavascriptFunction("ContentSettings.setExceptions",
+                                   type_string, zoom_levels_exceptions);
+}
+
 void ContentSettingsHandler::UpdateExceptionsViewFromHostContentSettingsMap(
     ContentSettingsType type) {
   base::ListValue exceptions;
   GetExceptionsFromHostContentSettingsMap(
       GetContentSettingsMap(), type, &exceptions);
   base::StringValue type_string(ContentSettingsTypeToGroupName(type));
   web_ui()->CallJavascriptFunction("ContentSettings.setExceptions", type_string,
                                    exceptions);
 
   UpdateExceptionsViewFromOTRHostContentSettingsMap(type);
@@ skipping 177 matching lines @@
         ContentSettingsPattern::FromString(pattern),
         secondary_pattern.empty()
             ? ContentSettingsPattern::Wildcard()
             : ContentSettingsPattern::FromString(secondary_pattern),
         type,
         std::string(),
         NULL);
   }
 }
 
+void ContentSettingsHandler::RemoveZoomLevelException(
+    const base::ListValue* args, size_t arg_index) {
+  std::string mode;
+  bool rv = args->GetString(arg_index++, &mode);
+  DCHECK(rv);
+
+  std::string pattern;
+  rv = args->GetString(arg_index++, &pattern);
+  DCHECK(rv);
+
+  content::HostZoomMap* host_zoom_map =
+      content::HostZoomMap::GetForBrowserContext(Profile::FromWebUI(web_ui()));
+  double default_level = host_zoom_map->GetDefaultZoomLevel();
+
+  std::string::size_type scheme_separator_position = pattern.find("://");

[markusheintz_, 2014/03/12 16:31:06]

In src/content/public/common/url_constants.cc there is a const for the standard
scheme separator (content::kStandardSchemeSeparator). Please use it.

[battre, 2014/03/13 09:22:14]

Done.

[battre, 2014/03/13 09:22:14]

Done.

+  if (scheme_separator_position == std::string::npos) {
+    host_zoom_map->SetZoomLevelForHost(pattern, default_level);
+  } else {
+    std::string scheme = pattern.substr(0, scheme_separator_position);
+    std::string host = pattern.substr(scheme_separator_position + 3);

[markusheintz_, 2014/03/12 16:31:06]

Please replace the '3' with the length of the content::kStandardSchemeSeparator.

[battre, 2014/03/13 09:22:14]

Done.

+    host_zoom_map->SetZoomLevelForHostAndScheme(scheme, host, default_level);
+  }
+}
+
 void ContentSettingsHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback("setContentFilter",
       base::Bind(&ContentSettingsHandler::SetContentFilter,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("removeException",
       base::Bind(&ContentSettingsHandler::RemoveException,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("setException",
       base::Bind(&ContentSettingsHandler::SetException,
                  base::Unretained(this)));
@@ skipping 107 matching lines @@
     default:
       break;
   }
 }
 
 void ContentSettingsHandler::RemoveException(const base::ListValue* args) {
   size_t arg_i = 0;
   std::string type_string;
   CHECK(args->GetString(arg_i++, &type_string));
 
+  if (type_string == kZoomContentType) {

[markusheintz_, 2014/03/12 16:31:06]

Please add a comment why this needs to go before the following code. So that
people that are touching the code later know that they need to keep it where it
is.

kZoomContentType can not be converted by "ContentSettingsTypeFromGroupName". 

[battre, 2014/03/13 09:22:14]

Done.

+    RemoveZoomLevelException(args, arg_i);
+    return;
+  }
+
   ContentSettingsType type = ContentSettingsTypeFromGroupName(type_string);
   switch (type) {
     case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
       RemoveNotificationException(args, arg_i);
       break;
     case CONTENT_SETTINGS_TYPE_MEDIASTREAM:
       RemoveMediaException(args, arg_i);
       break;
     default:
       RemoveExceptionFromHostContentSettingsMap(args, arg_i, type);
@@ skipping 98 matching lines @@
   ShowFlashMediaLink(DEFAULT_SETTING, false);
   ShowFlashMediaLink(EXCEPTIONS, false);
 
   PrefService* prefs = Profile::FromWebUI(web_ui())->GetPrefs();
   if (prefs->GetBoolean(prefs::kPepperFlashSettingsEnabled))
     RefreshFlashMediaSettings();
   else
     media_settings_.flash_settings_initialized = false;
 }
 
+void ContentSettingsHandler::OnZoomLevelChanged(
+    const content::HostZoomMap::ZoomLevelChange& change) {
+  UpdateZoomLevelsExceptionsView();
+}
+
 void ContentSettingsHandler::ShowFlashMediaLink(LinkType link_type, bool show) {
   bool& show_link = link_type == DEFAULT_SETTING ?
       media_settings_.show_flash_default_link :
       media_settings_.show_flash_exceptions_link;
   if (show_link != show) {
     web_ui()->CallJavascriptFunction(
         link_type == DEFAULT_SETTING ?
             "ContentSettings.showMediaPepperFlashDefaultLink" :
             "ContentSettings.showMediaPepperFlashExceptionsLink",
         base::FundamentalValue(show));
@@ skipping 49 matching lines @@
 void ContentSettingsHandler::UpdateProtectedContentExceptionsButton() {
   PrefService* prefs = Profile::FromWebUI(web_ui())->GetPrefs();
   // Exceptions apply only when the feature is enabled.
   bool enable_exceptions = prefs->GetBoolean(prefs::kEnableDRM);
   web_ui()->CallJavascriptFunction(
       "ContentSettings.enableProtectedContentExceptions",
       base::FundamentalValue(enable_exceptions));
 }
 
 }  // namespace options