Enable components_browsertests on Android

components/printing/test/print_web_view_helper_browsertest.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 "base/command_line.h"
 #include "base/run_loop.h"
 #include "components/printing/common/print_messages.h"
 #include "components/printing/renderer/print_web_view_helper.h"
 #include "components/printing/test/mock_printer.h"
 #include "components/printing/test/print_mock_render_thread.h"
@@ skipping 230 matching lines @@
     PrintWebViewHelper::Get(view_)->OnPrintForPrintPreview(dict);
     ProcessPendingMessages();
   }
 
   // Naked pointer as ownership is with content::RenderViewTest::render_thread_.
   PrintMockRenderThread* print_render_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(PrintWebViewHelperTestBase);
 };
 
-class PrintWebViewHelperTest : public PrintWebViewHelperTestBase {
+// RenderVIewTest-based tests crash on Android
+// http://crbug.com/187500
+#if defined(OS_ANDROID)
+#define MAYBE_PrintWebViewHelperTest DISABLED_PrintWebViewHelperTest
+#else
+#define MAYBE_PrintWebViewHelperTest PrintWebViewHelperTest
+#endif  // defined(OS_ANDROID)
+
+class MAYBE_PrintWebViewHelperTest : public PrintWebViewHelperTestBase {
  public:
-  PrintWebViewHelperTest() {}
-  ~PrintWebViewHelperTest() override {}
+  MAYBE_PrintWebViewHelperTest() {}
+  ~MAYBE_PrintWebViewHelperTest() override {}
 
   void SetUp() override { PrintWebViewHelperTestBase::SetUp(); }
 
  protected:
-  DISALLOW_COPY_AND_ASSIGN(PrintWebViewHelperTest);
+  DISALLOW_COPY_AND_ASSIGN(MAYBE_PrintWebViewHelperTest);
 };
 
 // This tests only for platforms without print preview.
 #if !defined(ENABLE_PRINT_PREVIEW)
 // Tests that the renderer blocks window.print() calls if they occur too
 // frequently.
-TEST_F(PrintWebViewHelperTest, BlockScriptInitiatedPrinting) {
+TEST_F(MAYBE_PrintWebViewHelperTest, BlockScriptInitiatedPrinting) {
   // Pretend user will cancel printing.
   print_render_thread_->set_print_dialog_user_response(false);
   // Try to print with window.print() a few times.
   PrintWithJavaScript();
   PrintWithJavaScript();
   PrintWithJavaScript();
   VerifyPagesPrinted(false);
 
   // Pretend user will print. (but printing is blocked.)
   print_render_thread_->set_print_dialog_user_response(true);
   PrintWithJavaScript();
   VerifyPagesPrinted(false);
 
   // Unblock script initiated printing and verify printing works.
   PrintWebViewHelper::Get(view_)->scripting_throttler_.Reset();
   print_render_thread_->printer()->ResetPrinter();
   PrintWithJavaScript();
   VerifyPageCount(1);
   VerifyPagesPrinted(true);
 }
 
 // Tests that the renderer always allows window.print() calls if they are user
 // initiated.
-TEST_F(PrintWebViewHelperTest, AllowUserOriginatedPrinting) {
+TEST_F(MAYBE_PrintWebViewHelperTest, AllowUserOriginatedPrinting) {
   // Pretend user will cancel printing.
   print_render_thread_->set_print_dialog_user_response(false);
   // Try to print with window.print() a few times.
   PrintWithJavaScript();
   PrintWithJavaScript();
   PrintWithJavaScript();
   VerifyPagesPrinted(false);
 
   // Pretend user will print. (but printing is blocked.)
   print_render_thread_->set_print_dialog_user_response(true);
@@ skipping 17 matching lines @@
   SendWebMouseEvent(mouse_event);
   mouse_event.type = blink::WebInputEvent::MouseUp;
   SendWebMouseEvent(mouse_event);
   ProcessPendingMessages();
 
   VerifyPageCount(1);
   VerifyPagesPrinted(true);
 }
 
 // Duplicate of OnPrintPagesTest only using javascript to print.
-TEST_F(PrintWebViewHelperTest, PrintWithJavascript) {
+TEST_F(MAYBE_PrintWebViewHelperTest, PrintWithJavascript) {
   PrintWithJavaScript();
 
   VerifyPageCount(1);
   VerifyPagesPrinted(true);
 }
 #endif  // !ENABLE_PRINT_PREVIEW
 
 #if defined(ENABLE_BASIC_PRINTING)
 // Tests that printing pages work and sending and receiving messages through
 // that channel all works.
-TEST_F(PrintWebViewHelperTest, OnPrintPages) {
+TEST_F(MAYBE_PrintWebViewHelperTest, OnPrintPages) {
   LoadHTML(kHelloWorldHTML);
   OnPrintPages();
 
   VerifyPageCount(1);
   VerifyPagesPrinted(true);
 }
 #endif  // ENABLE_BASIC_PRINTING
 
 #if defined(OS_MACOSX) && defined(ENABLE_BASIC_PRINTING)
 // TODO(estade): I don't think this test is worth porting to Linux. We will have
 // to rip out and replace most of the IPC code if we ever plan to improve
 // printing, and the comment below by sverrir suggests that it doesn't do much
 // for us anyway.
-TEST_F(PrintWebViewHelperTest, PrintWithIframe) {
+TEST_F(MAYBE_PrintWebViewHelperTest, PrintWithIframe) {
   // Document that populates an iframe.
   const char html[] =
       "<html><body>Lorem Ipsum:"
       "<iframe name=\"sub1\" id=\"sub1\"></iframe><script>"
       "  document.write(frames['sub1'].name);"
       "  frames['sub1'].document.write("
       "      '<p>Cras tempus ante eu felis semper luctus!</p>');"
       "  frames['sub1'].document.close();"
       "</script></body></html>";
 
@@ skipping 69 matching lines @@
     },
 };
 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
 }  // namespace
 
 // TODO(estade): need to port MockPrinter to get this on Linux. This involves
 // hooking up Cairo to read a pdf stream, or accessing the cairo surface in the
 // metafile directly.
 // Same for printing via PDF on Windows.
 #if defined(OS_MACOSX) && defined(ENABLE_BASIC_PRINTING)
-TEST_F(PrintWebViewHelperTest, PrintLayoutTest) {
+TEST_F(MAYBE_PrintWebViewHelperTest, PrintLayoutTest) {
   bool baseline = false;
 
   EXPECT_TRUE(print_render_thread_->printer() != NULL);
   for (size_t i = 0; i < arraysize(kTestPages); ++i) {
     // Load an HTML page and print it.
     LoadHTML(kTestPages[i].page);
     OnPrintPages();
     VerifyPagesPrinted(true);
 
     // MockRenderThread::Send() just calls MockRenderThread::OnReceived().
@@ skipping 35 matching lines @@
       base::FilePath bitmap_path;
       base::CreateTemporaryFile(&bitmap_path);
       print_render_thread_->printer()->SaveBitmap(0, bitmap_path);
     }
   }
 }
 #endif  // OS_MACOSX && ENABLE_BASIC_PRINTING
 
 // These print preview tests do not work on Chrome OS yet.
 #if !defined(OS_CHROMEOS)
-class PrintWebViewHelperPreviewTest : public PrintWebViewHelperTestBase {
+
+// RenderVIewTest-based tests crash on Android
+// http://crbug.com/187500
+#if defined(OS_ANDROID)
+#define MAYBE_PrintWebViewHelperPreviewTest \
+  DISABLED_PrintWebViewHelperPreviewTest
+#else
+#define MAYBE_PrintWebViewHelperPreviewTest PrintWebViewHelperPreviewTest
+#endif  // defined(OS_ANDROID)
+
+class MAYBE_PrintWebViewHelperPreviewTest : public PrintWebViewHelperTestBase {
  public:
-  PrintWebViewHelperPreviewTest() {}
-  ~PrintWebViewHelperPreviewTest() override {}
+  MAYBE_PrintWebViewHelperPreviewTest() {}
+  ~MAYBE_PrintWebViewHelperPreviewTest() override {}
 
  protected:
   void VerifyPrintPreviewCancelled(bool did_cancel) {
     bool print_preview_cancelled =
         (render_thread_->sink().GetUniqueMessageMatching(
              PrintHostMsg_PrintPreviewCancelled::ID) != NULL);
     EXPECT_EQ(did_cancel, print_preview_cancelled);
   }
 
   void VerifyPrintPreviewFailed(bool did_fail) {
@@ skipping 71 matching lines @@
       EXPECT_EQ(content_width, get<0>(param).content_width);
       EXPECT_EQ(content_height, get<0>(param).content_height);
       EXPECT_EQ(margin_top, get<0>(param).margin_top);
       EXPECT_EQ(margin_right, get<0>(param).margin_right);
       EXPECT_EQ(margin_left, get<0>(param).margin_left);
       EXPECT_EQ(margin_bottom, get<0>(param).margin_bottom);
       EXPECT_EQ(page_has_print_css, get<2>(param));
     }
   }
 
-  DISALLOW_COPY_AND_ASSIGN(PrintWebViewHelperPreviewTest);
+  DISALLOW_COPY_AND_ASSIGN(MAYBE_PrintWebViewHelperPreviewTest);
 };
 
 #if defined(ENABLE_PRINT_PREVIEW)
-TEST_F(PrintWebViewHelperPreviewTest, BlockScriptInitiatedPrinting) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest, BlockScriptInitiatedPrinting) {
   LoadHTML(kHelloWorldHTML);
   PrintWebViewHelper* print_web_view_helper = PrintWebViewHelper::Get(view_);
   print_web_view_helper->SetScriptedPrintBlocked(true);
   PrintWithJavaScript();
   VerifyPreviewRequest(false);
 
   print_web_view_helper->SetScriptedPrintBlocked(false);
   PrintWithJavaScript();
   VerifyPreviewRequest(true);
 }
 
-TEST_F(PrintWebViewHelperPreviewTest, PrintWithJavaScript) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest, PrintWithJavaScript) {
   LoadHTML(kPrintOnUserAction);
   gfx::Size new_size(200, 100);
   Resize(new_size, gfx::Rect(), false);
 
   gfx::Rect bounds = GetElementBounds("print");
   EXPECT_FALSE(bounds.IsEmpty());
   blink::WebMouseEvent mouse_event;
   mouse_event.type = blink::WebInputEvent::MouseDown;
   mouse_event.button = blink::WebMouseEvent::ButtonLeft;
   mouse_event.x = bounds.CenterPoint().x();
   mouse_event.y = bounds.CenterPoint().y();
   mouse_event.clickCount = 1;
   SendWebMouseEvent(mouse_event);
   mouse_event.type = blink::WebInputEvent::MouseUp;
   SendWebMouseEvent(mouse_event);
 
   VerifyPreviewRequest(true);
 }
 #endif  // ENABLE_PRINT_PREVIEW
 
 // Tests that print preview work and sending and receiving messages through
 // that channel all works.
-TEST_F(PrintWebViewHelperPreviewTest, OnPrintPreview) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest, OnPrintPreview) {
   LoadHTML(kHelloWorldHTML);
 
   // Fill in some dummy values.
   base::DictionaryValue dict;
   CreatePrintSettingsDictionary(&dict);
   OnPrintPreview(dict);
 
   EXPECT_EQ(0, print_render_thread_->print_preview_pages_remaining());
   VerifyDefaultPageLayout(540, 720, 36, 36, 36, 36, false);
   VerifyPrintPreviewCancelled(false);
   VerifyPrintPreviewFailed(false);
   VerifyPrintPreviewGenerated(true);
   VerifyPagesPrinted(false);
 }
 
-TEST_F(PrintWebViewHelperPreviewTest, PrintPreviewHTMLWithPageMarginsCss) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest,
+       PrintPreviewHTMLWithPageMarginsCss) {
   // A simple web page with print margins css.
   const char kHTMLWithPageMarginsCss[] =
       "<html><head><style>"
       "@media print {"
       "  @page {"
       "     margin: 3in 1in 2in 0.3in;"
       "  }"
       "}"
       "</style></head>"
       "<body>Lorem Ipsum:"
@@ skipping 10 matching lines @@
   EXPECT_EQ(0, print_render_thread_->print_preview_pages_remaining());
   VerifyDefaultPageLayout(519, 432, 216, 144, 21, 72, false);
   VerifyPrintPreviewCancelled(false);
   VerifyPrintPreviewFailed(false);
   VerifyPrintPreviewGenerated(true);
   VerifyPagesPrinted(false);
 }
 
 // Test to verify that print preview ignores print media css when non-default
 // margin is selected.
