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

extensions/browser/api/runtime/restart_after_delay_api_unittest.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 "base/callback_helpers.h"
+#include "base/run_loop.h"
+#include "components/pref_registry/pref_registry_syncable.h"
+#include "extensions/browser/api/runtime/runtime_api.h"
+#include "extensions/browser/api_test_utils.h"
+#include "extensions/browser/api_unittest.h"
+#include "extensions/browser/test_extensions_browser_client.h"
+
+namespace extensions {
+
+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 {
+    if (!quit_closure_.is_null())
+      base::ResetAndReturn(&quit_closure_).Run();
+
+    *error_message = "Success.";
+    return true;
+  }
+
+  base::TimeTicks WaitForSuccessfulRestart() {
+    base::RunLoop run_loop;

[Devlin, 2016/06/01 21:29:15]

Isn't this racy if the restart happens quickly enough?

[afakhry, 2016/06/02 01:43:40]

Added a bool to detect if the restart was done already before waiting for it.
Thanks.

+    quit_closure_ = run_loop.QuitClosure();
+    run_loop.Run();
+    return base::TimeTicks::Now();
+  }
+
+ private:
+  std::unique_ptr<RuntimeAPIDelegate> real_api_delegate_;
+
+  base::Closure quit_closure_;
+
+  DISALLOW_COPY_AND_ASSIGN(RestartOnWatchdogApiDelegate);
+};
+
+}  // namespace
+
+class RestartAfterDelayApiTest : public ApiUnitTest {
+ public:
+  RestartAfterDelayApiTest() : api_delegate_(nullptr) {}
+  ~RestartAfterDelayApiTest() override {}
+
+  void SetUp() override {
+    ApiUnitTest::SetUp();
+
+    RuntimeAPI* runtime_api =
+        RuntimeAPI::GetFactoryInstance()->Get(browser_context());
+    api_delegate_ =
+        new RestartOnWatchdogApiDelegate(std::move(runtime_api->delegate_));
+    runtime_api->delegate_.reset(api_delegate_);
+    runtime_api->set_min_duration_between_restarts_for_testing(
+        base::TimeDelta::FromSeconds(3));
+    runtime_api->AllowNonKiostAppsInRestartOnWatchdogForTesting();
+
+    RuntimeAPI::RegisterPrefs(
+        extensions_browser_client()->testing_pref_service()->registry());
+  }
+
+  base::TimeTicks WaitForSuccessfulRestart() {
+    return api_delegate_->WaitForSuccessfulRestart();
+  }
+
+  bool IsWatchdogTimerRunning() {
+    return RuntimeAPI::GetFactoryInstance()
+        ->Get(browser_context())
+        ->watchdog_timer_.IsRunning();
+  }
+
+  base::TimeTicks desired_restart_time() {
+    return RuntimeAPI::GetFactoryInstance()
+        ->Get(browser_context())
+        ->watchdog_timer_.desired_run_time();
+  }
+
+  void RunFunctionAssertNoError(UIThreadExtensionFunction* function,
+                                const std::string& args) {
+    scoped_refptr<ExtensionFunction> function_owner(function);
+    function->set_extension(extension());
+    function->set_has_callback(true);
+    api_test_utils::RunFunction(function, args, browser_context());
+    ASSERT_TRUE(function->GetError().empty()) << function->GetError();
+  }
+
+ private:
+  RestartOnWatchdogApiDelegate* api_delegate_;  // Not Owned.
+
+  DISALLOW_COPY_AND_ASSIGN(RestartAfterDelayApiTest);
+};
+
+TEST_F(RestartAfterDelayApiTest, RestartAfterDelayTest) {
+  RunFunctionAssertNoError(new RuntimeRestartAfterDelayFunction(), "[-1]");
+  ASSERT_FALSE(IsWatchdogTimerRunning());
+
+  // Request a restart after 3 seconds.
+  base::TimeTicks now = base::TimeTicks::Now();
+  RunFunctionAssertNoError(new RuntimeRestartAfterDelayFunction(), "[3]");
+  ASSERT_TRUE(IsWatchdogTimerRunning());
+  ASSERT_GE(desired_restart_time() - now, base::TimeDelta::FromSeconds(3));
+
+  // Request another restart after 4 seconds. It should reschedule the previous
+  // request.
+  now = base::TimeTicks::Now();
+  RunFunctionAssertNoError(new RuntimeRestartAfterDelayFunction(), "[4]");
+  ASSERT_TRUE(IsWatchdogTimerRunning());
+  ASSERT_GE(desired_restart_time() - now, base::TimeDelta::FromSeconds(4));
+
+  // Cancel restart requests.
+  RunFunctionAssertNoError(new RuntimeRestartAfterDelayFunction(), "[-1]");
+  ASSERT_FALSE(IsWatchdogTimerRunning());
+
+  // Schedule a restart and wait for it to happen.
+  now = base::TimeTicks::Now();
+  RunFunctionAssertNoError(new RuntimeRestartAfterDelayFunction(), "[3]");
+  ASSERT_TRUE(IsWatchdogTimerRunning());
+  ASSERT_GE(desired_restart_time() - now, base::TimeDelta::FromSeconds(3));
+  base::TimeTicks last_restart_time = WaitForSuccessfulRestart();

[Devlin, 2016/06/01 21:29:15]

Spinning for 3 seconds is really innefficient.  What if we reset the min delay
to 0 and schedule it for 0 seconds, then reset it back to 3 before the next
call?  Or, you could use a test clock, if you'd prefer that approach.

[afakhry, 2016/06/02 01:43:40]

Right. Since we reset (using -1) in the previous request, We can now request
with 1 second. Which will be accomplished a second later. I also lowered the
minimum time between two successive restarts to 2 seconds instead of 3, so the
next restart request (with 1 second) will be throttled to 2 seconds instead.

So now the whole test takes 3 seconds instead of 7.

+  ASSERT_FALSE(IsWatchdogTimerRunning());
+  ASSERT_GE(base::TimeTicks::Now() - now, base::TimeDelta::FromSeconds(3));
+
+  // This is a restart request that will be throttled, because it happens too
+  // soon after a successful restart.
+  RunFunctionAssertNoError(new RuntimeRestartAfterDelayFunction(), "[1]");
+  ASSERT_TRUE(IsWatchdogTimerRunning());
+  // Restart will happen 3 seconds later, even though the request was just one
+  // second.
+  ASSERT_NEAR((desired_restart_time() - last_restart_time).InSecondsF(),
+              base::TimeDelta::FromSeconds(3).InSecondsF(), 0.01);
+  base::TimeTicks this_restart_time = WaitForSuccessfulRestart();
+  ASSERT_FALSE(IsWatchdogTimerRunning());
+  ASSERT_NEAR((this_restart_time - last_restart_time).InSecondsF(),
+              base::TimeDelta::FromSeconds(3).InSecondsF(), 0.01);
+}
+
+}  // namespace extensions