Add minimal profile creation version for default apps install on Chrome OS

chrome/browser/extensions/external_provider_impl.cc

 // Copyright (c) 2012 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/external_provider_impl.h"
 
 #include <set>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/metrics/field_trial.h"
+#include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_management.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/external_component_loader.h"
 #include "chrome/browser/extensions/external_policy_loader.h"
 #include "chrome/browser/extensions/external_pref_loader.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/pref_names.h"
 #include "components/crx_file/id_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/external_provider_interface.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
@@ skipping 20 matching lines @@
 const char ExternalProviderImpl::kInstallParam[] = "install_parameter";
 const char ExternalProviderImpl::kExternalCrx[] = "external_crx";
 const char ExternalProviderImpl::kExternalVersion[] = "external_version";
 const char ExternalProviderImpl::kExternalUpdateUrl[] = "external_update_url";
 const char ExternalProviderImpl::kIsBookmarkApp[] = "is_bookmark_app";
 const char ExternalProviderImpl::kIsFromWebstore[] = "is_from_webstore";
 const char ExternalProviderImpl::kKeepIfPresent[] = "keep_if_present";
 const char ExternalProviderImpl::kWasInstalledByOem[] = "was_installed_by_oem";
 const char ExternalProviderImpl::kSupportedLocales[] = "supported_locales";
 const char ExternalProviderImpl::kMayBeUntrusted[] = "may_be_untrusted";
+const char ExternalProviderImpl::kMinProfileCreatedByVersion[] =
+    "min_profile_created_by_version";
 
 ExternalProviderImpl::ExternalProviderImpl(
     VisitorInterface* service,
     const scoped_refptr<ExternalLoader>& loader,
     Profile* profile,
     Manifest::Location crx_location,
     Manifest::Location download_location,
     int creation_flags)
     : crx_location_(crx_location),
       download_location_(download_location),
@@ skipping 132 matching lines @@
       creation_flags |= Extension::FROM_WEBSTORE;
     }
     bool keep_if_present = false;
     if (extension->GetBoolean(kKeepIfPresent, &keep_if_present) &&
         keep_if_present && profile_) {
       ExtensionServiceInterface* extension_service =
           ExtensionSystem::Get(profile_)->extension_service();
       const Extension* extension = extension_service ?
           extension_service->GetExtensionById(extension_id, true) : NULL;
       if (!extension) {
+        unsupported_extensions.insert(extension_id);
         VLOG(1) << "Skip installing (or uninstall) external extension: "
                 << extension_id << " because the extension should be kept "
                 << "only if it is already installed.";
         continue;
       }
     }
     bool was_installed_by_oem = false;
     if (extension->GetBoolean(kWasInstalledByOem, &was_installed_by_oem) &&
         was_installed_by_oem) {
       creation_flags |= Extension::WAS_INSTALLED_BY_OEM;
     }
     bool may_be_untrusted = false;
     if (extension->GetBoolean(kMayBeUntrusted, &may_be_untrusted) &&
         may_be_untrusted) {
       creation_flags |= Extension::MAY_BE_UNTRUSTED;
     }
 
+    if (!ExternalProviderImpl::HandleMinProfileVersion(extension, extension_id,
+                                                       &unsupported_extensions))
+      continue;
+
     std::string install_parameter;
     extension->GetString(kInstallParam, &install_parameter);
 
     if (has_external_crx) {
       if (crx_location_ == Manifest::INVALID_LOCATION) {
         LOG(WARNING) << "This provider does not support installing external "
                      << "extensions from crx files.";
         continue;
       }
       if (external_crx.find(base::FilePath::kParentDirectory) !=
@@ skipping 105 matching lines @@
     NOTREACHED();  // Chrome should not allow prefs to get into this state.
     return false;
   }
 
   if (location)
     *location = loc;
 
   return true;
 }
 
+bool ExternalProviderImpl::HandleMinProfileVersion(
+    const base::DictionaryValue* extension,
+    const std::string& extension_id,
+    std::set<std::string>* unsupported_extensions) {
+  std::string min_profile_created_by_version;
+  if (profile_ &&
+      extension->GetString(kMinProfileCreatedByVersion,
+                           &min_profile_created_by_version)) {
+    Version profile_version(
+        profile_->GetPrefs()->GetString(prefs::kProfileCreatedByVersion));
+    Version min_version(min_profile_created_by_version);
+    if (min_version.IsValid() && profile_version.CompareTo(min_version) < 0) {
+      unsupported_extensions->insert(extension_id);
+      VLOG(1) << "Skip installing (or uninstall) external extension: "
+              << extension_id
+              << " profile.created_by_version: " << profile_version.GetString()
+              << " min_profile_created_by_version: "
+              << min_profile_created_by_version;
+      return false;
+    }
+  }
+  return true;
+}
+
 // static
 void ExternalProviderImpl::CreateExternalProviders(
     VisitorInterface* service,
     Profile* profile,
     ProviderCollection* provider_list) {
   TRACE_EVENT0("browser,startup",
                "ExternalProviderImpl::CreateExternalProviders");
   scoped_refptr<ExternalLoader> external_loader;
   scoped_refptr<ExternalLoader> external_recommended_loader;
   extensions::Manifest::Location crx_location = Manifest::INVALID_LOCATION;
@@ skipping 211 matching lines @@
       new ExternalProviderImpl(
           service,
           new ExternalComponentLoader(profile),
           profile,
           Manifest::INVALID_LOCATION,
           Manifest::EXTERNAL_COMPONENT,
           Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT)));
 }
 
 }  // namespace extensions