-TEST_F(PrintWebViewHelperPreviewTest, NonDefaultMarginsSelectedIgnorePrintCss) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest,
+       NonDefaultMarginsSelectedIgnorePrintCss) {
   LoadHTML(kHTMLWithPageSizeCss);
 
   // Fill in some dummy values.
   base::DictionaryValue dict;
   CreatePrintSettingsDictionary(&dict);
   dict.SetBoolean(kSettingPrintToPDF, false);
   dict.SetInteger(kSettingMarginsType, NO_MARGINS);
   OnPrintPreview(dict);
 
   EXPECT_EQ(0, print_render_thread_->print_preview_pages_remaining());
   VerifyDefaultPageLayout(612, 792, 0, 0, 0, 0, true);
   VerifyPrintPreviewCancelled(false);
   VerifyPrintPreviewFailed(false);
   VerifyPrintPreviewGenerated(true);
   VerifyPagesPrinted(false);
 }
 
 // Test to verify that print preview honor print media size css when
 // PRINT_TO_PDF is selected and doesn't fit to printer default paper size.
-TEST_F(PrintWebViewHelperPreviewTest, PrintToPDFSelectedHonorPrintCss) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest, PrintToPDFSelectedHonorPrintCss) {
   LoadHTML(kHTMLWithPageSizeCss);
 
   // Fill in some dummy values.
   base::DictionaryValue dict;
   CreatePrintSettingsDictionary(&dict);
   dict.SetBoolean(kSettingPrintToPDF, true);
   dict.SetInteger(kSettingMarginsType, PRINTABLE_AREA_MARGINS);
   OnPrintPreview(dict);
 
   EXPECT_EQ(0, print_render_thread_->print_preview_pages_remaining());
   // Since PRINT_TO_PDF is selected, pdf page size is equal to print media page
   // size.
   VerifyDefaultPageLayout(252, 252, 18, 18, 18, 18, true);
   VerifyPrintPreviewCancelled(false);
   VerifyPrintPreviewFailed(false);
 }
 
 // Test to verify that print preview honor print margin css when PRINT_TO_PDF
 // is selected and doesn't fit to printer default paper size.
