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

extensions/browser/api/runtime/runtime_apitest.cc

 // 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.
 
 #include "chrome/browser/apps/app_browsertest_util.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/test_extension_dir.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 110 matching lines @@
       break;
     } else {
       load_observer.Wait();
       WaitForExtensionViewsToLoad();
     }
   }
   ASSERT_TRUE(
       registry->GetExtensionById(extension_id, ExtensionRegistry::TERMINATED));
 }
 
+namespace {
+
+// An intercepter of the real RuntimeAPIDelegate that simulates a successful
+// restart request every time.
+class RestartOnWatchdogApiDelegate : public RuntimeAPIDelegate {
+ public:
+  // Takes ownership of the |real_api_delegate|.
+  RestartOnWatchdogApiDelegate(
+      std::unique_ptr<RuntimeAPIDelegate> real_api_delegate)
+      : real_api_delegate_(std::move(real_api_delegate)) {}
+  ~RestartOnWatchdogApiDelegate() override {}
+
+  // RuntimeAPIDelegate:
+  void AddUpdateObserver(UpdateObserver* observer) override {
+    real_api_delegate_->AddUpdateObserver(observer);
+  }
+
+  void RemoveUpdateObserver(UpdateObserver* observer) override {
+    real_api_delegate_->RemoveUpdateObserver(observer);
+  }
+
+  base::Version GetPreviousExtensionVersion(
+      const Extension* extension) override {
+    return real_api_delegate_->GetPreviousExtensionVersion(extension);
+  }
+
+  void ReloadExtension(const std::string& extension_id) override {
+    real_api_delegate_->ReloadExtension(extension_id);
+  }
+
+  bool CheckForUpdates(const std::string& extension_id,
+                       const UpdateCheckCallback& callback) override {
+    return real_api_delegate_->CheckForUpdates(extension_id, callback);
+  }
+
+  void OpenURL(const GURL& uninstall_url) override {
+    real_api_delegate_->OpenURL(uninstall_url);
+  }
+
+  bool GetPlatformInfo(api::runtime::PlatformInfo* info) override {
+    return real_api_delegate_->GetPlatformInfo(info);
+  }
+
+  bool RestartDevice(std::string* error_message) override {
+    *error_message = "Success.";
+    return true;
+  }
+
+ private:
+  std::unique_ptr<RuntimeAPIDelegate> real_api_delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(RestartOnWatchdogApiDelegate);
+};
+
+}  // namespace
+
+class RestartOnWatchdogApiTest : public ExtensionApiTest {
+ public:
+  RestartOnWatchdogApiTest() {}
+  ~RestartOnWatchdogApiTest() override {}
+
+  void SetUpOnMainThread() override {
+    RuntimeAPI* runtime_api = RuntimeAPI::GetFactoryInstance()->Get(profile());
+    runtime_api->delegate_.reset(
+        new RestartOnWatchdogApiDelegate(std::move(runtime_api->delegate_)));
+    runtime_api->SetMinDurationBetweenRestartsForTesting(
+        base::TimeDelta::FromSeconds(3));
+    runtime_api->AllowNonKiostAppsInRestartOnWatchdogForTesting();
+
+    ExtensionApiTest::SetUpOnMainThread();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(RestartOnWatchdogApiTest);
+};
+
+IN_PROC_BROWSER_TEST_F(RestartOnWatchdogApiTest, RestartOnWatchdogTest) {
+  ASSERT_TRUE(RunExtensionTest("runtime/restartOnWatchdog")) << message_;
+}
+
 }  // namespace extensions