Add minimum version to extension management

chrome/browser/extensions/extension_management.cc

 // Copyright 2014 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_management.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
+#include "base/version.h"
 #include "chrome/browser/extensions/extension_management_constants.h"
 #include "chrome/browser/extensions/extension_management_internal.h"
 #include "chrome/browser/extensions/external_policy_loader.h"
 #include "chrome/browser/extensions/external_provider_impl.h"
 #include "chrome/browser/extensions/permissions_based_management_policy_provider.h"
 #include "chrome/browser/extensions/standard_management_policy_provider.h"
 #include "chrome/browser/profiles/incognito_helpers.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/crx_file/id_util.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
@@ skipping 185 matching lines @@
 bool ExtensionManagement::IsPermissionSetAllowed(
     const Extension* extension,
     scoped_refptr<const PermissionSet> perms) const {
   for (const auto& blocked_api : GetBlockedAPIPermissions(extension)) {
     if (perms->HasAPIPermission(blocked_api->id()))
       return false;
   }
   return true;
 }
 
+bool ExtensionManagement::CheckMinimumVersion(
+    const Extension* extension,
+    std::string* required_version) const {
+  auto iter = settings_by_id_.find(extension->id());
+  // If there are no minimum version required for |extension|, return true.
+  if (iter == settings_by_id_.end() || !iter->second->minimum_version_required)
+    return true;
+  bool met_requirement = extension->version()->CompareTo(
+                             *iter->second->minimum_version_required) >= 0;
+  // Output a human readable version string for prompting if necessary.
+  if (!met_requirement && required_version)
+    *required_version = iter->second->minimum_version_required->GetString();
+  return met_requirement;
+}
+
 void ExtensionManagement::Refresh() {
   // Load all extension management settings preferences.
   const base::ListValue* allowed_list_pref =
       static_cast<const base::ListValue*>(LoadPreference(
           pref_names::kInstallAllowList, true, base::Value::TYPE_LIST));
   // Allow user to use preference to block certain extensions. Note that policy
   // managed forcelist or whitelist will always override this.
   const base::ListValue* denied_list_pref =
       static_cast<const base::ListValue*>(LoadPreference(
           pref_names::kInstallDenyList, false, base::Value::TYPE_LIST));
@@ skipping 182 matching lines @@
   FOR_EACH_OBSERVER(
       Observer, observer_list_, OnExtensionManagementSettingsChanged());
 }
 
 internal::IndividualSettings* ExtensionManagement::AccessById(
     const ExtensionId& id) {
   DCHECK(crx_file::id_util::IdIsValid(id)) << "Invalid ID: " << id;
   SettingsIdMap::iterator it = settings_by_id_.find(id);
   if (it == settings_by_id_.end()) {
     scoped_ptr<internal::IndividualSettings> settings(
-        new internal::IndividualSettings(*default_settings_));
+        new internal::IndividualSettings(default_settings_.get()));
     it = settings_by_id_.add(id, settings.Pass()).first;
   }
   return it->second;
 }
 
 internal::IndividualSettings* ExtensionManagement::AccessByUpdateUrl(
     const std::string& update_url) {
   DCHECK(GURL(update_url).is_valid()) << "Invalid update URL: " << update_url;
   SettingsUpdateUrlMap::iterator it = settings_by_update_url_.find(update_url);
   if (it == settings_by_update_url_.end()) {
     scoped_ptr<internal::IndividualSettings> settings(
-        new internal::IndividualSettings(*default_settings_));
+        new internal::IndividualSettings(default_settings_.get()));
     it = settings_by_update_url_.add(update_url, settings.Pass()).first;
   }
   return it->second;
 }
 
 ExtensionManagement* ExtensionManagementFactory::GetForBrowserContext(
     content::BrowserContext* context) {
   return static_cast<ExtensionManagement*>(
       GetInstance()->GetServiceForBrowserContext(context, true));
 }
@@ skipping 23 matching lines @@
 }
 
 void ExtensionManagementFactory::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* user_prefs) {
   user_prefs->RegisterDictionaryPref(
       pref_names::kExtensionManagement,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 }  // namespace extensions