Add new promotional line for NTP....

chrome/browser/web_resource/web_resource_service.cc

 // Copyright (c) 2010 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/web_resource_service.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/string_util.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_thread.h"
+#include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/profile.h"
+#include "chrome/browser/sync/sync_ui_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/net/url_fetcher.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/pref_names.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request_status.h"
 
+namespace {
+
+// Delay on first fetch so we don't interfere with startup.
+static const int kStartResourceFetchDelay = 5000;
+
+// Long delay between calls to update the cache (48 hours).
+static const int kLongCacheUpdateDelay = 48 * 60 * 60 * 1000;
+
+// Short delay between calls to update the cache (8 hours).
+static const int kShortCacheUpdateDelay = 8 * 60 * 60 * 1000;
+
+}  // namespace
+
 const char* WebResourceService::kCurrentTipPrefName = "current_tip";
 const char* WebResourceService::kTipCachePrefName = "tips";
 
 class WebResourceService::WebResourceFetcher
     : public URLFetcher::Delegate {
  public:
   explicit WebResourceFetcher(WebResourceService* web_resource_service) :
       ALLOW_THIS_IN_INITIALIZER_LIST(fetcher_factory_(this)),
       web_resource_service_(web_resource_service) {
   }
 
   // Delay initial load of resource data into cache so as not to interfere
   // with startup time.
   void StartAfterDelay(int delay_ms) {
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
       fetcher_factory_.NewRunnableMethod(&WebResourceFetcher::StartFetch),
                                          delay_ms);
   }
 
   // Initializes the fetching of data from the resource server.  Data
   // load calls OnURLFetchComplete.
   void StartFetch() {
     // Balanced in OnURLFetchComplete.
     web_resource_service_->AddRef();
     // First, put our next cache load on the MessageLoop.
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
-      fetcher_factory_.NewRunnableMethod(&WebResourceFetcher::StartFetch),
-                                         kCacheUpdateDelay);
+        fetcher_factory_.NewRunnableMethod(&WebResourceFetcher::StartFetch),
+            web_resource_service_->cache_update_delay());
     // If we are still fetching data, exit.
     if (web_resource_service_->in_fetch_)
       return;
     else
       web_resource_service_->in_fetch_ = true;
 
     url_fetcher_.reset(new URLFetcher(GURL(
         web_resource_service_->web_resource_server_),
         URLFetcher::GET, this));
     // Do not let url fetcher affect existing state in profile (by setting
@@ skipping 116 matching lines @@
   scoped_refptr<WebResourceService> web_resource_service_;
 
   // Holds raw JSON string.
   const std::string& json_data_;
 
   // True if we got a response from the utility process and have cleaned up
   // already.
   bool got_response_;
 };
 
-// Server for custom logo signals.
-const char* WebResourceService::kDefaultResourceServer =
+// Server for dynamically loaded NTP HTML elements. TODO(mirandac): append
+// locale for future usage, when we're serving localizable strings.
+const char* WebResourceService::kDefaultWebResourceServer =
     "https://www.google.com/support/chrome/bin/topic/30248/inproduct";
 
 WebResourceService::WebResourceService(Profile* profile)
     : prefs_(profile->GetPrefs()),
