Remove unnecessary promo_type_ field from notification_promo.h/.cc.

ios/chrome/browser/notification_promo_unittest.cc

 // Copyright (c) 2016 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 <stddef.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/json/json_reader.h"
@@ skipping 93 matching lines @@
          it.Advance()) {
       std::string value;
       it.value().GetAsString(&value);
       field_trial_params[it.key()] = value;
     }
 
     variations::AssociateVariationParams("IOSNTPPromotion", "Group1",
                                          field_trial_params);
     base::FieldTrialList::CreateFieldTrial("IOSNTPPromotion", "Group1");
 
-    promo_type_ = NotificationPromo::MOBILE_NTP_WHATS_NEW_PROMO;
     promo_text_ = promo_text;
 
     start_ = start;
     end_ = year_from_now_epoch;
 
     promo_id_ = promo_id;
     max_views_ = max_views;
     max_seconds_ = max_seconds;
 
     closed_ = false;
     received_notification_ = false;
   }
 
   void InitPromoFromVariations() {
     notification_promo_.InitFromVariations();
 
     // Test the fields.
     TestServerProvidedParameters();
   }
 
   void InitPromoFromJson() {
-    notification_promo_.InitFromJson(*test_json_, promo_type_);
+    notification_promo_.InitFromJson(*test_json_);
 
     // Test the fields.
     TestServerProvidedParameters();
   }
 
   void TestServerProvidedParameters() {
     // Check values.
     EXPECT_EQ(notification_promo_.promo_text_, promo_text_);
 
     EXPECT_DOUBLE_EQ(notification_promo_.start_, start_);
     EXPECT_DOUBLE_EQ(notification_promo_.end_, end_);
 
     EXPECT_EQ(notification_promo_.promo_id_, promo_id_);
     EXPECT_EQ(notification_promo_.max_views_, max_views_);
     EXPECT_EQ(notification_promo_.max_seconds_, max_seconds_);
   }
 
   void TestViews() {
     notification_promo_.views_ = notification_promo_.max_views_ - 2;
     notification_promo_.WritePrefs();
 
     // Initialize promo from saved prefs and server params.
     NotificationPromo first_promo(&local_state_);
     first_promo.InitFromVariations();
-    first_promo.InitFromPrefs(promo_type_);
+    first_promo.InitFromPrefs();
     EXPECT_EQ(first_promo.max_views_ - 2, first_promo.views_);
     EXPECT_TRUE(first_promo.CanShow());
     first_promo.HandleViewed();
 
     // Initialize another promo to test that the new views were recorded
     // correctly in prefs.
     NotificationPromo second_promo(&local_state_);
     second_promo.InitFromVariations();
-    second_promo.InitFromPrefs(promo_type_);
+    second_promo.InitFromPrefs();
     EXPECT_EQ(second_promo.max_views_ - 1, second_promo.views_);
     EXPECT_TRUE(second_promo.CanShow());
     second_promo.HandleViewed();
 
     NotificationPromo third_promo(&local_state_);
     third_promo.InitFromVariations();
-    third_promo.InitFromPrefs(promo_type_);
+    third_promo.InitFromPrefs();
     EXPECT_EQ(third_promo.max_views_, third_promo.views_);
     EXPECT_FALSE(third_promo.CanShow());
 
     // Test out of range views.
     for (int i = max_views_; i < max_views_ * 2; ++i) {
       third_promo.views_ = i;
       EXPECT_FALSE(third_promo.CanShow());
     }
 
     // Test in range views.
     for (int i = 0; i < max_views_; ++i) {
       third_promo.views_ = i;
       EXPECT_TRUE(third_promo.CanShow());
     }
 
     // Reset prefs to default.
     notification_promo_.views_ = 0;
     notification_promo_.WritePrefs();
   }
 
   void TestClosed() {
     // Initialize promo from saved prefs and server params.
     NotificationPromo first_promo(&local_state_);
     first_promo.InitFromVariations();
-    first_promo.InitFromPrefs(promo_type_);
+    first_promo.InitFromPrefs();
     EXPECT_FALSE(first_promo.closed_);
     EXPECT_TRUE(first_promo.CanShow());
     first_promo.HandleClosed();
 
     // Initialize another promo to test that the the closing of the promo was
     // recorded correctly in prefs.
     NotificationPromo second_promo(&local_state_);
     second_promo.InitFromVariations();
-    second_promo.InitFromPrefs(promo_type_);
+    second_promo.InitFromPrefs();
     EXPECT_TRUE(second_promo.closed_);
     EXPECT_FALSE(second_promo.CanShow());
 
     // Reset prefs to default.
     second_promo.closed_ = false;
     EXPECT_TRUE(second_promo.CanShow());
     second_promo.WritePrefs();
   }
 
   void TestPromoText() {
@@ skipping 47 matching lines @@
   }
 
   // Tests that the first view time is recorded properly in prefs when the
   // first view occurs.
   void TestFirstViewTimeRecorded() {
     EXPECT_DOUBLE_EQ(0, notification_promo_.first_view_time_);
     notification_promo_.HandleViewed();
 
     NotificationPromo temp_promo(&local_state_);
     temp_promo.InitFromVariations();
-    temp_promo.InitFromPrefs(promo_type_);
+    temp_promo.InitFromPrefs();
     EXPECT_NE(0, temp_promo.first_view_time_);
 
     notification_promo_.views_ = 0;
     notification_promo_.first_view_time_ = 0;
     notification_promo_.WritePrefs();
   }
 
   // Tests that if data is saved in the old pref structure, it is successfully
   // migrated to the new structure that supports saving multiple promos.
   // TODO(crbug.com/623726) Remove this method when migration is no longer
