| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "content/shell/webkit_test_controller.h" | |
| 6 | |
| 7 #include <iostream> | |
| 8 | |
| 9 #include "base/base64.h" | |
| 10 #include "base/command_line.h" | |
| 11 #include "base/message_loop/message_loop.h" | |
| 12 #include "base/run_loop.h" | |
| 13 #include "base/strings/string_number_conversions.h" | |
| 14 #include "base/strings/stringprintf.h" | |
| 15 #include "content/public/browser/devtools_manager.h" | |
| 16 #include "content/public/browser/gpu_data_manager.h" | |
| 17 #include "content/public/browser/navigation_controller.h" | |
| 18 #include "content/public/browser/navigation_entry.h" | |
| 19 #include "content/public/browser/notification_service.h" | |
| 20 #include "content/public/browser/notification_types.h" | |
| 21 #include "content/public/browser/render_process_host.h" | |
| 22 #include "content/public/browser/render_view_host.h" | |
| 23 #include "content/public/browser/render_widget_host_view.h" | |
| 24 #include "content/public/browser/web_contents.h" | |
| 25 #include "content/public/browser/web_contents_view.h" | |
| 26 #include "content/public/common/content_switches.h" | |
| 27 #include "content/shell/common/shell_messages.h" | |
| 28 #include "content/shell/common/shell_switches.h" | |
| 29 #include "content/shell/common/webkit_test_helpers.h" | |
| 30 #include "content/shell/shell.h" | |
| 31 #include "content/shell/shell_browser_context.h" | |
| 32 #include "content/shell/shell_content_browser_client.h" | |
| 33 #include "ui/gfx/codec/png_codec.h" | |
| 34 | |
| 35 namespace content { | |
| 36 | |
| 37 const int kTestSVGWindowWidthDip = 480; | |
| 38 const int kTestSVGWindowHeightDip = 360; | |
| 39 | |
| 40 // WebKitTestResultPrinter ---------------------------------------------------- | |
| 41 | |
| 42 WebKitTestResultPrinter::WebKitTestResultPrinter( | |
| 43 std::ostream* output, std::ostream* error) | |
| 44 : state_(DURING_TEST), | |
| 45 capture_text_only_(false), | |
| 46 encode_binary_data_(false), | |
| 47 output_(output), | |
| 48 error_(error) { | |
| 49 } | |
| 50 | |
| 51 WebKitTestResultPrinter::~WebKitTestResultPrinter() { | |
| 52 } | |
| 53 | |
| 54 void WebKitTestResultPrinter::PrintTextHeader() { | |
| 55 if (state_ != DURING_TEST) | |
| 56 return; | |
| 57 if (!capture_text_only_) | |
| 58 *output_ << "Content-Type: text/plain\n"; | |
| 59 state_ = IN_TEXT_BLOCK; | |
| 60 } | |
| 61 | |
| 62 void WebKitTestResultPrinter::PrintTextBlock(const std::string& block) { | |
| 63 if (state_ != IN_TEXT_BLOCK) | |
| 64 return; | |
| 65 *output_ << block; | |
| 66 } | |
| 67 | |
| 68 void WebKitTestResultPrinter::PrintTextFooter() { | |
| 69 if (state_ != IN_TEXT_BLOCK) | |
| 70 return; | |
| 71 if (!capture_text_only_) { | |
| 72 *output_ << "#EOF\n"; | |
| 73 output_->flush(); | |
| 74 } | |
| 75 state_ = IN_IMAGE_BLOCK; | |
| 76 } | |
| 77 | |
| 78 void WebKitTestResultPrinter::PrintImageHeader( | |
| 79 const std::string& actual_hash, | |
| 80 const std::string& expected_hash) { | |
| 81 if (state_ != IN_IMAGE_BLOCK || capture_text_only_) | |
| 82 return; | |
| 83 *output_ << "\nActualHash: " << actual_hash << "\n"; | |
| 84 if (!expected_hash.empty()) | |
| 85 *output_ << "\nExpectedHash: " << expected_hash << "\n"; | |
| 86 } | |
| 87 | |
| 88 void WebKitTestResultPrinter::PrintImageBlock( | |
| 89 const std::vector<unsigned char>& png_image) { | |
| 90 if (state_ != IN_IMAGE_BLOCK || capture_text_only_) | |
| 91 return; | |
| 92 *output_ << "Content-Type: image/png\n"; | |
| 93 if (encode_binary_data_) { | |
| 94 PrintEncodedBinaryData(png_image); | |
| 95 return; | |
| 96 } | |
| 97 | |
| 98 *output_ << "Content-Length: " << png_image.size() << "\n"; | |
| 99 output_->write( | |
| 100 reinterpret_cast<const char*>(&png_image[0]), png_image.size()); | |
| 101 } | |
| 102 | |
| 103 void WebKitTestResultPrinter::PrintImageFooter() { | |
| 104 if (state_ != IN_IMAGE_BLOCK) | |
| 105 return; | |
| 106 if (!capture_text_only_) { | |
| 107 *output_ << "#EOF\n"; | |
| 108 *error_ << "#EOF\n"; | |
| 109 output_->flush(); | |
| 110 error_->flush(); | |
| 111 } | |
| 112 state_ = AFTER_TEST; | |
| 113 } | |
| 114 | |
| 115 void WebKitTestResultPrinter::PrintAudioHeader() { | |
| 116 DCHECK_EQ(state_, DURING_TEST); | |
| 117 if (!capture_text_only_) | |
| 118 *output_ << "Content-Type: audio/wav\n"; | |
| 119 state_ = IN_AUDIO_BLOCK; | |
| 120 } | |
| 121 | |
| 122 void WebKitTestResultPrinter::PrintAudioBlock( | |
| 123 const std::vector<unsigned char>& audio_data) { | |
| 124 if (state_ != IN_AUDIO_BLOCK || capture_text_only_) | |
| 125 return; | |
| 126 if (encode_binary_data_) { | |
| 127 PrintEncodedBinaryData(audio_data); | |
| 128 return; | |
| 129 } | |
| 130 | |
| 131 *output_ << "Content-Length: " << audio_data.size() << "\n"; | |
| 132 output_->write( | |
| 133 reinterpret_cast<const char*>(&audio_data[0]), audio_data.size()); | |
| 134 } | |
| 135 | |
| 136 void WebKitTestResultPrinter::PrintAudioFooter() { | |
| 137 if (state_ != IN_AUDIO_BLOCK) | |
| 138 return; | |
| 139 if (!capture_text_only_) { | |
| 140 *output_ << "#EOF\n"; | |
| 141 *error_ << "#EOF\n"; | |
| 142 output_->flush(); | |
| 143 error_->flush(); | |
| 144 } | |
| 145 state_ = IN_IMAGE_BLOCK; | |
| 146 } | |
| 147 | |
| 148 void WebKitTestResultPrinter::AddMessage(const std::string& message) { | |
| 149 AddMessageRaw(message + "\n"); | |
| 150 } | |
| 151 | |
| 152 void WebKitTestResultPrinter::AddMessageRaw(const std::string& message) { | |
| 153 if (state_ != DURING_TEST) | |
| 154 return; | |
| 155 *output_ << message; | |
| 156 } | |
| 157 | |
| 158 void WebKitTestResultPrinter::AddErrorMessage(const std::string& message) { | |
| 159 if (!capture_text_only_) | |
| 160 *error_ << message << "\n"; | |
| 161 if (state_ != DURING_TEST) | |
| 162 return; | |
| 163 PrintTextHeader(); | |
| 164 *output_ << message << "\n"; | |
| 165 PrintTextFooter(); | |
| 166 PrintImageFooter(); | |
| 167 } | |
| 168 | |
| 169 void WebKitTestResultPrinter::PrintEncodedBinaryData( | |
| 170 const std::vector<unsigned char>& data) { | |
| 171 *output_ << "Content-Transfer-Encoding: base64\n"; | |
| 172 | |
| 173 std::string data_base64; | |
| 174 const bool success = base::Base64Encode( | |
| 175 base::StringPiece(reinterpret_cast<const char*>(&data[0]), data.size()), | |
| 176 &data_base64); | |
| 177 DCHECK(success); | |
| 178 | |
| 179 *output_ << "Content-Length: " << data_base64.length() << "\n"; | |
| 180 output_->write(data_base64.c_str(), data_base64.length()); | |
| 181 } | |
| 182 | |
| 183 | |
| 184 // WebKitTestController ------------------------------------------------------- | |
| 185 | |
| 186 WebKitTestController* WebKitTestController::instance_ = NULL; | |
| 187 | |
| 188 // static | |
| 189 WebKitTestController* WebKitTestController::Get() { | |
| 190 DCHECK(instance_); | |
| 191 return instance_; | |
| 192 } | |
| 193 | |
| 194 WebKitTestController::WebKitTestController() | |
| 195 : main_window_(NULL), | |
| 196 test_phase_(BETWEEN_TESTS) { | |
| 197 CHECK(!instance_); | |
| 198 instance_ = this; | |
| 199 printer_.reset(new WebKitTestResultPrinter(&std::cout, &std::cerr)); | |
| 200 if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kEncodeBinary)) | |
| 201 printer_->set_encode_binary_data(true); | |
| 202 registrar_.Add(this, | |
| 203 NOTIFICATION_RENDERER_PROCESS_CREATED, | |
| 204 NotificationService::AllSources()); | |
| 205 GpuDataManager::GetInstance()->AddObserver(this); | |
| 206 ResetAfterLayoutTest(); | |
| 207 } | |
| 208 | |
| 209 WebKitTestController::~WebKitTestController() { | |
| 210 DCHECK(CalledOnValidThread()); | |
| 211 CHECK(instance_ == this); | |
| 212 CHECK(test_phase_ == BETWEEN_TESTS); | |
| 213 GpuDataManager::GetInstance()->RemoveObserver(this); | |
| 214 DiscardMainWindow(); | |
| 215 instance_ = NULL; | |
| 216 } | |
| 217 | |
| 218 bool WebKitTestController::PrepareForLayoutTest( | |
| 219 const GURL& test_url, | |
| 220 const base::FilePath& current_working_directory, | |
| 221 bool enable_pixel_dumping, | |
| 222 const std::string& expected_pixel_hash) { | |
| 223 DCHECK(CalledOnValidThread()); | |
| 224 test_phase_ = DURING_TEST; | |
| 225 current_working_directory_ = current_working_directory; | |
| 226 enable_pixel_dumping_ = enable_pixel_dumping; | |
| 227 expected_pixel_hash_ = expected_pixel_hash; | |
| 228 test_url_ = test_url; | |
| 229 printer_->reset(); | |
| 230 ShellBrowserContext* browser_context = | |
| 231 ShellContentBrowserClient::Get()->browser_context(); | |
| 232 if (test_url.spec().find("compositing/") != std::string::npos) | |
| 233 is_compositing_test_ = true; | |
| 234 initial_size_ = gfx::Size( | |
| 235 Shell::kDefaultTestWindowWidthDip, Shell::kDefaultTestWindowHeightDip); | |
| 236 // The W3C SVG layout tests use a different size than the other layout tests. | |
| 237 if (test_url.spec().find("W3C-SVG-1.1") != std::string::npos) | |
| 238 initial_size_ = gfx::Size(kTestSVGWindowWidthDip, kTestSVGWindowHeightDip); | |
| 239 if (!main_window_) { | |
| 240 main_window_ = content::Shell::CreateNewWindow( | |
| 241 browser_context, | |
| 242 GURL(), | |
| 243 NULL, | |
| 244 MSG_ROUTING_NONE, | |
| 245 initial_size_); | |
| 246 WebContentsObserver::Observe(main_window_->web_contents()); | |
| 247 send_configuration_to_next_host_ = true; | |
| 248 current_pid_ = base::kNullProcessId; | |
| 249 main_window_->LoadURL(test_url); | |
| 250 } else { | |
| 251 #if (defined(OS_WIN) && !defined(USE_AURA)) || \ | |
| 252 defined(TOOLKIT_GTK) || defined(OS_MACOSX) | |
| 253 // Shell::SizeTo is not implemented on all platforms. | |
| 254 main_window_->SizeTo(initial_size_.width(), initial_size_.height()); | |
| 255 #endif | |
| 256 main_window_->web_contents()->GetRenderViewHost()->GetView() | |
| 257 ->SetSize(initial_size_); | |
| 258 main_window_->web_contents()->GetRenderViewHost()->WasResized(); | |
| 259 RenderViewHost* render_view_host = | |
| 260 main_window_->web_contents()->GetRenderViewHost(); | |
| 261 WebPreferences prefs = render_view_host->GetWebkitPreferences(); | |
| 262 OverrideWebkitPrefs(&prefs); | |
| 263 render_view_host->UpdateWebkitPreferences(prefs); | |
| 264 SendTestConfiguration(); | |
| 265 | |
| 266 NavigationController::LoadURLParams params(test_url); | |
| 267 params.transition_type = PageTransitionFromInt( | |
| 268 PAGE_TRANSITION_TYPED | PAGE_TRANSITION_FROM_ADDRESS_BAR); | |
| 269 params.should_clear_history_list = true; | |
| 270 main_window_->web_contents()->GetController().LoadURLWithParams(params); | |
| 271 main_window_->web_contents()->GetView()->Focus(); | |
| 272 } | |
| 273 main_window_->web_contents()->GetRenderViewHost()->SetActive(true); | |
| 274 main_window_->web_contents()->GetRenderViewHost()->Focus(); | |
| 275 return true; | |
| 276 } | |
| 277 | |
| 278 bool WebKitTestController::ResetAfterLayoutTest() { | |
| 279 DCHECK(CalledOnValidThread()); | |
| 280 printer_->PrintTextFooter(); | |
| 281 printer_->PrintImageFooter(); | |
| 282 send_configuration_to_next_host_ = false; | |
| 283 test_phase_ = BETWEEN_TESTS; | |
| 284 is_compositing_test_ = false; | |
| 285 enable_pixel_dumping_ = false; | |
| 286 expected_pixel_hash_.clear(); | |
| 287 test_url_ = GURL(); | |
| 288 prefs_ = WebPreferences(); | |
| 289 should_override_prefs_ = false; | |
| 290 return true; | |
| 291 } | |
| 292 | |
| 293 void WebKitTestController::SetTempPath(const base::FilePath& temp_path) { | |
| 294 temp_path_ = temp_path; | |
| 295 } | |
| 296 | |
| 297 void WebKitTestController::RendererUnresponsive() { | |
| 298 DCHECK(CalledOnValidThread()); | |
| 299 LOG(WARNING) << "renderer unresponsive"; | |
| 300 } | |
| 301 | |
| 302 void WebKitTestController::WorkerCrashed() { | |
| 303 DCHECK(CalledOnValidThread()); | |
| 304 printer_->AddErrorMessage("#CRASHED - worker"); | |
| 305 DiscardMainWindow(); | |
| 306 } | |
| 307 | |
| 308 void WebKitTestController::OverrideWebkitPrefs(WebPreferences* prefs) { | |
| 309 if (should_override_prefs_) { | |
| 310 *prefs = prefs_; | |
| 311 } else { | |
| 312 ApplyLayoutTestDefaultPreferences(prefs); | |
| 313 if (is_compositing_test_) { | |
| 314 CommandLine& command_line = *CommandLine::ForCurrentProcess(); | |
| 315 if (!command_line.HasSwitch(switches::kEnableSoftwareCompositing)) | |
| 316 prefs->accelerated_2d_canvas_enabled = true; | |
| 317 prefs->accelerated_compositing_for_video_enabled = true; | |
| 318 prefs->mock_scrollbars_enabled = true; | |
| 319 } | |
| 320 } | |
| 321 } | |
| 322 | |
| 323 void WebKitTestController::OpenURL(const GURL& url) { | |
| 324 if (test_phase_ != DURING_TEST) | |
| 325 return; | |
| 326 | |
| 327 Shell::CreateNewWindow(main_window_->web_contents()->GetBrowserContext(), | |
| 328 url, | |
| 329 main_window_->web_contents()->GetSiteInstance(), | |
| 330 MSG_ROUTING_NONE, | |
| 331 gfx::Size()); | |
| 332 } | |
| 333 | |
| 334 void WebKitTestController::TestFinishedInSecondaryWindow() { | |
| 335 RenderViewHost* render_view_host = | |
| 336 main_window_->web_contents()->GetRenderViewHost(); | |
| 337 render_view_host->Send( | |
| 338 new ShellViewMsg_NotifyDone(render_view_host->GetRoutingID())); | |
| 339 } | |
| 340 | |
| 341 bool WebKitTestController::IsMainWindow(WebContents* web_contents) const { | |
| 342 return main_window_ && web_contents == main_window_->web_contents(); | |
| 343 } | |
| 344 | |
| 345 bool WebKitTestController::OnMessageReceived(const IPC::Message& message) { | |
| 346 DCHECK(CalledOnValidThread()); | |
| 347 bool handled = true; | |
| 348 IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message) | |
| 349 IPC_MESSAGE_HANDLER(ShellViewHostMsg_PrintMessage, OnPrintMessage) | |
| 350 IPC_MESSAGE_HANDLER(ShellViewHostMsg_TextDump, OnTextDump) | |
| 351 IPC_MESSAGE_HANDLER(ShellViewHostMsg_ImageDump, OnImageDump) | |
| 352 IPC_MESSAGE_HANDLER(ShellViewHostMsg_AudioDump, OnAudioDump) | |
| 353 IPC_MESSAGE_HANDLER(ShellViewHostMsg_OverridePreferences, | |
| 354 OnOverridePreferences) | |
| 355 IPC_MESSAGE_HANDLER(ShellViewHostMsg_TestFinished, OnTestFinished) | |
| 356 IPC_MESSAGE_HANDLER(ShellViewHostMsg_ShowDevTools, OnShowDevTools) | |
| 357 IPC_MESSAGE_HANDLER(ShellViewHostMsg_CloseDevTools, OnCloseDevTools) | |
| 358 IPC_MESSAGE_HANDLER(ShellViewHostMsg_GoToOffset, OnGoToOffset) | |
| 359 IPC_MESSAGE_HANDLER(ShellViewHostMsg_Reload, OnReload) | |
| 360 IPC_MESSAGE_HANDLER(ShellViewHostMsg_LoadURLForFrame, OnLoadURLForFrame) | |
| 361 IPC_MESSAGE_HANDLER(ShellViewHostMsg_CaptureSessionHistory, | |
| 362 OnCaptureSessionHistory) | |
| 363 IPC_MESSAGE_HANDLER(ShellViewHostMsg_CloseRemainingWindows, | |
| 364 OnCloseRemainingWindows) | |
| 365 IPC_MESSAGE_HANDLER(ShellViewHostMsg_ResetDone, OnResetDone) | |
| 366 IPC_MESSAGE_UNHANDLED(handled = false) | |
| 367 IPC_END_MESSAGE_MAP() | |
| 368 | |
| 369 return handled; | |
| 370 } | |
| 371 | |
| 372 void WebKitTestController::PluginCrashed(const base::FilePath& plugin_path, | |
| 373 base::ProcessId plugin_pid) { | |
| 374 DCHECK(CalledOnValidThread()); | |
| 375 printer_->AddErrorMessage( | |
| 376 base::StringPrintf("#CRASHED - plugin (pid %d)", plugin_pid)); | |
| 377 base::MessageLoop::current()->PostTask( | |
| 378 FROM_HERE, | |
| 379 base::Bind(base::IgnoreResult(&WebKitTestController::DiscardMainWindow), | |
| 380 base::Unretained(this))); | |
| 381 } | |
| 382 | |
| 383 void WebKitTestController::RenderViewCreated(RenderViewHost* render_view_host) { | |
| 384 DCHECK(CalledOnValidThread()); | |
| 385 // Might be kNullProcessHandle, in which case we will receive a notification | |
| 386 // later when the RenderProcessHost was created. | |
| 387 if (render_view_host->GetProcess()->GetHandle() != base::kNullProcessHandle) | |
| 388 current_pid_ = base::GetProcId(render_view_host->GetProcess()->GetHandle()); | |
| 389 if (!send_configuration_to_next_host_) | |
| 390 return; | |
| 391 send_configuration_to_next_host_ = false; | |
| 392 SendTestConfiguration(); | |
| 393 } | |
| 394 | |
| 395 void WebKitTestController::RenderProcessGone(base::TerminationStatus status) { | |
| 396 DCHECK(CalledOnValidThread()); | |
| 397 if (current_pid_ != base::kNullProcessId) { | |
| 398 printer_->AddErrorMessage(std::string("#CRASHED - renderer (pid ") + | |
| 399 base::IntToString(current_pid_) + ")"); | |
| 400 } else { | |
| 401 printer_->AddErrorMessage("#CRASHED - renderer"); | |
| 402 } | |
| 403 DiscardMainWindow(); | |
| 404 } | |
| 405 | |
| 406 void WebKitTestController::WebContentsDestroyed(WebContents* web_contents) { | |
| 407 DCHECK(CalledOnValidThread()); | |
| 408 printer_->AddErrorMessage("FAIL: main window was destroyed"); | |
| 409 DiscardMainWindow(); | |
| 410 } | |
| 411 | |
| 412 void WebKitTestController::Observe(int type, | |
| 413 const NotificationSource& source, | |
| 414 const NotificationDetails& details) { | |
| 415 DCHECK(CalledOnValidThread()); | |
| 416 switch (type) { | |
| 417 case NOTIFICATION_RENDERER_PROCESS_CREATED: { | |
| 418 if (!main_window_) | |
| 419 return; | |
| 420 RenderViewHost* render_view_host = | |
| 421 main_window_->web_contents()->GetRenderViewHost(); | |
| 422 if (!render_view_host) | |
| 423 return; | |
| 424 RenderProcessHost* render_process_host = | |
| 425 Source<RenderProcessHost>(source).ptr(); | |
| 426 if (render_process_host != render_view_host->GetProcess()) | |
| 427 return; | |
| 428 current_pid_ = base::GetProcId(render_process_host->GetHandle()); | |
| 429 break; | |
| 430 } | |
| 431 default: | |
| 432 NOTREACHED(); | |
| 433 } | |
| 434 } | |
| 435 | |
| 436 void WebKitTestController::OnGpuProcessCrashed( | |
| 437 base::TerminationStatus exit_code) { | |
| 438 DCHECK(CalledOnValidThread()); | |
| 439 printer_->AddErrorMessage("#CRASHED - gpu"); | |
| 440 DiscardMainWindow(); | |
| 441 } | |
| 442 | |
| 443 void WebKitTestController::TimeoutHandler() { | |
| 444 DCHECK(CalledOnValidThread()); | |
| 445 printer_->AddErrorMessage( | |
| 446 "FAIL: Timed out waiting for notifyDone to be called"); | |
| 447 DiscardMainWindow(); | |
| 448 } | |
| 449 | |
| 450 void WebKitTestController::DiscardMainWindow() { | |
| 451 // If we're running a test, we need to close all windows and exit the message | |
| 452 // loop. Otherwise, we're already outside of the message loop, and we just | |
| 453 // discard the main window. | |
| 454 WebContentsObserver::Observe(NULL); | |
| 455 if (test_phase_ != BETWEEN_TESTS) { | |
| 456 Shell::CloseAllWindows(); | |
| 457 base::MessageLoop::current()->PostTask(FROM_HERE, | |
| 458 base::MessageLoop::QuitClosure()); | |
| 459 test_phase_ = CLEAN_UP; | |
| 460 } else if (main_window_) { | |
| 461 main_window_->Close(); | |
| 462 } | |
| 463 main_window_ = NULL; | |
| 464 current_pid_ = base::kNullProcessId; | |
| 465 } | |
| 466 | |
| 467 void WebKitTestController::SendTestConfiguration() { | |
| 468 RenderViewHost* render_view_host = | |
| 469 main_window_->web_contents()->GetRenderViewHost(); | |
| 470 ShellTestConfiguration params; | |
| 471 params.current_working_directory = current_working_directory_; | |
| 472 params.temp_path = temp_path_; | |
| 473 params.test_url = test_url_; | |
| 474 params.enable_pixel_dumping = enable_pixel_dumping_; | |
| 475 params.allow_external_pages = CommandLine::ForCurrentProcess()->HasSwitch( | |
| 476 switches::kAllowExternalPages); | |
| 477 params.expected_pixel_hash = expected_pixel_hash_; | |
| 478 params.initial_size = initial_size_; | |
| 479 render_view_host->Send(new ShellViewMsg_SetTestConfiguration( | |
| 480 render_view_host->GetRoutingID(), params)); | |
| 481 } | |
| 482 | |
| 483 void WebKitTestController::OnTestFinished() { | |
| 484 test_phase_ = CLEAN_UP; | |
| 485 if (!printer_->output_finished()) | |
| 486 printer_->PrintImageFooter(); | |
| 487 RenderViewHost* render_view_host = | |
| 488 main_window_->web_contents()->GetRenderViewHost(); | |
| 489 base::MessageLoop::current()->PostTask( | |
| 490 FROM_HERE, | |
| 491 base::Bind(base::IgnoreResult(&WebKitTestController::Send), | |
| 492 base::Unretained(this), | |
| 493 new ShellViewMsg_Reset(render_view_host->GetRoutingID()))); | |
| 494 } | |
| 495 | |
| 496 void WebKitTestController::OnImageDump( | |
| 497 const std::string& actual_pixel_hash, | |
| 498 const SkBitmap& image) { | |
| 499 SkAutoLockPixels image_lock(image); | |
| 500 | |
| 501 printer_->PrintImageHeader(actual_pixel_hash, expected_pixel_hash_); | |
| 502 | |
| 503 // Only encode and dump the png if the hashes don't match. Encoding the | |
| 504 // image is really expensive. | |
| 505 if (actual_pixel_hash != expected_pixel_hash_) { | |
| 506 std::vector<unsigned char> png; | |
| 507 | |
| 508 // Only the expected PNGs for Mac have a valid alpha channel. | |
| 509 #if defined(OS_MACOSX) | |
| 510 bool discard_transparency = false; | |
| 511 #else | |
| 512 bool discard_transparency = true; | |
| 513 #endif | |
| 514 | |
| 515 std::vector<gfx::PNGCodec::Comment> comments; | |
| 516 comments.push_back(gfx::PNGCodec::Comment("checksum", actual_pixel_hash)); | |
| 517 bool success = gfx::PNGCodec::Encode( | |
| 518 static_cast<const unsigned char*>(image.getPixels()), | |
| 519 gfx::PNGCodec::FORMAT_BGRA, | |
| 520 gfx::Size(image.width(), image.height()), | |
| 521 static_cast<int>(image.rowBytes()), | |
| 522 discard_transparency, | |
| 523 comments, | |
| 524 &png); | |
| 525 if (success) | |
| 526 printer_->PrintImageBlock(png); | |
| 527 } | |
| 528 printer_->PrintImageFooter(); | |
| 529 } | |
| 530 | |
| 531 void WebKitTestController::OnAudioDump(const std::vector<unsigned char>& dump) { | |
| 532 printer_->PrintAudioHeader(); | |
| 533 printer_->PrintAudioBlock(dump); | |
| 534 printer_->PrintAudioFooter(); | |
| 535 } | |
| 536 | |
| 537 void WebKitTestController::OnTextDump(const std::string& dump) { | |
| 538 printer_->PrintTextHeader(); | |
| 539 printer_->PrintTextBlock(dump); | |
| 540 printer_->PrintTextFooter(); | |
| 541 } | |
| 542 | |
| 543 void WebKitTestController::OnPrintMessage(const std::string& message) { | |
| 544 printer_->AddMessageRaw(message); | |
| 545 } | |
| 546 | |
| 547 void WebKitTestController::OnOverridePreferences(const WebPreferences& prefs) { | |
| 548 should_override_prefs_ = true; | |
| 549 prefs_ = prefs; | |
| 550 } | |
| 551 | |
| 552 void WebKitTestController::OnShowDevTools() { | |
| 553 main_window_->ShowDevTools(); | |
| 554 } | |
| 555 | |
| 556 void WebKitTestController::OnCloseDevTools() { | |
| 557 main_window_->CloseDevTools(); | |
| 558 } | |
| 559 | |
| 560 void WebKitTestController::OnGoToOffset(int offset) { | |
| 561 main_window_->GoBackOrForward(offset); | |
| 562 } | |
| 563 | |
| 564 void WebKitTestController::OnReload() { | |
| 565 main_window_->Reload(); | |
| 566 } | |
| 567 | |
| 568 void WebKitTestController::OnLoadURLForFrame(const GURL& url, | |
| 569 const std::string& frame_name) { | |
| 570 main_window_->LoadURLForFrame(url, frame_name); | |
| 571 } | |
| 572 | |
| 573 void WebKitTestController::OnCaptureSessionHistory() { | |
| 574 std::vector<int> routing_ids; | |
| 575 std::vector<std::vector<PageState> > session_histories; | |
| 576 std::vector<unsigned> current_entry_indexes; | |
| 577 | |
| 578 RenderViewHost* render_view_host = | |
| 579 main_window_->web_contents()->GetRenderViewHost(); | |
| 580 | |
| 581 for (std::vector<Shell*>::iterator window = Shell::windows().begin(); | |
| 582 window != Shell::windows().end(); | |
| 583 ++window) { | |
| 584 WebContents* web_contents = (*window)->web_contents(); | |
| 585 // Only capture the history from windows in the same process as the main | |
| 586 // window. During layout tests, we only use two processes when an | |
| 587 // devtools window is open. This should not happen during history navigation | |
| 588 // tests. | |
| 589 if (render_view_host->GetProcess() != | |
| 590 web_contents->GetRenderViewHost()->GetProcess()) { | |
| 591 NOTREACHED(); | |
| 592 continue; | |
| 593 } | |
| 594 routing_ids.push_back(web_contents->GetRenderViewHost()->GetRoutingID()); | |
| 595 current_entry_indexes.push_back( | |
| 596 web_contents->GetController().GetCurrentEntryIndex()); | |
| 597 std::vector<PageState> history; | |
| 598 for (int entry = 0; entry < web_contents->GetController().GetEntryCount(); | |
| 599 ++entry) { | |
| 600 PageState state = web_contents->GetController().GetEntryAtIndex(entry)-> | |
| 601 GetPageState(); | |
| 602 if (!state.IsValid()) { | |
| 603 state = PageState::CreateFromURL( | |
| 604 web_contents->GetController().GetEntryAtIndex(entry)->GetURL()); | |
| 605 } | |
| 606 history.push_back(state); | |
| 607 } | |
| 608 session_histories.push_back(history); | |
| 609 } | |
| 610 | |
| 611 Send(new ShellViewMsg_SessionHistory(render_view_host->GetRoutingID(), | |
| 612 routing_ids, | |
| 613 session_histories, | |
| 614 current_entry_indexes)); | |
| 615 } | |
| 616 | |
| 617 void WebKitTestController::OnCloseRemainingWindows() { | |
| 618 DevToolsManager::GetInstance()->CloseAllClientHosts(); | |
| 619 std::vector<Shell*> open_windows(Shell::windows()); | |
| 620 for (size_t i = 0; i < open_windows.size(); ++i) { | |
| 621 if (open_windows[i] != main_window_) | |
| 622 open_windows[i]->Close(); | |
| 623 } | |
| 624 base::MessageLoop::current()->RunUntilIdle(); | |
| 625 } | |
| 626 | |
| 627 void WebKitTestController::OnResetDone() { | |
| 628 base::MessageLoop::current()->PostTask(FROM_HERE, | |
| 629 base::MessageLoop::QuitClosure()); | |
| 630 } | |
| 631 | |
| 632 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 23316003:
[content shell] move browser process stuff into browser/ subdir (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src