+      profile_(profile),
       in_fetch_(false) {
   Init();
 }
 
 WebResourceService::~WebResourceService() { }
 
 void WebResourceService::Init() {
+  // Much shorter update time if looking for a promo to display.
+  cache_update_delay_ =
+      WebResourceServiceUtil::CanShowPromo(profile_) ? kShortCacheUpdateDelay :
+                                                       kLongCacheUpdateDelay;
   resource_dispatcher_host_ = g_browser_process->resource_dispatcher_host();
   web_resource_fetcher_.reset(new WebResourceFetcher(this));
   prefs_->RegisterStringPref(prefs::kNTPWebResourceCacheUpdate, "0");
   prefs_->RegisterRealPref(prefs::kNTPCustomLogoStart, 0);
   prefs_->RegisterRealPref(prefs::kNTPCustomLogoEnd, 0);
+  prefs_->RegisterRealPref(prefs::kNTPPromoStart, 0);
+  prefs_->RegisterRealPref(prefs::kNTPPromoEnd, 0);
+  prefs_->RegisterStringPref(prefs::kNTPPromoLine, std::string());
+  prefs_->RegisterBooleanPref(prefs::kNTPPromoClosed, false);
 
-  if (prefs_->HasPrefPath(prefs::kNTPLogoResourceServer)) {
-    web_resource_server_ = prefs_->GetString(prefs::kNTPLogoResourceServer);
+  if (prefs_->HasPrefPath(prefs::kNTPWebResourceCache)) {
+    web_resource_server_ = prefs_->GetString(prefs::kNTPWebResourceCache);
     return;
   }
 
   // If we have not yet set a server, reset and force an immediate update.
-  web_resource_server_ = kDefaultResourceServer;
+  web_resource_server_ = kDefaultWebResourceServer;
   prefs_->SetString(prefs::kNTPWebResourceCacheUpdate, "");
 }
 
 void WebResourceService::EndFetch() {
   in_fetch_ = false;
 }
 
 void WebResourceService::OnWebResourceUnpacked(
   const DictionaryValue& parsed_json) {
   UnpackLogoSignal(parsed_json);
+  if (WebResourceServiceUtil::CanShowPromo(profile_))
+    UnpackPromoSignal(parsed_json);
   EndFetch();
 }
 
 void WebResourceService::StartAfterDelay() {
   int delay = kStartResourceFetchDelay;
   // Check whether we have ever put a value in the web resource cache;
   // if so, pull it out and see if it's time to update again.
   if (prefs_->HasPrefPath(prefs::kNTPWebResourceCacheUpdate)) {
     std::string last_update_pref =
         prefs_->GetString(prefs::kNTPWebResourceCacheUpdate);
     if (!last_update_pref.empty()) {
       double last_update_value;
       base::StringToDouble(last_update_pref, &last_update_value);
-      int ms_until_update = kCacheUpdateDelay -
+      int ms_until_update = cache_update_delay_ -
           static_cast<int>((base::Time::Now() - base::Time::FromDoubleT(
           last_update_value)).InMilliseconds());
 
-      delay = ms_until_update > kCacheUpdateDelay ?
-              kCacheUpdateDelay : (ms_until_update < kStartResourceFetchDelay ?
-                                   kStartResourceFetchDelay : ms_until_update);
+      delay = ms_until_update > cache_update_delay_ ?
+          cache_update_delay_ : (ms_until_update < kStartResourceFetchDelay ?
+                                kStartResourceFetchDelay : ms_until_update);
     }
   }
 
   // Start fetch and wait for UpdateResourceCache.
   web_resource_fetcher_->StartAfterDelay(static_cast<int>(delay));
 }
 
 void WebResourceService::UpdateResourceCache(const std::string& json_data) {
   UnpackerClient* client = new UnpackerClient(this, json_data);
   client->Start();
 
   // Update resource server and cache update time in preferences.
   prefs_->SetString(prefs::kNTPWebResourceCacheUpdate,
       base::DoubleToString(base::Time::Now().ToDoubleT()));
-  prefs_->SetString(prefs::kNTPLogoResourceServer, web_resource_server_);
+  prefs_->SetString(prefs::kNTPWebResourceServer, web_resource_server_);
 }
 
 void WebResourceService::UnpackTips(const DictionaryValue& parsed_json) {
   // Get dictionary of cached preferences.
   web_resource_cache_ =
       prefs_->GetMutableDictionary(prefs::kNTPWebResourceCache);
 
   // The list of individual tips.
   ListValue* tip_holder = new ListValue();
   web_resource_cache_->Set(WebResourceService::kTipCachePrefName, tip_holder);
@@ skipping 22 matching lines @@
       }
       // If tips exist, set current index to 0.
       if (!inproduct.empty()) {
         web_resource_cache_->SetInteger(
           WebResourceService::kCurrentTipPrefName, 0);
       }
     }
   }
 }
 