@@ skipping 19 matching lines @@
 
     std::string promo_list_key = "mobile_ntp_whats_new_promo";
     std::string promo_dict_key = "ios.ntppromo";
 
     base::DictionaryValue promo_dict;
     promo_dict.Set(promo_list_key, promo_list);
     local_state_.Set(promo_dict_key, promo_dict);
 
     // Initialize promo and verify that its instance variables match the data
     // saved in the old structure.
-    promo.InitFromPrefs(promo_type_);
+    promo.InitFromPrefs();
     EXPECT_DOUBLE_EQ(first_view_time, promo.first_view_time_);
     EXPECT_EQ(views, promo.views_);
     EXPECT_EQ(closed, promo.closed_);
     EXPECT_FALSE(promo.CanShow());
 
     // Verify that old pref structure was cleared.
     const base::DictionaryValue* current_promo_dict =
         local_state_.GetDictionary(promo_dict_key);
     // Do not continue further if no dictionary was found at the key in prefs.
     ASSERT_TRUE(current_promo_dict);
     const base::ListValue* current_promo_list = NULL;
     current_promo_dict->GetList(promo_list_key, &current_promo_list);
     EXPECT_FALSE(current_promo_list);
   }
 
   const NotificationPromo& promo() const { return notification_promo_; }
 
  protected:
   TestingPrefServiceSimple local_state_;
 
  private:
   NotificationPromo notification_promo_;
   std::unique_ptr<base::FieldTrialList> field_trial_list_;
   bool received_notification_;
   std::unique_ptr<base::DictionaryValue> test_json_;
 
-  NotificationPromo::PromoType promo_type_;
   std::string promo_text_;
 
   double start_;
   double end_;
   int promo_id_;
   int max_views_;
   int max_seconds_;
 
   bool closed_;
 };
@@ skipping 80 matching lines @@
       "  \"promo_id\":0"
       "}",
       "What do you think of Chrome?",
       933672366,  // unix epoch for 3 Aug 1999 9:26:06 GMT.
       0, 30, 30);
   InitPromoFromVariations();
   TestMigrationOfOldPrefs();
 }
 
 }  // namespace ios