[Android] Implement GetRuleIterator for channels provider

chrome/browser/notifications/notification_channels_provider_android_unittest.cc

 // Copyright 2017 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/notifications/notification_channels_provider_android.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "components/content_settings/core/browser/content_settings_pref.h"
+#include "components/content_settings/core/browser/content_settings_rule.h"
+#include "components/content_settings/core/browser/content_settings_utils.h"
 #include "components/content_settings/core/common/content_settings_pattern.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using ::testing::Return;
 
 namespace {
 const char kTestOrigin[] = "https://example.com/";
 }  // namespace
 
 class MockNotificationChannelsBridge
     : public NotificationChannelsProviderAndroid::NotificationChannelsBridge {
  public:
   ~MockNotificationChannelsBridge() = default;
   MOCK_METHOD0(ShouldUseChannelSettings, bool());
   MOCK_METHOD2(CreateChannel, void(const std::string&, bool));
   MOCK_METHOD1(GetChannelStatus, NotificationChannelStatus(const std::string&));
   MOCK_METHOD1(DeleteChannel, void(const std::string&));
+  MOCK_METHOD0(GetChannels, std::vector<NotificationChannel>());
 };
 
 class NotificationChannelsProviderAndroidTest : public testing::Test {
  public:
   NotificationChannelsProviderAndroidTest()
       : mock_bridge_(new MockNotificationChannelsBridge()) {}
   ~NotificationChannelsProviderAndroidTest() {
     channels_provider_->ShutdownOnUIThread();
   }
 
@@ skipping 83 matching lines @@
 TEST_F(NotificationChannelsProviderAndroidTest,
        SetWebsiteSettingDefault_DeletesChannelAndReturnsTrue) {
   InitChannelsProvider(true /* should_use_channels */);
   EXPECT_CALL(*mock_bridge_, DeleteChannel(kTestOrigin));
   bool result = channels_provider_->SetWebsiteSetting(
       ContentSettingsPattern::FromString(kTestOrigin), ContentSettingsPattern(),
       CONTENT_SETTINGS_TYPE_NOTIFICATIONS, std::string(), nullptr);
 
   EXPECT_TRUE(result);
 }
+
+TEST_F(NotificationChannelsProviderAndroidTest,
+       GetRuleIteratorWhenChannelsShouldNotBeUsed_ReturnsNull) {

[raymes, 2017/06/04 23:51:22]

nit: I think the _ReturnsNull in the name isn't necessary (I think peter@ may
have had a comment on this previously?)

[awdf, 2017/06/05 16:29:26]

Done.

+  InitChannelsProvider(false /* should_use_channels */);

[raymes, 2017/06/04 23:51:21]

nit: apparently (according to thakis@) the suggested syntax for commenting bools
is: 

InitChannelsProvider(/*should_use_channels=*/false);

https://google.github.io/styleguide/cppguide.html

[Peter Beverloo, 2017/06/05 12:40:24]

3200 vs. 60 hits. I prefer consistency -- all our current code uses the suffix.

[awdf, 2017/06/05 16:29:26]

Interesting - I agree with Peter that consistency justifies leaving it for now,
but in an ideal world the style guide should dictate style, so I'll remember
that syntax for future, thanks for bringing it to my attention.

Aside: I note the style guide also says "Consider changing the function
signature to replace a bool argument with an enum argument. This will make the
argument values self-describing" - which is a great point, so if I were to
change it I think actually I would go with something like
SystemChannelSupport::kSupported/kNotSupported

[raymes, 2017/06/06 01:39:04]

Yeah, there's probably an argument to be had about the issue which I don't
really want to be involved in :) I do think it's unfortunate to have 2 ways of
doing this going forward though. 