+void WebResourceService::UnpackPromoSignal(const DictionaryValue& parsed_json) {
+  DictionaryValue* topic_dict;
+  ListValue* answer_list;
+  double old_promo_start = 0;
+  double old_promo_end = 0;
+  double promo_start = 0;
+  double promo_end = 0;
+
+  // Check for preexisting start and end values.
+  if (prefs_->HasPrefPath(prefs::kNTPPromoStart) &&
+      prefs_->HasPrefPath(prefs::kNTPPromoEnd)) {
+    old_promo_start = prefs_->GetReal(prefs::kNTPPromoStart);
+    old_promo_end = prefs_->GetReal(prefs::kNTPPromoEnd);
+  }
+
+  // Check for newly received start and end values.
+  if (parsed_json.GetDictionary("topic", &topic_dict)) {
+    if (topic_dict->GetList("answers", &answer_list)) {
+      std::string promo_start_string = "";
+      std::string promo_end_string = "";
+      std::string promo_string = "";
+      for (ListValue::const_iterator tip_iter = answer_list->begin();
+           tip_iter != answer_list->end(); ++tip_iter) {
+        if (!(*tip_iter)->IsType(Value::TYPE_DICTIONARY))
+          continue;
+        DictionaryValue* a_dic =
+            static_cast<DictionaryValue*>(*tip_iter);
+        std::string promo_signal;
+        if (a_dic->GetString("name", &promo_signal)) {
+          if (promo_signal == "promo_start") {
+            a_dic->GetString("inproduct", &promo_start_string);
+            a_dic->GetString("tooltip", &promo_string);
+            prefs_->SetString(prefs::kNTPPromoLine, promo_string);
+          } else if (promo_signal == "promo_end") {
+            a_dic->GetString("inproduct", &promo_end_string);
+          }
+        }
+      }
+      if (!promo_start_string.empty() &&
+          promo_start_string.length() > 0 &&
+          !promo_end_string.empty() &&
+          promo_end_string.length() > 0) {
+        base::Time start_time;
+        base::Time end_time;
+        if (base::Time::FromString(
+                ASCIIToWide(promo_start_string).c_str(), &start_time) &&
+            base::Time::FromString(
+                ASCIIToWide(promo_end_string).c_str(), &end_time)) {
+          promo_start = start_time.ToDoubleT();
+          promo_end = end_time.ToDoubleT();
+        }
+      }
+    }
+  }
+
+  // If start or end times have changed, trigger a new web resource
+  // notification, so that the logo on the NTP is updated. This check is
+  // outside the reading of the web resource data, because the absence of
+  // dates counts as a triggering change if there were dates before.
+  if (!(old_promo_start == promo_start) ||
+      !(old_promo_end == promo_end)) {
+    prefs_->SetReal(prefs::kNTPPromoStart, promo_start);
+    prefs_->SetReal(prefs::kNTPPromoEnd, promo_end);
+    NotificationService* service = NotificationService::current();
+    service->Notify(NotificationType::WEB_RESOURCE_STATE_CHANGED,
+                    Source<WebResourceService>(this),
+                    NotificationService::NoDetails());
+  }
+}
+
 void WebResourceService::UnpackLogoSignal(const DictionaryValue& parsed_json) {
   DictionaryValue* topic_dict;
   ListValue* answer_list;
   double old_logo_start = 0;
   double old_logo_end = 0;
   double logo_start = 0;
   double logo_end = 0;
 
   // Check for preexisting start and end values.
   if (prefs_->HasPrefPath(prefs::kNTPCustomLogoStart) &&
@@ skipping 41 matching lines @@
 
   // If logo start or end times have changed, trigger a new web resource
   // notification, so that the logo on the NTP is updated. This check is
   // outside the reading of the web resource data, because the absence of
   // dates counts as a triggering change if there were dates before.
   if (!(old_logo_start == logo_start) ||
       !(old_logo_end == logo_end)) {
     prefs_->SetReal(prefs::kNTPCustomLogoStart, logo_start);
     prefs_->SetReal(prefs::kNTPCustomLogoEnd, logo_end);
     NotificationService* service = NotificationService::current();
-    service->Notify(NotificationType::WEB_RESOURCE_AVAILABLE,
+    service->Notify(NotificationType::WEB_RESOURCE_STATE_CHANGED,
                     Source<WebResourceService>(this),
                     NotificationService::NoDetails());
   }
 }
+
+
+namespace WebResourceServiceUtil {
+
+bool CanShowPromo(Profile* profile) {
+  bool promo_closed = false;
+  PrefService* prefs = profile->GetPrefs();
+  if (prefs->HasPrefPath(prefs::kNTPPromoClosed))
+    promo_closed = prefs->GetBoolean(prefs::kNTPPromoClosed);
+  ExtensionsService* extensions_service = profile->GetExtensionsService();
+  bool promo_options_set =
+      sync_ui_util::GetStatus(
+          profile->GetProfileSyncService()) == sync_ui_util::SYNCED ||
+      (extensions_service && extensions_service->HasInstalledExtensions());
+
+  return !promo_closed &&
+         promo_options_set &&
+         g_browser_process->GetApplicationLocale() == "en-US";
+}
+
+}  // namespace WebResourceService
+