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 "components/pref_registry/testing_pref_service_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"
+#include "extensions/browser/test_runtime_api_delegate.h"
+#include "extensions/common/manifest.h"
+
+namespace extensions {
+
+namespace {
+
+// An intercepter of the real RuntimeAPIDelegate that simulates a successful
+// restart request every time.
+class RestartOnWatchdogApiDelegate : public TestRuntimeAPIDelegate {
+ public:
+  // Takes ownership of the |real_api_delegate|.
+  RestartOnWatchdogApiDelegate() {}
+  ~RestartOnWatchdogApiDelegate() override {}
+
+  // TestRuntimeAPIDelegate:
+  bool RestartDevice(std::string* error_message) override {
+    if (!quit_closure_.is_null())
+      base::ResetAndReturn(&quit_closure_).Run();
+
+    *error_message = "Success.";
+    restart_done_ = true;
+
+    if (!on_device_restarting_.is_null())
+      on_device_restarting_.Run();
+
+    return true;
+  }
+
+  void SetOnDeviceShutdownCallback(const base::Closure& callback) override {
+    on_device_restarting_ = callback;
+  }
+
+  base::TimeTicks WaitForSuccessfulRestart() {
+    if (!restart_done_) {
+      base::RunLoop run_loop;
+      quit_closure_ = run_loop.QuitClosure();
+      run_loop.Run();
+    }
+    restart_done_ = false;
+    return base::TimeTicks::Now();
+  }
+
+ private:
+  base::Closure on_device_restarting_;
+
+  base::Closure quit_closure_;
+
+  bool restart_done_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(RestartOnWatchdogApiDelegate);
+};
+
+class WatchdogApiExtensionsBrowserClient : public TestExtensionsBrowserClient {
+ public:
+  WatchdogApiExtensionsBrowserClient(content::BrowserContext* context)
+      : TestExtensionsBrowserClient(context) {}
+  ~WatchdogApiExtensionsBrowserClient() override {}
+
+  // TestExtensionsBrowserClient:
+  PrefService* GetPrefServiceForContext(
+      content::BrowserContext* context) override {
+    return &testing_pref_service_;
+  }
+
+  std::unique_ptr<RuntimeAPIDelegate> CreateRuntimeAPIDelegate(
+      content::BrowserContext* context) const override {
+    const_cast<WatchdogApiExtensionsBrowserClient*>(this)->api_delegate_ =
+        new RestartOnWatchdogApiDelegate();
+    return base::WrapUnique(api_delegate_);
+  }
+
+  user_prefs::TestingPrefServiceSyncable* testing_pref_service() {
+    return &testing_pref_service_;
+  }
+
+  RestartOnWatchdogApiDelegate* api_delegate() const {
+    CHECK(api_delegate_);
+    return api_delegate_;
+  }
+
+ private:
+  RestartOnWatchdogApiDelegate* api_delegate_ = nullptr;  // Not owned.
+
+  user_prefs::TestingPrefServiceSyncable testing_pref_service_;
+
+  DISALLOW_COPY_AND_ASSIGN(WatchdogApiExtensionsBrowserClient);
+};
+
+}  // namespace
+
+class RestartAfterDelayApiTest : public ApiUnitTest {
+ public:
+  RestartAfterDelayApiTest() {}
+  ~RestartAfterDelayApiTest() override {}
+
+  void SetUp() override {
+    ApiUnitTest::SetUp();
+
+    // Use our ExtensionsBrowserClient that returns our RuntimeAPIDelegate.
+    test_browser_client_.reset(
+        new WatchdogApiExtensionsBrowserClient(browser_context()));
+    test_browser_client_->set_extension_system_factory(
+        extensions_browser_client()->extension_system_factory());
+    ExtensionsBrowserClient::Set(test_browser_client_.get());
+
+    // The RuntimeAPI should only be accessed (i.e. constructed) only after the
+    // above ExtensionsBrowserClient has been setup.
+    RuntimeAPI* runtime_api =
+        RuntimeAPI::GetFactoryInstance()->Get(browser_context());
+    runtime_api->set_min_duration_between_restarts_for_testing(
+        base::TimeDelta::FromSeconds(2));
+    runtime_api->AllowNonKiostAppsInRestartOnWatchdogForTesting();
+
+    RuntimeAPI::RegisterPrefs(
+        test_browser_client_->testing_pref_service()->registry());
+  }
+
+  base::TimeTicks WaitForSuccessfulRestart() {
+    return test_browser_client_->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();
+  }
+
+  std::string RunFunctionGetError(UIThreadExtensionFunction* function,
+                                  const Extension* extension,
+                                  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());
+    return function->GetError();
+  }
+
+  void RunFunctionAssertNoError(UIThreadExtensionFunction* function,
+                                const std::string& args) {
+    std::string error = RunFunctionGetError(function, extension(), args);
+    ASSERT_TRUE(error.empty()) << error;
+  }
+
+ private:
+  std::unique_ptr<WatchdogApiExtensionsBrowserClient> test_browser_client_;
+
+  DISALLOW_COPY_AND_ASSIGN(RestartAfterDelayApiTest);
+};
+
+TEST_F(RestartAfterDelayApiTest, RestartAfterDelayTest) {
+  RunFunctionAssertNoError(new RuntimeRestartAfterDelayFunction(), "[-1]");
+  ASSERT_FALSE(IsWatchdogTimerRunning());
+
+  std::string error = RunFunctionGetError(
+      new RuntimeRestartAfterDelayFunction(), extension(), "[-2]");
+  ASSERT_EQ(error, "Invalid argument: -2.");
+
+  // 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));
+
+  // Create another extension and make it attempt to use the api, and expect a
+  // failure.
+  std::unique_ptr<base::DictionaryValue> test_extension_value(
+      api_test_utils::ParseDictionary("{\n"
+                                      "  \"name\": \"Test\",\n"
+                                      "  \"version\": \"2.0\",\n"
+                                      "  \"app\": {\n"
+                                      "    \"background\": {\n"
+                                      "      \"scripts\": [\"background.js\"]\n"
+                                      "    }\n"
+                                      "  }\n"
+                                      "}"));
+  scoped_refptr<Extension> test_extension(api_test_utils::CreateExtension(
+      Manifest::INTERNAL, test_extension_value.get(), "id2"));
+  error = RunFunctionGetError(new RuntimeRestartAfterDelayFunction(),
+                              test_extension.get(), "[5]");
+  ASSERT_EQ(error, "Not the first extension to call this API.");
+
+  // 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(), "[1]");
+  ASSERT_TRUE(IsWatchdogTimerRunning());
+  ASSERT_GE(desired_restart_time() - now, base::TimeDelta::FromSeconds(1));
+  base::TimeTicks last_restart_time = WaitForSuccessfulRestart();
+  ASSERT_FALSE(IsWatchdogTimerRunning());
+  ASSERT_GE(base::TimeTicks::Now() - now, base::TimeDelta::FromSeconds(1));
+
+  // This is a restart request that will be throttled, because it happens too
+  // soon after a successful restart.
+  error = RunFunctionGetError(new RuntimeRestartAfterDelayFunction(),
+                              extension(), "[1]");
+  ASSERT_EQ(error, "Restart was requested too soon. It was throttled instead.");
+  ASSERT_TRUE(IsWatchdogTimerRunning());
+  // Restart will happen 2 seconds later, even though the request was just one
+  // second.
+  ASSERT_NEAR((desired_restart_time() - last_restart_time).InSecondsF(),
+              base::TimeDelta::FromSeconds(2).InSecondsF(), 0.01);
+
+  // Calling chrome.runtime.restart() will not clear the throttle, and any
+  // subsequent calls to chrome.runtime.restartAfterDelay will still be
+  // throttled.
+  WaitForSuccessfulRestart();
+  RunFunctionAssertNoError(new RuntimeRestartFunction(), "[]");
+  last_restart_time = WaitForSuccessfulRestart();
+  error = RunFunctionGetError(new RuntimeRestartAfterDelayFunction(),
+                              extension(), "[1]");
+  ASSERT_EQ(error, "Restart was requested too soon. It was throttled instead.");
+  ASSERT_TRUE(IsWatchdogTimerRunning());
+  // Restart will happen 2 seconds later, even though the request was just one
+  // second.
+  ASSERT_NEAR((desired_restart_time() - last_restart_time).InSecondsF(),
+              base::TimeDelta::FromSeconds(2).InSecondsF(), 0.01);
+}
+
+}  // namespace extensions