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| from |default_settings| here
+  // since it's not applicable to default settings.
+}
+
 IndividualSettings::~IndividualSettings() {
 }
 
 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;
@@ skipping 75 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_str;
+  if (scope == SCOPE_INDIVIDUAL &&
+      dict->GetStringWithoutPathExpansion(schema_constants::kMinimumVersion,
+                                          &minimum_version_str)) {
+    scoped_ptr<base::Version> version(new Version(minimum_version_str));
+    // We accept a general version string here. Note that count of components in

[pastarmovj, 2014/11/11 12:50:54]

nit: Some articles in the second sentence. 

Note that the count of the components in a version string of extensions is
limited to 4

[binjin, 2014/11/11 19:10:37]

Done.

+    // version string of extensions are limited up to 4.
+    if (!version->IsValid())
+      LOG(WARNING) << kMalformedPreferenceWarning;
+    else
+      minimum_version = 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