-TEST_F(PrintWebViewHelperPreviewTest, PrintToPDFSelectedHonorPageMarginsCss) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest,
+       PrintToPDFSelectedHonorPageMarginsCss) {
   // A simple web page with print margins css.
   const char kHTMLWithPageCss[] =
       "<html><head><style>"
       "@media print {"
       "  @page {"
       "     margin: 3in 1in 2in 0.3in;"
       "     size: 14in 14in;"
       "  }"
       "}"
       "</style></head>"
@@ skipping 11 matching lines @@
   EXPECT_EQ(0, print_render_thread_->print_preview_pages_remaining());
   // Since PRINT_TO_PDF is selected, pdf page size is equal to print media page
   // size.
   VerifyDefaultPageLayout(915, 648, 216, 144, 21, 72, true);
   VerifyPrintPreviewCancelled(false);
   VerifyPrintPreviewFailed(false);
 }
 
 // Test to verify that print preview workflow center the html page contents to
 // fit the page size.
-TEST_F(PrintWebViewHelperPreviewTest, PrintPreviewCenterToFitPage) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest, PrintPreviewCenterToFitPage) {
   LoadHTML(kHTMLWithPageSizeCss);
 
   // Fill in some dummy values.
   base::DictionaryValue dict;
   CreatePrintSettingsDictionary(&dict);
   dict.SetBoolean(kSettingPrintToPDF, false);
   dict.SetInteger(kSettingMarginsType, DEFAULT_MARGINS);
   OnPrintPreview(dict);
 
   EXPECT_EQ(0, print_render_thread_->print_preview_pages_remaining());
   VerifyDefaultPageLayout(216, 216, 288, 288, 198, 198, true);
   VerifyPrintPreviewCancelled(false);
   VerifyPrintPreviewFailed(false);
   VerifyPrintPreviewGenerated(true);
 }
 
 // Test to verify that print preview workflow scale the html page contents to
 // fit the page size.
