Check import module update before launching the primary kiosk app.

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 54 matching lines @@
 
 }  // namespace
 
 StartupAppLauncher::StartupAppLauncher(Profile* profile,
                                        const std::string& app_id,
                                        bool diagnostic_mode,
                                        StartupAppLauncher::Delegate* delegate)
     : profile_(profile),
       app_id_(app_id),
       diagnostic_mode_(diagnostic_mode),
-      delegate_(delegate),
-      network_ready_handled_(false),
-      launch_attempt_(0),
-      ready_to_launch_(false),
-      wait_for_crx_update_(false),
-      secondary_apps_updated_(false) {
+      delegate_(delegate) {
   DCHECK(profile_);
   DCHECK(crx_file::id_util::IdIsValid(app_id_));
   KioskAppManager::Get()->AddObserver(this);
 }
 
 StartupAppLauncher::~StartupAppLauncher() {
   KioskAppManager::Get()->RemoveObserver(this);
 
   // StartupAppLauncher can be deleted at anytime during the launch process
   // through a user bailout shortcut.
@@ skipping 171 matching lines @@
       BrowserThread::PostTask(
           BrowserThread::UI,
           FROM_HERE,
           base::Bind(&StartupAppLauncher::MaybeInitializeNetwork, AsWeakPtr()));
       return;
     }
     OnLaunchFailure(KioskAppLaunchError::UNABLE_TO_LAUNCH);
   }
 }
 
+void StartupAppLauncher::MaybeCheckExtensionUpdate() {
+  extensions::ExtensionUpdater* updater =
+      extensions::ExtensionSystem::Get(profile_)
+          ->extension_service()
+          ->updater();
+  if (!delegate_->IsNetworkReady() || !updater) {
+    MaybeLaunchApp();
+    return;
+  }
+
+  extension_update_found_ = false;
+  registrar_.Add(this, extensions::NOTIFICATION_EXTENSION_UPDATE_FOUND,
+                 content::NotificationService::AllSources());
+
+  // Enforce an immediate version update check for all extensions before
+  // launching the primary app. After the chromeos is updated, the shared
+  // module(e.g. ARC runtime) may need to be updated to a newer version
+  // compatible with the new chromeos. See crbug.com/555083.
+  extensions::ExtensionUpdater::CheckParams params;
+  params.install_immediately = true;
+  params.callback = base::Bind(
+      &StartupAppLauncher::OnExtensionUpdateCheckFinished, AsWeakPtr());
+  updater->CheckNow(params);
+}
+
+void StartupAppLauncher::OnExtensionUpdateCheckFinished() {
+  if (extension_update_found_) {
+    // Reload the primary app to make sure any reference to the previous version
+    // of the shared module, extension, etc will be cleaned up andthe new
+    // version will be loaded.
+    extensions::ExtensionSystem::Get(profile_)
+            ->extension_service()
+            ->ReloadExtension(app_id_);
+    extension_update_found_ = false;
+  }
+  registrar_.Remove(this, extensions::NOTIFICATION_EXTENSION_UPDATE_FOUND,
+                    content::NotificationService::AllSources());
+
+  MaybeLaunchApp();
+}
+
+void StartupAppLauncher::Observe(int type,
+                                 const content::NotificationSource& source,
+                                 const content::NotificationDetails& details) {
+  DCHECK(type == extensions::NOTIFICATION_EXTENSION_UPDATE_FOUND);
+  typedef const std::pair<std::string, Version> UpdateDetails;
+  const std::string& id = content::Details<UpdateDetails>(details)->first;
+  const Version& version = content::Details<UpdateDetails>(details)->second;
+  VLOG(1) << "Found extension update id=" << id
+      << " version=" << version.GetString();
+  extension_update_found_ = true;
+}
+
 void StartupAppLauncher::OnFinishCrxInstall(const std::string& extension_id,
                                             bool success) {
   // Wait for pending updates or dependent extensions to download.
   if (extensions::ExtensionSystem::Get(profile_)
           ->extension_service()
           ->pending_extension_manager()
           ->HasPendingExtensions()) {
     return;
   }
 
   extensions::InstallTracker* tracker =
       extensions::InstallTrackerFactory::GetForBrowserContext(profile_);
   tracker->RemoveObserver(this);
   if (delegate_->IsShowingNetworkConfigScreen()) {
     LOG(WARNING) << "Showing network config screen";
     return;
   }
 
   if (DidPrimaryOrSecondaryAppFailedToInstall(success, extension_id)) {
     OnLaunchFailure(KioskAppLaunchError::UNABLE_TO_INSTALL);
     return;
   }
 
   if (GetPrimaryAppExtension()) {
-    if (!secondary_apps_updated_)
+    if (!secondary_apps_installed_)
       MaybeInstallSecondaryApps();
     else
-      MaybeLaunchApp();
+      MaybeCheckExtensionUpdate();
   }
 }
 
 void StartupAppLauncher::OnKioskExtensionLoadedInCache(
     const std::string& app_id) {
   OnKioskAppDataLoadStatusChanged(app_id);
 }
 
 void StartupAppLauncher::OnKioskExtensionDownloadFailed(
     const std::string& app_id) {
@@ skipping 148 matching lines @@
     OnLaunchFailure(KioskAppLaunchError::UNABLE_TO_INSTALL);
   }
 }
 
 void StartupAppLauncher::MaybeInstallSecondaryApps() {
   if (!AreSecondaryAppsInstalled() && !delegate_->IsNetworkReady()) {
     OnLaunchFailure(KioskAppLaunchError::UNABLE_TO_INSTALL);
     return;
   }
 
-  secondary_apps_updated_ = true;
+  secondary_apps_installed_ = true;
   extensions::KioskModeInfo* info =
       extensions::KioskModeInfo::Get(GetPrimaryAppExtension());
   KioskAppManager::Get()->InstallSecondaryApps(info->secondary_app_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();
+    // Check extension update before launching the primary kiosk app.
+    MaybeCheckExtensionUpdate();
   } 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