Install and launch kiosk app from cached crx file at start up.

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"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/app_mode/app_session_lifetime.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_diagnosis_runner.h"
 #include "chrome/browser/chromeos/login/session/user_session_manager.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/install_tracker.h"
+#include "chrome/browser/extensions/install_tracker_factory.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
-#include "chrome/browser/extensions/webstore_startup_installer.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_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/extension.h"
 #include "extensions/common/manifest_handlers/kiosk_mode_info.h"
 #include "extensions/common/manifest_handlers/offline_enabled_info.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"
 
 using content::BrowserThread;
 using extensions::Extension;
-using extensions::WebstoreStartupInstaller;
 
 namespace chromeos {
 
 namespace {
 
 const char kOAuthRefreshToken[] = "refresh_token";
 const char kOAuthClientId[] = "client_id";
 const char kOAuthClientSecret[] = "client_secret";
 
 const base::FilePath::CharType kOAuthFileName[] =
     FILE_PATH_LITERAL("kiosk_auth");
 
-const int kMaxInstallAttempt = 5;
+const int kMaxLaunchAttempt = 5;
 
 }  // 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),
-      install_attempt_(0),
-      ready_to_launch_(false) {
+      launch_attempt_(0),
+      ready_to_launch_(false),
+      wait_for_crx_update_(false) {
   DCHECK(profile_);
   DCHECK(Extension::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.
   ProfileOAuth2TokenServiceFactory::GetForProfile(profile_)
       ->RemoveObserver(this);
 }
 
 void StartupAppLauncher::Initialize() {
   StartLoadingOAuthFile();
 }
 
 void StartupAppLauncher::ContinueWithNetworkReady() {
-  // Starts install if it is not started.
   if (!network_ready_handled_) {
     network_ready_handled_ = true;
-    MaybeInstall();
+    // The network might not be ready when KioskAppManager tries to update
+    // external cache initially. Update the external cache now that the network
+    // is ready for sure.
+    wait_for_crx_update_ = true;
+    KioskAppManager::Get()->UpdateExternalCache();
   }
 }
 
 void StartupAppLauncher::StartLoadingOAuthFile() {
   delegate_->OnLoadingOAuthFile();
 
   KioskOAuthParams* auth_params = new KioskOAuthParams();
   BrowserThread::PostBlockingPoolTaskAndReply(
       FROM_HERE,
       base::Bind(&StartupAppLauncher::LoadOAuthFileOnBlockingPool,
@@ skipping 38 matching lines @@
   }
 
   // If we are restarting chrome (i.e. on crash), we need to initialize
   // OAuth2TokenService as well.
   InitializeTokenService();
 }
 
 void StartupAppLauncher::RestartLauncher() {
   // If the installer is still running in the background, we don't need to
   // restart the launch process. We will just wait until it completes and
-  // lunches the kiosk app.
-  if (installer_ != NULL) {
+  // launches the kiosk app.
+  if (extensions::ExtensionSystem::Get(profile_)
+          ->extension_service()
+          ->pending_extension_manager()
+          ->IsIdPending(app_id_)) {
     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 bool requires_network = !extension ||
-      !extensions::OfflineEnabledInfo::IsOfflineEnabled(extension);
+  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;
   }
 
-  // Offline enabled app attempts update if network is ready. Otherwise,
-  // go directly to launch.
+  // Update the offline enabled crx cache if the network is ready;
+  // or just install the app.
   if (delegate_->IsNetworkReady())
     ContinueWithNetworkReady();
   else
-    OnReadyToLaunch();
+    BeginInstall();
 }
 
 void StartupAppLauncher::InitializeTokenService() {
   delegate_->OnInitializingTokenService();
 
   ProfileOAuth2TokenService* profile_token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfile(profile_);
   const std::string primary_account_id =
@@ skipping 28 matching lines @@
       ->RemoveObserver(this);
   MaybeInitializeNetwork();
 }
 
 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_);

[xiyuan, 2014/07/14 18:20:54]

nit: DCHECK(extension);

[jennyz, 2014/07/14 22:32:59]

Done.

+  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_;
+    if (launch_attempt_ < kMaxLaunchAttempt) {
+      BrowserThread::PostTask(
+          BrowserThread::UI,
+          FROM_HERE,
+          base::Bind(&StartupAppLauncher::MaybeInitializeNetwork, AsWeakPtr()));
+      return;
+    }
+    OnLaunchFailure(KioskAppLaunchError::UNABLE_TO_LAUNCH);
+  }
+}
+
+void StartupAppLauncher::OnFinishCrxInstall(const std::string& extension_id,
+                                            bool success) {
+  if (extension_id != app_id_)
+    return;
+
+  extensions::InstallTracker* tracker =
+      extensions::InstallTrackerFactory::GetForProfile(profile_);
+  tracker->RemoveObserver(this);
+  if (delegate_->IsShowingNetworkConfigScreen()) {
+    LOG(WARNING) << "Showing network config screen";
+    return;
+  }
+
+  if (success) {
+    // Check if the app is offline enabled.

[xiyuan, 2014/07/14 18:20:54]

The code inside this branch looks like MaybeLaunchApp().

[jennyz, 2014/07/14 22:32:58]

Done.

+    const Extension* extension = extensions::ExtensionSystem::Get(profile_)
+                                     ->extension_service()
+                                     ->GetInstalledExtension(extension_id);
+    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_;
+      if (launch_attempt_ < kMaxLaunchAttempt) {
+        BrowserThread::PostTask(
+            BrowserThread::UI,
+            FROM_HERE,
+            base::Bind(&StartupAppLauncher::MaybeInitializeNetwork,
+                       AsWeakPtr()));
+        return;
+      }
+      OnLaunchFailure(KioskAppLaunchError::UNABLE_TO_LAUNCH);
+    }
+    return;
+  }
+
+  LOG(ERROR) << "Failed to install the kiosk application app_id: "
+             << extension_id;
+  OnLaunchFailure(KioskAppLaunchError::UNABLE_TO_INSTALL);
+}
+
+void StartupAppLauncher::OnKioskAppDataChanged(const std::string& app_id) {
+  OnKioskAppDataLoadStatusChanged(app_id);
+}
+
+void StartupAppLauncher::OnKioskAppDataLoadFailure(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;
+
+  if (KioskAppManager::Get()->HasCachedCrx(app_id_)) {
+    BeginInstall();
+  } else if (extensions::ExtensionSystem::Get(profile_)

[xiyuan, 2014/07/14 18:20:54]

Why do we need this "else" branch?

[jennyz, 2014/07/14 22:32:58]

As we discussed, we won't launch the app if the app is installed but cache is
missing, consider this as an error case now.

+                 ->extension_service()
+                 ->GetInstalledExtension(app_id_)) {
+    MaybeLaunchApp();
+  }
+}
+
 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_);
   CHECK(extension);
 
