OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <memory> | 5 #include <memory> |
6 | 6 |
| 7 #include "base/json/json_reader.h" |
7 #include "content/public/test/browser_test.h" | 8 #include "content/public/test/browser_test.h" |
| 9 #include "headless/public/domains/browser.h" |
8 #include "headless/public/domains/network.h" | 10 #include "headless/public/domains/network.h" |
9 #include "headless/public/domains/page.h" | 11 #include "headless/public/domains/page.h" |
10 #include "headless/public/domains/runtime.h" | 12 #include "headless/public/domains/runtime.h" |
11 #include "headless/public/headless_browser.h" | 13 #include "headless/public/headless_browser.h" |
12 #include "headless/public/headless_devtools_client.h" | 14 #include "headless/public/headless_devtools_client.h" |
13 #include "headless/test/headless_browser_test.h" | 15 #include "headless/test/headless_browser_test.h" |
14 #include "testing/gtest/include/gtest/gtest.h" | 16 #include "testing/gtest/include/gtest/gtest.h" |
15 #include "url/gurl.h" | 17 #include "url/gurl.h" |
16 | 18 |
17 namespace headless { | 19 namespace headless { |
(...skipping 147 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
165 } | 167 } |
166 | 168 |
167 void OnFrameStoppedLoading( | 169 void OnFrameStoppedLoading( |
168 const page::FrameStoppedLoadingParams& params) override { | 170 const page::FrameStoppedLoadingParams& params) override { |
169 FinishAsynchronousTest(); | 171 FinishAsynchronousTest(); |
170 } | 172 } |
171 }; | 173 }; |
172 | 174 |
173 HEADLESS_ASYNC_DEVTOOLED_TEST_F(HeadlessDevToolsClientExperimentalTest); | 175 HEADLESS_ASYNC_DEVTOOLED_TEST_F(HeadlessDevToolsClientExperimentalTest); |
174 | 176 |
| 177 class BrowserDomainCreateAndDeletePageTest |
| 178 : public HeadlessAsyncDevTooledBrowserTest { |
| 179 void RunDevTooledTest() override { |
| 180 EXPECT_TRUE(embedded_test_server()->Start()); |
| 181 |
| 182 EXPECT_EQ(1u, browser()->GetAllWebContents().size()); |
| 183 |
| 184 devtools_client_->GetBrowser()->GetExperimental()->CreateTarget( |
| 185 browser::CreateTargetParams::Builder() |
| 186 .SetInitialUrl(embedded_test_server()->GetURL("/hello.html").spec()) |
| 187 .SetWidth(1) |
| 188 .SetHeight(1) |
| 189 .Build(), |
| 190 base::Bind(&BrowserDomainCreateAndDeletePageTest::OnCreateTargetResult, |
| 191 base::Unretained(this))); |
| 192 } |
| 193 |
| 194 void OnCreateTargetResult( |
| 195 std::unique_ptr<browser::CreateTargetResult> result) { |
| 196 EXPECT_EQ(2u, browser()->GetAllWebContents().size()); |
| 197 |
| 198 devtools_client_->GetBrowser()->GetExperimental()->CloseTarget( |
| 199 browser::CloseTargetParams::Builder() |
| 200 .SetTargetId(result->GetTargetId()) |
| 201 .Build(), |
| 202 base::Bind(&BrowserDomainCreateAndDeletePageTest::OnCloseTargetResult, |
| 203 base::Unretained(this))); |
| 204 } |
| 205 |
| 206 void OnCloseTargetResult(std::unique_ptr<browser::CloseTargetResult> result) { |
| 207 EXPECT_EQ(1u, browser()->GetAllWebContents().size()); |
| 208 FinishAsynchronousTest(); |
| 209 } |
| 210 }; |
| 211 |
| 212 HEADLESS_ASYNC_DEVTOOLED_TEST_F(BrowserDomainCreateAndDeletePageTest); |
| 213 |
| 214 class BrowserDomainDisposeContextFailsIfInUse |
| 215 : public HeadlessAsyncDevTooledBrowserTest { |
| 216 void RunDevTooledTest() override { |
| 217 EXPECT_TRUE(embedded_test_server()->Start()); |
| 218 |
| 219 EXPECT_EQ(1u, browser()->GetAllWebContents().size()); |
| 220 devtools_client_->GetBrowser()->GetExperimental()->CreateBrowserContext( |
| 221 browser::CreateBrowserContextParams::Builder().Build(), |
| 222 base::Bind(&BrowserDomainDisposeContextFailsIfInUse::OnContextCreated, |
| 223 base::Unretained(this))); |
| 224 } |
| 225 |
| 226 void OnContextCreated( |
| 227 std::unique_ptr<browser::CreateBrowserContextResult> result) { |
| 228 context_id_ = result->GetBrowserContextId(); |
| 229 |
| 230 devtools_client_->GetBrowser()->GetExperimental()->CreateTarget( |
| 231 browser::CreateTargetParams::Builder() |
| 232 .SetInitialUrl(embedded_test_server()->GetURL("/hello.html").spec()) |
| 233 .SetBrowserContextId(context_id_) |
| 234 .Build(), |
| 235 base::Bind( |
| 236 &BrowserDomainDisposeContextFailsIfInUse::OnCreateTargetResult, |
| 237 base::Unretained(this))); |
| 238 } |
| 239 |
| 240 void OnCreateTargetResult( |
| 241 std::unique_ptr<browser::CreateTargetResult> result) { |
| 242 page_id_ = result->GetTargetId(); |
| 243 |
| 244 devtools_client_->GetBrowser()->GetExperimental()->DisposeBrowserContext( |
| 245 browser::DisposeBrowserContextParams::Builder() |
| 246 .SetBrowserContextId(context_id_) |
| 247 .Build(), |
| 248 base::Bind(&BrowserDomainDisposeContextFailsIfInUse:: |
| 249 OnDisposeBrowserContextResult, |
| 250 base::Unretained(this))); |
| 251 } |
| 252 |
| 253 void OnDisposeBrowserContextResult( |
| 254 std::unique_ptr<browser::DisposeBrowserContextResult> result) { |
| 255 EXPECT_FALSE(result->GetSuccess()); |
| 256 |
| 257 // Close the page and try again. |
| 258 devtools_client_->GetBrowser()->GetExperimental()->CloseTarget( |
| 259 browser::CloseTargetParams::Builder().SetTargetId(page_id_).Build(), |
| 260 base::Bind( |
| 261 &BrowserDomainDisposeContextFailsIfInUse::OnCloseTargetResult, |
| 262 base::Unretained(this))); |
| 263 } |
| 264 |
| 265 void OnCloseTargetResult(std::unique_ptr<browser::CloseTargetResult> result) { |
| 266 EXPECT_TRUE(result->GetSuccess()); |
| 267 |
| 268 devtools_client_->GetBrowser()->GetExperimental()->DisposeBrowserContext( |
| 269 browser::DisposeBrowserContextParams::Builder() |
| 270 .SetBrowserContextId(context_id_) |
| 271 .Build(), |
| 272 base::Bind(&BrowserDomainDisposeContextFailsIfInUse:: |
| 273 OnDisposeBrowserContextResult2, |
| 274 base::Unretained(this))); |
| 275 } |
| 276 |
| 277 void OnDisposeBrowserContextResult2( |
| 278 std::unique_ptr<browser::DisposeBrowserContextResult> result) { |
| 279 EXPECT_TRUE(result->GetSuccess()); |
| 280 FinishAsynchronousTest(); |
| 281 } |
| 282 |
| 283 private: |
| 284 std::string context_id_; |
| 285 std::string page_id_; |
| 286 }; |
| 287 |
| 288 HEADLESS_ASYNC_DEVTOOLED_TEST_F(BrowserDomainDisposeContextFailsIfInUse); |
| 289 |
| 290 class BrowserDomainCreateTwoContexts : public HeadlessAsyncDevTooledBrowserTest, |
| 291 public browser::ExperimentalObserver { |
| 292 public: |
| 293 void RunDevTooledTest() override { |
| 294 EXPECT_TRUE(embedded_test_server()->Start()); |
| 295 |
| 296 devtools_client_->GetBrowser()->GetExperimental()->AddObserver(this); |
| 297 devtools_client_->GetBrowser()->GetExperimental()->CreateBrowserContext( |
| 298 browser::CreateBrowserContextParams::Builder().Build(), |
| 299 base::Bind(&BrowserDomainCreateTwoContexts::OnContextOneCreated, |
| 300 base::Unretained(this))); |
| 301 |
| 302 devtools_client_->GetBrowser()->GetExperimental()->CreateBrowserContext( |
| 303 browser::CreateBrowserContextParams::Builder().Build(), |
| 304 base::Bind(&BrowserDomainCreateTwoContexts::OnContextTwoCreated, |
| 305 base::Unretained(this))); |
| 306 } |
| 307 |
| 308 void OnContextOneCreated( |
| 309 std::unique_ptr<browser::CreateBrowserContextResult> result) { |
| 310 context_id_one_ = result->GetBrowserContextId(); |
| 311 MaybeCreatePages(); |
| 312 } |
| 313 |
| 314 void OnContextTwoCreated( |
| 315 std::unique_ptr<browser::CreateBrowserContextResult> result) { |
| 316 context_id_two_ = result->GetBrowserContextId(); |
| 317 MaybeCreatePages(); |
| 318 } |
| 319 |
| 320 void MaybeCreatePages() { |
| 321 if (context_id_one_.empty() || context_id_two_.empty()) |
| 322 return; |
| 323 |
| 324 devtools_client_->GetBrowser()->GetExperimental()->CreateTarget( |
| 325 browser::CreateTargetParams::Builder() |
| 326 .SetInitialUrl(embedded_test_server()->GetURL("/hello.html").spec()) |
| 327 .SetBrowserContextId(context_id_one_) |
| 328 .Build(), |
| 329 base::Bind(&BrowserDomainCreateTwoContexts::OnCreateTargetOneResult, |
| 330 base::Unretained(this))); |
| 331 |
| 332 devtools_client_->GetBrowser()->GetExperimental()->CreateTarget( |
| 333 browser::CreateTargetParams::Builder() |
| 334 .SetInitialUrl(embedded_test_server()->GetURL("/hello.html").spec()) |
| 335 .SetBrowserContextId(context_id_two_) |
| 336 .Build(), |
| 337 base::Bind(&BrowserDomainCreateTwoContexts::OnCreateTargetTwoResult, |
| 338 base::Unretained(this))); |
| 339 } |
| 340 |
| 341 void OnCreateTargetOneResult( |
| 342 std::unique_ptr<browser::CreateTargetResult> result) { |
| 343 page_id_one_ = result->GetTargetId(); |
| 344 MaybeTestIsolation(); |
| 345 } |
| 346 |
| 347 void OnCreateTargetTwoResult( |
| 348 std::unique_ptr<browser::CreateTargetResult> result) { |
| 349 page_id_two_ = result->GetTargetId(); |
| 350 MaybeTestIsolation(); |
| 351 } |
| 352 |
| 353 void MaybeTestIsolation() { |
| 354 if (page_id_one_.empty() || page_id_two_.empty()) |
| 355 return; |
| 356 |
| 357 devtools_client_->GetBrowser()->GetExperimental()->Attach( |
| 358 browser::AttachParams::Builder().SetTargetId(page_id_one_).Build(), |
| 359 base::Bind(&BrowserDomainCreateTwoContexts::OnAttachedOne, |
| 360 base::Unretained(this))); |
| 361 |
| 362 devtools_client_->GetBrowser()->GetExperimental()->Attach( |
| 363 browser::AttachParams::Builder().SetTargetId(page_id_two_).Build(), |
| 364 base::Bind(&BrowserDomainCreateTwoContexts::OnAttachedTwo, |
| 365 base::Unretained(this))); |
| 366 } |
| 367 |
| 368 void OnAttachedOne(std::unique_ptr<browser::AttachResult> result) { |
| 369 devtools_client_->GetBrowser()->GetExperimental()->SendMessage( |
| 370 browser::SendMessageParams::Builder() |
| 371 .SetTargetId(page_id_one_) |
| 372 .SetMessage("{\"id\":101, \"method\": \"Page.enable\"}") |
| 373 .Build()); |
| 374 } |
| 375 |
| 376 void OnAttachedTwo(std::unique_ptr<browser::AttachResult> result) { |
| 377 devtools_client_->GetBrowser()->GetExperimental()->SendMessage( |
| 378 browser::SendMessageParams::Builder() |
| 379 .SetTargetId(page_id_two_) |
| 380 .SetMessage("{\"id\":102, \"method\": \"Page.enable\"}") |
| 381 .Build()); |
| 382 } |
| 383 |
| 384 void MaybeSetCookieOnPageOne() { |
| 385 if (!page_one_loaded_ || !page_two_loaded_) |
| 386 return; |
| 387 |
| 388 devtools_client_->GetBrowser()->GetExperimental()->SendMessage( |
| 389 browser::SendMessageParams::Builder() |
| 390 .SetTargetId(page_id_one_) |
| 391 .SetMessage("{\"id\":201, \"method\": \"Runtime.evaluate\", " |
| 392 "\"params\": {\"expression\": " |
| 393 "\"document.cookie = 'foo=bar';\"}}") |
| 394 .Build()); |
| 395 } |
| 396 |
| 397 void OnDispatchMessage( |
| 398 const browser::DispatchMessageParams& params) override { |
| 399 std::unique_ptr<base::Value> message = |
| 400 base::JSONReader::Read(params.GetMessage(), base::JSON_PARSE_RFC); |
| 401 const base::DictionaryValue* message_dict; |
| 402 if (!message || !message->GetAsDictionary(&message_dict)) { |
| 403 return; |
| 404 } |
| 405 std::string method; |
| 406 if (message_dict->GetString("method", &method) && |
| 407 method == "Page.loadEventFired") { |
| 408 if (params.GetTargetId() == page_id_one_) { |
| 409 page_one_loaded_ = true; |
| 410 } else if (params.GetTargetId() == page_id_two_) { |
| 411 page_two_loaded_ = true; |
| 412 } |
| 413 MaybeSetCookieOnPageOne(); |
| 414 return; |
| 415 } |
| 416 const base::DictionaryValue* result_dict; |
| 417 if (message_dict->GetDictionary("result", &result_dict)) { |
| 418 // There's a nested result. We want the inner one. |
| 419 if (!result_dict->GetDictionary("result", &result_dict)) |
| 420 return; |
| 421 std::string value; |
| 422 if (params.GetTargetId() == page_id_one_) { |
| 423 // TODO(alexclarke): Make some better bindings for Browser.sendMessage. |
| 424 devtools_client_->GetBrowser()->GetExperimental()->SendMessage( |
| 425 browser::SendMessageParams::Builder() |
| 426 .SetTargetId(page_id_two_) |
| 427 .SetMessage("{\"id\":202, \"method\": \"Runtime.evaluate\", " |
| 428 "\"params\": {\"expression\": " |
| 429 "\"document.cookie;\"}}") |
| 430 .Build()); |
| 431 } else if (params.GetTargetId() == page_id_two_ && |
| 432 result_dict->GetString("value", &value)) { |
| 433 EXPECT_EQ("", value) << "Page 2 should not share cookies from page one"; |
| 434 |
| 435 devtools_client_->GetBrowser()->GetExperimental()->CloseTarget( |
| 436 browser::CloseTargetParams::Builder() |
| 437 .SetTargetId(page_id_one_) |
| 438 .Build(), |
| 439 base::Bind(&BrowserDomainCreateTwoContexts::OnCloseTarget, |
| 440 base::Unretained(this))); |
| 441 |
| 442 devtools_client_->GetBrowser()->GetExperimental()->CloseTarget( |
| 443 browser::CloseTargetParams::Builder() |
| 444 .SetTargetId(page_id_two_) |
| 445 .Build(), |
| 446 base::Bind(&BrowserDomainCreateTwoContexts::OnCloseTarget, |
| 447 base::Unretained(this))); |
| 448 |
| 449 devtools_client_->GetBrowser()->GetExperimental()->RemoveObserver(this); |
| 450 } |
| 451 } |
| 452 } |
| 453 |
| 454 void OnCloseTarget(std::unique_ptr<browser::CloseTargetResult> result) { |
| 455 page_close_count_++; |
| 456 |
| 457 if (page_close_count_ < 2) |
| 458 return; |
| 459 |
| 460 devtools_client_->GetBrowser()->GetExperimental()->DisposeBrowserContext( |
| 461 browser::DisposeBrowserContextParams::Builder() |
| 462 .SetBrowserContextId(context_id_one_) |
| 463 .Build(), |
| 464 base::Bind(&BrowserDomainCreateTwoContexts::OnCloseContext, |
| 465 base::Unretained(this))); |
| 466 |
| 467 devtools_client_->GetBrowser()->GetExperimental()->DisposeBrowserContext( |
| 468 browser::DisposeBrowserContextParams::Builder() |
| 469 .SetBrowserContextId(context_id_two_) |
| 470 .Build(), |
| 471 base::Bind(&BrowserDomainCreateTwoContexts::OnCloseContext, |
| 472 base::Unretained(this))); |
| 473 } |
| 474 |
| 475 void OnCloseContext( |
| 476 std::unique_ptr<browser::DisposeBrowserContextResult> result) { |
| 477 EXPECT_TRUE(result->GetSuccess()); |
| 478 if (++context_closed_count_ < 2) |
| 479 return; |
| 480 |
| 481 FinishAsynchronousTest(); |
| 482 } |
| 483 |
| 484 private: |
| 485 std::string context_id_one_; |
| 486 std::string context_id_two_; |
| 487 std::string page_id_one_; |
| 488 std::string page_id_two_; |
| 489 bool page_one_loaded_ = false; |
| 490 bool page_two_loaded_ = false; |
| 491 int page_close_count_ = 0; |
| 492 int context_closed_count_ = 0; |
| 493 }; |
| 494 |
| 495 HEADLESS_ASYNC_DEVTOOLED_TEST_F(BrowserDomainCreateTwoContexts); |
| 496 |
175 } // namespace headless | 497 } // namespace headless |
OLD | NEW |