Reset registered events and dispatch runtime.onInstalled to all extensions when

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"
+#include "base/version.h"
 #include "chrome/browser/extensions/admin_policy.h"
 #include "chrome/browser/extensions/api/omnibox/omnibox_api.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
 #include "chrome/browser/extensions/extension_sorting.h"
 #include "chrome/browser/prefs/pref_notifier.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension_switch_utils.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
 #include "chrome/common/extensions/permissions/permissions_info.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/notification_service.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 170 matching lines @@
 
 // List of media gallery permissions.
 const char kMediaGalleriesPermissions[] = "media_galleries_permissions";
 
 // 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";
+
 // 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 735 matching lines @@
       }
 
       UpdateExtensionPref(*ext_id, kPrefDisableReasons,
                           Value::CreateIntegerValue(new_value));
       // Remove the old disable reason.
       UpdateExtensionPref(*ext_id, kDeprecatedPrefDisableReason, NULL);
     }
   }
 }
 
+void ExtensionPrefs::ClearRegisteredEvents() {
+  const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
+  if (!extensions)
+    return;
+
+  for (DictionaryValue::key_iterator it = extensions->begin_keys();
+       it != extensions->end_keys(); ++it) {
+    UpdateExtensionPref(*it, kRegisteredEvents, NULL);
+  }
+}
+
 PermissionSet* ExtensionPrefs::GetGrantedPermissions(
     const std::string& extension_id) {
   CHECK(Extension::IdIsValid(extension_id));
   return ReadExtensionPrefPermissionSet(extension_id, kPrefGrantedPermissions);
 }
 
 void ExtensionPrefs::AddGrantedPermissions(
     const std::string& extension_id,
     const PermissionSet* permissions) {
   CHECK(Extension::IdIsValid(extension_id));
@@ skipping 35 matching lines @@
   return ReadExtensionPrefPermissionSet(extension_id, kPrefActivePermissions);
 }
 
 void ExtensionPrefs::SetActivePermissions(
     const std::string& extension_id,
     const PermissionSet* permissions) {
   SetExtensionPrefPermissionSet(
       extension_id, kPrefActivePermissions, permissions);
 }
 
+bool ExtensionPrefs::CheckRegisteredEventsUpToDate() {
+  // If we're running inside a test, then assume prefs are all up-to-date.
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kTestType))

[Matt Perry, 2012/09/19 23:32:46]

I had to add this bit to fix the chromeos tests. Chromeos has default extensions
installed, and the onInstalled event was causing those extensions to load when
they shouldn't have.

+    return true;
+
+  Version version;
+  if (prefs_->HasPrefPath(kExtensionsLastChromeVersion)) {
+    std::string version_str = prefs_->GetString(kExtensionsLastChromeVersion);
+    version = Version(version_str);
+  }
+
+  chrome::VersionInfo current_version_info;
+  std::string current_version = current_version_info.Version();
+  prefs_->SetString(kExtensionsLastChromeVersion, current_version);
+
+  // If there was no version string in prefs, assume we're out of date.
+  if (!version.IsValid() || version.IsOlderThan(current_version)) {
+    ClearRegisteredEvents();
+    return false;
+  }
+
+  return true;
+}
+
 std::set<std::string> ExtensionPrefs::GetRegisteredEvents(
     const std::string& extension_id) {
   std::set<std::string> events;
   const DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
     return events;
 
   const ListValue* value = NULL;
   if (!extension->GetList(kRegisteredEvents, &value))
     return events;
@@ skipping 1105 matching lines @@
                             "0",  // default value
                             PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kLastExtensionsUpdateCheck,
                            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);
 }
 
 ExtensionPrefs::ExtensionIds ExtensionPrefs::GetExtensionPrefAsVector(
     const char* pref) {
   ExtensionIds 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 ExtensionIds& strings) {
   ListPrefUpdate update(prefs_, pref);
   ListValue* list_of_values = update.Get();
   list_of_values->Clear();
   for (ExtensionIds::const_iterator iter = strings.begin();
        iter != strings.end(); ++iter)
     list_of_values->Append(new StringValue(*iter));
 }
 
 }  // namespace extensions