-TEST_F(PrintWebViewHelperPreviewTest, PrintPreviewShrinkToFitPage) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest, PrintPreviewShrinkToFitPage) {
   // A simple web page with print margins css.
   const char kHTMLWithPageCss[] =
       "<html><head><style>"
       "@media print {"
       "  @page {"
       "     size: 15in 17in;"
       "  }"
       "}"
       "</style></head>"
       "<body>Lorem Ipsum:"
       "</body></html>";
   LoadHTML(kHTMLWithPageCss);
 
   // Fill in some dummy values.
   base::DictionaryValue dict;
   CreatePrintSettingsDictionary(&dict);
   dict.SetBoolean(kSettingPrintToPDF, false);
   dict.SetInteger(kSettingMarginsType, DEFAULT_MARGINS);
   OnPrintPreview(dict);
 
   EXPECT_EQ(0, print_render_thread_->print_preview_pages_remaining());
   VerifyDefaultPageLayout(571, 652, 69, 71, 20, 21, true);
   VerifyPrintPreviewCancelled(false);
   VerifyPrintPreviewFailed(false);
 }
 
 // Test to verify that print preview workflow honor the orientation settings
 // specified in css.
-TEST_F(PrintWebViewHelperPreviewTest, PrintPreviewHonorsOrientationCss) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest, PrintPreviewHonorsOrientationCss) {
   LoadHTML(kHTMLWithLandscapePageCss);
 
   // Fill in some dummy values.
   base::DictionaryValue dict;
   CreatePrintSettingsDictionary(&dict);
   dict.SetBoolean(kSettingPrintToPDF, false);
   dict.SetInteger(kSettingMarginsType, NO_MARGINS);
   OnPrintPreview(dict);
 
   EXPECT_EQ(0, print_render_thread_->print_preview_pages_remaining());
   VerifyDefaultPageLayout(792, 612, 0, 0, 0, 0, true);
   VerifyPrintPreviewCancelled(false);
   VerifyPrintPreviewFailed(false);
 }
 
 // Test to verify that print preview workflow honors the orientation settings
 // specified in css when PRINT_TO_PDF is selected.
