MD Settings: Set all content setting values in Site Details Javascript.

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/content_settings/web_site_settings_uma_util.h"
 #include "chrome/browser/permissions/chooser_context_base.h"
+#include "chrome/browser/permissions/permission_manager.h"
+#include "chrome/browser/permissions/permission_result.h"
 #include "chrome/browser/permissions/permission_uma_util.h"
 #include "chrome/browser/permissions/permission_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/site_settings_helper.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/grit/generated_resources.h"
+#include "components/content_settings/core/browser/content_settings_utils.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"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/permissions/api_permission.h"
@@ skipping 55 matching lines @@
     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;
     site_settings::AddExceptionForHostedApp(
         launch_url.spec(), *extension->get(), exceptions);
   }
 }
 
+PermissionResult GetPermissionResultForOrigin(const GURL& requesting_origin,
+                                              const GURL& embedding_origin,
+                                              ContentSettingsType content_type,
+                                              Profile* profile) {
+  // TODO(patricialor): In future, PermissionManager should know about all
+  // content settings, not just the permissions, plus all the possible sources.
+  PermissionResult result(CONTENT_SETTING_DEFAULT,
+                          PermissionStatusSource::UNSPECIFIED);
+  content_settings::SettingInfo info;
+  HostContentSettingsMap* map =
+      HostContentSettingsMapFactory::GetForProfile(profile);
+  std::unique_ptr<base::Value> value = map->GetWebsiteSetting(
+      requesting_origin, embedding_origin, content_type, std::string(), &info);
+
+  // Retrieve the content setting.
+  if (PermissionUtil::IsPermission(content_type)) {
+    result = PermissionManager::Get(profile)->GetPermissionStatus(
+        content_type, requesting_origin, embedding_origin);
+  } else {
+    DCHECK(value.get());
+    if (value->GetType() == base::Value::Type::INTEGER)

[raymes, 2017/06/19 04:13:12]

Could this just be a DCHECK_EQ instead of a NOTREACHED below?

[Patti Lor, 2017/06/20 08:25:54]

Done.

+      result.content_setting =
+          content_settings::ValueToContentSetting(value.get());
+    else
+      NOTREACHED();
+  }
+
+  // Retrieve the source of the content setting. The PermissionManager currently
+  // only knows about SAFE_BROWSING_BLACKLIST, KILL_SWITCH, MULTIPLE_DISMISSALS,
+  // and MULTIPLE_IGNORES, so overwrite the PermissionStatusSource if the source
+  // is none of those.
+  switch (result.source) {
+    case PermissionStatusSource::UNSPECIFIED:
+      break;
+    case PermissionStatusSource::SAFE_BROWSING_BLACKLIST:
+    case PermissionStatusSource::KILL_SWITCH:
+    case PermissionStatusSource::MULTIPLE_DISMISSALS:
+    case PermissionStatusSource::MULTIPLE_IGNORES:
+      return result;
+    case PermissionStatusSource::INSECURE_ORIGIN:
+    case PermissionStatusSource::ENTERPRISE_POLICY:
+    case PermissionStatusSource::EXTENSION:

[raymes, 2017/06/19 04:13:12]

I think having the PermissionStatusSource's that aren't currently used in the
permission system adds some complexity that mightn't be needed right now. Could
we instead convert directly from PermissionStatusSource or content settings
source to the string that we need? Maybe We could have a single helper function
in this file to do that? 

[Patti Lor, 2017/06/20 08:25:54]

Done (with the helper function approach). I realised there was a bug currently
where if there was an embargoed setting that was also controlled by policy or
extension it would return that it was controlled by embargo, so I changed the
order to fix that.

+      // If these are now implemented, update this code to remove unnecessary
+      // calls to HostContentSettingsMap.
+      NOTREACHED();
+  }
+
+  result.source =
+      PermissionUtil::ConvertSettingSourceToPermissionStatusSource(info.source);
+  return result;
+}
+
 }  // namespace
 
 
 SiteSettingsHandler::SiteSettingsHandler(Profile* profile)
     : profile_(profile), observer_(this) {
 }
 
 SiteSettingsHandler::~SiteSettingsHandler() {
 }
 
