Revert 107645 (To see if it was responsible for increase in static initializers) - Fix test snaps...

chrome/test/automation/automation_proxy_uitest.cc

 // Copyright (c) 2011 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 <string>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/i18n/rtl.h"
 #include "base/json/json_value_serializer.h"
-#include "base/md5.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/test/test_timeouts.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/ui/view_ids.h"
@@ skipping 1499 matching lines @@
   AutomationProxySnapshotTest() {
     dom_automation_enabled_ = true;
     if (!snapshot_dir_.CreateUniqueTempDir())
       ADD_FAILURE() << "Unable to create temporary directory";
     else
       snapshot_path_ = snapshot_dir_.path().AppendASCII("snapshot.png");
   }
 
   // Asserts that the given png file can be read and decoded into the given
   // bitmap.
-  void AssertReadPNG(const FilePath& filename, std::string* data) {
+  void AssertReadPNG(const FilePath& filename, SkBitmap* bitmap) {
+    DCHECK(bitmap);
     ASSERT_TRUE(file_util::PathExists(filename));
 
     int64 size64;
     ASSERT_TRUE(file_util::GetFileSize(filename, &size64));
     // Check that the file is not too big to read in (less than 100 MB).
     ASSERT_LT(size64, 1024 * 1024 * 100);
 
     // Read and decode image.
     int size = static_cast<int>(size64);
-    data->resize(size);
-    int bytes_read = file_util::ReadFile(filename, &(*data)[0], size);
+    scoped_array<char> data(new char[size]);
+    int bytes_read = file_util::ReadFile(filename, &data[0], size);
     ASSERT_EQ(size, bytes_read);
+    ASSERT_TRUE(gfx::PNGCodec::Decode(
+        reinterpret_cast<unsigned char*>(&data[0]),
+        bytes_read,
+        bitmap));
   }
 
   // Returns the file path for the directory for these tests appended with
   // the given relative path.
   FilePath GetTestFilePath(const std::string& relative_path) {
     FilePath filename(test_data_directory_);
     return filename.AppendASCII("automation_proxy_snapshot")
         .AppendASCII(relative_path);
   }
 
   GURL GetTestUrl(const std::string& relative_path, const std::string& query) {
     FilePath file_path = GetTestFilePath(relative_path);
     return ui_test_utils::GetFileUrlWithQuery(file_path, query);
   }
 
   FilePath snapshot_path_;
   ScopedTempDir snapshot_dir_;
 };
 
+// See http://crbug.com/63022.
+#if defined(OS_LINUX)
+#define MAYBE_ContentLargerThanView FAILS_ContentLargerThanView
+#else
+#define MAYBE_ContentLargerThanView ContentLargerThanView
+#endif
 // Tests that taking a snapshot when the content is larger than the view
 // produces a snapshot equal to the content size.
