kiosk: Defer app update until platform matches

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 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/extensions/extension_service.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 81 matching lines @@
 #include "extensions/common/permissions/api_permission.h"
 #include "extensions/common/permissions/permission_message_provider.h"
 #include "extensions/common/permissions/permissions_data.h"
 
 #if defined(ENABLE_SUPERVISED_USERS)
 #include "chrome/browser/supervised_user/supervised_user_service.h"
 #include "chrome/browser/supervised_user/supervised_user_service_factory.h"
 #endif
 
 #if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
 #include "chrome/browser/chromeos/extensions/install_limiter.h"
 #include "storage/browser/fileapi/file_system_backend.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #endif
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using extensions::APIPermission;
 using extensions::AppSorting;
@@ skipping 1693 matching lines @@
     if (status == SharedModuleService::IMPORT_STATUS_UNSATISFIED) {
       extension_prefs_->SetDelayedInstallInfo(
           extension,
           initial_state,
           install_flags,
           extensions::ExtensionPrefs::DELAY_REASON_WAIT_FOR_IMPORTS,
           page_ordinal,
           install_parameter);
       delayed_installs_.Insert(extension);
     }
+#if defined(OS_CHROMEOS)
+  } else if (!chromeos::KioskAppManager::Get()->IsPlatformCompliantWithApp(
+                 extension) &&
+             !!GetInstalledExtension(extension->id())) {
+    // Delay updating of an existing extension when required platform version
+    // of the new extension is not compliant.
+    extension_prefs_->SetDelayedInstallInfo(
+        extension,
+        initial_state,
+        install_flags,
+        extensions::ExtensionPrefs::DELAY_REASON_WAIT_FOR_OS_UPDATE,
+        page_ordinal,
+        install_parameter);
+    delayed_installs_.Insert(extension);
+
+    // Updates the required platform version meta data to allow update engine
+    // to move on to the new OS version.
+    chromeos::KioskAppManager::Get()->UpdateAppDataFromProfile(
+        extension->id(), profile(), extension);
+#endif

[asargent_no_longer_on_chrome, 2016/04/06 19:32:23]

This function is already getting kind of long and complicated, so instead of
adding another block of ifdef'd code, I'd prefer we do the following:

-Add some sort of "InstallDelayer" interface with a method can be be called to
see if they'd like to delay install of an extension, and also a method that
would be called down in MaybeFinishDelayedInstallation. The ExtensionService
will have a way for objects implementing this interface to register themselves.
You could then have an object that implements this interface for chromeos, and
it would register with the ExtensionService in one of the existing places where
we do similar stuff to setup the ExtensionService, perhaps in
extension_system_impl.cc. 

-We'd consolidate all the checks related to delaying install into
ShouldDelayExtensionUpdate, including checking with all the registered
InstallDelayer's. Also the SharedModule checks above could probably be moved
into the SharedModuleService, and make the SharedModuleService implement the
InstallDelayer interface. 


Basically I think our goal should be to make ExtensionService a general purpose
object that doesn't have any #ifdef OS_CHROMEOS blocks of code in it, but rather
has config values and delegate objects to abstract different behaviors. 

[xiyuan, 2016/04/19 18:38:54]

Done.

   } else {
     AddNewOrUpdatedExtension(extension,
                              initial_state,
                              install_flags,
                              page_ordinal,
                              install_parameter);
   }
 }
 
 void ExtensionService::OnExtensionManagementSettingsChanged() {
@@ skipping 66 matching lines @@
         delayed_installs_.Remove(extension_id);
         // Make sure no version of the extension is actually installed, (i.e.,
         // that this delayed install was not an update).
         CHECK(!extension_prefs_->GetInstalledExtensionInfo(extension_id).get());
         extension_prefs_->DeleteExtensionPrefs(extension_id);
       }
       return;
     }
   }
 
+#if defined(OS_CHROMEOS)
+  if (reason == extensions::ExtensionPrefs::DELAY_REASON_WAIT_FOR_OS_UPDATE &&
+      !chromeos::KioskAppManager::Get()->IsPlatformCompliantWithApp(
+          extension)) {
+    return;
+  }
+#endif
+
   FinishDelayedInstallation(extension_id);
 }
 
 void ExtensionService::FinishDelayedInstallation(
     const std::string& extension_id) {
   scoped_refptr<const Extension> extension(
       GetPendingExtensionUpdate(extension_id));
   CHECK(extension.get());
   delayed_installs_.Remove(extension_id);
 
@@ skipping 540 matching lines @@
 }
 
 void ExtensionService::OnProfileDestructionStarted() {
   ExtensionIdSet ids_to_unload = registry_->enabled_extensions().GetIDs();
   for (ExtensionIdSet::iterator it = ids_to_unload.begin();
        it != ids_to_unload.end();
        ++it) {
     UnloadExtension(*it, UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN);
   }
 }