Move PromoResourceService from Profile to BrowserProcessImpl/local_state().

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"
 #include "base/rand_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
+#include "base/threading/thread_restrictions.h"
 #include "base/time.h"
 #include "base/values.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
-#include "chrome/browser/profiles/profile_impl.h"
+#include "chrome/browser/prefs/pref_service_simple.h"
+#include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/browser/web_resource/promo_resource_service.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/net/url_util.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/user_metrics.h"
 #include "googleurl/src/gurl.h"
 
 #if defined(OS_ANDROID)
 #include "base/command_line.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 17 matching lines @@
 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 kPrefPromoGroup[] = "group";
 const char kPrefPromoViews[] = "views";
 const char kPrefPromoClosed[] = "closed";
-const char kPrefPromoGPlusRequired[] = "gplus_required";
 
 // Returns a string suitable for the Promo Server URL 'osname' value.
 std::string PlatformString() {
 #if defined(OS_WIN)
   return "win";
 #elif defined(OS_IOS)
   // TODO(noyau): add iOS-specific implementation
   const bool isTablet = false;
   return std::string("ios-") + (isTablet ? "tablet" : "phone");
 #elif defined(OS_MACOSX)
@@ skipping 115 matching lines @@
 }
 
 void AppendQueryParameter(GURL* url,
                           const std::string& param,
                           const std::string& value) {
   *url = chrome_common_net::AppendQueryParameter(*url, param, value);
 }
 
 }  // namespace
 
-NotificationPromo::NotificationPromo(Profile* profile)
-    : profile_(profile),
-      prefs_(profile_->GetPrefs()),
+NotificationPromo::NotificationPromo()
+    : prefs_(g_browser_process->local_state()),

[Robert Sesek, 2013/01/03 21:40:10]

Can you dependency inject this, potentially allowing you to remove the
ForTesting methods?

[Dan Beam, 2013/01/03 22:47:38]

I was doing that before but estade@ and I thought a little awkwardness for
testing was an acceptable tradeoff to remove this from all the calling code's
API.

We talked about this over chat and TestingBrowserProcess::SetLocalState() seemed
to do the trick.

       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),
       group_(0),
       views_(0),
       closed_(false),
-      gplus_required_(false),
       new_notification_(false) {
-  DCHECK(profile);
   DCHECK(prefs_);
 }
 
 NotificationPromo::~NotificationPromo() {}
 
 void NotificationPromo::InitFromJson(const DictionaryValue& json,
                                      PromoType promo_type) {
   promo_type_ = promo_type;
   const ListValue* promo_list = NULL;
   DVLOG(1) << "InitFromJson " << PromoTypeToString(promo_type_);
@@ skipping 43 matching lines @@
              << ", max_group_ = " << max_group_;
   }
 
   // Strings.
   const DictionaryValue* strings = NULL;
   promo->GetDictionary("strings", &strings);
 
   // Payload.
   const DictionaryValue* payload = NULL;
   if (promo->GetDictionary("payload", &payload)) {
-    payload->GetBoolean("gplus_required", &gplus_required_);
-    DVLOG(1) << "gplus_required_ = " << gplus_required_;
-
     base::Value* ppcopy = DeepCopyAndResolveStrings(payload, strings);
     DCHECK(ppcopy && ppcopy->IsType(base::Value::TYPE_DICTIONARY));
     promo_payload_.reset(static_cast<base::DictionaryValue*>(ppcopy));
   }
 
   if (!promo_payload_->GetString("promo_message_short", &promo_text_) &&
       strings) {
     // For compatibility with the legacy desktop version,
     // if no |payload.promo_message_short| is specified,
     // the first string in |strings| is used.
     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_;
 
   CheckForNewNotification();
 }
 
 void NotificationPromo::CheckForNewNotification() {
-  NotificationPromo old_promo(profile_);
+  NotificationPromo old_promo(prefs_);
   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();
 }
 
 void NotificationPromo::OnNewNotification() {
   DVLOG(1) << "OnNewNotification";
   // Create a new promo group.
   group_ = base::RandInt(0, num_groups_ - 1);
   WritePrefs();
 }
 
 // static
