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

[Joao da Silva, 2014/11/17 16:17:41]

In this case, the administrator won't see any problem reported in about:policy
and won't detect that there is a problem with this policy at all.

WDYT of setting |minimum_version| to 0.0.0.0 in this case?

Another idea: can you file a bug to get errors out of the parsing of this
policy? Basically this function could take an "std::string* errors" parameter,
and instead of logging we would append the errors to that string. Then we could
still "return true" in general but show any parsing errors in about:policy. That
would be for another CL though.

[binjin, 2014/11/18 13:25:55]

It's possible to enforce the exact requirement with regex (up to four digits
from 0 to 65535 without leading zero and joined with dot), but I'm just not sure
if it's a good idea to add such unreadable regex to policy template. Another
reason for accepting a general string is that I'm not sure if the extension
format is persistent or not.

These parsing error are actually not expected since we already do verbose
checking in policyhandler (with help of schema). But yes, I left some cases
unresolved.

+    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