-TEST_F(PrintWebViewHelperPreviewTest, PrintToPDFSelectedHonorOrientationCss) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest,
+       PrintToPDFSelectedHonorOrientationCss) {
   LoadHTML(kHTMLWithLandscapePageCss);
 
   // Fill in some dummy values.
   base::DictionaryValue dict;
   CreatePrintSettingsDictionary(&dict);
   dict.SetBoolean(kSettingPrintToPDF, true);
   dict.SetInteger(kSettingMarginsType, CUSTOM_MARGINS);
   OnPrintPreview(dict);
 
   EXPECT_EQ(0, print_render_thread_->print_preview_pages_remaining());
   VerifyDefaultPageLayout(748, 568, 21, 23, 21, 23, true);
   VerifyPrintPreviewCancelled(false);
   VerifyPrintPreviewFailed(false);
 }
 
 // Test to verify that complete metafile is generated for a subset of pages
 // without creating draft pages.
-TEST_F(PrintWebViewHelperPreviewTest, OnPrintPreviewForSelectedPages) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest, OnPrintPreviewForSelectedPages) {
   LoadHTML(kMultipageHTML);
 
   // Fill in some dummy values.
   base::DictionaryValue dict;
   CreatePrintSettingsDictionary(&dict);
 
   // Set a page range and update the dictionary to generate only the complete
   // metafile with the selected pages. Page numbers used in the dictionary
   // are 1-based.
   base::DictionaryValue* page_range = new base::DictionaryValue();
@@ skipping 12 matching lines @@
   VerifyDidPreviewPage(false, 1);
   VerifyDidPreviewPage(false, 2);
   VerifyPreviewPageCount(3);
   VerifyPrintPreviewCancelled(false);
   VerifyPrintPreviewFailed(false);
   VerifyPrintPreviewGenerated(true);
   VerifyPagesPrinted(false);
 }
 
 // Test to verify that preview generated only for one page.