-TEST_F(AutomationProxySnapshotTest, ContentLargerThanView) {
-  const char kReferenceMd5[] = "3d594850fd25cb116338cb3610afe18e";
+TEST_F(AutomationProxySnapshotTest, MAYBE_ContentLargerThanView) {
   scoped_refptr<BrowserProxy> browser(automation()->GetBrowserWindow(0));
   ASSERT_TRUE(browser.get());
+
+  // Resize the window to guarantee that the content is larger than the view.
+  scoped_refptr<WindowProxy> window(browser->GetWindow());
+  ASSERT_TRUE(window.get());
+  ASSERT_TRUE(window->SetBounds(gfx::Rect(300, 400)));
+
   scoped_refptr<TabProxy> tab(browser->GetTab(0));
   ASSERT_TRUE(tab.get());
 
   ASSERT_EQ(AUTOMATION_MSG_NAVIGATION_SUCCESS,
-            tab->NavigateToURL(GetTestUrl("set_size.html", "2000,2500")));
+            tab->NavigateToURL(GetTestUrl("set_size.html", "600,800")));
 
   ASSERT_TRUE(tab->CaptureEntirePageAsPNG(snapshot_path_));
 
-  std::string data;
-  ASSERT_NO_FATAL_FAILURE(AssertReadPNG(snapshot_path_, &data));
-  EXPECT_STREQ(kReferenceMd5, base::MD5String(data).c_str());
-  if (CommandLine::ForCurrentProcess()->HasSwitch("dump-test-image")) {
-    FilePath path(FILE_PATH_LITERAL("snapshot.png"));
-    EXPECT_EQ(file_util::WriteFile(path, &data[0], data.length()),
-              static_cast<int>(data.length()));
+  SkBitmap bitmap;
+  ASSERT_NO_FATAL_FAILURE(AssertReadPNG(snapshot_path_, &bitmap));
+  ASSERT_EQ(600, bitmap.width());
+  ASSERT_EQ(800, bitmap.height());
+}
+
+// Tests taking a large snapshot works.
+#if defined(OS_LINUX)
+// See http://code.google.com/p/chromium/issues/detail?id=89777
+#define MAYBE_LargeSnapshot DISABLED_LargeSnapshot
+#else
+#define MAYBE_LargeSnapshot LargeSnapshot
+#endif
+TEST_F(AutomationProxySnapshotTest, MAYBE_LargeSnapshot) {
+  scoped_refptr<BrowserProxy> browser(automation()->GetBrowserWindow(0));
+  ASSERT_TRUE(browser.get());
+
+  scoped_refptr<TabProxy> tab(browser->GetTab(0));
+  ASSERT_TRUE(tab.get());
+
+  // 2000x2000 creates an approximately 15 MB bitmap.
+  // Don't increase this too much. At least my linux box has SHMMAX set at
+  // 32 MB.
+  ASSERT_EQ(AUTOMATION_MSG_NAVIGATION_SUCCESS,
+            tab->NavigateToURL(GetTestUrl("set_size.html", "2000,2000")));
+
+  ASSERT_TRUE(tab->CaptureEntirePageAsPNG(snapshot_path_));
+
+  SkBitmap bitmap;
+  ASSERT_NO_FATAL_FAILURE(AssertReadPNG(snapshot_path_, &bitmap));
+  ASSERT_EQ(2000, bitmap.width());
+  ASSERT_EQ(2000, bitmap.height());
+}
+
+#if defined(OS_MACOSX)
+// Most pixels on mac are slightly off.
+#define MAYBE_ContentsCorrect DISABLED_ContentsCorrect
+#elif defined(OS_LINUX)
+// See http://crbug.com/63022.
+#define MAYBE_ContentsCorrect FAILS_ContentsCorrect
+#else
+#define MAYBE_ContentsCorrect ContentsCorrect
+#endif
+
+// Tests that the snapshot contents are correct.
+TEST_F(AutomationProxySnapshotTest, MAYBE_ContentsCorrect) {
+  scoped_refptr<BrowserProxy> browser(automation()->GetBrowserWindow(0));
+  ASSERT_TRUE(browser.get());
+
+  const gfx::Size img_size(400, 300);
+  scoped_refptr<WindowProxy> window(browser->GetWindow());
+  ASSERT_TRUE(window.get());
+  ASSERT_TRUE(window->SetBounds(gfx::Rect(img_size)));
+
+  scoped_refptr<TabProxy> tab(browser->GetTab(0));
+  ASSERT_TRUE(tab.get());
+
+  ASSERT_EQ(AUTOMATION_MSG_NAVIGATION_SUCCESS,
+            tab->NavigateToURL(GetTestUrl("just_image.html", "")));
+
+  ASSERT_TRUE(tab->CaptureEntirePageAsPNG(snapshot_path_));
+
+  SkBitmap snapshot_bmp;
+  ASSERT_NO_FATAL_FAILURE(AssertReadPNG(snapshot_path_, &snapshot_bmp));
+  ASSERT_EQ(img_size.width(), snapshot_bmp.width());
+  ASSERT_EQ(img_size.height(), snapshot_bmp.height());
+
+  SkBitmap reference_bmp;
+  ASSERT_NO_FATAL_FAILURE(AssertReadPNG(GetTestFilePath("image.png"),
+                                        &reference_bmp));
+  ASSERT_EQ(img_size.width(), reference_bmp.width());
+  ASSERT_EQ(img_size.height(), reference_bmp.height());
+
+  SkAutoLockPixels lock_snapshot(snapshot_bmp);
+  SkAutoLockPixels lock_reference(reference_bmp);
+  int diff_pixels_count = 0;
+  for (int x = 0; x < img_size.width(); ++x) {
+    for (int y = 0; y < img_size.height(); ++y) {
+      if (*snapshot_bmp.getAddr32(x, y) != *reference_bmp.getAddr32(x, y)) {
+        ++diff_pixels_count;
+      }
+    }
   }
+  ASSERT_EQ(diff_pixels_count, 0);
 }