Limit the window of time a promo can be visible after first view.

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 31 matching lines @@
 const char kPrefPromoText[] = "text";
 const char kPrefPromoPayload[] = "payload";
 const char kPrefPromoStart[] = "start";
 const char kPrefPromoEnd[] = "end";
 const char kPrefPromoNumGroups[] = "num_groups";
 const char kPrefPromoSegment[] = "segment";
 const char kPrefPromoIncrement[] = "increment";
 const char kPrefPromoIncrementFrequency[] = "increment_frequency";
 const char kPrefPromoIncrementMax[] = "increment_max";
 const char kPrefPromoMaxViews[] = "max_views";
+const char kPrefPromoMaxSeconds[] = "max_seconds";
+const char kPrefPromoFirstViewTime[] = "first_view_time";
 const char kPrefPromoGroup[] = "group";
 const char kPrefPromoViews[] = "views";
 const char kPrefPromoClosed[] = "closed";
 
 // Returns a string suitable for the Promo Server URL 'osname' value.
 std::string PlatformString() {
 #if defined(OS_WIN)
   return "win";
 #elif defined(OS_ANDROID)
   ui::DeviceFormFactor form_factor = ui::GetDeviceFormFactor();
@@ skipping 130 matching lines @@
       promo_type_(NO_PROMO),
       promo_payload_(new base::DictionaryValue()),
       start_(0.0),
       end_(0.0),
       num_groups_(kDefaultGroupSize),
       initial_segment_(0),
       increment_(1),
       time_slice_(0),
       max_group_(0),
       max_views_(0),
+      max_seconds_(0),
+      first_view_time_(0),
       group_(0),
       views_(0),
       closed_(false),
       new_notification_(false) {
   DCHECK(prefs_);
 }
 
 NotificationPromo::~NotificationPromo() {}
 
 void NotificationPromo::InitFromJson(const base::DictionaryValue& json,
@@ skipping 65 matching lines @@
     // if no |payload.promo_message_short| is specified,
     // the first string in |strings| is used.
     base::DictionaryValue::Iterator iter(*strings);
     iter.value().GetAsString(&promo_text_);
   }
   DVLOG(1) << "promo_text_=" << promo_text_;
 
   promo->GetInteger("max_views", &max_views_);
   DVLOG(1) << "max_views_ " << max_views_;
 
+  promo->GetInteger("max_seconds", &max_seconds_);
+  DVLOG(1) << "max_seconds_ " << max_seconds_;
+
   CheckForNewNotification();
 }
 
 void NotificationPromo::CheckForNewNotification() {
   NotificationPromo old_promo;
   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_;
 
@@ skipping 37 matching lines @@
   ntp_promo->SetDouble(kPrefPromoStart, start_);
   ntp_promo->SetDouble(kPrefPromoEnd, end_);
 
   ntp_promo->SetInteger(kPrefPromoNumGroups, num_groups_);
   ntp_promo->SetInteger(kPrefPromoSegment, initial_segment_);
   ntp_promo->SetInteger(kPrefPromoIncrement, increment_);
   ntp_promo->SetInteger(kPrefPromoIncrementFrequency, time_slice_);
   ntp_promo->SetInteger(kPrefPromoIncrementMax, max_group_);
 
   ntp_promo->SetInteger(kPrefPromoMaxViews, max_views_);
+  ntp_promo->SetInteger(kPrefPromoMaxSeconds, max_seconds_);
+  ntp_promo->SetDouble(kPrefPromoFirstViewTime, first_view_time_);
 
   ntp_promo->SetInteger(kPrefPromoGroup, group_);
   ntp_promo->SetInteger(kPrefPromoViews, views_);
   ntp_promo->SetBoolean(kPrefPromoClosed, closed_);
 
   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.MergeDictionary(prefs_->GetDictionary(kPrefPromoObject));
@@ skipping 27 matching lines @@
   ntp_promo->GetDouble(kPrefPromoStart, &start_);
   ntp_promo->GetDouble(kPrefPromoEnd, &end_);
 
   ntp_promo->GetInteger(kPrefPromoNumGroups, &num_groups_);
   ntp_promo->GetInteger(kPrefPromoSegment, &initial_segment_);
   ntp_promo->GetInteger(kPrefPromoIncrement, &increment_);
   ntp_promo->GetInteger(kPrefPromoIncrementFrequency, &time_slice_);
   ntp_promo->GetInteger(kPrefPromoIncrementMax, &max_group_);
 
   ntp_promo->GetInteger(kPrefPromoMaxViews, &max_views_);
+  ntp_promo->GetInteger(kPrefPromoMaxSeconds, &max_seconds_);
+  ntp_promo->GetDouble(kPrefPromoFirstViewTime, &first_view_time_);
 
   ntp_promo->GetInteger(kPrefPromoGroup, &group_);
   ntp_promo->GetInteger(kPrefPromoViews, &views_);
   ntp_promo->GetBoolean(kPrefPromoClosed, &closed_);
 }
 
 bool NotificationPromo::CheckAppLauncher() const {
 #if !defined(ENABLE_APP_LIST)
   return true;
 #else
   bool is_app_launcher_promo = false;
   if (!promo_payload_->GetBoolean("is_app_launcher_promo",
                                   &is_app_launcher_promo))
     return true;
   return !is_app_launcher_promo ||
          !prefs_->GetBoolean(prefs::kAppLauncherIsEnabled);
 #endif  // !defined(ENABLE_APP_LIST)
 }
 
 bool NotificationPromo::CanShow() const {
   return !closed_ &&
          !promo_text_.empty() &&
          !ExceedsMaxGroup() &&
          !ExceedsMaxViews() &&
+         !ExceedsMaxSeconds() &&
          CheckAppLauncher() &&
          base::Time::FromDoubleT(StartTimeForGroup()) < base::Time::Now() &&
          base::Time::FromDoubleT(EndTime()) > base::Time::Now();
 }
 
 // static
 void NotificationPromo::HandleClosed(PromoType promo_type) {
   content::RecordAction(UserMetricsAction("NTPPromoClosed"));
   NotificationPromo promo;
   promo.InitFromPrefs(promo_type);
   if (!promo.closed_) {
     promo.closed_ = true;
     promo.WritePrefs();
   }
 }
 
 // static
 bool NotificationPromo::HandleViewed(PromoType promo_type) {
   content::RecordAction(UserMetricsAction("NTPPromoShown"));
   NotificationPromo promo;
   promo.InitFromPrefs(promo_type);
   ++promo.views_;
+  if (promo.first_view_time_ == 0) {
+    promo.first_view_time_ = base::Time::Now().ToDoubleT();
+  }
   promo.WritePrefs();
-  return promo.ExceedsMaxViews();
+  return promo.ExceedsMaxViews() || promo.ExceedsMaxSeconds();
 }
 
 bool NotificationPromo::ExceedsMaxGroup() const {
   return (max_group_ == 0) ? false : group_ >= max_group_;
 }
 
 bool NotificationPromo::ExceedsMaxViews() const {
   return (max_views_ == 0) ? false : views_ >= max_views_;
 }
 
+bool NotificationPromo::ExceedsMaxSeconds() const {
+  if (max_seconds_ == 0 || first_view_time_ == 0)
+    return false;
+
+  const base::Time last_view_time = base::Time::FromDoubleT(first_view_time_) +
+                                    base::TimeDelta::FromSeconds(max_seconds_);
+  return last_view_time < base::Time::Now();
+}
+
 // static
 GURL NotificationPromo::PromoServerURL() {
   GURL url(promo_server_url);
   AppendQueryParameter(&url, "dist", ChannelString());
   AppendQueryParameter(&url, "osname", PlatformString());
   AppendQueryParameter(&url, "branding", chrome::VersionInfo().Version());
   AppendQueryParameter(&url, "osver", base::SysInfo::OperatingSystemVersion());
   DVLOG(1) << "PromoServerURL=" << url.spec();
   // Note that locale param is added by WebResourceService.
   return url;
 }
 
 double NotificationPromo::StartTimeForGroup() const {
   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_;
 }