kiosk: Add kiosk.required_platform_version manifest key

extensions/common/manifest_handlers/kiosk_mode_info.cc

 // Copyright 2013 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 "extensions/common/manifest_handlers/kiosk_mode_info.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "extensions/common/api/extensions_manifest_types.h"
 #include "extensions/common/manifest_constants.h"
 
+namespace {
+
+// Whether the given |version| is a valid platform version. The acceptable
+// format is major[.minor[.micro]], where major, minor and micro are decimals.
+bool IsValidPlatformVersion(const std::string& version) {
+  int count = 0;
+
+  base::StringTokenizer tokenizer(version, ".");
+  while (tokenizer.GetNext()) {
+    int version_number;
+    if (!base::StringToInt(
+            base::StringPiece(tokenizer.token_begin(), tokenizer.token_end()),
+            &version_number)) {
+      return false;
+    }
+    ++count;
+    if (count > 3)
+      return false;
+  }
+
+  return count > 0;
+}

[asargent_no_longer_on_chrome, 2016/01/15 23:27:33]

could you just use base::Version for this instead of having custom parsing logic
here?

[xiyuan, 2016/01/19 23:40:52]

Good call. Done.

+
+}  // namespace
+
 namespace extensions {
 
 namespace keys = manifest_keys;
 
 using api::extensions_manifest_types::KioskSecondaryAppsType;
 
 KioskModeInfo::KioskModeInfo(KioskStatus kiosk_status,
-                             const std::vector<std::string>& secondary_app_ids)
-    : kiosk_status(kiosk_status), secondary_app_ids(secondary_app_ids) {}
+                             const std::vector<std::string>& secondary_app_ids,
+                             const std::string& required_platform_version)
+    : kiosk_status(kiosk_status),
+      secondary_app_ids(secondary_app_ids),
+      required_platform_version(required_platform_version) {}
 
 KioskModeInfo::~KioskModeInfo() {
 }
 
 // static
 KioskModeInfo* KioskModeInfo::Get(const Extension* extension) {
   return static_cast<KioskModeInfo*>(
       extension->GetManifestData(keys::kKioskMode));
 }
 
@@ skipping 12 matching lines @@
 // static
 bool KioskModeInfo::HasSecondaryApps(const Extension* extension) {
   KioskModeInfo* info = Get(extension);
   return info && !info->secondary_app_ids.empty();
 }
 
 KioskModeHandler::KioskModeHandler() {
   supported_keys_.push_back(keys::kKioskEnabled);
   supported_keys_.push_back(keys::kKioskOnly);
   supported_keys_.push_back(keys::kKioskSecondaryApps);
+  supported_keys_.push_back(keys::kRequiredPlatformVersion);
 }
 
 KioskModeHandler::~KioskModeHandler() {
 }
 
 bool KioskModeHandler::Parse(Extension* extension, base::string16* error) {
   const Manifest* manifest = extension->manifest();
   DCHECK(manifest->HasKey(keys::kKioskEnabled) ||
          manifest->HasKey(keys::kKioskOnly));
 
@@ skipping 20 matching lines @@
   // All other use cases should be already filtered out by manifest feature
   // checks.
   DCHECK(extension->is_platform_app());
 
   KioskModeInfo::KioskStatus kiosk_status = KioskModeInfo::NONE;
   if (kiosk_enabled)
     kiosk_status = kiosk_only ? KioskModeInfo::ONLY : KioskModeInfo::ENABLED;
 
   // Kiosk secondary apps key is optional.
   std::vector<std::string> ids;
-  if (extension->manifest()->HasKey(keys::kKioskSecondaryApps)) {
+  if (manifest->HasKey(keys::kKioskSecondaryApps)) {
     const base::Value* secondary_apps = nullptr;
     const base::ListValue* list = nullptr;
-    if (!extension->manifest()->Get(keys::kKioskSecondaryApps,
-                                    &secondary_apps) ||
+    if (!manifest->Get(keys::kKioskSecondaryApps, &secondary_apps) ||
         !secondary_apps->GetAsList(&list)) {
       *error = base::ASCIIToUTF16(manifest_errors::kInvalidKioskSecondaryApps);
       return false;
     }
 
     for (const base::Value* value : *list) {
       scoped_ptr<KioskSecondaryAppsType> app =
           KioskSecondaryAppsType::FromValue(*value, error);
       if (!app) {
         *error = base::ASCIIToUTF16(
             manifest_errors::kInvalidKioskSecondaryAppsBadAppId);
         return false;
       }
       ids.push_back(app->id);
     }
   }
 
-  extension->SetManifestData(keys::kKioskMode,
-                             new KioskModeInfo(kiosk_status, ids));
+  // Optional required_platform_version key.
+  std::string required_platform_version;
+  if (manifest->HasKey(keys::kRequiredPlatformVersion) &&
+      (!manifest->GetString(keys::kRequiredPlatformVersion,
+                            &required_platform_version) ||
+       !IsValidPlatformVersion(required_platform_version))) {
+    *error =
+        base::ASCIIToUTF16(manifest_errors::kInvalidRequiredPlatformVersion);
+    return false;
+  }
+
+  extension->SetManifestData(
+      keys::kKioskMode,
+      new KioskModeInfo(kiosk_status, ids, required_platform_version));
 
   return true;
 }
 
 const std::vector<std::string> KioskModeHandler::Keys() const {
   return supported_keys_;
 }
 
 }  // namespace extensions