Implement kiosk multiple apps feature.

chrome/browser/chromeos/app_mode/startup_app_launcher.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/startup_app_launcher.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/path_service.h"
@@ skipping 18 matching lines @@
 #include "components/crx_file/id_util.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/user_manager/user_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_handlers/kiosk_mode_info.h"
+#include "extensions/common/manifest_handlers/kiosk_secondary_apps_info.h"
 #include "extensions/common/manifest_handlers/offline_enabled_info.h"
 #include "extensions/common/manifest_url_handlers.h"
 #include "google_apis/gaia/gaia_auth_consumer.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
@@ skipping 122 matching lines @@
     LOG(WARNING) << "Installer still running";
     return;
   }
 
   MaybeInitializeNetwork();
 }
 
 void StartupAppLauncher::MaybeInitializeNetwork() {
   network_ready_handled_ = false;
 
-  const Extension* extension = extensions::ExtensionSystem::Get(profile_)->
-      extension_service()->GetInstalledExtension(app_id_);
+  const Extension* extension = GetPrimaryAppExtension();
   bool crx_cached = KioskAppManager::Get()->HasCachedCrx(app_id_);
   const bool requires_network =
       (!extension && !crx_cached) ||
       (extension &&
        !extensions::OfflineEnabledInfo::IsOfflineEnabled(extension));
 
   if (requires_network) {
     delegate_->InitializeNetwork();
     return;
   }
@@ skipping 47 matching lines @@
 }
 
 void StartupAppLauncher::OnRefreshTokensLoaded() {
   ProfileOAuth2TokenServiceFactory::GetForProfile(profile_)
       ->RemoveObserver(this);
   MaybeInitializeNetwork();
 }
 
 void StartupAppLauncher::MaybeLaunchApp() {
   // Check if the app is offline enabled.
-  const Extension* extension = extensions::ExtensionSystem::Get(profile_)
-                                   ->extension_service()
-                                   ->GetInstalledExtension(app_id_);
+  const Extension* extension = GetPrimaryAppExtension();
   DCHECK(extension);
   const bool offline_enabled =
       extensions::OfflineEnabledInfo::IsOfflineEnabled(extension);
   if (offline_enabled || delegate_->IsNetworkReady()) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&StartupAppLauncher::OnReadyToLaunch, AsWeakPtr()));
   } else {
     ++launch_attempt_;
@@ skipping 19 matching lines @@
   }
 
   extensions::InstallTracker* tracker =
       extensions::InstallTrackerFactory::GetForBrowserContext(profile_);
   tracker->RemoveObserver(this);
   if (delegate_->IsShowingNetworkConfigScreen()) {
     LOG(WARNING) << "Showing network config screen";
     return;
   }
 
-  if (success) {
-    MaybeLaunchApp();
+  if (extension_id == app_id_) {
+    if (success) {
+      MaybeInstallSecondaryApps();
+    } else {
+      LOG(ERROR) << "Failed to install the kiosk application app_id: "
+                 << extension_id;
+      OnLaunchFailure(KioskAppLaunchError::UNABLE_TO_INSTALL);
+    }
     return;
   }
 
-  LOG(ERROR) << "Failed to install the kiosk application app_id: "
-             << extension_id;
-  OnLaunchFailure(KioskAppLaunchError::UNABLE_TO_INSTALL);
+  if (AreSecondaryAppsInstalled()) {
+    MaybeLaunchApp();
+  } else {
+    LOG(ERROR) << "Failed to install one or more secondary apps.";
+    OnLaunchFailure(KioskAppLaunchError::UNABLE_TO_INSTALL);
+  }
 }
 
 void StartupAppLauncher::OnKioskExtensionLoadedInCache(
     const std::string& app_id) {
   OnKioskAppDataLoadStatusChanged(app_id);
 }
 
 void StartupAppLauncher::OnKioskExtensionDownloadFailed(
     const std::string& app_id) {
   OnKioskAppDataLoadStatusChanged(app_id);
 }
 
 void StartupAppLauncher::OnKioskAppDataLoadStatusChanged(
     const std::string& app_id) {
   if (app_id != app_id_ || !wait_for_crx_update_)
     return;
 
   wait_for_crx_update_ = false;
   if (KioskAppManager::Get()->HasCachedCrx(app_id_))
     BeginInstall();
   else
     OnLaunchFailure(KioskAppLaunchError::UNABLE_TO_DOWNLOAD);
 }
 