@@ skipping 25 matching lines @@
   delegate_->OnLaunchSucceeded();
 }
 
 void StartupAppLauncher::OnLaunchFailure(KioskAppLaunchError::Error error) {
   LOG(ERROR) << "App launch failed, error: " << error;
   DCHECK_NE(KioskAppLaunchError::NONE, error);
 
   delegate_->OnLaunchFailed(error);
 }
 
-void StartupAppLauncher::MaybeInstall() {
-  delegate_->OnInstallingApp();
-
-  ExtensionService* extension_service =
-      extensions::ExtensionSystem::Get(profile_)->extension_service();
-  if (!extension_service->GetInstalledExtension(app_id_)) {
-    BeginInstall();
-    return;
-  }
-
-  extensions::ExtensionUpdater::CheckParams check_params;
-  check_params.ids.push_back(app_id_);
-  check_params.install_immediately = true;
-  check_params.callback =
-      base::Bind(&StartupAppLauncher::OnUpdateCheckFinished, AsWeakPtr());
-  extension_service->updater()->CheckNow(check_params);
-}
-
 void StartupAppLauncher::OnUpdateCheckFinished() {
   OnReadyToLaunch();
   UpdateAppData();
 }
 
 void StartupAppLauncher::BeginInstall() {
-  installer_ = new WebstoreStartupInstaller(
-      app_id_,
-      profile_,
-      false,
-      base::Bind(&StartupAppLauncher::InstallCallback, AsWeakPtr()));
-  installer_->BeginInstall();
-}
-
-void StartupAppLauncher::InstallCallback(bool success,
-                                         const std::string& error) {
-  installer_ = NULL;
-  if (delegate_->IsShowingNetworkConfigScreen()) {
-    LOG(WARNING) << "Showing network config screen";
+  KioskAppManager::Get()->InstallFromCache(app_id_);
+  if (extensions::ExtensionSystem::Get(profile_)
+          ->extension_service()
+          ->pending_extension_manager()
+          ->IsIdPending(app_id_)) {
+    delegate_->OnInstallingApp();
+    // Observe the crx installation events.
+    extensions::InstallTracker* tracker =
+        extensions::InstallTrackerFactory::GetForProfile(profile_);
+    tracker->AddObserver(this);
     return;
   }
 
-  if (success) {
-    // Finish initialization after the callback returns.
-    // So that the app finishes its installation.
-    BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&StartupAppLauncher::OnReadyToLaunch,
-                   AsWeakPtr()));
-    return;
+  if (extensions::ExtensionSystem::Get(profile_)
+          ->extension_service()
+          ->GetInstalledExtension(app_id_)) {
+    // Launch the app.
+    OnReadyToLaunch();
+  } else {
+    // The extension is skipped for installation due to some error.
+    OnLaunchFailure(KioskAppLaunchError::UNABLE_TO_INSTALL);
   }
-
-  LOG(ERROR) << "App install failed: " << error
-             << ", for attempt " << install_attempt_;
-
-  ++install_attempt_;
-  if (install_attempt_ < kMaxInstallAttempt) {
-    BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&StartupAppLauncher::MaybeInitializeNetwork,
-                   AsWeakPtr()));
-    return;
-  }
-
-  OnLaunchFailure(KioskAppLaunchError::UNABLE_TO_INSTALL);
 }
 
 void StartupAppLauncher::OnReadyToLaunch() {
   ready_to_launch_ = true;
   delegate_->OnReadyToLaunch();
 }
 
 void StartupAppLauncher::UpdateAppData() {
   KioskAppManager::Get()->ClearAppData(app_id_);
   KioskAppManager::Get()->UpdateAppDataFromProfile(app_id_, profile_, NULL);
 }
 
 }   // namespace chromeos