Implement sideload wipeout for Extensions.

chrome/browser/extensions/extension_prefs.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/extensions/extension_prefs.h"
 
 #include "base/command_line.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 204 matching lines @@
 
 // Key for Media Gallery ID.
 const char kMediaGalleryIdKey[] = "id";
 
 // Key for Media Gallery Permission Value.
 const char kMediaGalleryHasPermissionKey[] = "has_permission";
 
 // Key for what version chrome was last time the extension prefs were loaded.
 const char kExtensionsLastChromeVersion[] = "extensions.last_chrome_version";
 
+// Key for whether the sideload wipeout effort is done.
+const char kSideloadWipeoutDone[] = "extensions.sideload_wipeout_done";
+
 // Provider of write access to a dictionary storing extension prefs.
 class ScopedExtensionPrefUpdate : public DictionaryPrefUpdate {
  public:
   ScopedExtensionPrefUpdate(PrefService* service,
                             const std::string& extension_id) :
     DictionaryPrefUpdate(service, ExtensionPrefs::kExtensionsPref),
     extension_id_(extension_id) {}
 
   virtual ~ScopedExtensionPrefUpdate() {
   }
@@ skipping 1564 matching lines @@
     *result = prefs_->GetString(kWebStoreLogin);
     return true;
   }
   return false;
 }
 
 void ExtensionPrefs::SetWebStoreLogin(const std::string& login) {
   prefs_->SetString(kWebStoreLogin, login);
 }
 
+bool ExtensionPrefs::GetSideloadWipeoutDone() const {
+  return prefs_->GetBoolean(kSideloadWipeoutDone);
+}
+
+void ExtensionPrefs::SetSideloadWipeoutDone() {
+  return prefs_->SetBoolean(kSideloadWipeoutDone, true);
+}
+
 bool ExtensionPrefs::WasAppDraggedByUser(const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id, kPrefUserDraggedApp);
 }
 
 void ExtensionPrefs::SetAppDraggedByUser(const std::string& extension_id) {
   UpdateExtensionPref(extension_id, kPrefUserDraggedApp,
                       Value::CreateBooleanValue(true));
 }
 
 void ExtensionPrefs::SetUpdateUrlData(const std::string& extension_id,
@@ skipping 372 matching lines @@
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kNextExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionAllowedInstallSites,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(kExtensionsLastChromeVersion,
                             std::string(),  // default value
                             PrefService::UNSYNCABLE_PREF);
+  // TODO(finnur): Should this be sync'able?
+  prefs->RegisterBooleanPref(kSideloadWipeoutDone,
+                             false,
+                             PrefService::UNSYNCABLE_PREF);
 }
 
 ExtensionIdList ExtensionPrefs::GetExtensionPrefAsVector(
     const char* pref) {
   ExtensionIdList extension_ids;
   const ListValue* list_of_values = prefs_->GetList(pref);
   if (!list_of_values)
     return extension_ids;
 
   std::string extension_id;
   for (size_t i = 0; i < list_of_values->GetSize(); ++i) {
     if (list_of_values->GetString(i, &extension_id))
       extension_ids.push_back(extension_id);
   }
   return extension_ids;
 }
 
 void ExtensionPrefs::SetExtensionPrefFromVector(
     const char* pref,
     const ExtensionIdList& strings) {
   ListPrefUpdate update(prefs_, pref);
   ListValue* list_of_values = update.Get();
   list_of_values->Clear();
   for (ExtensionIdList::const_iterator iter = strings.begin();
        iter != strings.end(); ++iter)
     list_of_values->Append(new StringValue(*iter));
 }
 
 }  // namespace extensions