chrome/browser/web_resource/notification_promo.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/web_resource/notification_promo.h"
   6
   7 #include <cmath>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/prefs/pref_registry_simple.h"
  12 #include "base/prefs/pref_service.h"
  13 #include "base/rand_util.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/sys_info.h"
  17 #include "base/threading/thread_restrictions.h"
  18 #include "base/time/time.h"
  19 #include "base/values.h"
  20 #include "chrome/browser/browser_process.h"
  21 #include "chrome/browser/web_resource/promo_resource_service.h"
  22 #include "chrome/common/chrome_version_info.h"
  23 #include "chrome/common/pref_names.h"
  24 #include "components/pref_registry/pref_registry_syncable.h"
  25 #include "content/public/browser/user_metrics.h"
  26 #include "net/base/url_util.h"
  27 #include "ui/base/device_form_factor.h"
  28 #include "url/gurl.h"
  29
  30 using base::UserMetricsAction;
  31
  32 namespace {
  33
  34 const int kDefaultGroupSize = 100;
  35
  36 const char promo_server_url[] = "https://clients3.google.com/crsignal/client";
  37
  38 // The name of the preference that stores the promotion object.
  39 const char kPrefPromoObject[] = "promo";
  40
  41 // Keys in the kPrefPromoObject dictionary; used only here.
  42 const char kPrefPromoText[] = "text";
  43 const char kPrefPromoPayload[] = "payload";
  44 const char kPrefPromoStart[] = "start";
  45 const char kPrefPromoEnd[] = "end";
  46 const char kPrefPromoNumGroups[] = "num_groups";
  47 const char kPrefPromoSegment[] = "segment";
  48 const char kPrefPromoIncrement[] = "increment";
  49 const char kPrefPromoIncrementFrequency[] = "increment_frequency";
  50 const char kPrefPromoIncrementMax[] = "increment_max";
  51 const char kPrefPromoMaxViews[] = "max_views";
  52 const char kPrefPromoGroup[] = "group";
  53 const char kPrefPromoViews[] = "views";
  54 const char kPrefPromoClosed[] = "closed";
  55
  56 // Returns a string suitable for the Promo Server URL 'osname' value.
  57 std::string PlatformString() {
  58 #if defined(OS_WIN)
  59   return "win";
  60 #elif defined(OS_ANDROID)
  61   ui::DeviceFormFactor form_factor = ui::GetDeviceFormFactor();
  62   return std::string("android-") +
  63       (form_factor == ui::DEVICE_FORM_FACTOR_TABLET ? "tablet" : "phone");
  64 #elif defined(OS_IOS)
  65   ui::DeviceFormFactor form_factor = ui::GetDeviceFormFactor();
  66   return std::string("ios-") +
  67       (form_factor == ui::DEVICE_FORM_FACTOR_TABLET ? "tablet" : "phone");
  68 #elif defined(OS_MACOSX)
  69   return "mac";
  70 #elif defined(OS_CHROMEOS)
  71   return "chromeos";
  72 #elif defined(OS_LINUX)
  73   return "linux";
  74 #else
  75   return "none";
  76 #endif
  77 }
  78
  79 // Returns a string suitable for the Promo Server URL 'dist' value.
  80 const char* ChannelString() {
  81 #if defined (OS_WIN)
  82   // GetChannel hits the registry on Windows. See http://crbug.com/70898.
  83   // TODO(achuith): Move NotificationPromo::PromoServerURL to the blocking pool.
  84   base::ThreadRestrictions::ScopedAllowIO allow_io;
  85 #endif
  86   const chrome::VersionInfo::Channel channel =
  87       chrome::VersionInfo::GetChannel();
  88   switch (channel) {
  89     case chrome::VersionInfo::CHANNEL_CANARY:
  90       return "canary";
  91     case chrome::VersionInfo::CHANNEL_DEV:
  92       return "dev";
  93     case chrome::VersionInfo::CHANNEL_BETA:
  94       return "beta";
  95     case chrome::VersionInfo::CHANNEL_STABLE:
  96       return "stable";
  97     default:
  98       return "none";
  99   }
 100 }
 101
 102 struct PromoMapEntry {
 103   NotificationPromo::PromoType promo_type;
 104   const char* promo_type_str;
 105 };
 106
 107 const PromoMapEntry kPromoMap[] = {
 108     { NotificationPromo::NO_PROMO, "" },
 109     { NotificationPromo::NTP_NOTIFICATION_PROMO, "ntp_notification_promo" },
 110     { NotificationPromo::NTP_BUBBLE_PROMO, "ntp_bubble_promo" },
 111     { NotificationPromo::MOBILE_NTP_SYNC_PROMO, "mobile_ntp_sync_promo" },
 112 };
 113
 114 // Convert PromoType to appropriate string.
 115 const char* PromoTypeToString(NotificationPromo::PromoType promo_type) {
 116   for (size_t i = 0; i < arraysize(kPromoMap); ++i) {
 117     if (kPromoMap[i].promo_type == promo_type)
 118       return kPromoMap[i].promo_type_str;
 119   }
 120   NOTREACHED();
 121   return "";
 122 }
 123
 124 // Deep-copies a node, replacing any "value" that is a key
 125 // into "strings" dictionary with its value from "strings".
 126 // E.g. for
 127 //   {promo_action_args:['MSG_SHORT']} + strings:{MSG_SHORT:'yes'}
 128 // it will return
 129 //   {promo_action_args:['yes']}
 130 // |node| - a value to be deep copied and resolved.
 131 // |strings| - a dictionary of strings to be used for resolution.
 132 // Returns a _new_ object that is a deep copy with replacements.
 133 // TODO(aruslan): http://crbug.com/144320 Consider moving it to values.cc/h.
 134 base::Value* DeepCopyAndResolveStrings(
 135     const base::Value* node,
 136     const base::DictionaryValue* strings) {
 137   switch (node->GetType()) {
 138     case base::Value::TYPE_LIST: {
 139       const base::ListValue* list = static_cast<const base::ListValue*>(node);
 140       base::ListValue* copy = new base::ListValue;
 141       for (base::ListValue::const_iterator it = list->begin();
 142            it != list->end();
 143            ++it) {
 144         base::Value* child_copy = DeepCopyAndResolveStrings(*it, strings);
 145         copy->Append(child_copy);
 146       }
 147       return copy;
 148     }
 149
 150     case base::Value::TYPE_DICTIONARY: {
 151       const base::DictionaryValue* dict =
 152           static_cast<const base::DictionaryValue*>(node);
 153       base::DictionaryValue* copy = new base::DictionaryValue;
 154       for (base::DictionaryValue::Iterator it(*dict);
 155            !it.IsAtEnd();
 156            it.Advance()) {
 157         base::Value* child_copy = DeepCopyAndResolveStrings(&it.value(),
 158                                                             strings);
 159         copy->SetWithoutPathExpansion(it.key(), child_copy);
 160       }
 161       return copy;
 162     }
 163
 164     case base::Value::TYPE_STRING: {
 165       std::string value;
 166       bool rv = node->GetAsString(&value);
 167       DCHECK(rv);
 168       std::string actual_value;
 169       if (!strings || !strings->GetString(value, &actual_value))
 170         actual_value = value;
 171       return new base::StringValue(actual_value);
 172     }
 173
 174     default:
 175       // For everything else, just make a copy.
 176       return node->DeepCopy();
 177   }
 178 }
 179
 180 void AppendQueryParameter(GURL* url,
 181                           const std::string& param,
 182                           const std::string& value) {
 183   *url = net::AppendQueryParameter(*url, param, value);
 184 }
 185
 186 }  // namespace
 187
 188 NotificationPromo::NotificationPromo()
 189     : prefs_(g_browser_process->local_state()),
 190       promo_type_(NO_PROMO),
 191       promo_payload_(new base::DictionaryValue()),
 192       start_(0.0),
 193       end_(0.0),
 194       num_groups_(kDefaultGroupSize),
 195       initial_segment_(0),
 196       increment_(1),
 197       time_slice_(0),
 198       max_group_(0),
 199       max_views_(0),
 200       group_(0),
 201       views_(0),
 202       closed_(false),
 203       new_notification_(false) {
 204   DCHECK(prefs_);
 205 }
 206
 207 NotificationPromo::~NotificationPromo() {}
 208
 209 void NotificationPromo::InitFromJson(const base::DictionaryValue& json,
 210                                      PromoType promo_type) {
 211   promo_type_ = promo_type;
 212   const base::ListValue* promo_list = NULL;
 213   DVLOG(1) << "InitFromJson " << PromoTypeToString(promo_type_);
 214   if (!json.GetList(PromoTypeToString(promo_type_), &promo_list))
 215     return;
 216
 217   // No support for multiple promos yet. Only consider the first one.
 218   const base::DictionaryValue* promo = NULL;
 219   if (!promo_list->GetDictionary(0, &promo))
 220     return;
 221
 222   // Date.
 223   const base::ListValue* date_list = NULL;
 224   if (promo->GetList("date", &date_list)) {
 225     const base::DictionaryValue* date;
 226     if (date_list->GetDictionary(0, &date)) {
 227       std::string time_str;
 228       base::Time time;
 229       if (date->GetString("start", &time_str) &&
 230           base::Time::FromString(time_str.c_str(), &time)) {
 231         start_ = time.ToDoubleT();
 232         DVLOG(1) << "start str=" << time_str
 233                  << ", start_="<< base::DoubleToString(start_);
 234       }
 235       if (date->GetString("end", &time_str) &&
 236           base::Time::FromString(time_str.c_str(), &time)) {
 237         end_ = time.ToDoubleT();
 238         DVLOG(1) << "end str =" << time_str
 239                  << ", end_=" << base::DoubleToString(end_);
 240       }
 241     }
 242   }
 243
 244   // Grouping.
 245   const base::DictionaryValue* grouping = NULL;
 246   if (promo->GetDictionary("grouping", &grouping)) {
 247     grouping->GetInteger("buckets", &num_groups_);
 248     grouping->GetInteger("segment", &initial_segment_);
 249     grouping->GetInteger("increment", &increment_);
 250     grouping->GetInteger("increment_frequency", &time_slice_);
 251     grouping->GetInteger("increment_max", &max_group_);
 252
 253     DVLOG(1) << "num_groups_ = " << num_groups_
 254              << ", initial_segment_ = " << initial_segment_
 255              << ", increment_ = " << increment_
 256              << ", time_slice_ = " << time_slice_
 257              << ", max_group_ = " << max_group_;
 258   }
 259
 260   // Strings.
 261   const base::DictionaryValue* strings = NULL;
 262   promo->GetDictionary("strings", &strings);
 263
 264   // Payload.
 265   const base::DictionaryValue* payload = NULL;
 266   if (promo->GetDictionary("payload", &payload)) {
 267     base::Value* ppcopy = DeepCopyAndResolveStrings(payload, strings);
 268     DCHECK(ppcopy && ppcopy->IsType(base::Value::TYPE_DICTIONARY));
 269     promo_payload_.reset(static_cast<base::DictionaryValue*>(ppcopy));
 270   }
 271
 272   if (!promo_payload_->GetString("promo_message_short", &promo_text_) &&
 273       strings) {
 274     // For compatibility with the legacy desktop version,
 275     // if no |payload.promo_message_short| is specified,
 276     // the first string in |strings| is used.
 277     base::DictionaryValue::Iterator iter(*strings);
 278     iter.value().GetAsString(&promo_text_);
 279   }
 280   DVLOG(1) << "promo_text_=" << promo_text_;
 281
 282   promo->GetInteger("max_views", &max_views_);
 283   DVLOG(1) << "max_views_ " << max_views_;
 284
 285   CheckForNewNotification();
 286 }
 287
 288 void NotificationPromo::CheckForNewNotification() {
 289   NotificationPromo old_promo;
 290   old_promo.InitFromPrefs(promo_type_);
 291   const double old_start = old_promo.start_;
 292   const double old_end = old_promo.end_;
 293   const std::string old_promo_text = old_promo.promo_text_;
 294
 295   new_notification_ =
 296       old_start != start_ || old_end != end_ || old_promo_text != promo_text_;
 297   if (new_notification_)
 298     OnNewNotification();
 299 }
 300
 301 void NotificationPromo::OnNewNotification() {
 302   DVLOG(1) << "OnNewNotification";
 303   // Create a new promo group.
 304   group_ = base::RandInt(0, num_groups_ - 1);
 305   WritePrefs();
 306 }
 307
 308 // static
 309 void NotificationPromo::RegisterPrefs(PrefRegistrySimple* registry) {
 310   registry->RegisterDictionaryPref(kPrefPromoObject);
 311 }
 312
 313 // static
 314 void NotificationPromo::RegisterProfilePrefs(
 315     user_prefs::PrefRegistrySyncable* registry) {
 316   // TODO(dbeam): Registered only for migration. Remove in M28 when
 317   // we're reasonably sure all prefs are gone.
 318   // http://crbug.com/168887
 319   registry->RegisterDictionaryPref(
 320       kPrefPromoObject, user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 321 }
 322
 323 // static
 324 void NotificationPromo::MigrateUserPrefs(PrefService* user_prefs) {
 325   user_prefs->ClearPref(kPrefPromoObject);
 326 }
 327
 328 void NotificationPromo::WritePrefs() {
 329   base::DictionaryValue* ntp_promo = new base::DictionaryValue;
 330   ntp_promo->SetString(kPrefPromoText, promo_text_);
 331   ntp_promo->Set(kPrefPromoPayload, promo_payload_->DeepCopy());
 332   ntp_promo->SetDouble(kPrefPromoStart, start_);
 333   ntp_promo->SetDouble(kPrefPromoEnd, end_);
 334
 335   ntp_promo->SetInteger(kPrefPromoNumGroups, num_groups_);
 336   ntp_promo->SetInteger(kPrefPromoSegment, initial_segment_);
 337   ntp_promo->SetInteger(kPrefPromoIncrement, increment_);
 338   ntp_promo->SetInteger(kPrefPromoIncrementFrequency, time_slice_);
 339   ntp_promo->SetInteger(kPrefPromoIncrementMax, max_group_);
 340
 341   ntp_promo->SetInteger(kPrefPromoMaxViews, max_views_);
 342
 343   ntp_promo->SetInteger(kPrefPromoGroup, group_);
 344   ntp_promo->SetInteger(kPrefPromoViews, views_);
 345   ntp_promo->SetBoolean(kPrefPromoClosed, closed_);
 346
 347   base::ListValue* promo_list = new base::ListValue;
 348   promo_list->Set(0, ntp_promo);  // Only support 1 promo for now.
 349
 350   base::DictionaryValue promo_dict;
 351   promo_dict.MergeDictionary(prefs_->GetDictionary(kPrefPromoObject));
 352   promo_dict.Set(PromoTypeToString(promo_type_), promo_list);
 353   prefs_->Set(kPrefPromoObject, promo_dict);
 354   DVLOG(1) << "WritePrefs " << promo_dict;
 355 }
 356
 357 void NotificationPromo::InitFromPrefs(PromoType promo_type) {
 358   promo_type_ = promo_type;
 359   const base::DictionaryValue* promo_dict =
 360       prefs_->GetDictionary(kPrefPromoObject);
 361   if (!promo_dict)
 362     return;
 363
 364   const base::ListValue* promo_list = NULL;
 365   promo_dict->GetList(PromoTypeToString(promo_type_), &promo_list);
 366   if (!promo_list)
 367     return;
 368
 369   const base::DictionaryValue* ntp_promo = NULL;
 370   promo_list->GetDictionary(0, &ntp_promo);
 371   if (!ntp_promo)
 372     return;
 373
 374   ntp_promo->GetString(kPrefPromoText, &promo_text_);
 375   const base::DictionaryValue* promo_payload = NULL;
 376   if (ntp_promo->GetDictionary(kPrefPromoPayload, &promo_payload))
 377     promo_payload_.reset(promo_payload->DeepCopy());
 378
 379   ntp_promo->GetDouble(kPrefPromoStart, &start_);
 380   ntp_promo->GetDouble(kPrefPromoEnd, &end_);
 381
 382   ntp_promo->GetInteger(kPrefPromoNumGroups, &num_groups_);
 383   ntp_promo->GetInteger(kPrefPromoSegment, &initial_segment_);
 384   ntp_promo->GetInteger(kPrefPromoIncrement, &increment_);
 385   ntp_promo->GetInteger(kPrefPromoIncrementFrequency, &time_slice_);
 386   ntp_promo->GetInteger(kPrefPromoIncrementMax, &max_group_);
 387
 388   ntp_promo->GetInteger(kPrefPromoMaxViews, &max_views_);
 389
 390   ntp_promo->GetInteger(kPrefPromoGroup, &group_);
 391   ntp_promo->GetInteger(kPrefPromoViews, &views_);
 392   ntp_promo->GetBoolean(kPrefPromoClosed, &closed_);
 393 }
 394
 395 bool NotificationPromo::CheckAppLauncher() const {
 396 #if !defined(ENABLE_APP_LIST)
 397   return true;
 398 #else
 399   bool is_app_launcher_promo = false;
 400   if (!promo_payload_->GetBoolean("is_app_launcher_promo",
 401                                   &is_app_launcher_promo))
 402     return true;
 403   return !is_app_launcher_promo ||
 404          !prefs_->GetBoolean(prefs::kAppLauncherIsEnabled);
 405 #endif  // !defined(ENABLE_APP_LIST)
 406 }
 407
 408 bool NotificationPromo::CanShow() const {
 409   return !closed_ &&
 410          !promo_text_.empty() &&
 411          !ExceedsMaxGroup() &&
 412          !ExceedsMaxViews() &&
 413          CheckAppLauncher() &&
 414          base::Time::FromDoubleT(StartTimeForGroup()) < base::Time::Now() &&
 415          base::Time::FromDoubleT(EndTime()) > base::Time::Now();
 416 }
 417
 418 // static
 419 void NotificationPromo::HandleClosed(PromoType promo_type) {
 420   content::RecordAction(UserMetricsAction("NTPPromoClosed"));
 421   NotificationPromo promo;
 422   promo.InitFromPrefs(promo_type);
 423   if (!promo.closed_) {
 424     promo.closed_ = true;
 425     promo.WritePrefs();
 426   }
 427 }
 428
 429 // static
 430 bool NotificationPromo::HandleViewed(PromoType promo_type) {
 431   content::RecordAction(UserMetricsAction("NTPPromoShown"));
 432   NotificationPromo promo;
 433   promo.InitFromPrefs(promo_type);
 434   ++promo.views_;
 435   promo.WritePrefs();
 436   return promo.ExceedsMaxViews();
 437 }
 438
 439 bool NotificationPromo::ExceedsMaxGroup() const {
 440   return (max_group_ == 0) ? false : group_ >= max_group_;
 441 }
 442
 443 bool NotificationPromo::ExceedsMaxViews() const {
 444   return (max_views_ == 0) ? false : views_ >= max_views_;
 445 }
 446
 447 // static
 448 GURL NotificationPromo::PromoServerURL() {
 449   GURL url(promo_server_url);
 450   AppendQueryParameter(&url, "dist", ChannelString());
 451   AppendQueryParameter(&url, "osname", PlatformString());
 452   AppendQueryParameter(&url, "branding", chrome::VersionInfo().Version());
 453   AppendQueryParameter(&url, "osver", base::SysInfo::OperatingSystemVersion());
 454   DVLOG(1) << "PromoServerURL=" << url.spec();
 455   // Note that locale param is added by WebResourceService.
 456   return url;
 457 }
 458
 459 double NotificationPromo::StartTimeForGroup() const {
 460   if (group_ < initial_segment_)
 461     return start_;
 462   return start_ +
 463       std::ceil(static_cast<float>(group_ - initial_segment_ + 1) / increment_)
 464       * time_slice_;
 465 }
 466
 467 double NotificationPromo::EndTime() const {
 468   return end_;
 469 }