content/shell/renderer/test_runner/WebTestProxy.cpp

   1 // Copyright 2013 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/test_runner/WebTestProxy.h"
   6
   7 #include <cctype>
   8
   9 #include "base/logging.h"
  10 #include "content/shell/renderer/test_runner/event_sender.h"
  11 #include "content/shell/renderer/test_runner/MockColorChooser.h"
  12 #include "content/shell/renderer/test_runner/MockWebSpeechInputController.h"
  13 #include "content/shell/renderer/test_runner/MockWebSpeechRecognizer.h"
  14 #include "content/shell/renderer/test_runner/SpellCheckClient.h"
  15 #include "content/shell/renderer/test_runner/TestCommon.h"
  16 #include "content/shell/renderer/test_runner/TestInterfaces.h"
  17 #include "content/shell/renderer/test_runner/TestPlugin.h"
  18 #include "content/shell/renderer/test_runner/WebTestDelegate.h"
  19 #include "content/shell/renderer/test_runner/WebTestInterfaces.h"
  20 #include "content/shell/renderer/test_runner/WebTestRunner.h"
  21 #include "content/shell/renderer/test_runner/WebUserMediaClientMock.h"
  22 #include "content/shell/renderer/test_runner/accessibility_controller.h"
  23 #include "content/shell/renderer/test_runner/test_runner.h"
  24 // FIXME: Including platform_canvas.h here is a layering violation.
  25 #include "skia/ext/platform_canvas.h"
  26 #include "third_party/WebKit/public/platform/WebCString.h"
  27 #include "third_party/WebKit/public/platform/WebURLError.h"
  28 #include "third_party/WebKit/public/platform/WebURLRequest.h"
  29 #include "third_party/WebKit/public/platform/WebURLResponse.h"
  30 #include "third_party/WebKit/public/web/WebAXEnums.h"
  31 #include "third_party/WebKit/public/web/WebAXObject.h"
  32 #include "third_party/WebKit/public/web/WebCachedURLRequest.h"
  33 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
  34 #include "third_party/WebKit/public/web/WebDataSource.h"
  35 #include "third_party/WebKit/public/web/WebDocument.h"
  36 #include "third_party/WebKit/public/web/WebElement.h"
  37 #include "third_party/WebKit/public/web/WebHistoryItem.h"
  38 #include "third_party/WebKit/public/web/WebLocalFrame.h"
  39 #include "third_party/WebKit/public/web/WebMIDIClientMock.h"
  40 #include "third_party/WebKit/public/web/WebNode.h"
  41 #include "third_party/WebKit/public/web/WebPluginParams.h"
  42 #include "third_party/WebKit/public/web/WebPrintParams.h"
  43 #include "third_party/WebKit/public/web/WebRange.h"
  44 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
  45 #include "third_party/WebKit/public/web/WebView.h"
  46
  47 using namespace WebTestRunner;
  48 using namespace blink;
  49 using namespace std;
  50
  51 namespace content {
  52
  53 namespace {
  54
  55 class HostMethodTask : public WebMethodTask<WebTestProxyBase> {
  56 public:
  57     typedef void (WebTestProxyBase::*CallbackMethodType)();
  58     HostMethodTask(WebTestProxyBase* object, CallbackMethodType callback)
  59         : WebMethodTask<WebTestProxyBase>(object)
  60         , m_callback(callback)
  61     { }
  62
  63     virtual void runIfValid() OVERRIDE { (m_object->*m_callback)(); }
  64
  65 private:
  66     CallbackMethodType m_callback;
  67 };
  68
  69 class ClosureTask : public WebMethodTask<WebTestProxyBase> {
  70  public:
  71   ClosureTask(WebTestProxyBase* object, base::Closure callback)
  72       : WebMethodTask<WebTestProxyBase>(object), m_callback(callback) {}
  73
  74   virtual void runIfValid() OVERRIDE {
  75     if (!m_callback.is_null())
  76       m_callback.Run();
  77   }
  78
  79  private:
  80   base::Closure m_callback;
  81 };
  82
  83 void printFrameDescription(WebTestDelegate* delegate, WebFrame* frame)
  84 {
  85     string name8 = frame->uniqueName().utf8();
  86     if (frame == frame->view()->mainFrame()) {
  87         if (!name8.length()) {
  88             delegate->printMessage("main frame");
  89             return;
  90         }
  91         delegate->printMessage(string("main frame \"") + name8 + "\"");
  92         return;
  93     }
  94     if (!name8.length()) {
  95         delegate->printMessage("frame (anonymous)");
  96         return;
  97     }
  98     delegate->printMessage(string("frame \"") + name8 + "\"");
  99 }
 100
 101 void printFrameUserGestureStatus(WebTestDelegate* delegate, WebFrame* frame, const char* msg)
 102 {
 103     bool isUserGesture = WebUserGestureIndicator::isProcessingUserGesture();
 104     delegate->printMessage(string("Frame with user gesture \"") + (isUserGesture ? "true" : "false") + "\"" + msg);
 105 }
 106
 107 // Used to write a platform neutral file:/// URL by taking the
 108 // filename and its directory. (e.g., converts
 109 // "file:///tmp/foo/bar.txt" to just "bar.txt").
 110 string descriptionSuitableForTestResult(const string& url)
 111 {
 112     if (url.empty() || string::npos == url.find("file://"))
 113         return url;
 114
 115     size_t pos = url.rfind('/');
 116     if (pos == string::npos || !pos)
 117         return "ERROR:" + url;
 118     pos = url.rfind('/', pos - 1);
 119     if (pos == string::npos)
 120         return "ERROR:" + url;
 121
 122     return url.substr(pos + 1);
 123 }
 124
 125 void printResponseDescription(WebTestDelegate* delegate, const WebURLResponse& response)
 126 {
 127     if (response.isNull()) {
 128         delegate->printMessage("(null)");
 129         return;
 130     }
 131     string url = response.url().spec();
 132     char data[100];
 133     snprintf(data, sizeof(data), "%d", response. httpStatusCode());
 134     delegate->printMessage(string("<NSURLResponse ") + descriptionSuitableForTestResult(url) + ", http status code " + data + ">");
 135 }
 136
 137 string URLDescription(const GURL& url)
 138 {
 139     if (url.SchemeIs("file"))
 140         return url.ExtractFileName();
 141     return url.possibly_invalid_spec();
 142 }
 143
 144 string PriorityDescription(const WebURLRequest::Priority& priority)
 145 {
 146     switch (priority) {
 147     case WebURLRequest::PriorityVeryLow:
 148         return "VeryLow";
 149     case WebURLRequest::PriorityLow:
 150         return "Low";
 151     case WebURLRequest::PriorityMedium:
 152         return "Medium";
 153     case WebURLRequest::PriorityHigh:
 154         return "High";
 155     case WebURLRequest::PriorityVeryHigh:
 156         return "VeryHigh";
 157     case WebURLRequest::PriorityUnresolved:
 158     default:
 159         return "Unresolved";
 160     }
 161 }
 162
 163 void blockRequest(WebURLRequest& request)
 164 {
 165     request.setURL(GURL("255.255.255.255"));
 166 }
 167
 168 bool isLocalhost(const string& host)
 169 {
 170     return host == "127.0.0.1" || host == "localhost";
 171 }
 172
 173 bool hostIsUsedBySomeTestsToGenerateError(const string& host)
 174 {
 175     return host == "255.255.255.255";
 176 }
 177
 178 // Used to write a platform neutral file:/// URL by only taking the filename
 179 // (e.g., converts "file:///tmp/foo.txt" to just "foo.txt").
 180 string urlSuitableForTestResult(const string& url)
 181 {
 182     if (url.empty() || string::npos == url.find("file://"))
 183         return url;
 184
 185     size_t pos = url.rfind('/');
 186     if (pos == string::npos) {
 187 #ifdef WIN32
 188         pos = url.rfind('\\');
 189         if (pos == string::npos)
 190             pos = 0;
 191 #else
 192         pos = 0;
 193 #endif
 194     }
 195     string filename = url.substr(pos + 1);
 196     if (filename.empty())
 197         return "file:"; // A WebKit test has this in its expected output.
 198     return filename;
 199 }
 200
 201 // WebNavigationType debugging strings taken from PolicyDelegate.mm.
 202 const char* linkClickedString = "link clicked";
 203 const char* formSubmittedString = "form submitted";
 204 const char* backForwardString = "back/forward";
 205 const char* reloadString = "reload";
 206 const char* formResubmittedString = "form resubmitted";
 207 const char* otherString = "other";
 208 const char* illegalString = "illegal value";
 209
 210 // Get a debugging string from a WebNavigationType.
 211 const char* webNavigationTypeToString(WebNavigationType type)
 212 {
 213     switch (type) {
 214     case blink::WebNavigationTypeLinkClicked:
 215         return linkClickedString;
 216     case blink::WebNavigationTypeFormSubmitted:
 217         return formSubmittedString;
 218     case blink::WebNavigationTypeBackForward:
 219         return backForwardString;
 220     case blink::WebNavigationTypeReload:
 221         return reloadString;
 222     case blink::WebNavigationTypeFormResubmitted:
 223         return formResubmittedString;
 224     case blink::WebNavigationTypeOther:
 225         return otherString;
 226     }
 227     return illegalString;
 228 }
 229
 230 string dumpDocumentText(WebFrame* frame)
 231 {
 232     // We use the document element's text instead of the body text here because
 233     // not all documents have a body, such as XML documents.
 234     WebElement documentElement = frame->document().documentElement();
 235     if (documentElement.isNull())
 236         return string();
 237     return documentElement.innerText().utf8();
 238 }
 239
 240 string dumpFramesAsText(WebFrame* frame, bool recursive)
 241 {
 242     string result;
 243
 244     // Add header for all but the main frame. Skip empty frames.
 245     if (frame->parent() && !frame->document().documentElement().isNull()) {
 246         result.append("\n--------\nFrame: '");
 247         result.append(frame->uniqueName().utf8().data());
 248         result.append("'\n--------\n");
 249     }
 250
 251     result.append(dumpDocumentText(frame));
 252     result.append("\n");
 253
 254     if (recursive) {
 255         for (WebFrame* child = frame->firstChild(); child; child = child->nextSibling())
 256             result.append(dumpFramesAsText(child, recursive));
 257     }
 258
 259     return result;
 260 }
 261
 262 string dumpFramesAsPrintedText(WebFrame* frame, bool recursive)
 263 {
 264     string result;
 265
 266     // Cannot do printed format for anything other than HTML
 267     if (!frame->document().isHTMLDocument())
 268         return string();
 269
 270     // Add header for all but the main frame. Skip empty frames.
 271     if (frame->parent() && !frame->document().documentElement().isNull()) {
 272         result.append("\n--------\nFrame: '");
 273         result.append(frame->uniqueName().utf8().data());
 274         result.append("'\n--------\n");
 275     }
 276
 277     result.append(frame->renderTreeAsText(WebFrame::RenderAsTextPrinting).utf8());
 278     result.append("\n");
 279
 280     if (recursive) {
 281         for (WebFrame* child = frame->firstChild(); child; child = child->nextSibling())
 282             result.append(dumpFramesAsPrintedText(child, recursive));
 283     }
 284
 285     return result;
 286 }
 287
 288 string dumpFrameScrollPosition(WebFrame* frame, bool recursive)
 289 {
 290     string result;
 291     WebSize offset = frame->scrollOffset();
 292     if (offset.width > 0 || offset.height > 0) {
 293         if (frame->parent())
 294             result = string("frame '") + frame->uniqueName().utf8().data() + "' ";
 295         char data[100];
 296         snprintf(data, sizeof(data), "scrolled to %d,%d\n", offset.width, offset.height);
 297         result += data;
 298     }
 299
 300     if (!recursive)
 301         return result;
 302     for (WebFrame* child = frame->firstChild(); child; child = child->nextSibling())
 303         result += dumpFrameScrollPosition(child, recursive);
 304     return result;
 305 }
 306
 307 string dumpAllBackForwardLists(TestInterfaces* interfaces, WebTestDelegate* delegate)
 308 {
 309     string result;
 310     const vector<WebTestProxyBase*>& windowList = interfaces->windowList();
 311     for (unsigned i = 0; i < windowList.size(); ++i)
 312         result.append(delegate->dumpHistoryForWindow(windowList.at(i)));
 313     return result;
 314 }
 315
 316 }
 317
 318 WebTestProxyBase::WebTestProxyBase()
 319     : m_testInterfaces(0)
 320     , m_delegate(0)
 321     , m_webWidget(0)
 322     , m_spellcheck(new SpellCheckClient(this))
 323     , m_chooserCount(0)
 324 {
 325     reset();
 326 }
 327
 328 WebTestProxyBase::~WebTestProxyBase()
 329 {
 330     m_testInterfaces->windowClosed(this);
 331 }
 332
 333 void WebTestProxyBase::setInterfaces(WebTestInterfaces* interfaces)
 334 {
 335     m_testInterfaces = interfaces->testInterfaces();
 336     m_testInterfaces->windowOpened(this);
 337 }
 338
 339 void WebTestProxyBase::setDelegate(WebTestDelegate* delegate)
 340 {
 341     m_delegate = delegate;
 342     m_spellcheck->setDelegate(delegate);
 343 #if ENABLE_INPUT_SPEECH
 344     if (m_speechInputController.get())
 345         m_speechInputController->setDelegate(delegate);
 346 #endif
 347     if (m_speechRecognizer.get())
 348         m_speechRecognizer->setDelegate(delegate);
 349 }
 350
 351 void WebTestProxyBase::setWidget(WebWidget* widget)
 352 {
 353     m_webWidget = widget;
 354 }
 355
 356 WebWidget* WebTestProxyBase::webWidget()
 357 {
 358     return m_webWidget;
 359 }
 360
 361 WebView* WebTestProxyBase::webView()
 362 {
 363     DCHECK(m_webWidget);
 364     // TestRunner does not support popup widgets. So m_webWidget is always a WebView.
 365     return static_cast<WebView*>(m_webWidget);
 366 }
 367
 368 void WebTestProxyBase::didForceResize()
 369 {
 370     invalidateAll();
 371     discardBackingStore();
 372 }
 373
 374 void WebTestProxyBase::reset()
 375 {
 376     m_paintRect = WebRect();
 377     m_canvas.reset();
 378     m_isPainting = false;
 379     m_animateScheduled = false;
 380     m_resourceIdentifierMap.clear();
 381     m_logConsoleOutput = true;
 382     if (m_midiClient.get())
 383         m_midiClient->resetMock();
 384 #if ENABLE_INPUT_SPEECH
 385     if (m_speechInputController.get())
 386         m_speechInputController->clearResults();
 387 #endif
 388 }
 389
 390 WebSpellCheckClient* WebTestProxyBase::spellCheckClient() const
 391 {
 392     return m_spellcheck.get();
 393 }
 394
 395 WebColorChooser* WebTestProxyBase::createColorChooser(WebColorChooserClient* client, const blink::WebColor& color, const blink::WebVector<blink::WebColorSuggestion>& suggestions)
 396 {
 397     // This instance is deleted by WebCore::ColorInputType
 398     return new MockColorChooser(client, m_delegate, this);
 399 }
 400
 401 bool WebTestProxyBase::runFileChooser(const blink::WebFileChooserParams&, blink::WebFileChooserCompletion*)
 402 {
 403     m_delegate->printMessage("Mock: Opening a file chooser.\n");
 404     // FIXME: Add ability to set file names to a file upload control.
 405     return false;
 406 }
 407
 408 void WebTestProxyBase::showValidationMessage(const WebRect&, const WebString& message, const WebString& subMessage, WebTextDirection)
 409 {
 410     m_delegate->printMessage(std::string("ValidationMessageClient: main-message=") + std::string(message.utf8()) + " sub-message=" + std::string(subMessage.utf8()) + "\n");
 411 }
 412
 413 void WebTestProxyBase::hideValidationMessage()
 414 {
 415 }
 416
 417 void WebTestProxyBase::moveValidationMessage(const WebRect&)
 418 {
 419 }
 420
 421 string WebTestProxyBase::captureTree(bool debugRenderTree)
 422 {
 423     bool shouldDumpAsText = m_testInterfaces->testRunner()->shouldDumpAsText();
 424     bool shouldDumpAsMarkup = m_testInterfaces->testRunner()->shouldDumpAsMarkup();
 425     bool shouldDumpAsPrinted = m_testInterfaces->testRunner()->isPrinting();
 426     WebFrame* frame = webView()->mainFrame();
 427     string dataUtf8;
 428     if (shouldDumpAsText) {
 429         bool recursive = m_testInterfaces->testRunner()->shouldDumpChildFramesAsText();
 430         dataUtf8 = shouldDumpAsPrinted ? dumpFramesAsPrintedText(frame, recursive) : dumpFramesAsText(frame, recursive);
 431     } else if (shouldDumpAsMarkup) {
 432         // Append a newline for the test driver.
 433         dataUtf8 = frame->contentAsMarkup().utf8() + "\n";
 434     } else {
 435         bool recursive = m_testInterfaces->testRunner()->shouldDumpChildFrameScrollPositions();
 436         WebFrame::RenderAsTextControls renderTextBehavior = WebFrame::RenderAsTextNormal;
 437         if (shouldDumpAsPrinted)
 438             renderTextBehavior |= WebFrame::RenderAsTextPrinting;
 439         if (debugRenderTree)
 440             renderTextBehavior |= WebFrame::RenderAsTextDebug;
 441         dataUtf8 = frame->renderTreeAsText(renderTextBehavior).utf8();
 442         dataUtf8 += dumpFrameScrollPosition(frame, recursive);
 443     }
 444
 445     if (m_testInterfaces->testRunner()->shouldDumpBackForwardList())
 446         dataUtf8 += dumpAllBackForwardLists(m_testInterfaces, m_delegate);
 447
 448     return dataUtf8;
 449 }
 450
 451 SkCanvas* WebTestProxyBase::capturePixels()
 452 {
 453     webWidget()->layout();
 454     if (m_testInterfaces->testRunner()->isPrinting())
 455         paintPagesWithBoundaries();
 456     else
 457         paintInvalidatedRegion();
 458
 459     // See if we need to draw the selection bounds rect. Selection bounds
 460     // rect is the rect enclosing the (possibly transformed) selection.
 461     // The rect should be drawn after everything is laid out and painted.
 462     if (m_testInterfaces->testRunner()->shouldDumpSelectionRect()) {
 463         // If there is a selection rect - draw a red 1px border enclosing rect
 464         WebRect wr = webView()->mainFrame()->selectionBoundsRect();
 465         if (!wr.isEmpty()) {
 466             // Render a red rectangle bounding selection rect
 467             SkPaint paint;
 468             paint.setColor(0xFFFF0000); // Fully opaque red
 469             paint.setStyle(SkPaint::kStroke_Style);
 470             paint.setFlags(SkPaint::kAntiAlias_Flag);
 471             paint.setStrokeWidth(1.0f);
 472             SkIRect rect; // Bounding rect
 473             rect.set(wr.x, wr.y, wr.x + wr.width, wr.y + wr.height);
 474             canvas()->drawIRect(rect, paint);
 475         }
 476     }
 477
 478     return canvas();
 479 }
 480
 481 void WebTestProxyBase::setLogConsoleOutput(bool enabled)
 482 {
 483     m_logConsoleOutput = enabled;
 484 }
 485
 486 void WebTestProxyBase::paintRect(const WebRect& rect)
 487 {
 488     DCHECK(!m_isPainting);
 489     DCHECK(canvas());
 490     m_isPainting = true;
 491     float deviceScaleFactor = webView()->deviceScaleFactor();
 492     int scaledX = static_cast<int>(static_cast<float>(rect.x) * deviceScaleFactor);
 493     int scaledY = static_cast<int>(static_cast<float>(rect.y) * deviceScaleFactor);
 494     int scaledWidth = static_cast<int>(ceil(static_cast<float>(rect.width) * deviceScaleFactor));
 495     int scaledHeight = static_cast<int>(ceil(static_cast<float>(rect.height) * deviceScaleFactor));
 496     WebRect deviceRect(scaledX, scaledY, scaledWidth, scaledHeight);
 497     webWidget()->paint(canvas(), deviceRect);
 498     m_isPainting = false;
 499 }
 500
 501 void WebTestProxyBase::paintInvalidatedRegion()
 502 {
 503     webWidget()->animate(0.0);
 504     webWidget()->layout();
 505     WebSize widgetSize = webWidget()->size();
 506     WebRect clientRect(0, 0, widgetSize.width, widgetSize.height);
 507
 508     // Paint the canvas if necessary. Allow painting to generate extra rects
 509     // for the first two calls. This is necessary because some WebCore rendering
 510     // objects update their layout only when painted.
 511     // Store the total area painted in total_paint. Then tell the gdk window
 512     // to update that area after we're done painting it.
 513     for (int i = 0; i < 3; ++i) {
 514         // rect = intersect(m_paintRect , clientRect)
 515         WebRect damageRect = m_paintRect;
 516         int left = max(damageRect.x, clientRect.x);
 517         int top = max(damageRect.y, clientRect.y);
 518         int right = min(damageRect.x + damageRect.width, clientRect.x + clientRect.width);
 519         int bottom = min(damageRect.y + damageRect.height, clientRect.y + clientRect.height);
 520         WebRect rect;
 521         if (left < right && top < bottom)
 522             rect = WebRect(left, top, right - left, bottom - top);
 523
 524         m_paintRect = WebRect();
 525         if (rect.isEmpty())
 526             continue;
 527         paintRect(rect);
 528     }
 529     DCHECK(m_paintRect.isEmpty());
 530 }
 531
 532 void WebTestProxyBase::paintPagesWithBoundaries()
 533 {
 534     DCHECK(!m_isPainting);
 535     DCHECK(canvas());
 536     m_isPainting = true;
 537
 538     WebSize pageSizeInPixels = webWidget()->size();
 539     WebFrame* webFrame = webView()->mainFrame();
 540
 541     int pageCount = webFrame->printBegin(pageSizeInPixels);
 542     int totalHeight = pageCount * (pageSizeInPixels.height + 1) - 1;
 543
 544     SkCanvas* testCanvas = skia::TryCreateBitmapCanvas(pageSizeInPixels.width, totalHeight, false);
 545     if (testCanvas) {
 546         discardBackingStore();
 547         m_canvas.reset(testCanvas);
 548     } else {
 549         webFrame->printEnd();
 550         return;
 551     }
 552
 553     webFrame->printPagesWithBoundaries(canvas(), pageSizeInPixels);
 554     webFrame->printEnd();
 555
 556     m_isPainting = false;
 557 }
 558
 559 SkCanvas* WebTestProxyBase::canvas()
 560 {
 561     if (m_canvas.get())
 562         return m_canvas.get();
 563     WebSize widgetSize = webWidget()->size();
 564     float deviceScaleFactor = webView()->deviceScaleFactor();
 565     int scaledWidth = static_cast<int>(ceil(static_cast<float>(widgetSize.width) * deviceScaleFactor));
 566     int scaledHeight = static_cast<int>(ceil(static_cast<float>(widgetSize.height) * deviceScaleFactor));
 567     // We're allocating the canvas to be non-opaque (third parameter), so we
 568     // don't end up with uninitialized memory if a layout test doesn't damage
 569     // the entire view.
 570     m_canvas.reset(skia::CreateBitmapCanvas(scaledWidth, scaledHeight, false));
 571     return m_canvas.get();
 572 }
 573
 574 void WebTestProxyBase::display(base::Closure callback)
 575 {
 576     const blink::WebSize& size = webWidget()->size();
 577     WebRect rect(0, 0, size.width, size.height);
 578     m_paintRect = rect;
 579     paintInvalidatedRegion();
 580
 581     if (!callback.is_null())
 582         callback.Run();
 583 }
 584
 585 void WebTestProxyBase::displayAsyncThen(base::Closure callback)
 586 {
 587   // TODO(enne): When compositing, this should invoke a real rAF, paint,
 588   // and commit.  For now, just make sure that displayAsync is actually
 589   // async so that callers can't depend on synchronous behavior.
 590   m_delegate->postTask(new ClosureTask(
 591       this,
 592       base::Bind(
 593           &WebTestProxyBase::display, base::Unretained(this), callback)));
 594 }
 595
 596 void WebTestProxyBase::discardBackingStore()
 597 {
 598     m_canvas.reset();
 599 }
 600
 601 WebMIDIClientMock* WebTestProxyBase::midiClientMock()
 602 {
 603     if (!m_midiClient.get())
 604         m_midiClient.reset(new WebMIDIClientMock);
 605     return m_midiClient.get();
 606 }
 607
 608 #if ENABLE_INPUT_SPEECH
 609 MockWebSpeechInputController* WebTestProxyBase::speechInputControllerMock()
 610 {
 611     DCHECK(m_speechInputController.get());
 612     return m_speechInputController.get();
 613 }
 614 #endif
 615
 616 MockWebSpeechRecognizer* WebTestProxyBase::speechRecognizerMock()
 617 {
 618     if (!m_speechRecognizer.get()) {
 619         m_speechRecognizer.reset(new MockWebSpeechRecognizer());
 620         m_speechRecognizer->setDelegate(m_delegate);
 621     }
 622     return m_speechRecognizer.get();
 623 }
 624
 625 void WebTestProxyBase::didInvalidateRect(const WebRect& rect)
 626 {
 627     // m_paintRect = m_paintRect U rect
 628     if (rect.isEmpty())
 629         return;
 630     if (m_paintRect.isEmpty()) {
 631         m_paintRect = rect;
 632         return;
 633     }
 634     int left = min(m_paintRect.x, rect.x);
 635     int top = min(m_paintRect.y, rect.y);
 636     int right = max(m_paintRect.x + m_paintRect.width, rect.x + rect.width);
 637     int bottom = max(m_paintRect.y + m_paintRect.height, rect.y + rect.height);
 638     m_paintRect = WebRect(left, top, right - left, bottom - top);
 639 }
 640
 641 void WebTestProxyBase::didScrollRect(int, int, const WebRect& clipRect)
 642 {
 643     didInvalidateRect(clipRect);
 644 }
 645
 646 void WebTestProxyBase::invalidateAll()
 647 {
 648     m_paintRect = WebRect(0, 0, INT_MAX, INT_MAX);
 649 }
 650
 651 void WebTestProxyBase::scheduleComposite()
 652 {
 653     invalidateAll();
 654 }
 655
 656 void WebTestProxyBase::scheduleAnimation()
 657 {
 658     if (!m_testInterfaces->testRunner()->TestIsRunning())
 659         return;
 660
 661     if (!m_animateScheduled) {
 662         m_animateScheduled = true;
 663         m_delegate->postDelayedTask(new HostMethodTask(this, &WebTestProxyBase::animateNow), 1);
 664     }
 665 }
 666
 667 void WebTestProxyBase::animateNow()
 668 {
 669     if (m_animateScheduled) {
 670         m_animateScheduled = false;
 671         webWidget()->animate(0.0);
 672         webWidget()->layout();
 673     }
 674 }
 675
 676 bool WebTestProxyBase::isCompositorFramePending() const
 677 {
 678     return m_animateScheduled || !m_paintRect.isEmpty();
 679 }
 680
 681 void WebTestProxyBase::show(WebNavigationPolicy)
 682 {
 683     invalidateAll();
 684 }
 685
 686 void WebTestProxyBase::setWindowRect(const WebRect& rect)
 687 {
 688     invalidateAll();
 689     discardBackingStore();
 690 }
 691
 692 void WebTestProxyBase::didAutoResize(const WebSize&)
 693 {
 694     invalidateAll();
 695 }
 696
 697 void WebTestProxyBase::postAccessibilityEvent(const blink::WebAXObject& obj, blink::WebAXEvent event)
 698 {
 699     // Only hook the accessibility events occured during the test run.
 700     // This check prevents false positives in WebLeakDetector.
 701     // The pending tasks in browser/renderer message queue may trigger accessibility events,
 702     // and AccessibilityController will hold on to their target nodes if we don't ignore them here.
 703     if (!m_testInterfaces->testRunner()->TestIsRunning())
 704         return;
 705
 706     if (event == blink::WebAXEventFocus)
 707         m_testInterfaces->accessibilityController()->SetFocusedElement(obj);
 708
 709     const char* eventName = 0;
 710     switch (event) {
 711     case blink::WebAXEventActiveDescendantChanged:
 712         eventName = "ActiveDescendantChanged";
 713         break;
 714     case blink::WebAXEventAlert:
 715         eventName = "Alert";
 716         break;
 717     case blink::WebAXEventAriaAttributeChanged:
 718         eventName = "AriaAttributeChanged";
 719         break;
 720     case blink::WebAXEventAutocorrectionOccured:
 721         eventName = "AutocorrectionOccured";
 722         break;
 723     case blink::WebAXEventBlur:
 724         eventName = "Blur";
 725         break;
 726     case blink::WebAXEventCheckedStateChanged:
 727         eventName = "CheckedStateChanged";
 728         break;
 729     case blink::WebAXEventChildrenChanged:
 730         eventName = "ChildrenChanged";
 731         break;
 732     case blink::WebAXEventFocus:
 733         eventName = "Focus";
 734         break;
 735     case blink::WebAXEventHide:
 736         eventName = "Hide";
 737         break;
 738     case blink::WebAXEventInvalidStatusChanged:
 739         eventName = "InvalidStatusChanged";
 740         break;
 741     case blink::WebAXEventLayoutComplete:
 742         eventName = "LayoutComplete";
 743         break;
 744     case blink::WebAXEventLiveRegionChanged:
 745         eventName = "LiveRegionChanged";
 746         break;
 747     case blink::WebAXEventLoadComplete:
 748         eventName = "LoadComplete";
 749         break;
 750     case blink::WebAXEventLocationChanged:
 751         eventName = "LocationChanged";
 752         break;
 753     case blink::WebAXEventMenuListItemSelected:
 754         eventName = "MenuListItemSelected";
 755         break;
 756     case blink::WebAXEventMenuListValueChanged:
 757         eventName = "MenuListValueChanged";
 758         break;
 759     case blink::WebAXEventRowCollapsed:
 760         eventName = "RowCollapsed";
 761         break;
 762     case blink::WebAXEventRowCountChanged:
 763         eventName = "RowCountChanged";
 764         break;
 765     case blink::WebAXEventRowExpanded:
 766         eventName = "RowExpanded";
 767         break;
 768     case blink::WebAXEventScrollPositionChanged:
 769         eventName = "ScrollPositionChanged";
 770         break;
 771     case blink::WebAXEventScrolledToAnchor:
 772         eventName = "ScrolledToAnchor";
 773         break;
 774     case blink::WebAXEventSelectedChildrenChanged:
 775         eventName = "SelectedChildrenChanged";
 776         break;
 777     case blink::WebAXEventSelectedTextChanged:
 778         eventName = "SelectedTextChanged";
 779         break;
 780     case blink::WebAXEventShow:
 781         eventName = "Show";
 782         break;
 783     case blink::WebAXEventTextChanged:
 784         eventName = "TextChanged";
 785         break;
 786     case blink::WebAXEventTextInserted:
 787         eventName = "TextInserted";
 788         break;
 789     case blink::WebAXEventTextRemoved:
 790         eventName = "TextRemoved";
 791         break;
 792     case blink::WebAXEventValueChanged:
 793         eventName = "ValueChanged";
 794         break;
 795     default:
 796         eventName = "Unknown";
 797         break;
 798     }
 799
 800     m_testInterfaces->accessibilityController()->NotificationReceived(obj, eventName);
 801
 802     if (m_testInterfaces->accessibilityController()->ShouldLogAccessibilityEvents()) {
 803         string message("AccessibilityNotification - ");
 804         message += eventName;
 805
 806         blink::WebNode node = obj.node();
 807         if (!node.isNull() && node.isElementNode()) {
 808             blink::WebElement element = node.to<blink::WebElement>();
 809             if (element.hasAttribute("id")) {
 810                 message += " - id:";
 811                 message += element.getAttribute("id").utf8().data();
 812             }
 813         }
 814
 815         m_delegate->printMessage(message + "\n");
 816     }
 817 }
 818
 819 void WebTestProxyBase::startDragging(WebLocalFrame*, const WebDragData& data, WebDragOperationsMask mask, const WebImage&, const WebPoint&)
 820 {
 821     // When running a test, we need to fake a drag drop operation otherwise
 822     // Windows waits for real mouse events to know when the drag is over.
 823     m_testInterfaces->eventSender()->DoDragDrop(data, mask);
 824 }
 825
 826 // The output from these methods in layout test mode should match that
 827 // expected by the layout tests. See EditingDelegate.m in DumpRenderTree.
 828
 829 void WebTestProxyBase::didChangeSelection(bool isEmptySelection)
 830 {
 831     if (m_testInterfaces->testRunner()->shouldDumpEditingCallbacks())
 832         m_delegate->printMessage("EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification\n");
 833 }
 834
 835 void WebTestProxyBase::didChangeContents()
 836 {
 837     if (m_testInterfaces->testRunner()->shouldDumpEditingCallbacks())
 838         m_delegate->printMessage("EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification\n");
 839 }
 840
 841 bool WebTestProxyBase::createView(WebLocalFrame*, const WebURLRequest& request, const WebWindowFeatures&, const WebString&, WebNavigationPolicy, bool)
 842 {
 843     if (!m_testInterfaces->testRunner()->canOpenWindows())
 844         return false;
 845     if (m_testInterfaces->testRunner()->shouldDumpCreateView())
 846         m_delegate->printMessage(string("createView(") + URLDescription(request.url()) + ")\n");
 847     return true;
 848 }
 849
 850 WebPlugin* WebTestProxyBase::createPlugin(WebLocalFrame* frame, const WebPluginParams& params)
 851 {
 852     if (TestPlugin::isSupportedMimeType(params.mimeType))
 853         return TestPlugin::create(frame, params, m_delegate);
 854     return 0;
 855 }
 856
 857 void WebTestProxyBase::setStatusText(const WebString& text)
 858 {
 859     if (!m_testInterfaces->testRunner()->shouldDumpStatusCallbacks())
 860         return;
 861     m_delegate->printMessage(string("UI DELEGATE STATUS CALLBACK: setStatusText:") + text.utf8().data() + "\n");
 862 }
 863
 864 void WebTestProxyBase::didStopLoading()
 865 {
 866     if (m_testInterfaces->testRunner()->shouldDumpProgressFinishedCallback())
 867         m_delegate->printMessage("postProgressFinishedNotification\n");
 868 }
 869
 870 void WebTestProxyBase::showContextMenu(WebLocalFrame*, const WebContextMenuData& contextMenuData)
 871 {
 872     m_testInterfaces->eventSender()->SetContextMenuData(contextMenuData);
 873 }
 874
 875 WebUserMediaClient* WebTestProxyBase::userMediaClient()
 876 {
 877     if (!m_userMediaClient.get())
 878         m_userMediaClient.reset(new WebUserMediaClientMock(m_delegate));
 879     return m_userMediaClient.get();
 880 }
 881
 882 // Simulate a print by going into print mode and then exit straight away.
 883 void WebTestProxyBase::printPage(WebLocalFrame* frame)
 884 {
 885     WebSize pageSizeInPixels = webWidget()->size();
 886     if (pageSizeInPixels.isEmpty())
 887         return;
 888     WebPrintParams printParams(pageSizeInPixels);
 889     frame->printBegin(printParams);
 890     frame->printEnd();
 891 }
 892
 893 WebNotificationPresenter* WebTestProxyBase::notificationPresenter()
 894 {
 895     return m_testInterfaces->testRunner()->notification_presenter();
 896 }
 897
 898 WebMIDIClient* WebTestProxyBase::webMIDIClient()
 899 {
 900     return midiClientMock();
 901 }
 902
 903 WebSpeechInputController* WebTestProxyBase::speechInputController(WebSpeechInputListener* listener)
 904 {
 905 #if ENABLE_INPUT_SPEECH
 906     if (!m_speechInputController.get()) {
 907         m_speechInputController.reset(new MockWebSpeechInputController(listener));
 908         m_speechInputController->setDelegate(m_delegate);
 909     }
 910     return m_speechInputController.get();
 911 #else
 912     DCHECK(listener);
 913     return 0;
 914 #endif
 915 }
 916
 917 WebSpeechRecognizer* WebTestProxyBase::speechRecognizer()
 918 {
 919     return speechRecognizerMock();
 920 }
 921
 922 bool WebTestProxyBase::requestPointerLock()
 923 {
 924     return m_testInterfaces->testRunner()->RequestPointerLock();
 925 }
 926
 927 void WebTestProxyBase::requestPointerUnlock()
 928 {
 929     m_testInterfaces->testRunner()->RequestPointerUnlock();
 930 }
 931
 932 bool WebTestProxyBase::isPointerLocked()
 933 {
 934     return m_testInterfaces->testRunner()->isPointerLocked();
 935 }
 936
 937 void WebTestProxyBase::didFocus()
 938 {
 939     m_delegate->setFocus(this, true);
 940 }
 941
 942 void WebTestProxyBase::didBlur()
 943 {
 944     m_delegate->setFocus(this, false);
 945 }
 946
 947 void WebTestProxyBase::setToolTipText(const WebString& text, WebTextDirection)
 948 {
 949     m_testInterfaces->testRunner()->setToolTipText(text);
 950 }
 951
 952 void WebTestProxyBase::didOpenChooser()
 953 {
 954     m_chooserCount++;
 955 }
 956
 957 void WebTestProxyBase::didCloseChooser()
 958 {
 959     m_chooserCount--;
 960 }
 961
 962 bool WebTestProxyBase::isChooserShown()
 963 {
 964     return 0 < m_chooserCount;
 965 }
 966
 967 void WebTestProxyBase::loadURLExternally(WebLocalFrame* frame, const WebURLRequest& request, WebNavigationPolicy policy, const WebString& suggested_name)
 968 {
 969     if (m_testInterfaces->testRunner()->shouldWaitUntilExternalURLLoad()) {
 970         if (policy == WebNavigationPolicyDownload) {
 971             m_delegate->printMessage(string("Downloading URL with suggested filename \"") + suggested_name.utf8() + "\"\n");
 972         } else {
 973             m_delegate->printMessage(string("Loading URL externally - \"") + URLDescription(request.url()) + "\"\n");
 974         }
 975         m_delegate->testFinished();
 976     }
 977 }
 978
 979 void WebTestProxyBase::didStartProvisionalLoad(WebLocalFrame* frame)
 980 {
 981     if (!m_testInterfaces->testRunner()->topLoadingFrame())
 982         m_testInterfaces->testRunner()->setTopLoadingFrame(frame, false);
 983
 984     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
 985         printFrameDescription(m_delegate, frame);
 986         m_delegate->printMessage(" - didStartProvisionalLoadForFrame\n");
 987     }
 988
 989     if (m_testInterfaces->testRunner()->shouldDumpUserGestureInFrameLoadCallbacks())
 990         printFrameUserGestureStatus(m_delegate, frame, " - in didStartProvisionalLoadForFrame\n");
 991 }
 992
 993 void WebTestProxyBase::didReceiveServerRedirectForProvisionalLoad(WebLocalFrame* frame)
 994 {
 995     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
 996         printFrameDescription(m_delegate, frame);
 997         m_delegate->printMessage(" - didReceiveServerRedirectForProvisionalLoadForFrame\n");
 998     }
 999 }
