Support for promo_type.

chrome/browser/web_resource/promo_resource_service_unittest.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 <vector>
 
 #include "base/json/json_reader.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
@@ skipping 59 matching lines @@
             int num_groups, int initial_segment, int increment,
             int time_slice, int max_group, int max_views,
             bool gplus_required) {
     Value* value(base::JSONReader::Read(json));
     ASSERT_TRUE(value);
     DictionaryValue* dict = NULL;
     value->GetAsDictionary(&dict);
     ASSERT_TRUE(dict);
     test_json_.reset(dict);
 
+    promo_type_ =
+#if !defined(OS_ANDROID)
+        NotificationPromo::NTP_NOTIFICATION_PROMO;
+#else
+        NotificationPromo::MOBILE_NTP_SYNC_PROMO;
+#endif
+
     promo_text_ = promo_text;
 
 #if defined(OS_ANDROID)
     promo_text_long_ = promo_text_long;
     promo_action_type_ = promo_action_type;
     promo_action_args_.push_back(promo_action_arg0);
     promo_action_args_.push_back(promo_action_arg1);
 #endif  // defined(OS_ANDROID)
 
     start_ = start;
     end_ = end;
 
     num_groups_ = num_groups;
     initial_segment_ = initial_segment;
     increment_ = increment;
     time_slice_ = time_slice;
     max_group_ = max_group;
 
     max_views_ = max_views;
 
     gplus_required_ = gplus_required;
 
     closed_ = false;
     received_notification_ = false;
   }
 
   void InitPromoFromJson(bool should_receive_notification) {
-    notification_promo_.InitFromJson(*test_json_);
+    notification_promo_.InitFromJson(*test_json_, promo_type_);
     EXPECT_EQ(should_receive_notification,
               notification_promo_.new_notification());
 
     // Test the fields.
     TestNotification();
   }
 
   void TestNotification() {
     // Check values.
     EXPECT_EQ(notification_promo_.promo_text_, promo_text_);
@@ skipping 31 matching lines @@
     // Views should be 0 for now.
     EXPECT_EQ(notification_promo_.views_, 0);
 
     EXPECT_EQ(notification_promo_.gplus_required_, gplus_required_);
   }
 
   // Create a new NotificationPromo from prefs and compare to current
   // notification.
   void TestInitFromPrefs() {
     NotificationPromo prefs_notification_promo(profile_);
-    prefs_notification_promo.InitFromPrefs();
+    prefs_notification_promo.InitFromPrefs(promo_type_);
 
     EXPECT_EQ(notification_promo_.prefs_,
               prefs_notification_promo.prefs_);
     EXPECT_EQ(notification_promo_.promo_text_,
               prefs_notification_promo.promo_text_);
 #if defined(OS_ANDROID)
     EXPECT_EQ(notification_promo_.promo_text_long_,
               prefs_notification_promo.promo_text_long_);
     EXPECT_EQ(notification_promo_.promo_action_type_,
               prefs_notification_promo.promo_action_type_);
@@ skipping 59 matching lines @@
       notification_promo_.group_ = i;
       EXPECT_TRUE(notification_promo_.CanShow());
     }
     notification_promo_.WritePrefs();
   }
 
   void TestViews() {
     notification_promo_.views_ = notification_promo_.max_views_ - 2;
     notification_promo_.WritePrefs();
 
+    NotificationPromo::HandleViewed(profile_, promo_type_);
     NotificationPromo new_promo(profile_);
-    new_promo.HandleViewed();
+    new_promo.InitFromPrefs(promo_type_);
+    EXPECT_EQ(new_promo.max_views_ - 1, new_promo.views_);
     EXPECT_TRUE(new_promo.CanShow());
-    new_promo.HandleViewed();
+    NotificationPromo::HandleViewed(profile_, promo_type_);
+    new_promo.InitFromPrefs(promo_type_);
+    EXPECT_EQ(new_promo.max_views_, new_promo.views_);
     EXPECT_FALSE(new_promo.CanShow());
 
-    notification_promo_.InitFromPrefs();
-    EXPECT_FALSE(notification_promo_.CanShow());
-
     // Test out of range views.
     for (int i = max_views_; i < max_views_ * 2; ++i) {
-      notification_promo_.views_ = i;
-      EXPECT_FALSE(notification_promo_.CanShow());
+      new_promo.views_ = i;
+      EXPECT_FALSE(new_promo.CanShow());
     }
 
     // Test in range views.
     for (int i = 0; i < max_views_; ++i) {
-      notification_promo_.views_ = i;
-      EXPECT_TRUE(notification_promo_.CanShow());
+      new_promo.views_ = i;
+      EXPECT_TRUE(new_promo.CanShow());
     }
-    notification_promo_.WritePrefs();
+    new_promo.WritePrefs();
   }
 
   void TestClosed() {
     NotificationPromo new_promo(profile_);
-    new_promo.InitFromPrefs();
+    new_promo.InitFromPrefs(promo_type_);
+    EXPECT_FALSE(new_promo.closed_);
     EXPECT_TRUE(new_promo.CanShow());
-    new_promo.HandleClosed();
-    EXPECT_FALSE(new_promo.CanShow());
-    new_promo.InitFromPrefs();
+
+    NotificationPromo::HandleClosed(profile_, promo_type_);
+    new_promo.InitFromPrefs(promo_type_);
+    EXPECT_TRUE(new_promo.closed_);
     EXPECT_FALSE(new_promo.CanShow());
 
-    notification_promo_.closed_ = true;
-    EXPECT_FALSE(notification_promo_.CanShow());
-
-    notification_promo_.closed_ = false;
-    EXPECT_TRUE(notification_promo_.CanShow());
-    notification_promo_.WritePrefs();
+    new_promo.closed_ = false;
+    EXPECT_TRUE(new_promo.CanShow());
+    new_promo.WritePrefs();
   }
 
   void TestPromoText() {
     notification_promo_.promo_text_.clear();
     EXPECT_FALSE(notification_promo_.CanShow());
 
     notification_promo_.promo_text_ = promo_text_;
     EXPECT_TRUE(notification_promo_.CanShow());
   }
 
@@ skipping 84 matching lines @@
     EXPECT_TRUE(notification_promo_.CanShow());
   }
 
  private:
   Profile* profile_;
   PrefService* prefs_;
   NotificationPromo notification_promo_;
   bool received_notification_;
   scoped_ptr<DictionaryValue> test_json_;
 
+  NotificationPromo::PromoType promo_type_;
   std::string promo_text_;
 #if defined(OS_ANDROID)
   std::string promo_text_long_;
   std::string promo_action_type_;
   std::vector<std::string> promo_action_args_;
 #endif  // defined(OS_ANDROID)
 
   double start_;
   double end_;
 
@@ skipping 127 matching lines @@
   promo_test.TestIncrement();
   promo_test.TestGplus();
 }
 
 TEST_F(PromoResourceServiceTest, PromoServerURLTest) {
   GURL promo_server_url = NotificationPromo::PromoServerURL();
   EXPECT_FALSE(promo_server_url.is_empty());
   EXPECT_TRUE(promo_server_url.SchemeIs("https"));
   // TODO(achuith): Test this better.
 }