[cros] Support global carrier config.

chrome/browser/chromeos/customization_document.cc

 // Copyright (c) 2011 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/chromeos/customization_document.h"
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
@@ skipping 26 matching lines @@
 const char kHelpPageAttr[] = "help_page";
 const char kEulaPageAttr[] = "eula_page";
 const char kAppContentAttr[] = "app_content";
 const char kInitialStartPageAttr[] = "initial_start_page";
 const char kSupportPageAttr[] = "support_page";
 
 const char kAcceptedManifestVersion[] = "1.0";
 
 const char kHardwareClass[] = "hardware_class";
 
-// Carrier deals attributes.
-const char kCarrierDealsAttr[] = "carrier_deals";
-const char kDealLocaleAttr[] = "deal_locale";
-const char kInfoURLAttr[] = "info_url";
-const char kTopUpURLAttr[] = "top_up_url";
-const char kNotificationCountAttr[] = "notification_count";
-const char kDealExpireDateAttr[] = "expire_date";
-const char kLocalizedContentAttr[] = "localized_content";
-const char kNotificationTextAttr[] = "notification_text";
-
 // Path to OEM partner startup customization manifest.
 const char kStartupCustomizationManifestPath[] =
     "/opt/oem/etc/startup_manifest.json";
 
 // URL where to fetch OEM services customization manifest from.
 const char kServicesCustomizationManifestUrl[] =
     "file:///opt/oem/etc/services_manifest.json";
 
 // Name of local state option that tracks if services customization has been
 // applied.
 const char kServicesCustomizationAppliedPref[] = "ServicesCustomizationApplied";
 
 // Maximum number of retries to fetch file if network is not available.
 const int kMaxFetchRetries = 3;
 
 // Delay between file fetch retries if network is not available.
 const int kRetriesDelayInSec = 2;
 
 }  // anonymous namespace
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::ServicesCustomizationDocument);
 
 namespace chromeos {
 
 // CustomizationDocument implementation. ---------------------------------------
 
-CustomizationDocument::CustomizationDocument() {}
+CustomizationDocument::CustomizationDocument(
+    const std::string& accepted_version)
+    : accepted_version_(accepted_version) {}
 
 CustomizationDocument::~CustomizationDocument() {}
 
 bool CustomizationDocument::LoadManifestFromFile(
     const FilePath& manifest_path) {
   std::string manifest;
   if (!file_util::ReadFileToString(manifest_path, &manifest))
     return false;
   return LoadManifestFromString(manifest);
 }
 
 bool CustomizationDocument::LoadManifestFromString(
     const std::string& manifest) {
-  scoped_ptr<Value> root(base::JSONReader::Read(manifest, true));
+  int error_code = 0;
+  std::string error;
+  scoped_ptr<Value> root(base::JSONReader::ReadAndReturnError(manifest,
+                                                              true,
+                                                              &error_code,
+                                                              &error));
+  if (error_code != base::JSONReader::JSON_NO_ERROR)
+    LOG(ERROR) << error;
   DCHECK(root.get() != NULL);
   if (root.get() == NULL)
     return false;
   DCHECK(root->GetType() == Value::TYPE_DICTIONARY);
   if (root->GetType() == Value::TYPE_DICTIONARY) {
     root_.reset(static_cast<DictionaryValue*>(root.release()));
     std::string result;
     if (root_->GetString(kVersionAttr, &result) &&
-        result == kAcceptedManifestVersion)
+        result == accepted_version_)
       return true;
 
     LOG(ERROR) << "Wrong customization manifest version";
     root_.reset(NULL);
   }
   return false;
 }
 
 std::string CustomizationDocument::GetLocaleSpecificString(
     const std::string& locale,
@@ skipping 16 matching lines @@
     std::string result;
     if (default_dictionary->GetString(entry_name, &result))
       return result;
   }
 
   return std::string();
 }
 
 // StartupCustomizationDocument implementation. --------------------------------
 
-StartupCustomizationDocument::StartupCustomizationDocument() {
+StartupCustomizationDocument::StartupCustomizationDocument()
+    : CustomizationDocument(kAcceptedManifestVersion) {
   {
     // Loading manifest causes us to do blocking IO on UI thread.
     // Temporarily allow it until we fix http://crosbug.com/11103
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     LoadManifestFromFile(FilePath(kStartupCustomizationManifestPath));
   }
   Init(chromeos::system::StatisticsProvider::GetInstance());
 }
 
 StartupCustomizationDocument::StartupCustomizationDocument(
     chromeos::system::StatisticsProvider* statistics_provider,
-    const std::string& manifest) {
+    const std::string& manifest)
+    : CustomizationDocument(kAcceptedManifestVersion) {
   LoadManifestFromString(manifest);
   Init(statistics_provider);
 }
 
 StartupCustomizationDocument::~StartupCustomizationDocument() {}
 
 StartupCustomizationDocument* StartupCustomizationDocument::GetInstance() {
   return Singleton<StartupCustomizationDocument,
       DefaultSingletonTraits<StartupCustomizationDocument> >::get();
 }
@@ skipping 53 matching lines @@
   return GetLocaleSpecificString(locale, kSetupContentAttr, kHelpPageAttr);
 }
 
 std::string StartupCustomizationDocument::GetEULAPage(
     const std::string& locale) const {
   return GetLocaleSpecificString(locale, kSetupContentAttr, kEulaPageAttr);
 }
 
 // ServicesCustomizationDocument implementation. -------------------------------
 