+bool StartupAppLauncher::IsAnySecondaryAppPending() const {
+  DCHECK(HaveSecondaryApps());
+  const extensions::Extension* extension = GetPrimaryAppExtension();
+  DCHECK(extension);
+  extensions::KioskSecondaryAppsInfo* info =
+      extensions::KioskSecondaryAppsInfo::Get(extension);
+  for (size_t i = 0; i < info->ids.size(); ++i) {
+    if (extensions::ExtensionSystem::Get(profile_)
+            ->extension_service()
+            ->pending_extension_manager()
+            ->IsIdPending(info->ids[i])) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool StartupAppLauncher::AreSecondaryAppsInstalled() const {
+  DCHECK(HaveSecondaryApps());
+  const extensions::Extension* extension = GetPrimaryAppExtension();
+  DCHECK(extension);
+  extensions::KioskSecondaryAppsInfo* info =
+      extensions::KioskSecondaryAppsInfo::Get(extension);
+  for (size_t i = 0; i < info->ids.size(); ++i) {
+    if (!extensions::ExtensionSystem::Get(profile_)
+             ->extension_service()
+             ->GetInstalledExtension(info->ids[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool StartupAppLauncher::HaveSecondaryApps() const {
+  const extensions::Extension* extension = GetPrimaryAppExtension();
+  DCHECK(extension);
+  return extensions::KioskSecondaryAppsInfo::HaveSecondaryApps(extension);
+}
+
+const extensions::Extension* StartupAppLauncher::GetPrimaryAppExtension()
+    const {
+  return extensions::ExtensionSystem::Get(profile_)
+      ->extension_service()
+      ->GetInstalledExtension(app_id_);
+}
+
 void StartupAppLauncher::LaunchApp() {
   if (!ready_to_launch_) {
     NOTREACHED();
     LOG(ERROR) << "LaunchApp() called but launcher is not initialized.";
   }
 
-  const Extension* extension = extensions::ExtensionSystem::Get(profile_)->
-      extension_service()->GetInstalledExtension(app_id_);
+  const Extension* extension = GetPrimaryAppExtension();
   CHECK(extension);
 
   if (!extensions::KioskModeInfo::IsKioskEnabled(extension)) {
     OnLaunchFailure(KioskAppLaunchError::NOT_KIOSK_ENABLED);
     return;
   }
 
   // Always open the app in a window.
   OpenApplication(AppLaunchParams(profile_, extension,
                                   extensions::LAUNCH_CONTAINER_WINDOW,
@@ skipping 31 matching lines @@
           ->pending_extension_manager()
           ->IsIdPending(app_id_)) {
     delegate_->OnInstallingApp();
     // Observe the crx installation events.
     extensions::InstallTracker* tracker =
         extensions::InstallTrackerFactory::GetForBrowserContext(profile_);
     tracker->AddObserver(this);
     return;
   }
 
-  if (extensions::ExtensionSystem::Get(profile_)
-          ->extension_service()
-          ->GetInstalledExtension(app_id_)) {
-    // Launch the app.
-    OnReadyToLaunch();
+  if (GetPrimaryAppExtension()) {
+    // Install secondary apps.
+    MaybeInstallSecondaryApps();
   } else {
     // The extension is skipped for installation due to some error.
     OnLaunchFailure(KioskAppLaunchError::UNABLE_TO_INSTALL);
   }
 }
 
+void StartupAppLauncher::MaybeInstallSecondaryApps() {
+  if (!HaveSecondaryApps()) {
+    // Launch the primary app.
+    MaybeLaunchApp();
+    return;
+  }
+
+  if (!AreSecondaryAppsInstalled() && !delegate_->IsNetworkReady()) {
+    OnLaunchFailure(KioskAppLaunchError::UNABLE_TO_INSTALL);
+    return;
+  }
+
+  extensions::KioskSecondaryAppsInfo* info =
+      extensions::KioskSecondaryAppsInfo::Get(GetPrimaryAppExtension());
+  KioskAppManager::Get()->InstallSecondaryApps(info->ids);
+  if (IsAnySecondaryAppPending()) {
+    delegate_->OnInstallingApp();
+    // Observe the crx installation events.
+    extensions::InstallTracker* tracker =
+        extensions::InstallTrackerFactory::GetForBrowserContext(profile_);
+    tracker->AddObserver(this);
+    return;
+  }
+
+  if (AreSecondaryAppsInstalled()) {
+    // Launch the primary app.
+    MaybeLaunchApp();
+  } else {
+    OnLaunchFailure(KioskAppLaunchError::UNABLE_TO_INSTALL);
+  }
+}
+
 void StartupAppLauncher::OnReadyToLaunch() {
   ready_to_launch_ = true;
   UpdateAppData();
   delegate_->OnReadyToLaunch();
 }
 
 void StartupAppLauncher::UpdateAppData() {
   KioskAppManager::Get()->ClearAppData(app_id_);
   KioskAppManager::Get()->UpdateAppDataFromProfile(app_id_, profile_, NULL);
 }
 
 }   // namespace chromeos