+  EXPECT_FALSE(channels_provider_->GetRuleIterator(
+      CONTENT_SETTINGS_TYPE_NOTIFICATIONS, std::string(),
+      false /* incognito */));
+}
+
+TEST_F(NotificationChannelsProviderAndroidTest,
+       GetRuleIteratorForIncognito_ReturnsNull) {
+  InitChannelsProvider(true /* should_use_channels */);
+  EXPECT_FALSE(
+      channels_provider_->GetRuleIterator(CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
+                                          std::string(), true /* incognito */));
+}
+
+TEST_F(NotificationChannelsProviderAndroidTest,
+       GetRuleIteratorWhenNoChannelsExist_ReturnsNull) {
+  InitChannelsProvider(true /* should_use_channels */);
+  EXPECT_CALL(*mock_bridge_, GetChannels());
+  EXPECT_FALSE(channels_provider_->GetRuleIterator(
+      CONTENT_SETTINGS_TYPE_NOTIFICATIONS, std::string(),
+      false /* incognito */));
+}
+
+TEST_F(NotificationChannelsProviderAndroidTest,
+       GetRuleIteratorWhenOneBlockedChannelExists) {
+  InitChannelsProvider(true /* should_use_channels */);
+  std::vector<NotificationChannel> channels;
+  channels.emplace_back(kTestOrigin, NotificationChannelStatus::BLOCKED);
+  EXPECT_CALL(*mock_bridge_, GetChannels()).WillOnce(Return(channels));
+  std::unique_ptr<content_settings::RuleIterator> result =
+      channels_provider_->GetRuleIterator(CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
+                                          std::string(), false /* incognito */);
+  EXPECT_TRUE(result->HasNext());
+  content_settings::Rule rule = result->Next();
+  EXPECT_EQ(rule.primary_pattern,

[raymes, 2017/06/04 23:51:22]

nit (here and below): The expected value always comes first with EXPECT_EQ

[awdf, 2017/06/05 16:29:26]

Done.

+            ContentSettingsPattern::FromString(kTestOrigin));
+  EXPECT_EQ(content_settings::ValueToContentSetting(rule.value.get()),
+            CONTENT_SETTING_BLOCK);
+  EXPECT_FALSE(result->HasNext());
+}
+
+TEST_F(NotificationChannelsProviderAndroidTest,
+       GetRuleIteratorWhenOneAllowedChannelExists) {
+  InitChannelsProvider(true /* should_use_channels */);
+  std::vector<NotificationChannel> channels;
+  channels.emplace_back(kTestOrigin, NotificationChannelStatus::ENABLED);
+  EXPECT_CALL(*mock_bridge_, GetChannels()).WillOnce(Return(channels));
+  std::unique_ptr<content_settings::RuleIterator> result =
+      channels_provider_->GetRuleIterator(CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
+                                          std::string(), false /* incognito */);
+  EXPECT_TRUE(result->HasNext());
+  content_settings::Rule rule = result->Next();
+  EXPECT_EQ(rule.primary_pattern,
+            ContentSettingsPattern::FromString(kTestOrigin));
+  EXPECT_EQ(content_settings::ValueToContentSetting(rule.value.get()),
+            CONTENT_SETTING_ALLOW);
+  EXPECT_FALSE(result->HasNext());
+}
+
+TEST_F(NotificationChannelsProviderAndroidTest,
+       GetRuleIteratorWhenMultipleChannelsExist) {
+  InitChannelsProvider(true /* should_use_channels */);
+  std::vector<NotificationChannel> channels;
+  channels.emplace_back("https://abc.com", NotificationChannelStatus::ENABLED);
+  channels.emplace_back("https://xyz.com", NotificationChannelStatus::BLOCKED);
+  EXPECT_CALL(*mock_bridge_, GetChannels()).WillOnce(Return(channels));
+  std::unique_ptr<content_settings::RuleIterator> result =
+      channels_provider_->GetRuleIterator(CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
+                                          std::string(), false /* incognito */);
+  EXPECT_TRUE(result->HasNext());
+  content_settings::Rule first_rule = result->Next();
+  EXPECT_EQ(first_rule.primary_pattern,
+            ContentSettingsPattern::FromString("https://abc.com"));
+  EXPECT_EQ(content_settings::ValueToContentSetting(first_rule.value.get()),
+            CONTENT_SETTING_ALLOW);
+  EXPECT_TRUE(result->HasNext());
+  content_settings::Rule second_rule = result->Next();
+  EXPECT_EQ(second_rule.primary_pattern,
+            ContentSettingsPattern::FromString("https://xyz.com"));
+  EXPECT_EQ(content_settings::ValueToContentSetting(second_rule.value.get()),
+            CONTENT_SETTING_BLOCK);
+  EXPECT_FALSE(result->HasNext());
+}