Update cached kiosk app crx from usb stick.

chrome/browser/chromeos/app_mode/kiosk_external_updater.h

Index: chrome/browser/chromeos/app_mode/kiosk_external_updater.h
diff --git a/chrome/browser/chromeos/app_mode/kiosk_external_updater.h b/chrome/browser/chromeos/app_mode/kiosk_external_updater.h
new file mode 100644
index 0000000000000000000000000000000000000000..a234a774974f11d84a50cf5c9e57723aac749d65
--- /dev/null
+++ b/chrome/browser/chromeos/app_mode/kiosk_external_updater.h
@@ -0,0 +1,147 @@
+// Copyright 2014 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_APP_MODE_KIOSK_EXTERNAL_UPDATER_H_
+#define CHROME_BROWSER_CHROMEOS_APP_MODE_KIOSK_EXTERNAL_UPDATER_H_
+
+#include <string>
+
+#include "base/files/file_path.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/sequenced_task_runner.h"
+#include "chrome/browser/chromeos/app_mode/kiosk_external_update_validator.h"
+#include "chromeos/disks/disk_mount_manager.h"
+
+namespace chromeos {
+
+class KioskExternalUpdateNotification;
+
+// Observes the disk mount/unmount events, scans the usb stick for external
+// kiosk app updates, validates the external crx, and updates the cache.
+class KioskExternalUpdater : public disks::DiskMountManager::Observer,
+                             public KioskExternalUpdateValidatorDelegate {
+ public:
+  enum ExternalUpdateErrorCode {
+    ERROR_NONE,
+    ERROR_NO_MANIFEST,
+    ERROR_INVALID_MANIFEST,
+  };
+
+  KioskExternalUpdater(
+      const scoped_refptr<base::SequencedTaskRunner>& backend_task_runner,
+      const base::FilePath& crx_cache_dir,
+      const base::FilePath& crx_unpack_dir);
+
+  virtual ~KioskExternalUpdater();
+
+ private:
+  enum ExternalUpdateStatus {
+    PENDING,
+    SUCCESS,
+    FAILED,
+  };
+  struct ExternalUpdate {
+    ExternalUpdate();
+
+    std::string app_name;
+    base::FilePath external_crx;
+    ExternalUpdateStatus update_status;
+    base::string16 error;
+  };
+
+  // disks::DiskMountManager::Observer overrides.
+  virtual void OnDiskEvent(disks::DiskMountManager::DiskEvent event,
+                           const disks::DiskMountManager::Disk* disk) OVERRIDE;
+  virtual void OnDeviceEvent(disks::DiskMountManager::DeviceEvent event,
+                             const std::string& device_path) OVERRIDE;
+  virtual void OnMountEvent(
+      disks::DiskMountManager::MountEvent event,
+      MountError error_code,
+      const disks::DiskMountManager::MountPointInfo& mount_info) OVERRIDE;
+  virtual void OnFormatEvent(disks::DiskMountManager::FormatEvent event,
+                             FormatError error_code,
+                             const std::string& device_path) OVERRIDE;
+
+  // KioskExternalUpdateValidatorDelegate overrides:
+  virtual void OnExtenalUpdateUnpackSuccess(
+      const std::string& app_id,
+      const std::string& version,
+      const std::string& min_browser_version,
+      const base::FilePath& temp_dir) OVERRIDE;
+  virtual void OnExternalUpdateUnpackFailure(
+      const std::string& app_id) OVERRIDE;
+
+  // Processes the parsed external update manifest, check |parsing_error| for
+  // any manifest parsing error.
+  void ProcessParsedManifest(ExternalUpdateErrorCode* parsing_error,
+                             const base::FilePath& external_update_dir,
+                             base::DictionaryValue* parsed_manifest);
+
+  // Returns true if |external_update_| is interrupted before the updating
+  // completes.
+  bool CheckExternalUpdateInterrupted();
+
+  // Validates the external updates.
+  void ValidateExternalUpdates();
+
+  // Called upon completion of caching external crx file.
+  // |cache_success| pass in the result of caching crx file.
+  void OnCacheExternalCrx(const std::string& app_id,
+                          const base::FilePath& target_file,
+                          bool* cache_success);
+
+  // Returns true if there are any external updates pending.
+  bool IsExternalUpdatePending();
+
+  // Returns true if the app with |app_id| should be updated to
+  // |external_extension|.
+  bool ShouldDoExternalUpdate(const std::string& app_id,
+                              const std::string& version,
+                              const std::string& min_browser_version);
+
+  void NotifyKioskUpdateProgress(const base::string16& message);
+
+  void MaybeValidateNextExternalUpdate();
+
+  // Notifies the kiosk update status with UI and KioskAppUpdateService, if
+  // there is no kiosk external updates pending.
+  void MayBeNotifyKioskAppUpdate();
+
+  void NotifyKioskAppUpdateAvailable();
+
+  void ShowKioskUpdateProgress(const base::string16& message);
+
+  // Dismisses the UI notification for kiosk updates.
+  void DismissKioskUpdateNotificationOnUIThread();
+  void DismissKioskUpdateNotification();
+
+  // Return a detailed message for kiosk updating status.
+  base::string16 GetUpdateReportMessage();
+
+  // Task runner for executing file I/O tasks.
+  const scoped_refptr<base::SequencedTaskRunner> backend_task_runner_;
+
+  // The directory where kiosk crx files are cached.
+  const base::FilePath crx_cache_dir_;
+
+  // The directory used by SandBoxedUnpacker for unpack extensions.
+  const base::FilePath crx_unpack_dir_;
+
+  // The path where external crx files resides(usb stick mount path).
+  base::FilePath external_update_path_;
+
+  // map of app_id: ExternalUpdate
+  typedef std::map<std::string, ExternalUpdate> ExternalUpdateMap;
+  ExternalUpdateMap external_updates_;
+  scoped_ptr<KioskExternalUpdateNotification> notification_;
+
+  base::WeakPtrFactory<KioskExternalUpdater> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(KioskExternalUpdater);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_APP_MODE_KIOSK_EXTERNAL_UPDATER_H_