Add minimum version to extension management

chrome/browser/extensions/extension_management_internal.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_internal.h"
 
 #include "base/logging.h"
 #include "base/values.h"
+#include "base/version.h"
 #include "chrome/browser/extensions/extension_management_constants.h"
 #include "extensions/common/url_pattern_set.h"
 #include "url/gurl.h"
 
 namespace extensions {
 
 namespace internal {
 
 namespace {
 const char kMalformedPreferenceWarning[] =
     "Malformed extension management preference.";
 }  // namespace
 
 IndividualSettings::IndividualSettings() {
   Reset();
 }
 
+// Initializes from default settings.
+IndividualSettings::IndividualSettings(
+    const IndividualSettings* default_settings) {
+  installation_mode = default_settings->installation_mode;
+  update_url = default_settings->installation_mode;
+  blocked_permissions = default_settings->blocked_permissions;
+  // We are not initializing |minimum_version_required| from |default_settings|
+  // here since it's not applicable to default settings.
+}
+
 IndividualSettings::~IndividualSettings() {
 }

[Finnur, 2014/11/19 10:16:25]

Can you initialize installation_mode here?

[binjin, 2014/11/19 13:36:10]

In a destructor? I assume you mean Parse(), the purpose of Parse() and
constructor is different, Parse() are meant for parsing only and the caller had
to inherit settings from default settings before calling Parse(). That is, if
the installation_mode is not specified, we will use inherited installation_mode
settings.

 
 bool IndividualSettings::Parse(const base::DictionaryValue* dict,
                                ParsingScope scope) {
   std::string installation_mode_str;
   if (dict->GetStringWithoutPathExpansion(schema_constants::kInstallationMode,
                                           &installation_mode_str)) {
     if (installation_mode_str == schema_constants::kAllowed) {
       installation_mode = ExtensionManagement::INSTALLATION_ALLOWED;
     } else if (installation_mode_str == schema_constants::kBlocked) {
       installation_mode = ExtensionManagement::INSTALLATION_BLOCKED;
@@ skipping 73 matching lines @@
             APIPermissionSet::kDisallowInternalPermissions,
             &permissions_parsed,
             &error,
             nullptr)) {
       LOG(WARNING) << error;
     }
     APIPermissionSet::Union(
         permissions_to_merge_from, permissions_parsed, &blocked_permissions);
   }
 
+  // Parses the minimum version settings.
+  std::string minimum_version_required_str;
+  if (scope == SCOPE_INDIVIDUAL &&
+      dict->GetStringWithoutPathExpansion(
+          schema_constants::kMinimumVersionRequired,
+          &minimum_version_required_str)) {
+    scoped_ptr<base::Version> version(
+        new Version(minimum_version_required_str));
+    // We accept a general version string here. Note that count of components in
+    // version string of extensions is limited to 4.
+    if (!version->IsValid())
+      LOG(WARNING) << kMalformedPreferenceWarning;
+    else
+      minimum_version_required = version.Pass();
+  }
+
   return true;
 }
 
 void IndividualSettings::Reset() {
   installation_mode = ExtensionManagement::INSTALLATION_ALLOWED;
   update_url.clear();
   blocked_permissions.clear();
 }
 
 GlobalSettings::GlobalSettings() {
   Reset();
 }
 
 GlobalSettings::~GlobalSettings() {
 }
 
 void GlobalSettings::Reset() {
   has_restricted_install_sources = false;
   install_sources.ClearPatterns();
   has_restricted_allowed_types = false;
   allowed_types.clear();
 }
 
 }  // namespace internal
 
 }  // namespace extensions