Add basic support to dump pixel results

content/shell/layout_test_controller_host.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/shell/layout_test_controller_host.h"
 
 #include <iostream>
 
+#include "base/md5.h"
 #include "base/message_loop.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/shell/shell_messages.h"
+#include "webkit/support/webkit_support_gfx.h"
 
 namespace content {
 
 std::map<RenderViewHost*, LayoutTestControllerHost*>
     LayoutTestControllerHost::controllers_;
+std::string LayoutTestControllerHost::expected_pixel_hash_;
 
 // static
 LayoutTestControllerHost* LayoutTestControllerHost::FromRenderViewHost(
     RenderViewHost* render_view_host) {
   const std::map<RenderViewHost*, LayoutTestControllerHost*>::iterator it =
       controllers_.find(render_view_host);
   if (it == controllers_.end())
     return NULL;
   return it->second;
 }
 
+// static
+void LayoutTestControllerHost::Init(const std::string& expected_pixel_hash) {
+  // TODO(jochen): We should only dump the results for the "main window".
+  expected_pixel_hash_ = expected_pixel_hash_;

[marja, 2012/06/26 13:32:44]

This NOOP line is probably not what you want (extra _).

[jochen (gone - plz use gerrit), 2012/06/26 13:38:55]

Done.

+}
+
 LayoutTestControllerHost::LayoutTestControllerHost(
     RenderViewHost* render_view_host)
     : RenderViewHostObserver(render_view_host),
       dump_as_text_(false),
       dump_child_frames_(false),
       is_printing_(false),
       should_stay_on_page_after_handling_before_unload_(false),
       wait_until_done_(false) {
   controllers_[render_view_host] = this;
 }
 
 LayoutTestControllerHost::~LayoutTestControllerHost() {
   controllers_.erase(render_view_host());
 }
 
 void LayoutTestControllerHost::CaptureDump() {
   render_view_host()->Send(
       new ShellViewMsg_CaptureTextDump(render_view_host()->GetRoutingID(),
                                        dump_as_text_,
                                        is_printing_,
                                        dump_child_frames_));
+  if (!dump_as_text_) {
+    render_view_host()->Send(
+        new ShellViewMsg_CaptureImageDump(render_view_host()->GetRoutingID()));
+  }
 }
 
 bool LayoutTestControllerHost::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(LayoutTestControllerHost, message)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_DidFinishLoad, OnDidFinishLoad)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_TextDump, OnTextDump)
+    IPC_MESSAGE_HANDLER(ShellViewHostMsg_ImageDump, OnImageDump)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_NotifyDone, OnNotifyDone)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_DumpAsText, OnDumpAsText)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_DumpChildFramesAsText,
                         OnDumpChildFramesAsText)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_SetPrinting, OnSetPrinting)
     IPC_MESSAGE_HANDLER(
         ShellViewHostMsg_SetShouldStayOnPageAfterHandlingBeforeUnload,
         OnSetShouldStayOnPageAfterHandlingBeforeUnload)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_WaitUntilDone, OnWaitUntilDone)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 void LayoutTestControllerHost::OnDidFinishLoad() {
   if (wait_until_done_)
     return;
 
   CaptureDump();
 }
 
 void LayoutTestControllerHost::OnTextDump(const std::string& dump) {
   std::cout << dump;
   std::cout << "#EOF\n";
   std::cerr << "#EOF\n";
 
+  if (dump_as_text_)
+    MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+}
+
+void LayoutTestControllerHost::OnImageDump(const SkBitmap& image) {
+  SkAutoLockPixels image_lock(image);
+  base::MD5Digest digest;
+  base::MD5Sum(reinterpret_cast<void*>(image.getPixels()),
+               image.getSize(),
+               &digest);
+  std::string actual_pixel_hash = base::MD5DigestToBase16(digest);
+
+  std::cout << "\nActualHash: " << actual_pixel_hash << "\n";
+  if (!expected_pixel_hash_.empty())
+    std::cout << "\nExpectedHash: " << expected_pixel_hash_ << "\n";
+
+  // Only encode and dump the png if the hashes don't match. Encoding the
+  // image is really expensive.
+  if (actual_pixel_hash != expected_pixel_hash_) {
+    std::vector<unsigned char> png;
+
+    // Only the expected PNGs for Mac have a valid alpha channel.
+#if defined(OS_MACOSX)
+    bool discard_transparency = false;
+#else
+    bool discard_transparency = true;
+#endif
+
+#if !defined(OS_ANDROID)
+    // DumpRenderTree is not currently supported for Android. Also, Android
+    // uses a different byte order, so this method is not implemented on
+    // Android.
+    webkit_support::EncodeBGRAPNGWithChecksum(
+        reinterpret_cast<const unsigned char*>(image.getPixels()),
+        image.width(),
+        image.height(),
+        static_cast<int>(image.rowBytes()),
+        discard_transparency,
+        actual_pixel_hash,
+        &png);
+#endif
+
+    std::cout << "Content-Type: image/png\n";
+    std::cout << "Content-Length: " << png.size() << "\n";
+    std::cout.write(reinterpret_cast<const char*>(&png[0]), png.size());
+  }
+
   MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
 void LayoutTestControllerHost::OnNotifyDone() {
   CaptureDump();
 }
 
 void LayoutTestControllerHost::OnDumpAsText() {
   dump_as_text_ = true;
 }
 
 void LayoutTestControllerHost::OnSetPrinting() {
   is_printing_ = true;
 }
 
 void LayoutTestControllerHost::OnSetShouldStayOnPageAfterHandlingBeforeUnload(
     bool should_stay_on_page) {
   should_stay_on_page_after_handling_before_unload_ = should_stay_on_page;
 }
 
 void LayoutTestControllerHost::OnDumpChildFramesAsText() {
   dump_child_frames_ = true;
 }
 
 void LayoutTestControllerHost::OnWaitUntilDone() {
   wait_until_done_ = true;
 }
 
 }  // namespace content