content/shell/renderer/webkit_test_runner.cc

   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/renderer/webkit_test_runner.h"
   6
   7 #include <algorithm>
   8 #include <clocale>
   9 #include <cmath>
  10
  11 #include "base/base64.h"
  12 #include "base/command_line.h"
  13 #include "base/debug/debugger.h"
  14 #include "base/files/file_path.h"
  15 #include "base/md5.h"
  16 #include "base/memory/scoped_ptr.h"
  17 #include "base/message_loop/message_loop.h"
  18 #include "base/strings/string_util.h"
  19 #include "base/strings/stringprintf.h"
  20 #include "base/strings/sys_string_conversions.h"
  21 #include "base/strings/utf_string_conversions.h"
  22 #include "base/time/time.h"
  23 #include "content/public/common/content_switches.h"
  24 #include "content/public/common/url_constants.h"
  25 #include "content/public/renderer/history_item_serialization.h"
  26 #include "content/public/renderer/render_view.h"
  27 #include "content/public/renderer/render_view_visitor.h"
  28 #include "content/public/test/layouttest_support.h"
  29 #include "content/shell/common/shell_messages.h"
  30 #include "content/shell/common/webkit_test_helpers.h"
  31 #include "content/shell/renderer/shell_render_process_observer.h"
  32 #include "content/shell/renderer/test_runner/WebTask.h"
  33 #include "content/shell/renderer/test_runner/WebTestInterfaces.h"
  34 #include "content/shell/renderer/test_runner/WebTestProxy.h"
  35 #include "content/shell/renderer/test_runner/WebTestRunner.h"
  36 #include "net/base/net_errors.h"
  37 #include "net/base/net_util.h"
  38 #include "skia/ext/platform_canvas.h"
  39 #include "third_party/WebKit/public/platform/Platform.h"
  40 #include "third_party/WebKit/public/platform/WebCString.h"
  41 #include "third_party/WebKit/public/platform/WebPoint.h"
  42 #include "third_party/WebKit/public/platform/WebRect.h"
  43 #include "third_party/WebKit/public/platform/WebSize.h"
  44 #include "third_party/WebKit/public/platform/WebString.h"
  45 #include "third_party/WebKit/public/platform/WebURL.h"
  46 #include "third_party/WebKit/public/platform/WebURLError.h"
  47 #include "third_party/WebKit/public/platform/WebURLRequest.h"
  48 #include "third_party/WebKit/public/platform/WebURLResponse.h"
  49 #include "third_party/WebKit/public/web/WebArrayBufferView.h"
  50 #include "third_party/WebKit/public/web/WebContextMenuData.h"
  51 #include "third_party/WebKit/public/web/WebDataSource.h"
  52 #include "third_party/WebKit/public/web/WebDevToolsAgent.h"
  53 #include "third_party/WebKit/public/web/WebDocument.h"
  54 #include "third_party/WebKit/public/web/WebElement.h"
  55 #include "third_party/WebKit/public/web/WebFrame.h"
  56 #include "third_party/WebKit/public/web/WebHistoryItem.h"
  57 #include "third_party/WebKit/public/web/WebKit.h"
  58 #include "third_party/WebKit/public/web/WebScriptSource.h"
  59 #include "third_party/WebKit/public/web/WebTestingSupport.h"
  60 #include "third_party/WebKit/public/web/WebView.h"
  61 #include "ui/gfx/rect.h"
  62 #include "webkit/common/webpreferences.h"
  63
  64 using blink::Platform;
  65 using blink::WebArrayBufferView;
  66 using blink::WebContextMenuData;
  67 using blink::WebDevToolsAgent;
  68 using blink::WebDeviceMotionData;
  69 using blink::WebDeviceOrientationData;
  70 using blink::WebElement;
  71 using blink::WebFrame;
  72 using blink::WebGamepads;
  73 using blink::WebHistoryItem;
  74 using blink::WebPoint;
  75 using blink::WebRect;
  76 using blink::WebScriptSource;
  77 using blink::WebSize;
  78 using blink::WebString;
  79 using blink::WebURL;
  80 using blink::WebURLError;
  81 using blink::WebURLRequest;
  82 using blink::WebTestingSupport;
  83 using blink::WebVector;
  84 using blink::WebView;
  85 using WebTestRunner::WebTask;
  86 using WebTestRunner::WebTestInterfaces;
  87 using WebTestRunner::WebTestProxyBase;
  88
  89 namespace content {
  90
  91 namespace {
  92
  93 void InvokeTaskHelper(void* context) {
  94   WebTask* task = reinterpret_cast<WebTask*>(context);
  95   task->run();
  96   delete task;
  97 }
  98
  99 #if !defined(OS_MACOSX)
 100 void MakeBitmapOpaque(SkBitmap* bitmap) {
 101   SkAutoLockPixels lock(*bitmap);
 102   DCHECK_EQ(bitmap->config(), SkBitmap::kARGB_8888_Config);
 103   for (int y = 0; y < bitmap->height(); ++y) {
 104     uint32_t* row = bitmap->getAddr32(0, y);
 105     for (int x = 0; x < bitmap->width(); ++x)
 106       row[x] |= 0xFF000000;  // Set alpha bits to 1.
 107   }
 108 }
 109 #endif
 110
 111 void CopyCanvasToBitmap(SkCanvas* canvas,  SkBitmap* snapshot) {
 112   SkBaseDevice* device = skia::GetTopDevice(*canvas);
 113   const SkBitmap& bitmap = device->accessBitmap(false);
 114   const bool success = bitmap.copyTo(snapshot, SkBitmap::kARGB_8888_Config);
 115   DCHECK(success);
 116
 117 #if !defined(OS_MACOSX)
 118   // Only the expected PNGs for Mac have a valid alpha channel.
 119   if (!CommandLine::ForCurrentProcess()->HasSwitch(
 120       switches::kEnableOverlayFullscreenVideo))
 121     MakeBitmapOpaque(snapshot);
 122 #endif
 123 }
 124
 125 class SyncNavigationStateVisitor : public RenderViewVisitor {
 126  public:
 127   SyncNavigationStateVisitor() {}
 128   virtual ~SyncNavigationStateVisitor() {}
 129
 130   virtual bool Visit(RenderView* render_view) OVERRIDE {
 131     SyncNavigationState(render_view);
 132     return true;
 133   }
 134  private:
 135   DISALLOW_COPY_AND_ASSIGN(SyncNavigationStateVisitor);
 136 };
 137
 138 class ProxyToRenderViewVisitor : public RenderViewVisitor {
 139  public:
 140   explicit ProxyToRenderViewVisitor(WebTestProxyBase* proxy)
 141       : proxy_(proxy),
 142         render_view_(NULL) {
 143   }
 144   virtual ~ProxyToRenderViewVisitor() {}
 145
 146   RenderView* render_view() const { return render_view_; }
 147
 148   virtual bool Visit(RenderView* render_view) OVERRIDE {
 149     WebKitTestRunner* test_runner = WebKitTestRunner::Get(render_view);
 150     if (!test_runner) {
 151       NOTREACHED();
 152       return true;
 153     }
 154     if (test_runner->proxy() == proxy_) {
 155       render_view_ = render_view;
 156       return false;
 157     }
 158     return true;
 159   }
 160
 161  private:
 162   WebTestProxyBase* proxy_;
 163   RenderView* render_view_;
 164
 165   DISALLOW_COPY_AND_ASSIGN(ProxyToRenderViewVisitor);
 166 };
 167
 168 class NavigateAwayVisitor : public RenderViewVisitor {
 169  public:
 170   explicit NavigateAwayVisitor(RenderView* main_render_view)
 171       : main_render_view_(main_render_view) {}
 172   virtual ~NavigateAwayVisitor() {}
 173
 174   virtual bool Visit(RenderView* render_view) OVERRIDE {
 175     if (render_view == main_render_view_)
 176       return true;
 177     render_view->GetWebView()->mainFrame()->loadRequest(
 178         WebURLRequest(GURL(kAboutBlankURL)));
 179     return true;
 180   }
 181
 182  private:
 183   RenderView* main_render_view_;
 184
 185   DISALLOW_COPY_AND_ASSIGN(NavigateAwayVisitor);
 186 };
 187
 188 class UseSynchronousResizeModeVisitor : public RenderViewVisitor {
 189  public:
 190   explicit UseSynchronousResizeModeVisitor(bool enable) : enable_(enable) {}
 191   virtual ~UseSynchronousResizeModeVisitor() {}
 192
 193   virtual bool Visit(RenderView* render_view) OVERRIDE {
 194     UseSynchronousResizeMode(render_view, enable_);
 195     return true;
 196   }
 197
 198  private:
 199   bool enable_;
 200 };
 201
 202 }  // namespace
 203
 204 WebKitTestRunner::WebKitTestRunner(RenderView* render_view)
 205     : RenderViewObserver(render_view),
 206       RenderViewObserverTracker<WebKitTestRunner>(render_view),
 207       proxy_(NULL),
 208       focused_view_(NULL),
 209       is_main_window_(false),
 210       focus_on_next_commit_(false) {
 211   UseMockMediaStreams(render_view);
 212 }
 213
 214 WebKitTestRunner::~WebKitTestRunner() {
 215 }
 216
 217 // WebTestDelegate  -----------------------------------------------------------
 218
 219 void WebKitTestRunner::clearEditCommand() {
 220   render_view()->ClearEditCommands();
 221 }
 222
 223 void WebKitTestRunner::setEditCommand(const std::string& name,
 224                                       const std::string& value) {
 225   render_view()->SetEditCommandForNextKeyEvent(name, value);
 226 }
 227
 228 void WebKitTestRunner::setGamepadData(const WebGamepads& gamepads) {
 229   SetMockGamepads(gamepads);
 230 }
 231
 232 void WebKitTestRunner::setDeviceMotionData(const WebDeviceMotionData& data) {
 233   SetMockDeviceMotionData(data);
 234 }
 235
 236 void WebKitTestRunner::setDeviceOrientationData(
 237     const WebDeviceOrientationData& data) {
 238   SetMockDeviceOrientationData(data);
 239 }
 240
 241 void WebKitTestRunner::printMessage(const std::string& message) {
 242   Send(new ShellViewHostMsg_PrintMessage(routing_id(), message));
 243 }
 244
 245 void WebKitTestRunner::postTask(WebTask* task) {
 246   Platform::current()->callOnMainThread(InvokeTaskHelper, task);
 247 }
 248
 249 void WebKitTestRunner::postDelayedTask(WebTask* task, long long ms) {
 250   base::MessageLoop::current()->PostDelayedTask(
 251       FROM_HERE,
 252       base::Bind(&WebTask::run, base::Owned(task)),
 253       base::TimeDelta::FromMilliseconds(ms));
 254 }
 255
 256 WebString WebKitTestRunner::registerIsolatedFileSystem(
 257     const blink::WebVector<blink::WebString>& absolute_filenames) {
 258   std::vector<base::FilePath> files;
 259   for (size_t i = 0; i < absolute_filenames.size(); ++i)
 260     files.push_back(base::FilePath::FromUTF16Unsafe(absolute_filenames[i]));
 261   std::string filesystem_id;
 262   Send(new ShellViewHostMsg_RegisterIsolatedFileSystem(
 263       routing_id(), files, &filesystem_id));
 264   return WebString::fromUTF8(filesystem_id);
 265 }
 266
 267 long long WebKitTestRunner::getCurrentTimeInMillisecond() {
 268   return base::TimeDelta(base::Time::Now() -
 269                          base::Time::UnixEpoch()).ToInternalValue() /
 270          base::Time::kMicrosecondsPerMillisecond;
 271 }
 272
 273 WebString WebKitTestRunner::getAbsoluteWebStringFromUTF8Path(
 274     const std::string& utf8_path) {
 275   base::FilePath path = base::FilePath::FromUTF8Unsafe(utf8_path);
 276   if (!path.IsAbsolute()) {
 277     GURL base_url =
 278         net::FilePathToFileURL(test_config_.current_working_directory.Append(
 279             FILE_PATH_LITERAL("foo")));
 280     net::FileURLToFilePath(base_url.Resolve(utf8_path), &path);
 281   }
 282   return path.AsUTF16Unsafe();
 283 }
 284
 285 WebURL WebKitTestRunner::localFileToDataURL(const WebURL& file_url) {
 286   base::FilePath local_path;
 287   if (!net::FileURLToFilePath(file_url, &local_path))
 288     return WebURL();
 289
 290   std::string contents;
 291   Send(new ShellViewHostMsg_ReadFileToString(
 292         routing_id(), local_path, &contents));
 293
 294   std::string contents_base64;
 295   base::Base64Encode(contents, &contents_base64);
 296
 297   const char data_url_prefix[] = "data:text/css:charset=utf-8;base64,";
 298   return WebURL(GURL(data_url_prefix + contents_base64));
 299 }
 300
 301 WebURL WebKitTestRunner::rewriteLayoutTestsURL(const std::string& utf8_url) {
 302   const char kPrefix[] = "file:///tmp/LayoutTests/";
 303   const int kPrefixLen = arraysize(kPrefix) - 1;
 304
 305   if (utf8_url.compare(0, kPrefixLen, kPrefix, kPrefixLen))
 306     return WebURL(GURL(utf8_url));
 307
 308   base::FilePath replace_path =
 309       ShellRenderProcessObserver::GetInstance()->webkit_source_dir().Append(
 310           FILE_PATH_LITERAL("LayoutTests/"));
 311 #if defined(OS_WIN)
 312   std::string utf8_path = base::WideToUTF8(replace_path.value());
 313 #else
 314   std::string utf8_path =
 315       base::WideToUTF8(base::SysNativeMBToWide(replace_path.value()));
 316 #endif
 317   std::string new_url =
 318       std::string("file://") + utf8_path + utf8_url.substr(kPrefixLen);
 319   return WebURL(GURL(new_url));
 320 }
 321
 322 WebTestRunner::WebPreferences* WebKitTestRunner::preferences() {
 323   return &prefs_;
 324 }
 325
 326 void WebKitTestRunner::applyPreferences() {
 327   WebPreferences prefs = render_view()->GetWebkitPreferences();
 328   ExportLayoutTestSpecificPreferences(prefs_, &prefs);
 329   render_view()->SetWebkitPreferences(prefs);
 330   Send(new ShellViewHostMsg_OverridePreferences(routing_id(), prefs));
 331 }
 332
 333 std::string WebKitTestRunner::makeURLErrorDescription(
 334     const WebURLError& error) {
 335   std::string domain = error.domain.utf8();
 336   int code = error.reason;
 337
 338   if (domain == net::kErrorDomain) {
 339     domain = "NSURLErrorDomain";
 340     switch (error.reason) {
 341     case net::ERR_ABORTED:
 342       code = -999;  // NSURLErrorCancelled
 343       break;
 344     case net::ERR_UNSAFE_PORT:
 345       // Our unsafe port checking happens at the network stack level, but we
 346       // make this translation here to match the behavior of stock WebKit.
 347       domain = "WebKitErrorDomain";
 348       code = 103;
 349       break;
 350     case net::ERR_ADDRESS_INVALID:
 351     case net::ERR_ADDRESS_UNREACHABLE:
 352     case net::ERR_NETWORK_ACCESS_DENIED:
 353       code = -1004;  // NSURLErrorCannotConnectToHost
 354       break;
 355     }
 356   } else {
 357     DLOG(WARNING) << "Unknown error domain";
 358   }
 359
 360   return base::StringPrintf("<NSError domain %s, code %d, failing URL \"%s\">",
 361       domain.c_str(), code, error.unreachableURL.spec().data());
 362 }
 363
 364 void WebKitTestRunner::useUnfortunateSynchronousResizeMode(bool enable) {
 365   UseSynchronousResizeModeVisitor visitor(enable);
 366   RenderView::ForEach(&visitor);
 367 }
 368
 369 void WebKitTestRunner::enableAutoResizeMode(const WebSize& min_size,
 370                                             const WebSize& max_size) {
 371   EnableAutoResizeMode(render_view(), min_size, max_size);
 372 }
 373
 374 void WebKitTestRunner::disableAutoResizeMode(const WebSize& new_size) {
 375   DisableAutoResizeMode(render_view(), new_size);
 376   if (!new_size.isEmpty())
 377     ForceResizeRenderView(render_view(), new_size);
 378 }
 379
 380 void WebKitTestRunner::showDevTools() {
 381   Send(new ShellViewHostMsg_ShowDevTools(routing_id()));
 382 }
 383
 384 void WebKitTestRunner::closeDevTools() {
 385   Send(new ShellViewHostMsg_CloseDevTools(routing_id()));
 386   WebDevToolsAgent* agent = render_view()->GetWebView()->devToolsAgent();
 387   if (agent)
 388     agent->detach();
 389 }
 390
 391 void WebKitTestRunner::evaluateInWebInspector(long call_id,
 392                                               const std::string& script) {
 393   WebDevToolsAgent* agent = render_view()->GetWebView()->devToolsAgent();
 394   if (agent)
 395     agent->evaluateInWebInspector(call_id, WebString::fromUTF8(script));
 396 }
 397
 398 void WebKitTestRunner::clearAllDatabases() {
 399   Send(new ShellViewHostMsg_ClearAllDatabases(routing_id()));
 400 }
 401
 402 void WebKitTestRunner::setDatabaseQuota(int quota) {
 403   Send(new ShellViewHostMsg_SetDatabaseQuota(routing_id(), quota));
 404 }
 405
 406 void WebKitTestRunner::setDeviceScaleFactor(float factor) {
 407   SetDeviceScaleFactor(render_view(), factor);
 408 }
 409
 410 void WebKitTestRunner::setFocus(WebTestProxyBase* proxy, bool focus) {
 411   ProxyToRenderViewVisitor visitor(proxy);
 412   RenderView::ForEach(&visitor);
 413   if (!visitor.render_view()) {
 414     NOTREACHED();
 415     return;
 416   }
 417
 418   // Check whether the focused view was closed meanwhile.
 419   if (!WebKitTestRunner::Get(focused_view_))
 420     focused_view_ = NULL;
 421
 422   if (focus) {
 423     if (focused_view_ != visitor.render_view()) {
 424       if (focused_view_)
 425         SetFocusAndActivate(focused_view_, false);
 426       SetFocusAndActivate(visitor.render_view(), true);
 427       focused_view_ = visitor.render_view();
 428     }
 429   } else {
 430     if (focused_view_ == visitor.render_view()) {
 431       SetFocusAndActivate(visitor.render_view(), false);
 432       focused_view_ = NULL;
 433     }
 434   }
 435 }
 436
 437 void WebKitTestRunner::setAcceptAllCookies(bool accept) {
 438   Send(new ShellViewHostMsg_AcceptAllCookies(routing_id(), accept));
 439 }
 440
 441 std::string WebKitTestRunner::pathToLocalResource(const std::string& resource) {
 442 #if defined(OS_WIN)
 443   if (resource.find("/tmp/") == 0) {
 444     // We want a temp file.
 445     GURL base_url = net::FilePathToFileURL(test_config_.temp_path);
 446     return base_url.Resolve(resource.substr(strlen("/tmp/"))).spec();
 447   }
 448 #endif
 449
 450   // Some layout tests use file://// which we resolve as a UNC path. Normalize
 451   // them to just file:///.
 452   std::string result = resource;
 453   while (StringToLowerASCII(result).find("file:////") == 0) {
 454     result = result.substr(0, strlen("file:///")) +
 455              result.substr(strlen("file:////"));
 456   }
 457   return rewriteLayoutTestsURL(result).spec();
 458 }
 459
 460 void WebKitTestRunner::setLocale(const std::string& locale) {
 461   setlocale(LC_ALL, locale.c_str());
 462 }
 463
 464 void WebKitTestRunner::testFinished() {
 465   if (!is_main_window_) {
 466     Send(new ShellViewHostMsg_TestFinishedInSecondaryWindow(routing_id()));
 467     return;
 468   }
 469   WebTestInterfaces* interfaces =
 470       ShellRenderProcessObserver::GetInstance()->test_interfaces();
 471   interfaces->setTestIsRunning(false);
 472   if (interfaces->testRunner()->shouldDumpBackForwardList()) {
 473     SyncNavigationStateVisitor visitor;
 474     RenderView::ForEach(&visitor);
 475     Send(new ShellViewHostMsg_CaptureSessionHistory(routing_id()));
 476   } else {
 477     CaptureDump();
 478   }
 479 }
 480
 481 void WebKitTestRunner::closeRemainingWindows() {
 482   NavigateAwayVisitor visitor(render_view());
 483   RenderView::ForEach(&visitor);
 484   Send(new ShellViewHostMsg_CloseRemainingWindows(routing_id()));
 485 }
 486
 487 void WebKitTestRunner::deleteAllCookies() {
 488   Send(new ShellViewHostMsg_DeleteAllCookies(routing_id()));
 489 }
 490
 491 int WebKitTestRunner::navigationEntryCount() {
 492   return GetLocalSessionHistoryLength(render_view());
 493 }
 494
 495 void WebKitTestRunner::goToOffset(int offset) {
 496   Send(new ShellViewHostMsg_GoToOffset(routing_id(), offset));
 497 }
 498
 499 void WebKitTestRunner::reload() {
 500   Send(new ShellViewHostMsg_Reload(routing_id()));
 501 }
 502
 503 void WebKitTestRunner::loadURLForFrame(const WebURL& url,
 504                              const std::string& frame_name) {
 505   Send(new ShellViewHostMsg_LoadURLForFrame(
 506       routing_id(), url, frame_name));
 507 }
 508
 509 bool WebKitTestRunner::allowExternalPages() {
 510   return test_config_.allow_external_pages;
 511 }
 512
 513 void WebKitTestRunner::captureHistoryForWindow(
 514     WebTestProxyBase* proxy,
 515     WebVector<blink::WebHistoryItem>* history,
 516     size_t* currentEntryIndex) {
 517   size_t pos = 0;
 518   std::vector<int>::iterator id;
 519   for (id = routing_ids_.begin(); id != routing_ids_.end(); ++id, ++pos) {
 520     RenderView* render_view = RenderView::FromRoutingID(*id);
 521     if (!render_view) {
 522       NOTREACHED();
 523       continue;
 524     }
 525     if (WebKitTestRunner::Get(render_view)->proxy() == proxy)
 526       break;
 527   }
 528
 529   if (id == routing_ids_.end()) {
 530     NOTREACHED();
 531     return;
 532   }
 533   size_t num_entries = session_histories_[pos].size();
 534   *currentEntryIndex = current_entry_indexes_[pos];
 535   WebVector<WebHistoryItem> result(num_entries);
 536   for (size_t entry = 0; entry < num_entries; ++entry) {
 537     result[entry] =
 538         PageStateToHistoryItem(session_histories_[pos][entry]);
 539   }
 540   history->swap(result);
 541 }
 542
 543 // RenderViewObserver  --------------------------------------------------------
 544
 545 void WebKitTestRunner::DidClearWindowObject(WebFrame* frame) {
 546   WebTestingSupport::injectInternalsObject(frame);
 547   ShellRenderProcessObserver::GetInstance()->test_interfaces()->bindTo(frame);
 548 }
 549
 550 bool WebKitTestRunner::OnMessageReceived(const IPC::Message& message) {
 551   bool handled = true;
 552   IPC_BEGIN_MESSAGE_MAP(WebKitTestRunner, message)
 553     IPC_MESSAGE_HANDLER(ShellViewMsg_SetTestConfiguration,
 554                         OnSetTestConfiguration)
 555     IPC_MESSAGE_HANDLER(ShellViewMsg_SessionHistory, OnSessionHistory)
 556     IPC_MESSAGE_HANDLER(ShellViewMsg_Reset, OnReset)
 557     IPC_MESSAGE_HANDLER(ShellViewMsg_NotifyDone, OnNotifyDone)
 558     IPC_MESSAGE_UNHANDLED(handled = false)
 559   IPC_END_MESSAGE_MAP()
 560
 561   return handled;
 562 }
 563
 564 void WebKitTestRunner::Navigate(const GURL& url) {
 565   focus_on_next_commit_ = true;
 566   if (!is_main_window_ &&
 567       ShellRenderProcessObserver::GetInstance()->main_test_runner() == this) {
 568     WebTestInterfaces* interfaces =
 569         ShellRenderProcessObserver::GetInstance()->test_interfaces();
 570     interfaces->setTestIsRunning(true);
 571     interfaces->configureForTestWithURL(GURL(), false);
 572     ForceResizeRenderView(render_view(), WebSize(800, 600));
 573   }
 574 }
 575
 576 void WebKitTestRunner::DidCommitProvisionalLoad(WebFrame* frame,
 577                                                 bool is_new_navigation) {
 578   if (!focus_on_next_commit_)
 579     return;
 580   focus_on_next_commit_ = false;
 581   render_view()->GetWebView()->setFocusedFrame(frame);
 582 }
 583
 584 void WebKitTestRunner::DidFailProvisionalLoad(WebFrame* frame,
 585                                               const WebURLError& error) {
 586   focus_on_next_commit_ = false;
 587 }
 588
 589 // Public methods - -----------------------------------------------------------
 590
 591 void WebKitTestRunner::Reset() {
 592   // The proxy_ is always non-NULL, it is set right after construction.
 593   proxy_->setWidget(render_view()->GetWebView());
 594   proxy_->reset();
 595   prefs_.reset();
 596   routing_ids_.clear();
 597   session_histories_.clear();
 598   current_entry_indexes_.clear();
 599
 600   render_view()->ClearEditCommands();
 601   render_view()->GetWebView()->mainFrame()->setName(WebString());
 602   render_view()->GetWebView()->mainFrame()->clearOpener();
 603   render_view()->GetWebView()->setPageScaleFactorLimits(-1, -1);
 604   render_view()->GetWebView()->setPageScaleFactor(1, WebPoint(0, 0));
 605
 606   // Resetting the internals object also overrides the WebPreferences, so we
 607   // have to sync them to WebKit again.
 608   WebTestingSupport::resetInternalsObject(
 609       render_view()->GetWebView()->mainFrame());
 610   render_view()->SetWebkitPreferences(render_view()->GetWebkitPreferences());
 611 }
 612
 613 // Private methods  -----------------------------------------------------------
 614
 615 void WebKitTestRunner::CaptureDump() {
 616   WebTestInterfaces* interfaces =
 617       ShellRenderProcessObserver::GetInstance()->test_interfaces();
 618
 619   if (interfaces->testRunner()->shouldDumpAsAudio()) {
 620     const WebArrayBufferView* audio_data =
 621         interfaces->testRunner()->audioData();
 622     std::vector<unsigned char> vector_data(
 623         static_cast<const unsigned char*>(audio_data->baseAddress()),
 624         static_cast<const unsigned char*>(audio_data->baseAddress()) +
 625             audio_data->byteLength());
 626     Send(new ShellViewHostMsg_AudioDump(routing_id(), vector_data));
 627   } else {
 628     Send(new ShellViewHostMsg_TextDump(routing_id(),
 629                                        proxy()->captureTree(false)));
 630
 631     if (test_config_.enable_pixel_dumping &&
 632         interfaces->testRunner()->shouldGeneratePixelResults()) {
 633       SkBitmap snapshot;
 634       CopyCanvasToBitmap(proxy()->capturePixels(), &snapshot);
 635
 636       SkAutoLockPixels snapshot_lock(snapshot);
 637       base::MD5Digest digest;
 638       base::MD5Sum(snapshot.getPixels(), snapshot.getSize(), &digest);
 639       std::string actual_pixel_hash = base::MD5DigestToBase16(digest);
 640
 641       if (actual_pixel_hash == test_config_.expected_pixel_hash) {
 642         SkBitmap empty_image;
 643         Send(new ShellViewHostMsg_ImageDump(
 644             routing_id(), actual_pixel_hash, empty_image));
 645       } else {
 646         Send(new ShellViewHostMsg_ImageDump(
 647             routing_id(), actual_pixel_hash, snapshot));
 648       }
 649     }
 650   }
 651
 652   render_view()->GetWebView()->mainFrame()->stopLoading();
 653
 654   base::MessageLoop::current()->PostTask(
 655       FROM_HERE,
 656       base::Bind(base::IgnoreResult(&WebKitTestRunner::Send),
 657                  base::Unretained(this),
 658                  new ShellViewHostMsg_TestFinished(routing_id())));
 659 }
 660
 661 void WebKitTestRunner::OnSetTestConfiguration(
 662     const ShellTestConfiguration& params) {
 663   test_config_ = params;
 664   is_main_window_ = true;
 665
 666   ForceResizeRenderView(
 667       render_view(),
 668       WebSize(params.initial_size.width(), params.initial_size.height()));
 669   setFocus(proxy_, true);
 670
 671   WebTestInterfaces* interfaces =
 672       ShellRenderProcessObserver::GetInstance()->test_interfaces();
 673   interfaces->setTestIsRunning(true);
 674   interfaces->configureForTestWithURL(params.test_url,
 675                                       params.enable_pixel_dumping);
 676 }
 677
 678 void WebKitTestRunner::OnSessionHistory(
 679     const std::vector<int>& routing_ids,
 680     const std::vector<std::vector<PageState> >& session_histories,
 681     const std::vector<unsigned>& current_entry_indexes) {
 682   routing_ids_ = routing_ids;
 683   session_histories_ = session_histories;
 684   current_entry_indexes_ = current_entry_indexes;
 685   CaptureDump();
 686 }
 687
 688 void WebKitTestRunner::OnReset() {
 689   ShellRenderProcessObserver::GetInstance()->test_interfaces()->resetAll();
 690   Reset();
 691   // Navigating to about:blank will make sure that no new loads are initiated
 692   // by the renderer.
 693   render_view()->GetWebView()->mainFrame()->loadRequest(
 694       WebURLRequest(GURL(kAboutBlankURL)));
 695   Send(new ShellViewHostMsg_ResetDone(routing_id()));
 696 }
 697
 698 void WebKitTestRunner::OnNotifyDone() {
 699   render_view()->GetWebView()->mainFrame()->executeScript(
 700       WebScriptSource(WebString::fromUTF8("testRunner.notifyDone();")));
 701 }
 702
 703 }  // namespace content