[Android] Adding content settings provider for notification channels

components/content_settings/core/browser/host_content_settings_map.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/content_settings/core/browser/host_content_settings_map.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 37 matching lines @@
 struct ProviderNamesSourceMapEntry {
   const char* provider_name;
   content_settings::SettingSource provider_source;
 };
 
 const ProviderNamesSourceMapEntry kProviderNamesSourceMap[] = {
     {"platform_app", content_settings::SETTING_SOURCE_EXTENSION},
     {"policy", content_settings::SETTING_SOURCE_POLICY},
     {"supervised_user", content_settings::SETTING_SOURCE_SUPERVISED},
     {"extension", content_settings::SETTING_SOURCE_EXTENSION},
+    {"notification_android", content_settings::SETTING_SOURCE_USER},
     {"preference", content_settings::SETTING_SOURCE_USER},
     {"default", content_settings::SETTING_SOURCE_USER},
 };
 
 // Enum describing the status of domain to origin migration of content settings.
 // Migration will be done twice: once upon construction of the
 // HostContentSettingsMap (before syncing any content settings) and once after
 // sync has finished. We always migrate before sync to ensure that settings will
 // get migrated even if a user doesn't have sync enabled. We migrate after sync
 // to ensure that any sync'd settings will be migrated. Once these events have
@@ skipping 309 matching lines @@
 }
 
 void HostContentSettingsMap::SetWebsiteSettingCustomScope(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     const std::string& resource_identifier,
     std::unique_ptr<base::Value> value) {
   DCHECK(SupportsResourceIdentifier(content_type) ||
          resource_identifier.empty());
+#if defined(OS_ANDROID) && DCHECK_IS_ON()
+  // The notification permission on Android only allows valid origins with a
+  // restricted set of settings, or the global wildcard origin.
+  if (content_type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS &&
+      !primary_pattern.MatchesAllHosts()) {
+    // The |primary_pattern| must be a valid GURL as it may be presented to the
+    // user: Android Notification Channels may be used on Android O onward.
+    DCHECK(GURL(primary_pattern.ToString()).is_valid());
+
+    ContentSetting setting =
+        content_settings::ValueToContentSetting(value.get());
+
+    // Disallow notification content setting updates for specific origins that
+    // are not ALLOW/BLOCK/DEFAULT on Android.
+    DCHECK(setting == CONTENT_SETTING_ALLOW ||
+           setting == CONTENT_SETTING_BLOCK ||
+           setting == CONTENT_SETTING_DEFAULT);
+  }
+#endif

[raymes, 2017/06/06 01:08:14]

This is getting complicated and I'm not quite happy about the cost of adding it
to HostContentSettingsMap in terms of code readability. How about we just remove
this whole block for now. It would still be nice to have these checks but
they're not all specific to this CL and we can consider how to add them later.

[awdf, 2017/06/08 14:46:11]

I agree there's got to be a nicer way to ensure our assumptions here. And there
must be other content settings with their own assumptions - would be awesome if
we could come up with a way to ensure all these assumptions are enforced at
compile time while keeping things simple. Do you have any thoughts about that
longer term?

Have removed this stuff for now but filed crbug.com/731126 so we don't forget to
put it back in some form. These checks already helped me fix a bug in my code
(they caused a test to fail which motivated me to check prod code for the same
thing and add the wildcard special case), so I think they are important.

+
   UsedContentSettingsProviders();
 
   for (const auto& provider_pair : content_settings_providers_) {
     if (provider_pair.second->SetWebsiteSetting(
             primary_pattern, secondary_pattern, content_type,
             resource_identifier, value.get())) {
       // If successful then ownership is passed to the provider.
       ignore_result(value.release());
       return;
     }
@@ skipping 506 matching lines @@
         return base::WrapUnique(rule.value.get()->DeepCopy());
       }
     }
   }
   return std::unique_ptr<base::Value>();
 }
 
 void HostContentSettingsMap::SetClockForTesting(
     std::unique_ptr<base::Clock> clock) {
   pref_provider_->SetClockForTesting(std::move(clock));
-}
+}