Add a new app API to enable watchdog behavior restarts in kiosk apps

extensions/browser/api/runtime/runtime_api.h

 // 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 EXTENSIONS_BROWSER_API_RUNTIME_RUNTIME_API_H_
 #define EXTENSIONS_BROWSER_API_RUNTIME_RUNTIME_API_H_
 
 #include <string>
 
 #include "base/macros.h"
 #include "base/scoped_observer.h"
+#include "base/time/time.h"
+#include "base/timer/timer.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "extensions/browser/api/runtime/runtime_api_delegate.h"
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "extensions/browser/extension_function.h"
 #include "extensions/browser/extension_registry_observer.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_manager_observer.h"
 #include "extensions/browser/update_observer.h"
 #include "extensions/common/api/runtime.h"
@@ skipping 20 matching lines @@
 
 // Runtime API dispatches onStartup, onInstalled, and similar events to
 // extensions. There is one instance shared between a browser context and
 // its related incognito instance.
 class RuntimeAPI : public BrowserContextKeyedAPI,
                    public content::NotificationObserver,
                    public ExtensionRegistryObserver,
                    public UpdateObserver,
                    public ProcessManagerObserver {
  public:
+  // The status of the restart on watchdog request.
+  enum class RestartOnWatchdogStatus {
+    // The request was made by a different extension other than the first one to
+    // invoke the restartOnWatchdog runtime API.
+    FAILED_NOT_FIRST_EXTENSION,
+
+    // Any previously scheduled restart was successfully canceled.
+    SUCCESS_RESTART_CANCELLED,
+
+    // A restart was successfully scheduled.
+    SUCCESS_RESTART_SCHEDULED,
+  };
+
   static BrowserContextKeyedAPIFactory<RuntimeAPI>* GetFactoryInstance();
 
   explicit RuntimeAPI(content::BrowserContext* context);
   ~RuntimeAPI() override;
 
   // content::NotificationObserver overrides:
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override;
 
   void ReloadExtension(const std::string& extension_id);
   bool CheckForUpdates(const std::string& extension_id,
                        const RuntimeAPIDelegate::UpdateCheckCallback& callback);
   void OpenURL(const GURL& uninstall_url);
   bool GetPlatformInfo(api::runtime::PlatformInfo* info);
   bool RestartDevice(std::string* error_message);
+
+  using OnWatchdogTimeoutCallback =
+      base::Callback<void(bool success, const std::string& message)>;
+  RestartOnWatchdogStatus RestartDeviceOnWatchdogTimeout(
+      const std::string& extension_id,
+      int seconds_from_now,
+      const OnWatchdogTimeoutCallback& callback);
+
   bool OpenOptionsPage(const Extension* extension);
 
  private:
   friend class BrowserContextKeyedAPIFactory<RuntimeAPI>;
+  friend class RestartOnWatchdogApiTest;
 
   // ExtensionRegistryObserver implementation.
   void OnExtensionLoaded(content::BrowserContext* browser_context,
                          const Extension* extension) override;
   void OnExtensionWillBeInstalled(content::BrowserContext* browser_context,
                                   const Extension* extension,
                                   bool is_update,
                                   const std::string& old_name) override;
   void OnExtensionUninstalled(content::BrowserContext* browser_context,
                               const Extension* extension,
                               UninstallReason reason) override;
 
+  // Cancels any previously scheduled restart request, invoking its associated
+  // JS callback function stored in |current_watchdog_request_callback_|.
+  void MaybeCancelRunningWatchdogTimer();
+
+  void ScheduleDelayedRestart(const std::string& extension_id,
+                              const base::Time& now,
+                              int seconds_from_now,
+                              const OnWatchdogTimeoutCallback& callback,
+                              std::unique_ptr<base::Value> stored_last_restart);
+
+  void OnRestartWatchdogTimeout(const std::string& extension_id);

[Devlin, 2016/05/20 17:26:32]

Function docs

[afakhry, 2016/05/21 01:13:00]

Done.

+
   // BrowserContextKeyedAPI implementation:
   static const char* service_name() { return "RuntimeAPI"; }
   static const bool kServiceRedirectedInIncognito = true;
   static const bool kServiceIsNULLWhileTesting = true;
   void Shutdown() override;
 
   // extensions::UpdateObserver overrides:
   void OnAppUpdateAvailable(const Extension* extension) override;
   void OnChromeUpdateAvailable() override;
 
   // ProcessManagerObserver implementation:
   void OnBackgroundHostStartup(const Extension* extension) override;
 
   // Pref related functions that deals with info about installed extensions that
   // has not been loaded yet.
   // Used to send chrome.runtime.onInstalled event upon loading the extensions.
   bool ReadPendingOnInstallInfoFromPref(const ExtensionId& extension_id,
                                         base::Version* previous_version);
   void RemovePendingOnInstallInfoFromPref(const ExtensionId& extension_id);
   void StorePendingOnInstallInfoToPref(const Extension* extension);
 
+  void SetMinDurationBetweenRestartsForTesting(base::TimeDelta delta) {
+    minimum_duration_between_restarts_ = delta;
+  }
+
+  void AllowNonKiostAppsInRestartOnWatchdogForTesting();
+
   std::unique_ptr<RuntimeAPIDelegate> delegate_;
 
   content::BrowserContext* browser_context_;
 
   // True if we should dispatch the chrome.runtime.onInstalled event with
   // reason "chrome_update" upon loading each extension.
   bool dispatch_chrome_updated_event_;
 
   content::NotificationRegistrar registrar_;
 
   // Listen to extension notifications.
   ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
       extension_registry_observer_;
   ScopedObserver<ProcessManager, ProcessManagerObserver>
       process_manager_observer_;
 
+  // The ID of the first extension to call the restartOnWatchdog API. Any other
+  // extensions to call this API after that will fail.
+  std::string schedule_restart_first_extension_id_;
+
+  // The current JS callback for the current scheduled restart which will be
+  // invoked when that restart attempt is executed.
+  OnWatchdogTimeoutCallback current_watchdog_request_callback_;

[Devlin, 2016/05/20 17:26:33]

Are we guaranteed to only have one of these?

[afakhry, 2016/05/21 01:13:00]

This API is only allowed to be called by only one extension (the first to invoke
it) and it must be running in kiosk mode. Any subsequent calls to this API will
cancel the previous one. So yes, at any point in time, we have only a single
"current" restart request.

+
+  // The timer that will trigger a device restart when it times out.
+  base::OneShotTimer watchdog_timer_;
+
+  // The minimum allowed duration between two successive restarts on watchdog
+  // timer.
+  base::TimeDelta minimum_duration_between_restarts_;
+
+  base::WeakPtrFactory<RuntimeAPI> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(RuntimeAPI);
 };
 
 template <>
 void BrowserContextKeyedAPIFactory<RuntimeAPI>::DeclareFactoryDependencies();
 
 class RuntimeEventRouter {
  public:
   // Dispatches the onStartup event to all currently-loaded extensions.
   static void DispatchOnStartupEvent(content::BrowserContext* context,
@@ skipping 82 matching lines @@
 
 class RuntimeRestartFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("runtime.restart", RUNTIME_RESTART)
 
  protected:
   ~RuntimeRestartFunction() override {}
   ResponseAction Run() override;
 };
 
+class RuntimeRestartOnWatchdogFunction : public UIThreadExtensionFunction {
+ public:
+  DECLARE_EXTENSION_FUNCTION("runtime.restartOnWatchdog",

[Devlin, 2016/05/20 17:26:32]

I still think this is weird naming. Maybe restartAfterDelay? Or perhaps better,
just scheduleRestart?

[afakhry, 2016/05/21 01:13:00]

I agree, the name is weird. I guess the intention was to suggest a watchdog
behavior, that user must call this API repeatedly.

We can raise the question of this API's name on the bug and raise consensus
regarding the best name. I'm fine with any.

+                             RUNTIME_RESTARTONWATCHDOG)
+
+ protected:
+  ~RuntimeRestartOnWatchdogFunction() override {}
+  ResponseAction Run() override;
+
+ private:
+  void OnWatchdogTimeout(bool success, const std::string& message);
+};
+
 class RuntimeGetPlatformInfoFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("runtime.getPlatformInfo",
                              RUNTIME_GETPLATFORMINFO);
 
  protected:
   ~RuntimeGetPlatformInfoFunction() override {}
   ResponseAction Run() override;
 };
 
 class RuntimeGetPackageDirectoryEntryFunction
     : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("runtime.getPackageDirectoryEntry",
                              RUNTIME_GETPACKAGEDIRECTORYENTRY)
 
  protected:
   ~RuntimeGetPackageDirectoryEntryFunction() override {}
   ResponseAction Run() override;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_RUNTIME_RUNTIME_API_H_