Added in-session captive portal notification.

chrome/browser/chromeos/net/network_portal_notification_controller_unittest.cc

+// Copyright 2014 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 "base/command_line.h"
+#include "chrome/browser/chromeos/net/network_portal_notification_controller.h"
+#include "chromeos/chromeos_switches.h"
+#include "chromeos/network/network_state.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/message_center/message_center.h"
+#include "ui/message_center/message_center_observer.h"
+
+using message_center::MessageCenter;
+
+namespace chromeos {
+
+namespace {
+
+const char* kNotificationId =
+    NetworkPortalNotificationController::kNotificationId;
+
+bool HasNotification() {
+  return MessageCenter::Get()->HasNotification(kNotificationId);
+}
+
+class NotificationObserver : public message_center::MessageCenterObserver {
+ public:
+  NotificationObserver() : add_count_(0), remove_count_(0), update_count_(0) {}
+
+  // Overridden from message_center::MessageCenterObserver:
+  virtual void OnNotificationAdded(
+      const std::string& notification_id) OVERRIDE {
+    if (notification_id == kNotificationId)
+      ++add_count_;
+  }
+
+  virtual void OnNotificationRemoved(const std::string& notification_id,
+                                     bool /* by_user */) OVERRIDE {
+    if (notification_id == kNotificationId)
+      ++remove_count_;
+  }
+
+  virtual void OnNotificationUpdated(
+      const std::string& notification_id) OVERRIDE {
+    if (notification_id == kNotificationId)
+      ++update_count_;
+  }
+
+  unsigned add_count() const { return add_count_; }
+  unsigned remove_count() const { return remove_count_; }
+  unsigned update_count() const { return update_count_; }
+
+ private:
+  unsigned add_count_;
+  unsigned remove_count_;
+  unsigned update_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(NotificationObserver);
+};
+
+}  // namespace
+
+class NetworkPortalNotificationControllerTest : public testing::Test {
+ public:
+  NetworkPortalNotificationControllerTest() {}
+  virtual ~NetworkPortalNotificationControllerTest() {}
+
+  virtual void SetUp() OVERRIDE {
+    CommandLine* cl = CommandLine::ForCurrentProcess();
+    cl->AppendSwitch(switches::kEnableNetworkPortalNotification);
+    MessageCenter::Initialize();
+    MessageCenter::Get()->AddObserver(&observer_);

[Jun Mukai, 2014/02/20 18:30:15]

What I wanted to say is putting into constructor and destructor of
NotificationObserver -- but certainly you'll have to add some other tricks
instead.

[oshima, 2014/02/20 19:00:54]

I still think it's good practice to use SetUp/TearDown. 
SetUp/TearDown always works, while ctor/dtor may or may not work depending on
what you do in initialization code.

+  }
+
+  virtual void TearDown() OVERRIDE {
+    MessageCenter::Get()->RemoveObserver(&observer_);
+    MessageCenter::Shutdown();
+  }
+
+ protected:
+  void OnPortalDetectionCompleted(
+      const NetworkState* network,
+      const NetworkPortalDetector::CaptivePortalState& state) {
+    controller_.OnPortalDetectionCompleted(network, state);
+  }
+
+  NotificationObserver& observer() { return observer_; }
+
+ private:
+  NetworkPortalNotificationController controller_;
+  NotificationObserver observer_;
+
+  DISALLOW_COPY_AND_ASSIGN(NetworkPortalNotificationControllerTest);
+};
+
+TEST_F(NetworkPortalNotificationControllerTest, NetworkStateChanged) {
+  NetworkState wifi("wifi");
+  NetworkPortalDetector::CaptivePortalState wifi_state;
+
+  // Notification is not displayed for online state.
+  wifi_state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE;
+  wifi_state.response_code = 204;
+  OnPortalDetectionCompleted(&wifi, wifi_state);
+  ASSERT_FALSE(HasNotification());
+
+  // Notification is displayed for portal state
+  wifi_state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL;
+  wifi_state.response_code = 200;
+  OnPortalDetectionCompleted(&wifi, wifi_state);
+  ASSERT_TRUE(HasNotification());
+
+  // Notification is closed for online state.
+  wifi_state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE;
+  wifi_state.response_code = 204;
+  OnPortalDetectionCompleted(&wifi, wifi_state);
+  ASSERT_FALSE(HasNotification());
+}
+
+TEST_F(NetworkPortalNotificationControllerTest, NetworkChanged) {
+  NetworkState wifi1("wifi1");
+  NetworkPortalDetector::CaptivePortalState wifi1_state;
+  wifi1_state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL;
+  wifi1_state.response_code = 200;
+  OnPortalDetectionCompleted(&wifi1, wifi1_state);
+  ASSERT_TRUE(HasNotification());
+
+  MessageCenter::Get()->RemoveNotification(kNotificationId, true /* by_user */);
+  ASSERT_FALSE(HasNotification());
+
+  // User already closed notification about portal state for this network,
+  // so notification shouldn't be displayed second time.
+  OnPortalDetectionCompleted(&wifi1, wifi1_state);
+  ASSERT_FALSE(HasNotification());
+
+  NetworkState wifi2("wifi2");
+  NetworkPortalDetector::CaptivePortalState wifi2_state;
+  wifi2_state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE;
+  wifi2_state.response_code = 204;
+
+  // Second network is in online state, so there shouldn't be any
+  // notifications.
+  OnPortalDetectionCompleted(&wifi2, wifi2_state);
+  ASSERT_FALSE(HasNotification());
+
+  // User switches back to the first network, so notification should
+  // be displayed.
+  OnPortalDetectionCompleted(&wifi1, wifi1_state);
+  ASSERT_TRUE(HasNotification());
+}
+
+TEST_F(NetworkPortalNotificationControllerTest, NotificationUpdated) {
+  NetworkPortalDetector::CaptivePortalState portal_state;
+  portal_state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL;
+  portal_state.response_code = 200;
+
+  // First network is behind a captive portal, so notification should
+  // be displayed.
+  NetworkState wifi1("wifi1");
+  OnPortalDetectionCompleted(&wifi1, portal_state);
+  ASSERT_TRUE(HasNotification());
+  EXPECT_EQ(1u, observer().add_count());
+  EXPECT_EQ(0u, observer().remove_count());
+  EXPECT_EQ(0u, observer().update_count());
+
+  // Second network is also behind a captive portal, so notification
+  // should be updated.
+  NetworkState wifi2("wifi2");
+  OnPortalDetectionCompleted(&wifi2, portal_state);
+  ASSERT_TRUE(HasNotification());
+  EXPECT_EQ(1u, observer().add_count());
+  EXPECT_EQ(0u, observer().remove_count());
+  EXPECT_EQ(1u, observer().update_count());
+
+  // User closes the notification.
+  MessageCenter::Get()->RemoveNotification(kNotificationId, true /* by_user */);
+  ASSERT_FALSE(HasNotification());
+  EXPECT_EQ(1u, observer().add_count());
+  EXPECT_EQ(1u, observer().remove_count());
+  EXPECT_EQ(1u, observer().update_count());
+
+  // Portal detector notified that second network is still behind captive
+  // portal, but user already closed the notification, so there should
+  // not be any notifications.
+  OnPortalDetectionCompleted(&wifi2, portal_state);
+  ASSERT_FALSE(HasNotification());
+  EXPECT_EQ(1u, observer().add_count());
+  EXPECT_EQ(1u, observer().remove_count());
+  EXPECT_EQ(1u, observer().update_count());
+
+  // Network was switched (by shill or by user) to wifi1. Notification
+  // should be displayed.
+  OnPortalDetectionCompleted(&wifi1, portal_state);
+  ASSERT_TRUE(HasNotification());
+  EXPECT_EQ(2u, observer().add_count());
+  EXPECT_EQ(1u, observer().remove_count());
+  EXPECT_EQ(1u, observer().update_count());
+}
+
+}  // namespace chromeos