git.sesse.net Git - casparcg/blob - dependencies64/cef/linux/tests/ceftests/life_span_unittest.cc

   1 // Copyright (c) 2013 The Chromium Embedded Framework Authors. All rights
   2 // reserved. Use of this source code is governed by a BSD-style license that
   3 // can be found in the LICENSE file.
   4
   5 #include "include/base/cef_bind.h"
   6 #include "include/wrapper/cef_closure_task.h"
   7 #include "tests/ceftests/routing_test_handler.h"
   8 #include "tests/gtest/include/gtest/gtest.h"
   9
  10 namespace {
  11
  12 const char kLifeSpanUrl[] = "http://tests-life-span/test.html";
  13 const char kUnloadDialogText[] = "Are you sure?";
  14 const char kUnloadMsg[] = "LifeSpanTestHandler.Unload";
  15
  16 // Browser side.
  17 class LifeSpanTestHandler : public RoutingTestHandler {
  18  public:
  19   struct Settings {
  20     Settings()
  21       : force_close(false),
  22         add_onunload_handler(false),
  23         allow_do_close(true),
  24         accept_before_unload_dialog(true) {}
  25
  26     bool force_close;
  27     bool add_onunload_handler;
  28     bool allow_do_close;
  29     bool accept_before_unload_dialog;
  30   };
  31
  32   explicit LifeSpanTestHandler(const Settings& settings)
  33       : settings_(settings),
  34         executing_delay_close_(false) {
  35     // By default no LifeSpan tests call DestroyTest().
  36     SetDestroyTestExpected(false);
  37   }
  38
  39   void RunTest() override {
  40     // Add the resources that we will navigate to/from.
  41     std::string page = "<html><script>";
  42
  43     page += "window.onunload = function() { window.testQuery({request:'" +
  44         std::string(kUnloadMsg) + "'}); };";
  45
  46     if (settings_.add_onunload_handler) {
  47       page += "window.onbeforeunload = function() { return '" +
  48               std::string(kUnloadDialogText) + "'; };";
  49     }
  50
  51     page += "</script><body>Page</body></html>";
  52     AddResource(kLifeSpanUrl, page, "text/html");
  53
  54     // Create the browser.
  55     CreateBrowser(kLifeSpanUrl);
  56
  57     // Intentionally don't call SetTestTimeout() for these tests.
  58   }
  59
  60   void OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
  61     got_after_created_.yes();
  62     RoutingTestHandler::OnAfterCreated(browser);
  63   }
  64
  65   bool DoClose(CefRefPtr<CefBrowser> browser) override {
  66     if (executing_delay_close_)
  67       return false;
  68
  69     EXPECT_TRUE(browser->IsSame(GetBrowser()));
  70
  71     got_do_close_.yes();
  72
  73     if (!settings_.allow_do_close) {
  74       // The close will be canceled.
  75       ScheduleDelayClose();
  76     }
  77
  78     return !settings_.allow_do_close;
  79   }
  80
  81   void OnBeforeClose(CefRefPtr<CefBrowser> browser) override {
  82     if (!executing_delay_close_) {
  83       got_before_close_.yes();
  84       EXPECT_TRUE(browser->IsSame(GetBrowser()));
  85     }
  86
  87     RoutingTestHandler::OnBeforeClose(browser);
  88   }
  89
  90   bool OnBeforeUnloadDialog(
  91       CefRefPtr<CefBrowser> browser,
  92       const CefString& message_text,
  93       bool is_reload,
  94       CefRefPtr<CefJSDialogCallback> callback) override {
  95     if (executing_delay_close_) {
  96       callback->Continue(true, CefString());
  97       return true;
  98     }
  99
 100     EXPECT_TRUE(browser->IsSame(GetBrowser()));
 101
 102     // The message is no longer configurable via JavaScript.
 103     // See http://crbug.com/587940.
 104     EXPECT_STREQ("Is it OK to leave/reload this page?",
 105                  message_text.ToString().c_str());
 106
 107     EXPECT_FALSE(is_reload);
 108     EXPECT_TRUE(callback.get());
 109
 110     if (!settings_.accept_before_unload_dialog) {
 111       // The close will be canceled.
 112       ScheduleDelayClose();
 113     }
 114
 115     got_before_unload_dialog_.yes();
 116     callback->Continue(settings_.accept_before_unload_dialog, CefString());
 117     return true;
 118   }
 119
 120   void OnLoadEnd(CefRefPtr<CefBrowser> browser,
 121                  CefRefPtr<CefFrame> frame,
 122                  int httpStatusCode) override {
 123     got_load_end_.yes();
 124     EXPECT_TRUE(browser->IsSame(GetBrowser()));
 125
 126     // Attempt to close the browser.
 127     CloseBrowser(browser, settings_.force_close);
 128   }
 129
 130   bool OnQuery(CefRefPtr<CefBrowser> browser,
 131                CefRefPtr<CefFrame> frame,
 132                int64 query_id,
 133                const CefString& request,
 134                bool persistent,
 135                CefRefPtr<Callback> callback) override {
 136     if (request.ToString() == kUnloadMsg) {
 137       if (!executing_delay_close_)
 138         got_unload_message_.yes();
 139     }
 140     callback->Success("");
 141     return true;
 142   }
 143
 144   TrackCallback got_after_created_;
 145   TrackCallback got_do_close_;
 146   TrackCallback got_before_close_;
 147   TrackCallback got_before_unload_dialog_;
 148   TrackCallback got_unload_message_;
 149   TrackCallback got_load_end_;
 150   TrackCallback got_delay_close_;
 151
 152  private:
 153   // Wait a bit to make sure no additional events are received and then close
 154   // the window.
 155   void ScheduleDelayClose() {
 156     // This test will call DestroyTest().
 157     SetDestroyTestExpected(true);
 158
 159     CefPostDelayedTask(TID_UI,
 160         base::Bind(&LifeSpanTestHandler::DelayClose, this), 100);
 161   }
 162
 163   void DelayClose() {
 164     got_delay_close_.yes();
 165     executing_delay_close_ = true;
 166     DestroyTest();
 167   }
 168
 169   Settings settings_;
 170
 171   // Forces the window to close (bypasses test conditions).
 172   bool executing_delay_close_;
 173
 174   IMPLEMENT_REFCOUNTING(LifeSpanTestHandler);
 175 };
 176
 177 }  // namespace
 178
 179 TEST(LifeSpanTest, DoCloseAllow) {
 180   LifeSpanTestHandler::Settings settings;
 181   settings.allow_do_close = true;
 182   CefRefPtr<LifeSpanTestHandler> handler = new LifeSpanTestHandler(settings);
 183   handler->ExecuteTest();
 184
 185   EXPECT_TRUE(handler->got_after_created_);
 186   EXPECT_TRUE(handler->got_do_close_);
 187   EXPECT_TRUE(handler->got_before_close_);
 188   EXPECT_FALSE(handler->got_before_unload_dialog_);
 189   EXPECT_TRUE(handler->got_unload_message_);
 190   EXPECT_TRUE(handler->got_load_end_);
 191   EXPECT_FALSE(handler->got_delay_close_);
 192
 193   ReleaseAndWaitForDestructor(handler);
 194 }
 195
 196 TEST(LifeSpanTest, DoCloseAllowForce) {
 197   LifeSpanTestHandler::Settings settings;
 198   settings.allow_do_close = true;
 199   settings.force_close = true;
 200   CefRefPtr<LifeSpanTestHandler> handler = new LifeSpanTestHandler(settings);
 201   handler->ExecuteTest();
 202
 203   EXPECT_TRUE(handler->got_after_created_);
 204   EXPECT_TRUE(handler->got_do_close_);
 205   EXPECT_TRUE(handler->got_before_close_);
 206   EXPECT_FALSE(handler->got_before_unload_dialog_);
 207   EXPECT_TRUE(handler->got_unload_message_);
 208   EXPECT_TRUE(handler->got_load_end_);
 209   EXPECT_FALSE(handler->got_delay_close_);
 210
 211   ReleaseAndWaitForDestructor(handler);
 212 }
 213
 214 TEST(LifeSpanTest, DoCloseDisallow) {
 215   LifeSpanTestHandler::Settings settings;
 216   settings.allow_do_close = false;
 217   CefRefPtr<LifeSpanTestHandler> handler = new LifeSpanTestHandler(settings);
 218   handler->ExecuteTest();
 219
 220   EXPECT_TRUE(handler->got_after_created_);
 221   EXPECT_TRUE(handler->got_do_close_);
 222   EXPECT_FALSE(handler->got_before_close_);
 223   EXPECT_FALSE(handler->got_before_unload_dialog_);
 224   EXPECT_TRUE(handler->got_unload_message_);
 225   EXPECT_TRUE(handler->got_load_end_);
 226   EXPECT_TRUE(handler->got_delay_close_);
 227
 228   ReleaseAndWaitForDestructor(handler);
 229 }
 230
 231 TEST(LifeSpanTest, DoCloseDisallowForce) {
 232   LifeSpanTestHandler::Settings settings;
 233   settings.allow_do_close = false;
 234   settings.force_close = true;
 235   CefRefPtr<LifeSpanTestHandler> handler = new LifeSpanTestHandler(settings);
 236   handler->ExecuteTest();
 237
 238   EXPECT_TRUE(handler->got_after_created_);
 239   EXPECT_TRUE(handler->got_do_close_);
 240   EXPECT_FALSE(handler->got_before_close_);
 241   EXPECT_FALSE(handler->got_before_unload_dialog_);
 242   EXPECT_TRUE(handler->got_unload_message_);
 243   EXPECT_TRUE(handler->got_load_end_);
 244   EXPECT_TRUE(handler->got_delay_close_);
 245
 246   ReleaseAndWaitForDestructor(handler);
 247 }
 248
 249 TEST(LifeSpanTest, DoCloseDisallowWithOnUnloadAllow) {
 250   LifeSpanTestHandler::Settings settings;
 251   settings.allow_do_close = false;
 252   settings.add_onunload_handler = true;
 253   settings.accept_before_unload_dialog = true;
 254   CefRefPtr<LifeSpanTestHandler> handler = new LifeSpanTestHandler(settings);
 255   handler->ExecuteTest();
 256
 257   EXPECT_TRUE(handler->got_after_created_);
 258   EXPECT_TRUE(handler->got_do_close_);
 259   EXPECT_FALSE(handler->got_before_close_);
 260   EXPECT_TRUE(handler->got_before_unload_dialog_);
 261   EXPECT_TRUE(handler->got_unload_message_);
 262   EXPECT_TRUE(handler->got_load_end_);
 263   EXPECT_TRUE(handler->got_delay_close_);
 264
 265   ReleaseAndWaitForDestructor(handler);
 266 }
 267
 268 TEST(LifeSpanTest, DoCloseAllowWithOnUnloadForce) {
 269   LifeSpanTestHandler::Settings settings;
 270   settings.allow_do_close = true;
 271   settings.add_onunload_handler = true;
 272   settings.force_close = true;
 273   CefRefPtr<LifeSpanTestHandler> handler = new LifeSpanTestHandler(settings);
 274   handler->ExecuteTest();
 275
 276   EXPECT_TRUE(handler->got_after_created_);
 277   EXPECT_TRUE(handler->got_do_close_);
 278   EXPECT_TRUE(handler->got_before_close_);
 279   EXPECT_FALSE(handler->got_before_unload_dialog_);
 280   EXPECT_TRUE(handler->got_unload_message_);
 281   EXPECT_TRUE(handler->got_load_end_);
 282   EXPECT_FALSE(handler->got_delay_close_);
 283
 284   ReleaseAndWaitForDestructor(handler);
 285 }
 286
 287 TEST(LifeSpanTest, DoCloseDisallowWithOnUnloadForce) {
 288   LifeSpanTestHandler::Settings settings;
 289   settings.allow_do_close = false;
 290   settings.add_onunload_handler = true;
 291   settings.force_close = true;
 292   CefRefPtr<LifeSpanTestHandler> handler = new LifeSpanTestHandler(settings);
 293   handler->ExecuteTest();
 294
 295   EXPECT_TRUE(handler->got_after_created_);
 296   EXPECT_TRUE(handler->got_do_close_);
 297   EXPECT_FALSE(handler->got_before_close_);
 298   EXPECT_FALSE(handler->got_before_unload_dialog_);
 299   EXPECT_TRUE(handler->got_unload_message_);
 300   EXPECT_TRUE(handler->got_load_end_);
 301   EXPECT_TRUE(handler->got_delay_close_);
 302
 303   ReleaseAndWaitForDestructor(handler);
 304 }
 305
 306 TEST(LifeSpanTest, OnUnloadAllow) {
 307   LifeSpanTestHandler::Settings settings;
 308   settings.add_onunload_handler = true;
 309   settings.accept_before_unload_dialog = true;
 310   CefRefPtr<LifeSpanTestHandler> handler = new LifeSpanTestHandler(settings);
 311   handler->ExecuteTest();
 312
 313   EXPECT_TRUE(handler->got_after_created_);
 314   EXPECT_TRUE(handler->got_do_close_);
 315   EXPECT_TRUE(handler->got_before_close_);
 316   EXPECT_TRUE(handler->got_before_unload_dialog_);
 317   EXPECT_TRUE(handler->got_unload_message_);
 318   EXPECT_TRUE(handler->got_load_end_);
 319   EXPECT_FALSE(handler->got_delay_close_);
 320
 321   ReleaseAndWaitForDestructor(handler);
 322 }
 323
 324 TEST(LifeSpanTest, OnUnloadDisallow) {
 325   LifeSpanTestHandler::Settings settings;
 326   settings.add_onunload_handler = true;
 327   settings.accept_before_unload_dialog = false;
 328   CefRefPtr<LifeSpanTestHandler> handler = new LifeSpanTestHandler(settings);
 329   handler->ExecuteTest();
 330
 331   EXPECT_TRUE(handler->got_after_created_);
 332   EXPECT_FALSE(handler->got_do_close_);
 333   EXPECT_FALSE(handler->got_before_close_);
 334   EXPECT_TRUE(handler->got_before_unload_dialog_);
 335   EXPECT_FALSE(handler->got_unload_message_);
 336   EXPECT_TRUE(handler->got_load_end_);
 337   EXPECT_TRUE(handler->got_delay_close_);
 338
 339   ReleaseAndWaitForDestructor(handler);
 340 }