arc: Add splash screen for ARC++ Kiosk startup

chrome/browser/chromeos/app_mode/arc/arc_kiosk_app_service.cc

 // Copyright 2016 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/arc/arc_kiosk_app_service.h>
 
 #include "chrome/browser/chromeos/app_mode/arc/arc_kiosk_app_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_utils.h"
@@ skipping 33 matching lines @@
 // static
 ArcKioskAppService* ArcKioskAppService::Create(Profile* profile) {
   return new ArcKioskAppService(profile);
 }
 
 // static
 ArcKioskAppService* ArcKioskAppService::Get(content::BrowserContext* context) {
   return ArcKioskAppServiceFactory::GetForBrowserContext(context);
 }
 
+void ArcKioskAppService::SetDelegate(Delegate* delegate) {
+  delegate_ = delegate;
+}
+
 void ArcKioskAppService::Shutdown() {
   ArcAppListPrefs::Get(profile_)->RemoveObserver(this);
   app_manager_->RemoveObserver(this);
 }
 
 void ArcKioskAppService::OnAppRegistered(
     const std::string& app_id,
     const ArcAppListPrefs::AppInfo& app_info) {
+  if (!app_id_.empty() && app_id != app_id_)
+    return;
   PreconditionsChanged();
 }
 
 void ArcKioskAppService::OnAppReadyChanged(const std::string& id, bool ready) {
+  if (!app_id_.empty() && id != app_id_)
+    return;
   PreconditionsChanged();
 }
 
 void ArcKioskAppService::OnPackageListInitialRefreshed() {
   // The app could already be registered.
   PreconditionsChanged();
 }
 
 void ArcKioskAppService::OnArcKioskAppsChanged() {
   PreconditionsChanged();
 }
 
 void ArcKioskAppService::OnTaskCreated(int32_t task_id,
                                        const std::string& package_name,
                                        const std::string& activity,
                                        const std::string& intent) {
   // Store task id of the app to stop it later when needed.
   if (app_info_ && package_name == app_info_->package_name &&
       activity == app_info_->activity) {
     task_id_ = task_id;
+    if (delegate_)
+      delegate_->OnAppStarted();
   }
 }
 
 void ArcKioskAppService::OnTaskDestroyed(int32_t task_id) {
   if (task_id == task_id_) {
     app_launcher_.reset();
     task_id_ = -1;
     // Trying to restart app if it was somehow closed or crashed
     // as kiosk app should always be running during the session.
     PreconditionsChanged();
   }
 }
 
 void ArcKioskAppService::OnMaintenanceSessionCreated() {
   maintenance_session_running_ = true;
   PreconditionsChanged();
 }
 
 void ArcKioskAppService::OnMaintenanceSessionFinished() {
   maintenance_session_running_ = false;
   PreconditionsChanged();
 }
 
+void ArcKioskAppService::OnAppWindowLaunched() {
+  if (delegate_)
+    delegate_->OnAppWindowLaunched();
+}
+
 ArcKioskAppService::ArcKioskAppService(Profile* profile) : profile_(profile) {
   ArcAppListPrefs::Get(profile_)->AddObserver(this);
   app_manager_ = ArcKioskAppManager::Get();
   DCHECK(app_manager_);
   app_manager_->AddObserver(this);
   pref_change_registrar_.reset(new PrefChangeRegistrar());
   pref_change_registrar_->Init(profile_->GetPrefs());
   // Try to start/stop kiosk app on policy compliance state change.
   pref_change_registrar_->Add(
       prefs::kArcPolicyCompliant,
       base::Bind(&ArcKioskAppService::PreconditionsChanged,
                  base::Unretained(this)));
   notification_blocker_.reset(new ArcKioskNotificationBlocker());
   PreconditionsChanged();
 }
 
 ArcKioskAppService::~ArcKioskAppService() = default;
 
 void ArcKioskAppService::PreconditionsChanged() {
   app_id_ = GetAppId();
   if (app_id_.empty())
     return;
   app_info_ = ArcAppListPrefs::Get(profile_)->GetApp(app_id_);
   if (app_info_ && app_info_->ready &&
       profile_->GetPrefs()->GetBoolean(prefs::kArcPolicyCompliant) &&
       !maintenance_session_running_) {
     if (!app_launcher_)
-      app_launcher_.reset(new ArcKioskAppLauncher(
-          profile_, ArcAppListPrefs::Get(profile_), app_id_));
+      app_launcher_ = base::MakeUnique<ArcKioskAppLauncher>(
+          profile_, ArcAppListPrefs::Get(profile_), app_id_, this);
   } else if (task_id_ != -1) {
     arc::CloseTask(task_id_);
   }
 }
 
 std::string ArcKioskAppService::GetAppId() {
   AccountId account_id = multi_user_util::GetAccountIdFromProfile(profile_);
   const ArcKioskAppManager::ArcKioskApp* app =
       app_manager_->GetAppByAccountId(account_id);
   if (!app)
     return std::string();
   std::unordered_set<std::string> app_ids =
       ArcAppListPrefs::Get(profile_)->GetAppsForPackage(
           app->app_info().package_name());
   if (app_ids.empty())
     return std::string();
   // TODO(poromov@): Choose appropriate app id to launch. See
   // http://crbug.com/665904
   return std::string(*app_ids.begin());
 }
 
 }  // namespace chromeos