Support for promo_type.

chrome/browser/web_resource/notification_promo.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 "chrome/browser/web_resource/notification_promo.h"
 
 #include <cmath>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 87 matching lines @@
       return "dev";
     case chrome::VersionInfo::CHANNEL_BETA:
       return "beta";
     case chrome::VersionInfo::CHANNEL_STABLE:
       return "stable";
     default:
       return "none";
   }
 }
 
+struct PromoMapEntry {
+  NotificationPromo::PromoType promo_type;
+  const char* promo_type_str;
+};
+
+const PromoMapEntry kPromoMap[] = {
+    { NotificationPromo::NO_PROMO, "" },
+    { NotificationPromo::NTP_NOTIFICATION_PROMO, "ntp_notification_promo" },
+    { NotificationPromo::BUBBLE_PROMO, "bubble_promo" },
+    { NotificationPromo::MOBILE_NTP_SYNC_PROMO, "mobile_ntp_sync_promo" },
+};
+
+// Convert PromoType to appropriate string.
+const char* PromoTypeToString(NotificationPromo::PromoType promo_type) {
+  for (size_t i = 0; i < arraysize(kPromoMap); ++i) {
+    if (kPromoMap[i].promo_type == promo_type)
+      return kPromoMap[i].promo_type_str;
+  }
+  NOTREACHED();
+  return "";
+}
+
 // TODO(achuith): remove this in m23.
 void ClearDeprecatedPrefs(PrefService* prefs) {
   prefs->RegisterStringPref(prefs::kNtpPromoLine,
                             std::string(),
                             PrefService::UNSYNCABLE_PREF);
   prefs->ClearPref(prefs::kNtpPromoLine);
 #if defined(OS_ANDROID)
   prefs->RegisterStringPref(prefs::kNtpPromoLineLong,
                             std::string(),
                             PrefService::UNSYNCABLE_PREF);
@@ skipping 58 matching lines @@
   prefs->ClearPref(prefs::kNtpPromoGroupMax);
   prefs->ClearPref(prefs::kNtpPromoViewsMax);
   prefs->ClearPref(prefs::kNtpPromoGroup);
   prefs->ClearPref(prefs::kNtpPromoViews);
   prefs->ClearPref(prefs::kNtpPromoClosed);
   prefs->ClearPref(prefs::kNtpPromoGplusRequired);
 }
 
 }  // namespace
 
-const char NotificationPromo::kNtpNotificationPromoType[] =
-    "ntp_notification_promo";
-const char NotificationPromo::kBubblePromoType[] = "bubble_promo";
-
 NotificationPromo::NotificationPromo(Profile* profile)
     : profile_(profile),
       prefs_(profile_->GetPrefs()),
-      promo_type_(kNtpNotificationPromoType),
+      promo_type_(NO_PROMO),
 #if defined(OS_ANDROID)
       promo_action_args_(new base::ListValue),
-#endif  // defined(OS_ANDROID)
+#endif
       start_(0.0),
       end_(0.0),
       num_groups_(kDefaultGroupSize),
       initial_segment_(0),
       increment_(1),
       time_slice_(0),
       max_group_(0),
       max_views_(0),
       group_(0),
       views_(0),
       closed_(false),
       gplus_required_(false),
       new_notification_(false) {
   DCHECK(profile);
   DCHECK(prefs_);
 }
 
 NotificationPromo::~NotificationPromo() {}
 