1000
1001 bool WebTestProxyBase::didFailProvisionalLoad(WebLocalFrame* frame, const WebURLError&)
1002 {
1003     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
1004         printFrameDescription(m_delegate, frame);
1005         m_delegate->printMessage(" - didFailProvisionalLoadWithError\n");
1006     }
1007     locationChangeDone(frame);
1008     return !frame->provisionalDataSource();
1009 }
1010
1011 void WebTestProxyBase::didCommitProvisionalLoad(WebLocalFrame* frame, const WebHistoryItem&, blink::WebHistoryCommitType)
1012 {
1013     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
1014         printFrameDescription(m_delegate, frame);
1015         m_delegate->printMessage(" - didCommitLoadForFrame\n");
1016     }
1017 }
1018
1019 void WebTestProxyBase::didReceiveTitle(WebLocalFrame* frame, const WebString& title, WebTextDirection direction)
1020 {
1021     WebCString title8 = title.utf8();
1022
1023     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
1024         printFrameDescription(m_delegate, frame);
1025         m_delegate->printMessage(string(" - didReceiveTitle: ") + title8.data() + "\n");
1026     }
1027
1028     if (m_testInterfaces->testRunner()->shouldDumpTitleChanges())
1029         m_delegate->printMessage(string("TITLE CHANGED: '") + title8.data() + "'\n");
1030 }
1031
1032 void WebTestProxyBase::didChangeIcon(WebLocalFrame* frame, WebIconURL::Type)
1033 {
1034     if (m_testInterfaces->testRunner()->shouldDumpIconChanges()) {
1035         printFrameDescription(m_delegate, frame);
1036         m_delegate->printMessage(string(" - didChangeIcons\n"));
1037     }
1038 }
1039
1040 void WebTestProxyBase::didFinishDocumentLoad(WebLocalFrame* frame)
1041 {
1042     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
1043         printFrameDescription(m_delegate, frame);
1044         m_delegate->printMessage(" - didFinishDocumentLoadForFrame\n");
1045     } else {
1046         unsigned pendingUnloadEvents = frame->unloadListenerCount();
1047         if (pendingUnloadEvents) {
1048             printFrameDescription(m_delegate, frame);
1049             char buffer[100];
1050             snprintf(buffer, sizeof(buffer), " - has %u onunload handler(s)\n", pendingUnloadEvents);
1051             m_delegate->printMessage(buffer);
1052         }
1053     }
1054 }
1055
1056 void WebTestProxyBase::didHandleOnloadEvents(WebLocalFrame* frame)
1057 {
1058     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
1059         printFrameDescription(m_delegate, frame);
1060         m_delegate->printMessage(" - didHandleOnloadEventsForFrame\n");
1061     }
1062 }
1063
1064 void WebTestProxyBase::didFailLoad(WebLocalFrame* frame, const WebURLError&)
1065 {
1066     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
1067         printFrameDescription(m_delegate, frame);
1068         m_delegate->printMessage(" - didFailLoadWithError\n");
1069     }
1070     locationChangeDone(frame);
1071 }
1072
1073 void WebTestProxyBase::didFinishLoad(WebLocalFrame* frame)
1074 {
1075     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
1076         printFrameDescription(m_delegate, frame);
1077         m_delegate->printMessage(" - didFinishLoadForFrame\n");
1078     }
1079     locationChangeDone(frame);
1080 }
1081
1082 void WebTestProxyBase::didDetectXSS(WebLocalFrame*, const WebURL&, bool)
1083 {
1084     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks())
1085         m_delegate->printMessage("didDetectXSS\n");
1086 }
1087
1088 void WebTestProxyBase::didDispatchPingLoader(WebLocalFrame*, const WebURL& url)
1089 {
1090     if (m_testInterfaces->testRunner()->shouldDumpPingLoaderCallbacks())
1091         m_delegate->printMessage(string("PingLoader dispatched to '") + URLDescription(url).c_str() + "'.\n");
1092 }
1093
1094 void WebTestProxyBase::willRequestResource(WebLocalFrame* frame, const blink::WebCachedURLRequest& request)
1095 {
1096     if (m_testInterfaces->testRunner()->shouldDumpResourceRequestCallbacks()) {
1097         printFrameDescription(m_delegate, frame);
1098         m_delegate->printMessage(string(" - ") + request.initiatorName().utf8().data());
1099         m_delegate->printMessage(string(" requested '") + URLDescription(request.urlRequest().url()).c_str() + "'\n");
1100     }
1101 }
1102
1103 void WebTestProxyBase::willSendRequest(WebLocalFrame*, unsigned identifier, blink::WebURLRequest& request, const blink::WebURLResponse& redirectResponse)
1104 {
1105     // Need to use GURL for host() and SchemeIs()
1106     GURL url = request.url();
1107     string requestURL = url.possibly_invalid_spec();
1108
1109     GURL mainDocumentURL = request.firstPartyForCookies();
1110
1111     if (redirectResponse.isNull() && (m_testInterfaces->testRunner()->shouldDumpResourceLoadCallbacks() || m_testInterfaces->testRunner()->shouldDumpResourcePriorities())) {
1112         DCHECK(m_resourceIdentifierMap.find(identifier) == m_resourceIdentifierMap.end());
1113         m_resourceIdentifierMap[identifier] = descriptionSuitableForTestResult(requestURL);
1114     }
1115
1116     if (m_testInterfaces->testRunner()->shouldDumpResourceLoadCallbacks()) {
1117         if (m_resourceIdentifierMap.find(identifier) == m_resourceIdentifierMap.end())
1118             m_delegate->printMessage("<unknown>");
1119         else
1120             m_delegate->printMessage(m_resourceIdentifierMap[identifier]);
1121         m_delegate->printMessage(" - willSendRequest <NSURLRequest URL ");
1122         m_delegate->printMessage(descriptionSuitableForTestResult(requestURL).c_str());
1123         m_delegate->printMessage(", main document URL ");
1124         m_delegate->printMessage(URLDescription(mainDocumentURL).c_str());
1125         m_delegate->printMessage(", http method ");
1126         m_delegate->printMessage(request.httpMethod().utf8().data());
1127         m_delegate->printMessage("> redirectResponse ");
1128         printResponseDescription(m_delegate, redirectResponse);
1129         m_delegate->printMessage("\n");
1130     }
1131
1132     if (m_testInterfaces->testRunner()->shouldDumpResourcePriorities()) {
1133         m_delegate->printMessage(descriptionSuitableForTestResult(requestURL).c_str());
1134         m_delegate->printMessage(" has priority ");
1135         m_delegate->printMessage(PriorityDescription(request.priority()));
1136         m_delegate->printMessage("\n");
1137     }
1138
1139     if (m_testInterfaces->testRunner()->httpHeadersToClear()) {
1140         const set<string> *clearHeaders = m_testInterfaces->testRunner()->httpHeadersToClear();
1141         for (set<string>::const_iterator header = clearHeaders->begin(); header != clearHeaders->end(); ++header)
1142             request.clearHTTPHeaderField(WebString::fromUTF8(*header));
1143     }
1144
1145     string host = url.host();
1146     if (!host.empty() && (url.SchemeIs("http") || url.SchemeIs("https"))) {
1147         if (!isLocalhost(host) && !hostIsUsedBySomeTestsToGenerateError(host)
1148             && ((!mainDocumentURL.SchemeIs("http") && !mainDocumentURL.SchemeIs("https")) || isLocalhost(mainDocumentURL.host()))
1149             && !m_delegate->allowExternalPages()) {
1150             m_delegate->printMessage(string("Blocked access to external URL ") + requestURL + "\n");
1151             blockRequest(request);
1152             return;
1153         }
1154     }
1155
1156     // Set the new substituted URL.
1157     request.setURL(m_delegate->rewriteLayoutTestsURL(request.url().spec()));
1158 }
1159
1160 void WebTestProxyBase::didReceiveResponse(WebLocalFrame*, unsigned identifier, const blink::WebURLResponse& response)
1161 {
1162     if (m_testInterfaces->testRunner()->shouldDumpResourceLoadCallbacks()) {
1163         if (m_resourceIdentifierMap.find(identifier) == m_resourceIdentifierMap.end())
1164             m_delegate->printMessage("<unknown>");
1165         else
1166             m_delegate->printMessage(m_resourceIdentifierMap[identifier]);
1167         m_delegate->printMessage(" - didReceiveResponse ");
1168         printResponseDescription(m_delegate, response);
1169         m_delegate->printMessage("\n");
1170     }
1171     if (m_testInterfaces->testRunner()->shouldDumpResourceResponseMIMETypes()) {
1172         GURL url = response.url();
1173         WebString mimeType = response.mimeType();
1174         m_delegate->printMessage(url.ExtractFileName());
1175         m_delegate->printMessage(" has MIME type ");
1176         // Simulate NSURLResponse's mapping of empty/unknown MIME types to application/octet-stream
1177         m_delegate->printMessage(mimeType.isEmpty() ? "application/octet-stream" : mimeType.utf8().data());
1178         m_delegate->printMessage("\n");
1179     }
1180 }
1181
1182 void WebTestProxyBase::didChangeResourcePriority(WebLocalFrame*, unsigned identifier, const blink::WebURLRequest::Priority& priority, int intra_priority_value)
1183 {
1184     if (m_testInterfaces->testRunner()->shouldDumpResourcePriorities()) {
1185         if (m_resourceIdentifierMap.find(identifier) == m_resourceIdentifierMap.end())
1186             m_delegate->printMessage("<unknown>");
1187         else
1188             m_delegate->printMessage(m_resourceIdentifierMap[identifier]);
1189         m_delegate->printMessage(" changed priority to ");
1190         m_delegate->printMessage(PriorityDescription(priority));
1191         char buffer[64];
1192         snprintf(buffer, sizeof(buffer), ", intra_priority %d", intra_priority_value);
1193         m_delegate->printMessage(buffer);
1194         m_delegate->printMessage("\n");
1195     }
1196 }
1197
1198 void WebTestProxyBase::didFinishResourceLoad(WebLocalFrame*, unsigned identifier)
1199 {
1200     if (m_testInterfaces->testRunner()->shouldDumpResourceLoadCallbacks()) {
1201         if (m_resourceIdentifierMap.find(identifier) == m_resourceIdentifierMap.end())
1202             m_delegate->printMessage("<unknown>");
1203         else
1204             m_delegate->printMessage(m_resourceIdentifierMap[identifier]);
1205         m_delegate->printMessage(" - didFinishLoading\n");
1206     }
1207     m_resourceIdentifierMap.erase(identifier);
1208 }
1209
1210 void WebTestProxyBase::didAddMessageToConsole(const WebConsoleMessage& message, const WebString& sourceName, unsigned sourceLine)
1211 {
1212     // This matches win DumpRenderTree's UIDelegate.cpp.
1213     if (!m_logConsoleOutput)
1214         return;
1215     string level;
1216     switch (message.level) {
1217     case WebConsoleMessage::LevelDebug:
1218         level = "DEBUG";
1219         break;
1220     case WebConsoleMessage::LevelLog:
1221         level = "MESSAGE";
1222         break;
1223     case WebConsoleMessage::LevelInfo:
1224         level = "INFO";
1225         break;
1226     case WebConsoleMessage::LevelWarning:
1227         level = "WARNING";
1228         break;
1229     case WebConsoleMessage::LevelError:
1230         level = "ERROR";
1231         break;
1232     }
1233     m_delegate->printMessage(string("CONSOLE ") + level + ": ");
1234     if (sourceLine) {
1235         char buffer[40];
1236         snprintf(buffer, sizeof(buffer), "line %d: ", sourceLine);
1237         m_delegate->printMessage(buffer);
1238     }
1239     if (!message.text.isEmpty()) {
1240         string newMessage;
1241         newMessage = message.text.utf8();
1242         size_t fileProtocol = newMessage.find("file://");
1243         if (fileProtocol != string::npos) {
1244             newMessage = newMessage.substr(0, fileProtocol)
1245                 + urlSuitableForTestResult(newMessage.substr(fileProtocol));
1246         }
1247         m_delegate->printMessage(newMessage);
1248     }
1249     m_delegate->printMessage(string("\n"));
1250 }
1251
1252 void WebTestProxyBase::locationChangeDone(WebFrame* frame)
1253 {
1254     if (frame != m_testInterfaces->testRunner()->topLoadingFrame())
1255         return;
1256     m_testInterfaces->testRunner()->setTopLoadingFrame(frame, true);
1257 }
1258
1259 WebNavigationPolicy WebTestProxyBase::decidePolicyForNavigation(WebLocalFrame*, WebDataSource::ExtraData*, const WebURLRequest& request, WebNavigationType type, WebNavigationPolicy defaultPolicy, bool isRedirect)
1260 {
1261     WebNavigationPolicy result;
1262     if (!m_testInterfaces->testRunner()->policyDelegateEnabled())
1263         return defaultPolicy;
1264
1265     m_delegate->printMessage(string("Policy delegate: attempt to load ") + URLDescription(request.url()) + " with navigation type '" + webNavigationTypeToString(type) + "'\n");
1266     if (m_testInterfaces->testRunner()->policyDelegateIsPermissive())
1267         result = blink::WebNavigationPolicyCurrentTab;
1268     else
1269         result = blink::WebNavigationPolicyIgnore;
1270
1271     if (m_testInterfaces->testRunner()->policyDelegateShouldNotifyDone())
1272         m_testInterfaces->testRunner()->policyDelegateDone();
1273     return result;
1274 }
1275
1276 bool WebTestProxyBase::willCheckAndDispatchMessageEvent(WebLocalFrame*, WebFrame*, WebSecurityOrigin, WebDOMMessageEvent)
1277 {
1278     if (m_testInterfaces->testRunner()->shouldInterceptPostMessage()) {
1279         m_delegate->printMessage("intercepted postMessage\n");
1280         return true;
1281     }
1282
1283     return false;
1284 }
1285
1286 void WebTestProxyBase::postSpellCheckEvent(const WebString& eventName)
1287 {
1288     if (m_testInterfaces->testRunner()->shouldDumpSpellCheckCallbacks()) {
1289         m_delegate->printMessage(string("SpellCheckEvent: ") + eventName.utf8().data() + "\n");
1290     }
1291 }
1292
1293 void WebTestProxyBase::resetInputMethod()
1294 {
1295     // If a composition text exists, then we need to let the browser process
1296     // to cancel the input method's ongoing composition session.
1297     if (m_webWidget)
1298         m_webWidget->confirmComposition();
1299 }
1300
1301 }  // namespace content