@@ skipping 24 matching lines @@
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "getExceptionList",
       base::Bind(&SiteSettingsHandler::HandleGetExceptionList,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "resetCategoryPermissionForOrigin",
       base::Bind(&SiteSettingsHandler::HandleResetCategoryPermissionForOrigin,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
+      "getCategoryPermissionForOrigin",
+      base::Bind(&SiteSettingsHandler::HandleGetCategoryPermissionForOrigin,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
       "setCategoryPermissionForOrigin",
       base::Bind(&SiteSettingsHandler::HandleSetCategoryPermissionForOrigin,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
-      "getSiteDetails",
-      base::Bind(&SiteSettingsHandler::HandleGetSiteDetails,
-                 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(
       "fetchZoomLevels",
       base::Bind(&SiteSettingsHandler::HandleFetchZoomLevels,
@@ skipping 330 matching lines @@
       profile, primary_pattern, secondary_pattern, content_type,
       PermissionSourceUI::SITE_SETTINGS);
 
   map->SetContentSettingCustomScope(primary_pattern, secondary_pattern,
                                     content_type, "", CONTENT_SETTING_DEFAULT);
 
   WebSiteSettingsUmaUtil::LogPermissionChange(
       content_type, ContentSetting::CONTENT_SETTING_DEFAULT);
 }
 
+void SiteSettingsHandler::HandleGetCategoryPermissionForOrigin(
+    const base::ListValue* args) {
+  AllowJavascript();
+
+  CHECK_EQ(4U, args->GetSize());
+  const base::Value* callback_id;
+  CHECK(args->Get(0, &callback_id));
+  std::string type;
+  CHECK(args->GetString(1, &type));
+  std::string origin;
+  CHECK(args->GetString(2, &origin));
+  std::string embedding_origin;
+  CHECK(args->GetString(3, &embedding_origin));
+
+  ContentSettingsType content_type = static_cast<ContentSettingsType>(
+      static_cast<int>(site_settings::ContentSettingsTypeFromGroupName(type)));
+  PermissionResult result = GetPermissionResultForOrigin(
+      GURL(origin), GURL(embedding_origin), content_type, profile_);
+
+  std::string content_setting_string =
+      content_settings::ContentSettingToString(result.content_setting);
+  std::string source_string = "";
+  switch (result.source) {
+    case PermissionStatusSource::UNSPECIFIED:
+    case PermissionStatusSource::SAFE_BROWSING_BLACKLIST:
+    case PermissionStatusSource::KILL_SWITCH:
+    case PermissionStatusSource::MULTIPLE_DISMISSALS:
+    case PermissionStatusSource::MULTIPLE_IGNORES:
+    case PermissionStatusSource::INSECURE_ORIGIN:
+      // TODO(patricialor): Plumb these sources through to the Web UI.
+      break;
+    case PermissionStatusSource::ENTERPRISE_POLICY:
+      source_string = site_settings::kPolicyProviderId;
+      break;
+    case PermissionStatusSource::EXTENSION:
+      source_string = site_settings::kExtensionProviderId;
+      break;
+  }
+
+  auto raw_site_exception = base::MakeUnique<base::DictionaryValue>();

[raymes, 2017/06/19 04:13:12]

nit: what does raw mean here?

[Patti Lor, 2017/06/20 08:25:54]

This method is supposed to return a RawSiteException (see
https://cs.chromium.org/chromium/src/chrome/browser/resources/settings/site_s...).
expandSiteException (called in <site-details>'s onOriginChanged() is meant to
convert that to a SiteException, similar to the original code.

[raymes, 2017/06/20 23:42:35]

Thanks for explaining :)

[Patti Lor, 2017/06/21 06:36:37]

Acknowledged :D

+  raw_site_exception->SetString(site_settings::kEmbeddingOrigin,
+                                embedding_origin);
+  raw_site_exception->SetBoolean(site_settings::kIncognito,
+                                 profile_->IsOffTheRecord());
+  raw_site_exception->SetString(site_settings::kOrigin, origin);
+  raw_site_exception->SetString(site_settings::kDisplayName, origin);
+  raw_site_exception->SetString(site_settings::kSetting,
+                                content_setting_string);
+  raw_site_exception->SetString(site_settings::kSource, source_string);
+  // The remaining "embeddingDisplayName" field is handled later in Javascript.
+
+  ResolveJavascriptCallback(*callback_id, *raw_site_exception);
+}
+
 void SiteSettingsHandler::HandleSetCategoryPermissionForOrigin(
     const base::ListValue* args) {
   CHECK_EQ(5U, args->GetSize());
   std::string primary_pattern_string;
   CHECK(args->GetString(0, &primary_pattern_string));
   // TODO(dschuyler): Review whether |secondary_pattern_string| should be used.
   std::string secondary_pattern_string;
   CHECK(args->GetString(1, &secondary_pattern_string));
   std::string type;
   CHECK(args->GetString(2, &type));
@@ skipping 30 matching lines @@
   PermissionUtil::ScopedRevocationReporter scoped_revocation_reporter(
       profile, primary_pattern, secondary_pattern, content_type,
       PermissionSourceUI::SITE_SETTINGS);
 
   map->SetContentSettingCustomScope(primary_pattern, secondary_pattern,
                                     content_type, "", setting);
 
   WebSiteSettingsUmaUtil::LogPermissionChange(content_type, setting);
 }
 
-void SiteSettingsHandler::HandleGetSiteDetails(
-    const base::ListValue* args) {
-  AllowJavascript();
-
-  CHECK_EQ(2U, args->GetSize());
-  const base::Value* callback_id;
-  CHECK(args->Get(0, &callback_id));
-  std::string site;
-  CHECK(args->GetString(1, &site));
-
-  // A subset of the ContentSettingsType enum that we show in the settings UI.
-  const ContentSettingsType kSettingsDetailTypes[] = {
-    CONTENT_SETTINGS_TYPE_COOKIES,
-    CONTENT_SETTINGS_TYPE_IMAGES,
-    CONTENT_SETTINGS_TYPE_JAVASCRIPT,
-    CONTENT_SETTINGS_TYPE_PLUGINS,
-    CONTENT_SETTINGS_TYPE_POPUPS,
-    CONTENT_SETTINGS_TYPE_GEOLOCATION,
-    CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
-    CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
-    CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
-    CONTENT_SETTINGS_TYPE_PROTOCOL_HANDLERS,
-    CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS,
-    CONTENT_SETTINGS_TYPE_BACKGROUND_SYNC,
-    CONTENT_SETTINGS_TYPE_USB_CHOOSER_DATA,
-    CONTENT_SETTINGS_TYPE_PROMPT_NO_DECISION_COUNT,
-  };
-
-  // Create a list to be consistent with existing API, we are expecting a single
-  // element (or none).
-  std::unique_ptr<base::ListValue> exceptions(new base::ListValue);
-  for (size_t type = 0; type < arraysize(kSettingsDetailTypes); ++type) {
-    ContentSettingsType content_type = kSettingsDetailTypes[type];
-
-    HostContentSettingsMap* map =
-        HostContentSettingsMapFactory::GetForProfile(profile_);
-    const auto* extension_registry =
-        extensions::ExtensionRegistry::Get(profile_);
-    site_settings::GetExceptionsFromHostContentSettingsMap(
-        map, content_type, extension_registry, web_ui(), /*incognito=*/false,
-        /*filter=*/&site, exceptions.get());
-
-    if (profile_->HasOffTheRecordProfile()) {
-      Profile* incognito = profile_->GetOffTheRecordProfile();
-      map = HostContentSettingsMapFactory::GetForProfile(incognito);
-      extension_registry = extensions::ExtensionRegistry::Get(incognito);
-      site_settings::GetExceptionsFromHostContentSettingsMap(
-          map, content_type, extension_registry, web_ui(), /*incognito=*/true,
-          /*filter=*/&site, exceptions.get());
-    }
-  }
-
-  if (!exceptions->GetSize()) {
-    RejectJavascriptCallback(*callback_id, base::Value());
-    return;
-  }
-
-  // We only need a single response element.
-  const base::DictionaryValue* exception = nullptr;
-  exceptions->GetDictionary(0, &exception);
-  ResolveJavascriptCallback(*callback_id, *exception);
-}
-
 void SiteSettingsHandler::HandleIsPatternValid(
     const base::ListValue* args) {
   CHECK_EQ(2U, args->GetSize());
   const base::Value* callback_id;
   CHECK(args->Get(0, &callback_id));
   std::string pattern_string;
   CHECK(args->GetString(1, &pattern_string));
 
   ContentSettingsPattern pattern =
       ContentSettingsPattern::FromString(pattern_string);
@@ skipping 122 matching lines @@
     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