+void NotificationPromo::RegisterPrefs(PrefServiceSimple* local_state) {
+  local_state->RegisterDictionaryPref(kPrefPromoObject);
+}
+
+// static
 void NotificationPromo::RegisterUserPrefs(PrefServiceSyncable* prefs) {
+  // TODO(dbeam): Remove in M28 when we're reasonably sure all prefs are gone.
   prefs->RegisterDictionaryPref(kPrefPromoObject,
-                                new base::DictionaryValue,
                                 PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->ClearPref(kPrefPromoObject);
 }
 
 void NotificationPromo::WritePrefs() {
   base::DictionaryValue* ntp_promo = new base::DictionaryValue;
   ntp_promo->SetString(kPrefPromoText, promo_text_);
   ntp_promo->Set(kPrefPromoPayload, promo_payload_->DeepCopy());
   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(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.MergeDictionary(prefs_->GetDictionary(kPrefPromoObject));
   promo_dict.Set(PromoTypeToString(promo_type_), promo_list);
   prefs_->Set(kPrefPromoObject, promo_dict);
   DVLOG(1) << "WritePrefs " << promo_dict;
 }
 
@@ skipping 26 matching lines @@
   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(kPrefPromoGroup, &group_);
   ntp_promo->GetInteger(kPrefPromoViews, &views_);
   ntp_promo->GetBoolean(kPrefPromoClosed, &closed_);
-
-  ntp_promo->GetBoolean(kPrefPromoGPlusRequired, &gplus_required_);
 }
 
 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();
+         base::Time::FromDoubleT(EndTime()) > base::Time::Now();
 }
 
 // static
-void NotificationPromo::HandleClosed(Profile* profile, PromoType promo_type) {
+void NotificationPromo::HandleClosed(PromoType promo_type) {
   content::RecordAction(UserMetricsAction("NTPPromoClosed"));
-  NotificationPromo promo(profile);
-  promo.InitFromPrefs(promo_type);
-  if (!promo.closed_) {
-    promo.closed_ = true;
-    promo.WritePrefs();
+  NotificationPromo promo;
+  HandleClosedInternal(&promo, promo_type);
+}
+
+// static
+bool NotificationPromo::HandleViewed(PromoType promo_type) {
+  content::RecordAction(UserMetricsAction("NTPPromoShown"));
+  NotificationPromo promo;
+  return HandleViewedInternal(&promo, promo_type);
+}
+
+// static
+void NotificationPromo::HandleClosedInternal(NotificationPromo* promo,
+                                             PromoType promo_type) {
+  promo->InitFromPrefs(promo_type);
+  if (!promo->closed_) {
+    promo->closed_ = true;
+    promo->WritePrefs();
   }
 }
 
 // static
-bool NotificationPromo::HandleViewed(Profile* profile, PromoType promo_type) {
-  content::RecordAction(UserMetricsAction("NTPPromoShown"));
-  NotificationPromo promo(profile);
-  promo.InitFromPrefs(promo_type);
-  ++promo.views_;
-  promo.WritePrefs();
-  return promo.ExceedsMaxViews();
+bool NotificationPromo::HandleViewedInternal(NotificationPromo* promo,
+                                             PromoType promo_type) {
+  promo->InitFromPrefs(promo_type);
+  ++promo->views_;
+  promo->WritePrefs();
+  return promo->ExceedsMaxViews();
+}
+
+// Testing constructor.
+NotificationPromo::NotificationPromo(PrefService* prefs)
+    : prefs_(prefs),
+      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),
+      group_(0),
+      views_(0),
+      closed_(false),
+      new_notification_(false) {
+  DCHECK(prefs_);
+}
+
+// static
+void NotificationPromo::HandleClosedForTesting(PrefService* prefs,
+                                               PromoType promo_type) {
+  NotificationPromo testing_promo(prefs);
+  HandleClosedInternal(&testing_promo, promo_type);
+}
+
+// static
+bool NotificationPromo::HandleViewedForTesting(PrefService* prefs,
+                                               PromoType promo_type) {
+  NotificationPromo testing_promo(prefs);
+  return HandleViewedInternal(&testing_promo, promo_type);
 }
 
 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::IsGPlusRequired() const {
-  return !gplus_required_ || prefs_->GetBoolean(prefs::kIsGooglePlusUser);
-}
-
 // 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_;
 }