Implement kiosk multiple apps feature.

chrome/browser/chromeos/app_mode/kiosk_app_manager.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 "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
 
 #include <map>
 #include <set>
 
 #include "base/barrier_closure.h"
@@ skipping 447 matching lines @@
   observers_.AddObserver(observer);
 }
 
 void KioskAppManager::RemoveObserver(KioskAppManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 extensions::ExternalLoader* KioskAppManager::CreateExternalLoader() {
   if (external_loader_created_) {
     NOTREACHED();
-    return NULL;
+    return nullptr;
   }
   external_loader_created_ = true;
   KioskAppExternalLoader* loader = new KioskAppExternalLoader();
   external_loader_ = loader->AsWeakPtr();
 
   return loader;
 }
 
+extensions::ExternalLoader*
+KioskAppManager::CreateSecondaryAppExternalLoader() {
+  if (secondary_app_external_loader_created_) {
+    NOTREACHED();
+    return nullptr;
+  }
+  secondary_app_external_loader_created_ = true;
+  KioskAppExternalLoader* secondary_loader = new KioskAppExternalLoader();
+  secondary_app_external_loader_ = secondary_loader->AsWeakPtr();
+
+  return secondary_loader;
+}
+
 void KioskAppManager::InstallFromCache(const std::string& id) {
   const base::DictionaryValue* extension = NULL;
   if (external_cache_->cached_extensions()->GetDictionary(id, &extension)) {
     scoped_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
     base::DictionaryValue* extension_copy = extension->DeepCopy();
     prefs->Set(id, extension_copy);
     external_loader_->SetCurrentAppExtensions(prefs.Pass());
   } else {
     LOG(ERROR) << "Can't find app in the cached externsions"
                << " id = " << id;
   }
 }
 
+void KioskAppManager::InstallSecondaryApps(
+    const std::vector<std::string>& ids) {
+  if (ids.empty())
+    return;
+
+  scoped_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
+  for (const std::string& id : ids) {
+    scoped_ptr<base::DictionaryValue> extension_entry(
+        new base::DictionaryValue);
+    extension_entry->SetStringWithoutPathExpansion(
+        extensions::ExternalProviderImpl::kExternalUpdateUrl,
+        extension_urls::GetWebstoreUpdateUrl().spec());
+    extension_entry->SetBoolean(
+        extensions::ExternalProviderImpl::kIsFromWebstore, true);
+    prefs->Set(id, extension_entry.Pass());
+  }
+  secondary_app_external_loader_->SetCurrentAppExtensions(prefs.Pass());
+}
+
 void KioskAppManager::UpdateExternalCache() {
   UpdateAppData();
 }
 
 void KioskAppManager::OnKioskAppCacheUpdated(const std::string& app_id) {
   FOR_EACH_OBSERVER(
       KioskAppManagerObserver, observers_, OnKioskAppCacheUpdated(app_id));
 }
 
 void KioskAppManager::OnKioskAppExternalUpdateComplete(bool success) {
   FOR_EACH_OBSERVER(KioskAppManagerObserver,
                     observers_,
                     OnKioskAppExternalUpdateComplete(success));
 }
 
 void KioskAppManager::PutValidatedExternalExtension(
     const std::string& app_id,
     const base::FilePath& crx_path,
     const std::string& version,
     const ExternalCache::PutExternalExtensionCallback& callback) {
   external_cache_->PutExternalExtension(app_id, crx_path, version, callback);
 }
 
 KioskAppManager::KioskAppManager()
-    : ownership_established_(false), external_loader_created_(false) {
+    : ownership_established_(false),
+      external_loader_created_(false),
+      secondary_app_external_loader_created_(false) {
   base::FilePath cache_dir;
   GetCrxCacheDir(&cache_dir);
   external_cache_.reset(
       new ExternalCache(cache_dir,
                         g_browser_process->system_request_context(),
                         GetBackgroundTaskRunner(),
                         this,
                         true /* always_check_updates */,
                         false /* wait_for_cache_initialization */));
   UpdateAppData();
@@ skipping 209 matching lines @@
   *cache_dir = user_data_dir.AppendASCII(kCrxCacheDir);
 }
 
 void KioskAppManager::GetCrxUnpackDir(base::FilePath* unpack_dir) {
   base::FilePath temp_dir;
   base::GetTempDir(&temp_dir);
   *unpack_dir = temp_dir.AppendASCII(kCrxUnpackDir);
 }
 
 }  // namespace chromeos