-ServicesCustomizationDocument::CarrierDeal::CarrierDeal(
-    DictionaryValue* deal_dict)
-    : notification_count_(0),
-      localized_strings_(NULL) {
-  deal_dict->GetString(kDealLocaleAttr, &deal_locale_);
-  deal_dict->GetString(kInfoURLAttr, &info_url_);
-  deal_dict->GetString(kTopUpURLAttr, &top_up_url_);
-  deal_dict->GetInteger(kNotificationCountAttr, &notification_count_);
-  std::string date_string;
-  if (deal_dict->GetString(kDealExpireDateAttr, &date_string)) {
-    if (!base::Time::FromString(date_string.c_str(), &expire_date_))
-      LOG(ERROR) << "Error parsing deal_expire_date: " << date_string;
-  }
-  deal_dict->GetDictionary(kLocalizedContentAttr, &localized_strings_);
-}
-
-ServicesCustomizationDocument::CarrierDeal::~CarrierDeal() {
-}
-
-std::string ServicesCustomizationDocument::CarrierDeal::GetLocalizedString(
-    const std::string& locale, const std::string& id) const {
-  std::string result;
-  if (localized_strings_) {
-    DictionaryValue* locale_dict = NULL;
-    if (localized_strings_->GetDictionary(locale, &locale_dict) &&
-        locale_dict->GetString(id, &result)) {
-      return result;
-    } else if (localized_strings_->GetDictionary(kDefaultAttr, &locale_dict) &&
-               locale_dict->GetString(id, &result)) {
-      return result;
-    }
-  }
-  return result;
-}
-
 ServicesCustomizationDocument::ServicesCustomizationDocument()
-  : url_(kServicesCustomizationManifestUrl),
-    initial_locale_(WizardController::GetInitialLocale()) {
+    : CustomizationDocument(kAcceptedManifestVersion),
+      url_(kServicesCustomizationManifestUrl) {
 }
 
 ServicesCustomizationDocument::ServicesCustomizationDocument(
-    const std::string& manifest, const std::string& initial_locale)
-    : initial_locale_(initial_locale) {
+    const std::string& manifest)
+    : CustomizationDocument(kAcceptedManifestVersion) {
   LoadManifestFromString(manifest);
 }
 
 ServicesCustomizationDocument::~ServicesCustomizationDocument() {}
 
 // static
 ServicesCustomizationDocument* ServicesCustomizationDocument::GetInstance() {
   return Singleton<ServicesCustomizationDocument,
       DefaultSingletonTraits<ServicesCustomizationDocument> >::get();
 }
@@ skipping 86 matching lines @@
   return GetLocaleSpecificString(
       locale, kAppContentAttr, kInitialStartPageAttr);
 }
 
 std::string ServicesCustomizationDocument::GetSupportPage(
     const std::string& locale) const {
   return GetLocaleSpecificString(
       locale, kAppContentAttr, kSupportPageAttr);
 }
 
-const ServicesCustomizationDocument::CarrierDeal*
-ServicesCustomizationDocument::GetCarrierDeal(const std::string& carrier_id,
-                                              bool check_restrictions) const {
-  CarrierDeals::const_iterator iter = carrier_deals_.find(carrier_id);
-  if (iter != carrier_deals_.end()) {
-    CarrierDeal* deal = iter->second;
-    if (check_restrictions) {
-      // Deal locale has to match initial_locale (= launch country).
-      if (initial_locale_ != deal->deal_locale())
-        return NULL;
-      // Make sure that deal is still active,
-      // i.e. if deal expire date is defined, check it.
-      if (!deal->expire_date().is_null() &&
-          deal->expire_date() <= base::Time::Now()) {
-        return NULL;
-      }
-    }
-    return deal;
-  } else {
-    return NULL;
-  }
-}
-
-bool ServicesCustomizationDocument::LoadManifestFromString(
-    const std::string& manifest) {
-  if (!CustomizationDocument::LoadManifestFromString(manifest))
-    return false;
-
-  DictionaryValue* carriers = NULL;
-  if (root_.get() && root_->GetDictionary(kCarrierDealsAttr, &carriers)) {
-    for (DictionaryValue::key_iterator iter = carriers->begin_keys();
-         iter != carriers->end_keys(); ++iter) {
-     DictionaryValue* carrier_deal = NULL;
-     if (carriers->GetDictionary(*iter, &carrier_deal)) {
-       carrier_deals_[*iter] = new CarrierDeal(carrier_deal);
-     }
-   }
-  }
-  return true;
-}
-
 }  // namespace chromeos