-void NotificationPromo::InitFromJson(const DictionaryValue& json) {
+void NotificationPromo::InitFromJson(const DictionaryValue& json,
+                                     PromoType promo_type) {
+  promo_type_ = promo_type;
   const ListValue* promo_list = NULL;
-#if !defined(OS_ANDROID)
-  if (!json.GetList(promo_type_, &promo_list))
-    return;
-#else
-  if (!json.GetList("mobile_ntp_sync_promo", &promo_list)) {
-    LOG(ERROR) << "Malfromed JSON: not a mobile_ntp_sync_promo";
+  if (!json.GetList(PromoTypeToString(promo_type_), &promo_list)) {
+    LOG(ERROR) << "Malformed JSON: not " << PromoTypeToString(promo_type_);
     return;
   }
-#endif  // !defined(OS_ANDROID)
 
   // No support for multiple promos yet. Only consider the first one.
   const DictionaryValue* promo = NULL;
   if (!promo_list->GetDictionary(0, &promo))
     return;
 
   // Strings. Assume the first one is the promo text.
   const DictionaryValue* strings = NULL;
   if (promo->GetDictionary("strings", &strings)) {
 #if !defined(OS_ANDROID)
@@ skipping 99 matching lines @@
       promo_action_args_->Append(base::Value::CreateStringValue(value));
     }
   }
 #endif  // defined(OS_ANDROID)
 
   CheckForNewNotification();
 }
 
 void NotificationPromo::CheckForNewNotification() {
   NotificationPromo old_promo(profile_);
-  old_promo.InitFromPrefs();
+  old_promo.InitFromPrefs(promo_type_);
   const double old_start = old_promo.start_;
   const double old_end = old_promo.end_;
   const std::string old_promo_text = old_promo.promo_text_;
 
   new_notification_ =
       old_start != start_ || old_end != end_ || old_promo_text != promo_text_;
   if (new_notification_)
     OnNewNotification();
 }
 
@@ skipping 36 matching lines @@
   ntp_promo->SetInteger(kPrefPromoGroup, group_);
   ntp_promo->SetInteger(kPrefPromoViews, views_);
   ntp_promo->SetBoolean(kPrefPromoClosed, closed_);
 
   ntp_promo->SetBoolean(kPrefPromoGPlusRequired, gplus_required_);
 
   base::ListValue* promo_list = new base::ListValue;
   promo_list->Set(0, ntp_promo);  // Only support 1 promo for now.
 
   base::DictionaryValue promo_dict;
-  promo_dict.Set(promo_type_, promo_list);
+  promo_dict.Set(PromoTypeToString(promo_type_), promo_list);
   prefs_->Set(kPrefPromoObject, promo_dict);
 }
 
-void NotificationPromo::InitFromPrefs() {
+void NotificationPromo::InitFromPrefs(PromoType promo_type) {
+  promo_type_ = promo_type;
   const base::DictionaryValue* promo_dict =
       prefs_->GetDictionary(kPrefPromoObject);
   if (!promo_dict)
     return;
 
   const base::ListValue* promo_list(NULL);
-  promo_dict->GetList(promo_type_, &promo_list);
+  promo_dict->GetList(PromoTypeToString(promo_type_), &promo_list);
   if (!promo_list)
     return;
 
   const base::DictionaryValue* ntp_promo(NULL);
   promo_list->GetDictionary(0, &ntp_promo);
   if (!ntp_promo)
     return;
 
   ntp_promo->GetString(kPrefPromoText, &promo_text_);
 #if defined(OS_ANDROID)
@@ skipping 26 matching lines @@
 bool NotificationPromo::CanShow() const {
   return !closed_ &&
          !promo_text_.empty() &&
          !ExceedsMaxGroup() &&
          !ExceedsMaxViews() &&
          base::Time::FromDoubleT(StartTimeForGroup()) < base::Time::Now() &&
          base::Time::FromDoubleT(EndTime()) > base::Time::Now() &&
          IsGPlusRequired();
 }
 
-void NotificationPromo::HandleClosed() {
+// static
+void NotificationPromo::HandleClosed(Profile* profile, PromoType promo_type) {
   content::RecordAction(UserMetricsAction("NTPPromoClosed"));
-  InitFromPrefs();
-  if (!closed_) {
-    closed_ = true;
-    WritePrefs();
+  NotificationPromo promo(profile);
+  promo.InitFromPrefs(promo_type);
+  if (!promo.closed_) {
+    promo.closed_ = true;
+    promo.WritePrefs();
   }
 }
 
-bool NotificationPromo::HandleViewed() {
+// static
+bool NotificationPromo::HandleViewed(Profile* profile, PromoType promo_type) {
   content::RecordAction(UserMetricsAction("NTPPromoShown"));
-  InitFromPrefs();
-  ++views_;
-  WritePrefs();
-  return ExceedsMaxViews();
+  NotificationPromo promo(profile);
+  promo.InitFromPrefs(promo_type);
+  ++promo.views_;
+  promo.WritePrefs();
+  return promo.ExceedsMaxViews();
 }
 
 bool NotificationPromo::ExceedsMaxGroup() const {
   return (max_group_ == 0) ? false : group_ >= max_group_;
 }
 
 bool NotificationPromo::ExceedsMaxViews() const {
   return (max_views_ == 0) ? false : views_ >= max_views_;
 }
 
@@ skipping 19 matching lines @@
   if (group_ < initial_segment_)
     return start_;
   return start_ +
       std::ceil(static_cast<float>(group_ - initial_segment_ + 1) / increment_)
       * time_slice_;
 }
 
 double NotificationPromo::EndTime() const {
   return end_;
 }