[Android] Implement GetRuleIterator for channels provider

chrome/browser/notifications/notification_channels_provider_android.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/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/content_settings/core/browser/content_settings_details.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/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings.h"
 #include "components/content_settings/core/common/content_settings_pattern.h"
 #include "jni/NotificationSettingsBridge_jni.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 #include "url/url_constants.h"
 
 using base::android::AttachCurrentThread;
@@ skipping 25 matching lines @@
     return static_cast<NotificationChannelStatus>(
         Java_NotificationSettingsBridge_getChannelStatus(
             env, ConvertUTF8ToJavaString(env, origin)));
   }
 
   void DeleteChannel(const std::string& origin) override {
     JNIEnv* env = AttachCurrentThread();
     Java_NotificationSettingsBridge_deleteChannel(
         env, ConvertUTF8ToJavaString(env, origin));
   }
+
+  std::vector<Channel> GetChannels() override {
+    JNIEnv* env = AttachCurrentThread();
+    ScopedJavaLocalRef<jobjectArray> raw_channels =
+        Java_NotificationSettingsBridge_getSiteChannels(env);
+    jsize num_channels = env->GetArrayLength(raw_channels.obj());
+    std::vector<Channel> channels;
+    for (jsize i = 0; i < num_channels; ++i) {
+      jobject jchannel = env->GetObjectArrayElement(raw_channels.obj(), i);
+      Channel channel = {.origin = ConvertJavaStringToUTF8(
+                             Java_SiteChannel_getOrigin(env, jchannel)),
+                         .status = static_cast<NotificationChannelStatus>(
+                             Java_SiteChannel_getStatus(env, jchannel))};

[Peter Beverloo, 2017/06/02 15:14:26]

Channel channel;
channel.origin = ConvertJ....
channel.status = static_cast<...

Alternatively, and maybe cleaner, you could give the Channel struct a
constructor that takes both. Then lines 69 - 73 could be replaced by:

channels.emplace_back(
        ConvertJavaStringToUTF8(Java_SiteChannel_getOrigin(env, jchannel)),
        static_cast<NotificationChannelStatus>(
            Java_SiteChannel_getStatus(env, jchannel)));

That constructs a new Channel object in its actual memory location in the
channels vector.

[awdf, 2017/06/02 16:59:48]

Done (with a constructor).

+      channels.push_back(channel);
+    }
+    return channels;
+  }
 };
 
+class ListIterator : public content_settings::RuleIterator {
+ public:
+  explicit ListIterator(const std::list<content_settings::Rule>& rules)
+      : rules_(rules) {}
+
+  ~ListIterator() override {}
+
+  bool HasNext() const override { return !rules_.empty(); }
+
+  content_settings::Rule Next() override {
+    // |front()| returns a reference but we're going to discard the object
+    // referred to; force copying here.
+    content_settings::Rule rule = rules_.front();
+    rules_.pop_front();
+    return rule;
+  }
+
+ private:
+  std::list<content_settings::Rule> rules_;

[Peter Beverloo, 2017/06/02 15:14:26]

Since an instance of the Rule object will be returned, what you could do is
change this class to just store the std::vector<Channel> you create above, and
the index of where you are in the vector.

Next() would then look something like:

content_settings::Rule Next() override {
  DCHECK(HasNext());
  return content_settings::Rule(
      ContentSettingsPattern::FromString(channels_[index_].origin),
      ContentSettingsPattern(),
      new
base::Value(ChannelStatusToContentSetting(channels_[index_++].status)));
}

[awdf, 2017/06/02 16:59:48]

Done.

+};
+
+ContentSetting ChannelStatusToContentSetting(NotificationChannelStatus status) {
+  switch (status) {
+    case NotificationChannelStatus::ENABLED:
+      return CONTENT_SETTING_ALLOW;
+    case NotificationChannelStatus::BLOCKED:
+      return CONTENT_SETTING_BLOCK;
+    case NotificationChannelStatus::UNAVAILABLE:
+      return CONTENT_SETTING_DEFAULT;
+  }
+  NOTREACHED();
+  return CONTENT_SETTING_DEFAULT;
+}
+
 }  // anonymous namespace
 
 NotificationChannelsProviderAndroid::NotificationChannelsProviderAndroid()
     : NotificationChannelsProviderAndroid(
           base::MakeUnique<NotificationChannelsBridgeImpl>()) {}
 
 NotificationChannelsProviderAndroid::NotificationChannelsProviderAndroid(
     std::unique_ptr<NotificationChannelsBridge> bridge)
     : bridge_(std::move(bridge)),
       should_use_channels_(bridge_->ShouldUseChannelSettings()) {}
 
 NotificationChannelsProviderAndroid::~NotificationChannelsProviderAndroid() =
     default;
 
 std::unique_ptr<content_settings::RuleIterator>
 NotificationChannelsProviderAndroid::GetRuleIterator(
     ContentSettingsType content_type,
     const content_settings::ResourceIdentifier& resource_identifier,
     bool incognito) const {
-  // TODO(crbug.com/700377) return rule iterator over all channels
-  return nullptr;
+  if (content_type != CONTENT_SETTINGS_TYPE_NOTIFICATIONS || incognito ||
+      !should_use_channels_) {
+    return nullptr;
+  }
+  std::vector<Channel> channels = bridge_->GetChannels();
+  if (channels.empty()) {
+    return nullptr;
+  }
+  std::list<content_settings::Rule> rules;
+  for (const auto& channel : channels) {
+    DCHECK(channel.status != NotificationChannelStatus::UNAVAILABLE);

[Peter Beverloo, 2017/06/02 15:14:26]

nit: DCHECK_NE

[awdf, 2017/06/02 16:59:48]

Done.

+    rules.push_back(content_settings::Rule(
+        ContentSettingsPattern::FromString(channel.origin),
+        ContentSettingsPattern(),
+        new base::Value(ChannelStatusToContentSetting(channel.status))));
+  }
+  return std::unique_ptr<content_settings::RuleIterator>(
+      new ListIterator(rules));

[Peter Beverloo, 2017/06/02 15:14:26]

nit (the compiler can figure out typing):

return base::MakeUnique<ListIterator>(std::move(channels));

[awdf, 2017/06/02 16:59:48]

Done.

 }
 
 bool NotificationChannelsProviderAndroid::SetWebsiteSetting(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     const content_settings::ResourceIdentifier& resource_identifier,
     base::Value* value) {
   if (content_type != CONTENT_SETTINGS_TYPE_NOTIFICATIONS ||
       !should_use_channels_) {
@@ skipping 31 matching lines @@
 
 void NotificationChannelsProviderAndroid::ClearAllContentSettingsRules(
     ContentSettingsType content_type) {
   // TODO(crbug.com/700377): If |content_type| == NOTIFICATIONS, delete
   // all channels.
 }
 
 void NotificationChannelsProviderAndroid::ShutdownOnUIThread() {
   RemoveAllObservers();
 }