-TEST_F(PrintWebViewHelperPreviewTest, OnPrintPreviewForSelectedText) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest, OnPrintPreviewForSelectedText) {
   LoadHTML(kMultipageHTML);
   GetMainFrame()->selectRange(
       blink::WebRange::fromDocumentRange(GetMainFrame(), 1, 3));
 
   // Fill in some dummy values.
   base::DictionaryValue dict;
   CreatePrintSettingsDictionary(&dict);
   dict.SetBoolean(kSettingShouldPrintSelectionOnly, true);
 
   OnPrintPreview(dict);
 
   VerifyPreviewPageCount(1);
   VerifyPrintPreviewCancelled(false);
   VerifyPrintPreviewFailed(false);
   VerifyPrintPreviewGenerated(true);
   VerifyPagesPrinted(false);
 }
 
 // Tests that print preview fails and receiving error messages through
 // that channel all works.
-TEST_F(PrintWebViewHelperPreviewTest, OnPrintPreviewFail) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest, OnPrintPreviewFail) {
   LoadHTML(kHelloWorldHTML);
 
   // An empty dictionary should fail.
   base::DictionaryValue empty_dict;
   OnPrintPreview(empty_dict);
 
   EXPECT_EQ(0, print_render_thread_->print_preview_pages_remaining());
   VerifyPrintPreviewCancelled(false);
   VerifyPrintPreviewFailed(true);
   VerifyPrintPreviewGenerated(false);
   VerifyPagesPrinted(false);
 }
 
 // Tests that cancelling print preview works.
-TEST_F(PrintWebViewHelperPreviewTest, OnPrintPreviewCancel) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest, OnPrintPreviewCancel) {
   LoadHTML(kLongPageHTML);
 
   const int kCancelPage = 3;
   print_render_thread_->set_print_preview_cancel_page_number(kCancelPage);
   // Fill in some dummy values.
   base::DictionaryValue dict;
   CreatePrintSettingsDictionary(&dict);
   OnPrintPreview(dict);
 
   EXPECT_EQ(kCancelPage, print_render_thread_->print_preview_pages_remaining());
   VerifyPrintPreviewCancelled(true);
   VerifyPrintPreviewFailed(false);
   VerifyPrintPreviewGenerated(false);
   VerifyPagesPrinted(false);
 }
 
 // Tests that printing from print preview works and sending and receiving
 // messages through that channel all works.
-TEST_F(PrintWebViewHelperPreviewTest, OnPrintForPrintPreview) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest, OnPrintForPrintPreview) {
   LoadHTML(kPrintPreviewHTML);
 
   // Fill in some dummy values.
   base::DictionaryValue dict;
   CreatePrintSettingsDictionary(&dict);
   OnPrintForPrintPreview(dict);
 
   VerifyPrintFailed(false);
   VerifyPagesPrinted(true);
 }
 
 // Tests that printing from print preview fails and receiving error messages
 // through that channel all works.
-TEST_F(PrintWebViewHelperPreviewTest, OnPrintForPrintPreviewFail) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest, OnPrintForPrintPreviewFail) {
   LoadHTML(kPrintPreviewHTML);
 
   // An empty dictionary should fail.
   base::DictionaryValue empty_dict;
   OnPrintForPrintPreview(empty_dict);
 
   VerifyPagesPrinted(false);
 }
 
 // Tests that when default printer has invalid printer settings, print preview
 // receives error message.
-TEST_F(PrintWebViewHelperPreviewTest,
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest,
        OnPrintPreviewUsingInvalidPrinterSettings) {
   LoadHTML(kPrintPreviewHTML);
 
   // Set mock printer to provide invalid settings.
   print_render_thread_->printer()->UseInvalidSettings();
 
   // Fill in some dummy values.
   base::DictionaryValue dict;
   CreatePrintSettingsDictionary(&dict);
   OnPrintPreview(dict);
 
   // We should have received invalid printer settings from |printer_|.
   VerifyPrintPreviewInvalidPrinterSettings(true);
   EXPECT_EQ(0, print_render_thread_->print_preview_pages_remaining());
 
   // It should receive the invalid printer settings message only.
   VerifyPrintPreviewFailed(false);
   VerifyPrintPreviewGenerated(false);
 }
 
 // Tests that when the selected printer has invalid page settings, print preview
 // receives error message.
-TEST_F(PrintWebViewHelperPreviewTest, OnPrintPreviewUsingInvalidPageSize) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest,
+       OnPrintPreviewUsingInvalidPageSize) {
   LoadHTML(kPrintPreviewHTML);
 
   print_render_thread_->printer()->UseInvalidPageSize();
 
   base::DictionaryValue dict;
   CreatePrintSettingsDictionary(&dict);
   OnPrintPreview(dict);
 
   VerifyPrintPreviewInvalidPrinterSettings(true);
   EXPECT_EQ(0, print_render_thread_->print_preview_pages_remaining());
 
   // It should receive the invalid printer settings message only.
   VerifyPrintPreviewFailed(false);
   VerifyPrintPreviewGenerated(false);
 }
 
 // Tests that when the selected printer has invalid content settings, print
 // preview receives error message.
-TEST_F(PrintWebViewHelperPreviewTest, OnPrintPreviewUsingInvalidContentSize) {
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest,
+       OnPrintPreviewUsingInvalidContentSize) {
   LoadHTML(kPrintPreviewHTML);
 
   print_render_thread_->printer()->UseInvalidContentSize();
 
   base::DictionaryValue dict;
   CreatePrintSettingsDictionary(&dict);
   OnPrintPreview(dict);
 
   VerifyPrintPreviewInvalidPrinterSettings(true);
   EXPECT_EQ(0, print_render_thread_->print_preview_pages_remaining());
 
   // It should receive the invalid printer settings message only.
   VerifyPrintPreviewFailed(false);
   VerifyPrintPreviewGenerated(false);
 }
 
-TEST_F(PrintWebViewHelperPreviewTest,
+TEST_F(MAYBE_PrintWebViewHelperPreviewTest,
        OnPrintForPrintPreviewUsingInvalidPrinterSettings) {
   LoadHTML(kPrintPreviewHTML);
 
   // Set mock printer to provide invalid settings.
   print_render_thread_->printer()->UseInvalidSettings();
 
   // Fill in some dummy values.
   base::DictionaryValue dict;
   CreatePrintSettingsDictionary(&dict);
   OnPrintForPrintPreview(dict);
 
   VerifyPrintFailed(true);
   VerifyPagesPrinted(false);
 }
 
 #endif  // !defined(OS_CHROMEOS)
 
 }  // namespace printing