src/chrome/renderer/printing/print_web_view_helper_browsertest.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 "base/command_line.h"
   6 #include "chrome/common/chrome_switches.h"
   7 #include "chrome/common/print_messages.h"
   8 #include "chrome/renderer/mock_printer.h"
   9 #include "chrome/renderer/printing/print_web_view_helper.h"
  10 #include "chrome/test/base/chrome_render_view_test.h"
  11 #include "content/public/renderer/render_view.h"
  12 #include "printing/print_job_constants.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14 #include "third_party/WebKit/public/platform/WebString.h"
  15 #include "third_party/WebKit/public/web/WebFrame.h"
  16 #include "third_party/WebKit/public/web/WebRange.h"
  17 #include "third_party/WebKit/public/web/WebView.h"
  18
  19 #if defined(OS_WIN) || defined(OS_MACOSX)
  20 #include "base/file_util.h"
  21 #include "printing/image.h"
  22
  23 using WebKit::WebFrame;
  24 using WebKit::WebString;
  25 #endif
  26
  27 namespace printing {
  28
  29 namespace {
  30
  31 // A simple web page.
  32 const char kHelloWorldHTML[] = "<body><p>Hello World!</p></body>";
  33
  34 // A simple webpage with a button to print itself with.
  35 const char kPrintOnUserAction[] =
  36     "<body>"
  37     "  <button id=\"print\" onclick=\"window.print();\">Hello World!</button>"
  38     "</body>";
  39
  40 #if !defined(OS_CHROMEOS)
  41 // HTML with 3 pages.
  42 const char kMultipageHTML[] =
  43   "<html><head><style>"
  44   ".break { page-break-after: always; }"
  45   "</style></head>"
  46   "<body>"
  47   "<div class='break'>page1</div>"
  48   "<div class='break'>page2</div>"
  49   "<div>page3</div>"
  50   "</body></html>";
  51
  52 // A simple web page with print page size css.
  53 const char kHTMLWithPageSizeCss[] =
  54     "<html><head><style>"
  55     "@media print {"
  56     "  @page {"
  57     "     size: 4in 4in;"
  58     "  }"
  59     "}"
  60     "</style></head>"
  61     "<body>Lorem Ipsum:"
  62     "</body></html>";
  63
  64 // A simple web page with print page layout css.
  65 const char kHTMLWithLandscapePageCss[] =
  66     "<html><head><style>"
  67     "@media print {"
  68     "  @page {"
  69     "     size: landscape;"
  70     "  }"
  71     "}"
  72     "</style></head>"
  73     "<body>Lorem Ipsum:"
  74     "</body></html>";
  75
  76 // A longer web page.
  77 const char kLongPageHTML[] =
  78     "<body><img src=\"\" width=10 height=10000 /></body>";
  79
  80 // A web page to simulate the print preview page.
  81 const char kPrintPreviewHTML[] =
  82     "<body><p id=\"pdf-viewer\">Hello World!</p></body>";
  83 #endif  // !defined(OS_CHROMEOS)
  84
  85 void CreatePrintSettingsDictionary(base::DictionaryValue* dict) {
  86   dict->SetBoolean(kSettingLandscape, false);
  87   dict->SetBoolean(kSettingCollate, false);
  88   dict->SetInteger(kSettingColor, GRAY);
  89   dict->SetBoolean(kSettingPrintToPDF, true);
  90   dict->SetInteger(kSettingDuplexMode, SIMPLEX);
  91   dict->SetInteger(kSettingCopies, 1);
  92   dict->SetString(kSettingDeviceName, "dummy");
  93   dict->SetInteger(kPreviewUIID, 4);
  94   dict->SetInteger(kPreviewRequestID, 12345);
  95   dict->SetBoolean(kIsFirstRequest, true);
  96   dict->SetInteger(kSettingMarginsType, DEFAULT_MARGINS);
  97   dict->SetBoolean(kSettingPreviewModifiable, false);
  98   dict->SetBoolean(kSettingHeaderFooterEnabled, false);
  99   dict->SetBoolean(kSettingGenerateDraftData, true);
 100   dict->SetBoolean(kSettingShouldPrintBackgrounds, false);
 101   dict->SetBoolean(kSettingShouldPrintSelectionOnly, false);
 102 }
 103
 104 }  // namespace
 105
 106 class PrintWebViewHelperTestBase : public ChromeRenderViewTest {
 107  public:
 108   PrintWebViewHelperTestBase() {}
 109   virtual ~PrintWebViewHelperTestBase() {}
 110
 111  protected:
 112   void PrintWithJavaScript() {
 113     ExecuteJavaScript("window.print();");
 114     ProcessPendingMessages();
 115   }
 116   // The renderer should be done calculating the number of rendered pages
 117   // according to the specified settings defined in the mock render thread.
 118   // Verify the page count is correct.
 119   void VerifyPageCount(int count) {
 120 #if defined(OS_CHROMEOS)
 121     // The DidGetPrintedPagesCount message isn't sent on ChromeOS. Right now we
 122     // always print all pages, and there are checks to that effect built into
 123     // the print code.
 124 #else
 125     const IPC::Message* page_cnt_msg =
 126         render_thread_->sink().GetUniqueMessageMatching(
 127             PrintHostMsg_DidGetPrintedPagesCount::ID);
 128     ASSERT_TRUE(page_cnt_msg);
 129     PrintHostMsg_DidGetPrintedPagesCount::Param post_page_count_param;
 130     PrintHostMsg_DidGetPrintedPagesCount::Read(page_cnt_msg,
 131                                                &post_page_count_param);
 132     EXPECT_EQ(count, post_page_count_param.b);
 133 #endif  // defined(OS_CHROMEOS)
 134   }
 135
 136   // The renderer should be done calculating the number of rendered pages
 137   // according to the specified settings defined in the mock render thread.
 138   // Verify the page count is correct.
 139   void VerifyPreviewPageCount(int count) {
 140     const IPC::Message* page_cnt_msg =
 141         render_thread_->sink().GetUniqueMessageMatching(
 142         PrintHostMsg_DidGetPreviewPageCount::ID);
 143     ASSERT_TRUE(page_cnt_msg);
 144     PrintHostMsg_DidGetPreviewPageCount::Param post_page_count_param;
 145     PrintHostMsg_DidGetPreviewPageCount::Read(page_cnt_msg,
 146                                               &post_page_count_param);
 147     EXPECT_EQ(count, post_page_count_param.a.page_count);
 148   }
 149
 150   // Verifies whether the pages printed or not.
 151   void VerifyPagesPrinted(bool printed) {
 152 #if defined(OS_CHROMEOS)
 153     bool did_print_msg = (render_thread_->sink().GetUniqueMessageMatching(
 154         PrintHostMsg_TempFileForPrintingWritten::ID) != NULL);
 155     ASSERT_EQ(printed, did_print_msg);
 156 #else
 157     const IPC::Message* print_msg =
 158         render_thread_->sink().GetUniqueMessageMatching(
 159             PrintHostMsg_DidPrintPage::ID);
 160     bool did_print_msg = (NULL != print_msg);
 161     ASSERT_EQ(printed, did_print_msg);
 162     if (printed) {
 163       PrintHostMsg_DidPrintPage::Param post_did_print_page_param;
 164       PrintHostMsg_DidPrintPage::Read(print_msg, &post_did_print_page_param);
 165       EXPECT_EQ(0, post_did_print_page_param.a.page_number);
 166     }
 167 #endif  // defined(OS_CHROMEOS)
 168   }
 169   void OnPrintPages() {
 170     PrintWebViewHelper::Get(view_)->OnPrintPages();
 171     ProcessPendingMessages();
 172   }
 173
 174   void OnPrintPreview(const base::DictionaryValue& dict) {
 175     PrintWebViewHelper* print_web_view_helper = PrintWebViewHelper::Get(view_);
 176     print_web_view_helper->OnInitiatePrintPreview(false);
 177     print_web_view_helper->OnPrintPreview(dict);
 178     ProcessPendingMessages();
 179   }
 180
 181   void OnPrintForPrintPreview(const base::DictionaryValue& dict) {
 182     PrintWebViewHelper::Get(view_)->OnPrintForPrintPreview(dict);
 183     ProcessPendingMessages();
 184   }
 185
 186   DISALLOW_COPY_AND_ASSIGN(PrintWebViewHelperTestBase);
 187 };
 188
 189 class PrintWebViewHelperTest : public PrintWebViewHelperTestBase {
 190  public:
 191   PrintWebViewHelperTest() {}
 192   virtual ~PrintWebViewHelperTest() {}
 193
 194   virtual void SetUp() OVERRIDE {
 195     ChromeRenderViewTest::SetUp();
 196   }
 197
 198  protected:
 199   DISALLOW_COPY_AND_ASSIGN(PrintWebViewHelperTest);
 200 };
 201
 202 // Tests that printing pages work and sending and receiving messages through
 203 // that channel all works.
 204 TEST_F(PrintWebViewHelperTest, OnPrintPages) {
 205   LoadHTML(kHelloWorldHTML);
 206   OnPrintPages();
 207
 208   VerifyPageCount(1);
 209   VerifyPagesPrinted(true);
 210 }
 211
 212 // Duplicate of OnPrintPagesTest only using javascript to print.
 213 TEST_F(PrintWebViewHelperTest, PrintWithJavascript) {
 214   PrintWithJavaScript();
 215
 216   VerifyPageCount(1);
 217   VerifyPagesPrinted(true);
 218 }
 219
 220 // Tests that the renderer blocks window.print() calls if they occur too
 221 // frequently.
 222 TEST_F(PrintWebViewHelperTest, BlockScriptInitiatedPrinting) {
 223   // Pretend user will cancel printing.
 224   chrome_render_thread_->set_print_dialog_user_response(false);
 225   // Try to print with window.print() a few times.
 226   PrintWithJavaScript();
 227   PrintWithJavaScript();
 228   PrintWithJavaScript();
 229   VerifyPagesPrinted(false);
 230
 231   // Pretend user will print. (but printing is blocked.)
 232   chrome_render_thread_->set_print_dialog_user_response(true);
 233   PrintWithJavaScript();
 234   VerifyPagesPrinted(false);
 235
 236   // Unblock script initiated printing and verify printing works.
 237   PrintWebViewHelper::Get(view_)->ResetScriptedPrintCount();
 238   chrome_render_thread_->printer()->ResetPrinter();
 239   PrintWithJavaScript();
 240   VerifyPageCount(1);
 241   VerifyPagesPrinted(true);
 242 }
 243
 244 // Tests that the renderer always allows window.print() calls if they are user
 245 // initiated.
 246 TEST_F(PrintWebViewHelperTest, AllowUserOriginatedPrinting) {
 247   // Pretend user will cancel printing.
 248   chrome_render_thread_->set_print_dialog_user_response(false);
 249   // Try to print with window.print() a few times.
 250   PrintWithJavaScript();
 251   PrintWithJavaScript();
 252   PrintWithJavaScript();
 253   VerifyPagesPrinted(false);
 254
 255   // Pretend user will print. (but printing is blocked.)
 256   chrome_render_thread_->set_print_dialog_user_response(true);
 257   PrintWithJavaScript();
 258   VerifyPagesPrinted(false);
 259
 260   // Try again as if user initiated, without resetting the print count.
 261   chrome_render_thread_->printer()->ResetPrinter();
 262   LoadHTML(kPrintOnUserAction);
 263   gfx::Size new_size(200, 100);
 264   Resize(new_size, gfx::Rect(), false);
 265
 266   gfx::Rect bounds = GetElementBounds("print");
 267   EXPECT_FALSE(bounds.IsEmpty());
 268   WebKit::WebMouseEvent mouse_event;
 269   mouse_event.type = WebKit::WebInputEvent::MouseDown;
 270   mouse_event.button = WebKit::WebMouseEvent::ButtonLeft;
 271   mouse_event.x = bounds.CenterPoint().x();
 272   mouse_event.y = bounds.CenterPoint().y();
 273   mouse_event.clickCount = 1;
 274   SendWebMouseEvent(mouse_event);
 275   mouse_event.type = WebKit::WebInputEvent::MouseUp;
 276   SendWebMouseEvent(mouse_event);
 277   ProcessPendingMessages();
 278
 279   VerifyPageCount(1);
 280   VerifyPagesPrinted(true);
 281 }
 282
 283 TEST_F(PrintWebViewHelperTest, BlockScriptInitiatedPrintingFromPopup) {
 284   PrintWebViewHelper* print_web_view_helper = PrintWebViewHelper::Get(view_);
 285   print_web_view_helper->SetScriptedPrintBlocked(true);
 286   PrintWithJavaScript();
 287   VerifyPagesPrinted(false);
 288
 289   print_web_view_helper->SetScriptedPrintBlocked(false);
 290   PrintWithJavaScript();
 291   VerifyPageCount(1);
 292   VerifyPagesPrinted(true);
 293 }
 294
 295 #if defined(OS_WIN) || defined(OS_MACOSX)
 296 // TODO(estade): I don't think this test is worth porting to Linux. We will have
 297 // to rip out and replace most of the IPC code if we ever plan to improve
 298 // printing, and the comment below by sverrir suggests that it doesn't do much
 299 // for us anyway.
 300 TEST_F(PrintWebViewHelperTest, PrintWithIframe) {
 301   // Document that populates an iframe.
 302   const char html[] =
 303       "<html><body>Lorem Ipsum:"
 304       "<iframe name=\"sub1\" id=\"sub1\"></iframe><script>"
 305       "  document.write(frames['sub1'].name);"
 306       "  frames['sub1'].document.write("
 307       "      '<p>Cras tempus ante eu felis semper luctus!</p>');"
 308       "</script></body></html>";
 309
 310   LoadHTML(html);
 311
 312   // Find the frame and set it as the focused one.  This should mean that that
 313   // the printout should only contain the contents of that frame.
 314   WebFrame* sub1_frame =
 315       view_->GetWebView()->findFrameByName(WebString::fromUTF8("sub1"));
 316   ASSERT_TRUE(sub1_frame);
 317   view_->GetWebView()->setFocusedFrame(sub1_frame);
 318   ASSERT_NE(view_->GetWebView()->focusedFrame(),
 319             view_->GetWebView()->mainFrame());
 320
 321   // Initiate printing.
 322   OnPrintPages();
 323   VerifyPagesPrinted(true);
 324
 325   // Verify output through MockPrinter.
 326   const MockPrinter* printer(chrome_render_thread_->printer());
 327   ASSERT_EQ(1, printer->GetPrintedPages());
 328   const Image& image1(printer->GetPrintedPage(0)->image());
 329
 330   // TODO(sverrir): Figure out a way to improve this test to actually print
 331   // only the content of the iframe.  Currently image1 will contain the full
 332   // page.
 333   EXPECT_NE(0, image1.size().width());
 334   EXPECT_NE(0, image1.size().height());
 335 }
 336 #endif
 337
 338 // Tests if we can print a page and verify its results.
 339 // This test prints HTML pages into a pseudo printer and check their outputs,
 340 // i.e. a simplified version of the PrintingLayoutTextTest UI test.
 341 namespace {
 342 // Test cases used in this test.
 343 struct TestPageData {
 344   const char* page;
 345   size_t printed_pages;
 346   int width;
 347   int height;
 348   const char* checksum;
 349   const wchar_t* file;
 350 };
 351
 352 #if defined(OS_WIN) || defined(OS_MACOSX)
 353 const TestPageData kTestPages[] = {
 354   {"<html>"
 355   "<head>"
 356   "<meta"
 357   "  http-equiv=\"Content-Type\""
 358   "  content=\"text/html; charset=utf-8\"/>"
 359   "<title>Test 1</title>"
 360   "</head>"
 361   "<body style=\"background-color: white;\">"
 362   "<p style=\"font-family: arial;\">Hello World!</p>"
 363   "</body>",
 364 #if defined(OS_MACOSX)
 365   // Mac printing code compensates for the WebKit scale factor while generating
 366   // the metafile, so we expect smaller pages.
 367   1, 600, 780,
 368 #else
 369   1, 675, 900,
 370 #endif
 371   NULL,
 372   NULL,
 373   },
 374 };
 375 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
 376 }  // namespace
 377
 378 // TODO(estade): need to port MockPrinter to get this on Linux. This involves
 379 // hooking up Cairo to read a pdf stream, or accessing the cairo surface in the
 380 // metafile directly.
 381 #if defined(OS_WIN) || defined(OS_MACOSX)
 382 TEST_F(PrintWebViewHelperTest, PrintLayoutTest) {
 383   bool baseline = false;
 384
 385   EXPECT_TRUE(chrome_render_thread_->printer() != NULL);
 386   for (size_t i = 0; i < arraysize(kTestPages); ++i) {
 387     // Load an HTML page and print it.
 388     LoadHTML(kTestPages[i].page);
 389     OnPrintPages();
 390     VerifyPagesPrinted(true);
 391
 392     // MockRenderThread::Send() just calls MockRenderThread::OnReceived().
 393     // So, all IPC messages sent in the above RenderView::OnPrintPages() call
 394     // has been handled by the MockPrinter object, i.e. this printing job
 395     // has been already finished.
 396     // So, we can start checking the output pages of this printing job.
 397     // Retrieve the number of pages actually printed.
 398     size_t pages = chrome_render_thread_->printer()->GetPrintedPages();
 399     EXPECT_EQ(kTestPages[i].printed_pages, pages);
 400
 401     // Retrieve the width and height of the output page.
 402     int width = chrome_render_thread_->printer()->GetWidth(0);
 403     int height = chrome_render_thread_->printer()->GetHeight(0);
 404
 405     // Check with margin for error.  This has been failing with a one pixel
 406     // offset on our buildbot.
 407     const int kErrorMargin = 5;  // 5%
 408     EXPECT_GT(kTestPages[i].width * (100 + kErrorMargin) / 100, width);
 409     EXPECT_LT(kTestPages[i].width * (100 - kErrorMargin) / 100, width);
 410     EXPECT_GT(kTestPages[i].height * (100 + kErrorMargin) / 100, height);
 411     EXPECT_LT(kTestPages[i].height* (100 - kErrorMargin) / 100, height);
 412
 413     // Retrieve the checksum of the bitmap data from the pseudo printer and
 414     // compare it with the expected result.
 415     std::string bitmap_actual;
 416     EXPECT_TRUE(
 417         chrome_render_thread_->printer()->GetBitmapChecksum(0, &bitmap_actual));
 418     if (kTestPages[i].checksum)
 419       EXPECT_EQ(kTestPages[i].checksum, bitmap_actual);
 420
 421     if (baseline) {
 422       // Save the source data and the bitmap data into temporary files to
 423       // create base-line results.
 424       base::FilePath source_path;
 425       file_util::CreateTemporaryFile(&source_path);
 426       chrome_render_thread_->printer()->SaveSource(0, source_path);
 427
 428       base::FilePath bitmap_path;
 429       file_util::CreateTemporaryFile(&bitmap_path);
 430       chrome_render_thread_->printer()->SaveBitmap(0, bitmap_path);
 431     }
 432   }
 433 }
 434 #endif
 435
 436 // These print preview tests do not work on Chrome OS yet.
 437 #if !defined(OS_CHROMEOS)
 438 class PrintWebViewHelperPreviewTest : public PrintWebViewHelperTestBase {
 439  public:
 440   PrintWebViewHelperPreviewTest() {}
 441   virtual ~PrintWebViewHelperPreviewTest() {}
 442
 443   virtual void SetUp() OVERRIDE {
 444     // Append the print preview switch before creating the PrintWebViewHelper.
 445     CommandLine::ForCurrentProcess()->AppendSwitch(
 446         switches::kRendererPrintPreview);
 447
 448     ChromeRenderViewTest::SetUp();
 449   }
 450
 451  protected:
 452   void VerifyPrintPreviewCancelled(bool did_cancel) {
 453     bool print_preview_cancelled =
 454         (render_thread_->sink().GetUniqueMessageMatching(
 455             PrintHostMsg_PrintPreviewCancelled::ID) != NULL);
 456     EXPECT_EQ(did_cancel, print_preview_cancelled);
 457   }
 458
 459   void VerifyPrintPreviewFailed(bool did_fail) {
 460     bool print_preview_failed =
 461         (render_thread_->sink().GetUniqueMessageMatching(
 462             PrintHostMsg_PrintPreviewFailed::ID) != NULL);
 463     EXPECT_EQ(did_fail, print_preview_failed);
 464   }
 465
 466   void VerifyPrintPreviewGenerated(bool generated_preview) {
 467     const IPC::Message* preview_msg =
 468         render_thread_->sink().GetUniqueMessageMatching(
 469             PrintHostMsg_MetafileReadyForPrinting::ID);
 470     bool did_get_preview_msg = (NULL != preview_msg);
 471     ASSERT_EQ(generated_preview, did_get_preview_msg);
 472     if (did_get_preview_msg) {
 473       PrintHostMsg_MetafileReadyForPrinting::Param preview_param;
 474       PrintHostMsg_MetafileReadyForPrinting::Read(preview_msg, &preview_param);
 475       EXPECT_NE(0, preview_param.a.document_cookie);
 476       EXPECT_NE(0, preview_param.a.expected_pages_count);
 477       EXPECT_NE(0U, preview_param.a.data_size);
 478     }
 479   }
 480
 481   void VerifyPrintFailed(bool did_fail) {
 482     bool print_failed = (render_thread_->sink().GetUniqueMessageMatching(
 483         PrintHostMsg_PrintingFailed::ID) != NULL);
 484     EXPECT_EQ(did_fail, print_failed);
 485   }
 486
 487   void VerifyPrintPreviewInvalidPrinterSettings(bool settings_invalid) {
 488     bool print_preview_invalid_printer_settings =
 489         (render_thread_->sink().GetUniqueMessageMatching(
 490             PrintHostMsg_PrintPreviewInvalidPrinterSettings::ID) != NULL);
 491     EXPECT_EQ(settings_invalid, print_preview_invalid_printer_settings);
 492   }
 493
 494   // |page_number| is 0-based.
 495   void VerifyDidPreviewPage(bool generate_draft_pages, int page_number) {
 496     bool msg_found = false;
 497     size_t msg_count = render_thread_->sink().message_count();
 498     for (size_t i = 0; i < msg_count; ++i) {
 499       const IPC::Message* msg = render_thread_->sink().GetMessageAt(i);
 500       if (msg->type() == PrintHostMsg_DidPreviewPage::ID) {
 501         PrintHostMsg_DidPreviewPage::Param page_param;
 502         PrintHostMsg_DidPreviewPage::Read(msg, &page_param);
 503         if (page_param.a.page_number == page_number) {
 504           msg_found = true;
 505           if (generate_draft_pages)
 506             EXPECT_NE(0U, page_param.a.data_size);
 507           else
 508             EXPECT_EQ(0U, page_param.a.data_size);
 509           break;
 510         }
 511       }
 512     }
 513     ASSERT_EQ(generate_draft_pages, msg_found);
 514   }
 515
 516   void VerifyDefaultPageLayout(int content_width, int content_height,
 517                                int margin_top, int margin_bottom,
 518                                int margin_left, int margin_right,
 519                                bool page_has_print_css) {
 520     const IPC::Message* default_page_layout_msg =
 521         render_thread_->sink().GetUniqueMessageMatching(
 522             PrintHostMsg_DidGetDefaultPageLayout::ID);
 523     bool did_get_default_page_layout_msg = (NULL != default_page_layout_msg);
 524     if (did_get_default_page_layout_msg) {
 525       PrintHostMsg_DidGetDefaultPageLayout::Param param;
 526       PrintHostMsg_DidGetDefaultPageLayout::Read(default_page_layout_msg,
 527                                                  &param);
 528       EXPECT_EQ(content_width, param.a.content_width);
 529       EXPECT_EQ(content_height, param.a.content_height);
 530       EXPECT_EQ(margin_top, param.a.margin_top);
 531       EXPECT_EQ(margin_right, param.a.margin_right);
 532       EXPECT_EQ(margin_left, param.a.margin_left);
 533       EXPECT_EQ(margin_bottom, param.a.margin_bottom);
 534       EXPECT_EQ(page_has_print_css, param.c);
 535     }
 536   }
 537
 538   DISALLOW_COPY_AND_ASSIGN(PrintWebViewHelperPreviewTest);
 539 };
 540
 541 // Tests that print preview work and sending and receiving messages through
 542 // that channel all works.
 543 TEST_F(PrintWebViewHelperPreviewTest, OnPrintPreview) {
 544   LoadHTML(kHelloWorldHTML);
 545
 546   // Fill in some dummy values.
 547   base::DictionaryValue dict;
 548   CreatePrintSettingsDictionary(&dict);
 549   OnPrintPreview(dict);
 550
 551   EXPECT_EQ(0, chrome_render_thread_->print_preview_pages_remaining());
 552   VerifyDefaultPageLayout(540, 720, 36, 36, 36, 36, false);
 553   VerifyPrintPreviewCancelled(false);
 554   VerifyPrintPreviewFailed(false);
 555   VerifyPrintPreviewGenerated(true);
 556   VerifyPagesPrinted(false);
 557 }
 558
 559 TEST_F(PrintWebViewHelperPreviewTest, PrintPreviewHTMLWithPageMarginsCss) {
 560   // A simple web page with print margins css.
 561   const char kHTMLWithPageMarginsCss[] =
 562       "<html><head><style>"
 563       "@media print {"
 564       "  @page {"
 565       "     margin: 3in 1in 2in 0.3in;"
 566       "  }"
 567       "}"
 568       "</style></head>"
 569       "<body>Lorem Ipsum:"
 570       "</body></html>";
 571   LoadHTML(kHTMLWithPageMarginsCss);
 572
 573   // Fill in some dummy values.
 574   base::DictionaryValue dict;
 575   CreatePrintSettingsDictionary(&dict);
 576   dict.SetBoolean(kSettingPrintToPDF, false);
 577   dict.SetInteger(kSettingMarginsType, DEFAULT_MARGINS);
 578   OnPrintPreview(dict);
 579
 580   EXPECT_EQ(0, chrome_render_thread_->print_preview_pages_remaining());
 581   VerifyDefaultPageLayout(519, 432, 216, 144, 21, 72, false);
 582   VerifyPrintPreviewCancelled(false);
 583   VerifyPrintPreviewFailed(false);
 584   VerifyPrintPreviewGenerated(true);
 585   VerifyPagesPrinted(false);
 586 }
 587
 588 // Test to verify that print preview ignores print media css when non-default
 589 // margin is selected.
 590 TEST_F(PrintWebViewHelperPreviewTest, NonDefaultMarginsSelectedIgnorePrintCss) {
 591   LoadHTML(kHTMLWithPageSizeCss);
 592
 593   // Fill in some dummy values.
 594   base::DictionaryValue dict;
 595   CreatePrintSettingsDictionary(&dict);
 596   dict.SetBoolean(kSettingPrintToPDF, false);
 597   dict.SetInteger(kSettingMarginsType, NO_MARGINS);
 598   OnPrintPreview(dict);
 599
 600   EXPECT_EQ(0, chrome_render_thread_->print_preview_pages_remaining());
 601   VerifyDefaultPageLayout(612, 792, 0, 0, 0, 0, true);
 602   VerifyPrintPreviewCancelled(false);
 603   VerifyPrintPreviewFailed(false);
 604   VerifyPrintPreviewGenerated(true);
 605   VerifyPagesPrinted(false);
 606 }
 607
 608 // Test to verify that print preview honor print media size css when
 609 // PRINT_TO_PDF is selected and doesn't fit to printer default paper size.
 610 TEST_F(PrintWebViewHelperPreviewTest, PrintToPDFSelectedHonorPrintCss) {
 611   LoadHTML(kHTMLWithPageSizeCss);
 612
 613   // Fill in some dummy values.
 614   base::DictionaryValue dict;
 615   CreatePrintSettingsDictionary(&dict);
 616   dict.SetBoolean(kSettingPrintToPDF, true);
 617   dict.SetInteger(kSettingMarginsType,
 618                   PRINTABLE_AREA_MARGINS);
 619   OnPrintPreview(dict);
 620
 621   EXPECT_EQ(0, chrome_render_thread_->print_preview_pages_remaining());
 622   // Since PRINT_TO_PDF is selected, pdf page size is equal to print media page
 623   // size.
 624   VerifyDefaultPageLayout(252, 252, 18, 18, 18, 18, true);
 625   VerifyPrintPreviewCancelled(false);
 626   VerifyPrintPreviewFailed(false);
 627 }
 628
 629 // Test to verify that print preview honor print margin css when PRINT_TO_PDF
 630 // is selected and doesn't fit to printer default paper size.
 631 TEST_F(PrintWebViewHelperPreviewTest, PrintToPDFSelectedHonorPageMarginsCss) {
 632   // A simple web page with print margins css.
 633   const char kHTMLWithPageCss[] =
 634       "<html><head><style>"
 635       "@media print {"
 636       "  @page {"
 637       "     margin: 3in 1in 2in 0.3in;"
 638       "     size: 14in 14in;"
 639       "  }"
 640       "}"
 641       "</style></head>"
 642       "<body>Lorem Ipsum:"
 643       "</body></html>";
 644   LoadHTML(kHTMLWithPageCss);
 645
 646   // Fill in some dummy values.
 647   base::DictionaryValue dict;
 648   CreatePrintSettingsDictionary(&dict);
 649   dict.SetBoolean(kSettingPrintToPDF, true);
 650   dict.SetInteger(kSettingMarginsType, DEFAULT_MARGINS);
 651   OnPrintPreview(dict);
 652
 653   EXPECT_EQ(0, chrome_render_thread_->print_preview_pages_remaining());
 654   // Since PRINT_TO_PDF is selected, pdf page size is equal to print media page
 655   // size.
 656   VerifyDefaultPageLayout(915, 648, 216, 144, 21, 72, true);
 657   VerifyPrintPreviewCancelled(false);
 658   VerifyPrintPreviewFailed(false);
 659 }
 660
 661 // Test to verify that print preview workflow center the html page contents to
 662 // fit the page size.
 663 TEST_F(PrintWebViewHelperPreviewTest, PrintPreviewCenterToFitPage) {
 664   LoadHTML(kHTMLWithPageSizeCss);
 665
 666   // Fill in some dummy values.
 667   base::DictionaryValue dict;
 668   CreatePrintSettingsDictionary(&dict);
 669   dict.SetBoolean(kSettingPrintToPDF, false);
 670   dict.SetInteger(kSettingMarginsType, DEFAULT_MARGINS);
 671   OnPrintPreview(dict);
 672
 673   EXPECT_EQ(0, chrome_render_thread_->print_preview_pages_remaining());
 674   VerifyDefaultPageLayout(216, 216, 288, 288, 198, 198, true);
 675   VerifyPrintPreviewCancelled(false);
 676   VerifyPrintPreviewFailed(false);
 677   VerifyPrintPreviewGenerated(true);
 678 }
 679
 680 // Test to verify that print preview workflow scale the html page contents to
 681 // fit the page size.
 682 TEST_F(PrintWebViewHelperPreviewTest, PrintPreviewShrinkToFitPage) {
 683   // A simple web page with print margins css.
 684   const char kHTMLWithPageCss[] =
 685       "<html><head><style>"
 686       "@media print {"
 687       "  @page {"
 688       "     size: 15in 17in;"
 689       "  }"
 690       "}"
 691       "</style></head>"
 692       "<body>Lorem Ipsum:"
 693       "</body></html>";
 694   LoadHTML(kHTMLWithPageCss);
 695
 696   // Fill in some dummy values.
 697   base::DictionaryValue dict;
 698   CreatePrintSettingsDictionary(&dict);
 699   dict.SetBoolean(kSettingPrintToPDF, false);
 700   dict.SetInteger(kSettingMarginsType, DEFAULT_MARGINS);
 701   OnPrintPreview(dict);
 702
 703   EXPECT_EQ(0, chrome_render_thread_->print_preview_pages_remaining());
 704   VerifyDefaultPageLayout(571, 652, 69, 71, 20, 21, true);
 705   VerifyPrintPreviewCancelled(false);
 706   VerifyPrintPreviewFailed(false);
 707 }
 708
 709 // Test to verify that print preview workflow honor the orientation settings
 710 // specified in css.
 711 TEST_F(PrintWebViewHelperPreviewTest, PrintPreviewHonorsOrientationCss) {
 712   LoadHTML(kHTMLWithLandscapePageCss);
 713
 714   // Fill in some dummy values.
 715   base::DictionaryValue dict;
 716   CreatePrintSettingsDictionary(&dict);
 717   dict.SetBoolean(kSettingPrintToPDF, false);
 718   dict.SetInteger(kSettingMarginsType, NO_MARGINS);
 719   OnPrintPreview(dict);
 720
 721   EXPECT_EQ(0, chrome_render_thread_->print_preview_pages_remaining());
 722   VerifyDefaultPageLayout(792, 612, 0, 0, 0, 0, true);
 723   VerifyPrintPreviewCancelled(false);
 724   VerifyPrintPreviewFailed(false);
 725 }
 726
 727 // Test to verify that print preview workflow honors the orientation settings
 728 // specified in css when PRINT_TO_PDF is selected.
 729 TEST_F(PrintWebViewHelperPreviewTest, PrintToPDFSelectedHonorOrientationCss) {
 730   LoadHTML(kHTMLWithLandscapePageCss);
 731
 732   // Fill in some dummy values.
 733   base::DictionaryValue dict;
 734   CreatePrintSettingsDictionary(&dict);
 735   dict.SetBoolean(kSettingPrintToPDF, true);
 736   dict.SetInteger(kSettingMarginsType, CUSTOM_MARGINS);
 737   OnPrintPreview(dict);
 738
 739   EXPECT_EQ(0, chrome_render_thread_->print_preview_pages_remaining());
 740   VerifyDefaultPageLayout(748, 568, 21, 23, 21, 23, true);
 741   VerifyPrintPreviewCancelled(false);
 742   VerifyPrintPreviewFailed(false);
 743 }
 744
 745 // Test to verify that complete metafile is generated for a subset of pages
 746 // without creating draft pages.
 747 TEST_F(PrintWebViewHelperPreviewTest, OnPrintPreviewForSelectedPages) {
 748   LoadHTML(kMultipageHTML);
 749
 750   // Fill in some dummy values.
 751   base::DictionaryValue dict;
 752   CreatePrintSettingsDictionary(&dict);
 753
 754   // Set a page range and update the dictionary to generate only the complete
 755   // metafile with the selected pages. Page numbers used in the dictionary
 756   // are 1-based.
 757   base::DictionaryValue* page_range = new base::DictionaryValue();
 758   page_range->SetInteger(kSettingPageRangeFrom, 2);
 759   page_range->SetInteger(kSettingPageRangeTo, 3);
 760
 761   base::ListValue* page_range_array = new base::ListValue();
 762   page_range_array->Append(page_range);
 763
 764   dict.Set(kSettingPageRange, page_range_array);
 765   dict.SetBoolean(kSettingGenerateDraftData, false);
 766
 767   OnPrintPreview(dict);
 768
 769   VerifyDidPreviewPage(false, 0);
 770   VerifyDidPreviewPage(false, 1);
 771   VerifyDidPreviewPage(false, 2);
 772   VerifyPreviewPageCount(3);
 773   VerifyPrintPreviewCancelled(false);
 774   VerifyPrintPreviewFailed(false);
 775   VerifyPrintPreviewGenerated(true);
 776   VerifyPagesPrinted(false);
 777 }
 778
 779 // Test to verify that preview generated only for one page.
 780 TEST_F(PrintWebViewHelperPreviewTest, OnPrintPreviewForSelectedText) {
 781   LoadHTML(kMultipageHTML);
 782   GetMainFrame()->selectRange(
 783       WebKit::WebRange::fromDocumentRange(GetMainFrame(), 1, 3));
 784
 785   // Fill in some dummy values.
 786   base::DictionaryValue dict;
 787   CreatePrintSettingsDictionary(&dict);
 788   dict.SetBoolean(kSettingShouldPrintSelectionOnly, true);
 789
 790   OnPrintPreview(dict);
 791
 792   VerifyPreviewPageCount(1);
 793   VerifyPrintPreviewCancelled(false);
 794   VerifyPrintPreviewFailed(false);
 795   VerifyPrintPreviewGenerated(true);
 796   VerifyPagesPrinted(false);
 797 }
 798
 799 // Tests that print preview fails and receiving error messages through
 800 // that channel all works.
 801 TEST_F(PrintWebViewHelperPreviewTest, OnPrintPreviewFail) {
 802   LoadHTML(kHelloWorldHTML);
 803
 804   // An empty dictionary should fail.
 805   base::DictionaryValue empty_dict;
 806   OnPrintPreview(empty_dict);
 807
 808   EXPECT_EQ(0, chrome_render_thread_->print_preview_pages_remaining());
 809   VerifyPrintPreviewCancelled(false);
 810   VerifyPrintPreviewFailed(true);
 811   VerifyPrintPreviewGenerated(false);
 812   VerifyPagesPrinted(false);
 813 }
 814
 815 // Tests that cancelling print preview works.
 816 TEST_F(PrintWebViewHelperPreviewTest, OnPrintPreviewCancel) {
 817   LoadHTML(kLongPageHTML);
 818
 819   const int kCancelPage = 3;
 820   chrome_render_thread_->set_print_preview_cancel_page_number(kCancelPage);
 821   // Fill in some dummy values.
 822   base::DictionaryValue dict;
 823   CreatePrintSettingsDictionary(&dict);
 824   OnPrintPreview(dict);
 825
 826   EXPECT_EQ(kCancelPage,
 827             chrome_render_thread_->print_preview_pages_remaining());
 828   VerifyPrintPreviewCancelled(true);
 829   VerifyPrintPreviewFailed(false);
 830   VerifyPrintPreviewGenerated(false);
 831   VerifyPagesPrinted(false);
 832 }
 833
 834 // Tests that printing from print preview works and sending and receiving
 835 // messages through that channel all works.
 836 TEST_F(PrintWebViewHelperPreviewTest, OnPrintForPrintPreview) {
 837   LoadHTML(kPrintPreviewHTML);
 838
 839   // Fill in some dummy values.
 840   base::DictionaryValue dict;
 841   CreatePrintSettingsDictionary(&dict);
 842   OnPrintForPrintPreview(dict);
 843
 844   VerifyPrintFailed(false);
 845   VerifyPagesPrinted(true);
 846 }
 847
 848 // Tests that printing from print preview fails and receiving error messages
 849 // through that channel all works.
 850 TEST_F(PrintWebViewHelperPreviewTest, OnPrintForPrintPreviewFail) {
 851   LoadHTML(kPrintPreviewHTML);
 852
 853   // An empty dictionary should fail.
 854   base::DictionaryValue empty_dict;
 855   OnPrintForPrintPreview(empty_dict);
 856
 857   VerifyPagesPrinted(false);
 858 }
 859
 860 // Tests that when default printer has invalid printer settings, print preview
 861 // receives error message.
 862 TEST_F(PrintWebViewHelperPreviewTest,
 863        OnPrintPreviewUsingInvalidPrinterSettings) {
 864   LoadHTML(kPrintPreviewHTML);
 865
 866   // Set mock printer to provide invalid settings.
 867   chrome_render_thread_->printer()->UseInvalidSettings();
 868
 869   // Fill in some dummy values.
 870   base::DictionaryValue dict;
 871   CreatePrintSettingsDictionary(&dict);
 872   OnPrintPreview(dict);
 873
 874   // We should have received invalid printer settings from |printer_|.
 875   VerifyPrintPreviewInvalidPrinterSettings(true);
 876   EXPECT_EQ(0, chrome_render_thread_->print_preview_pages_remaining());
 877
 878   // It should receive the invalid printer settings message only.
 879   VerifyPrintPreviewFailed(false);
 880   VerifyPrintPreviewGenerated(false);
 881 }
 882
 883 // Tests that when the selected printer has invalid page settings, print preview
 884 // receives error message.
 885 TEST_F(PrintWebViewHelperPreviewTest,
 886        OnPrintPreviewUsingInvalidPageSize) {
 887   LoadHTML(kPrintPreviewHTML);
 888
 889   chrome_render_thread_->printer()->UseInvalidPageSize();
 890
 891   base::DictionaryValue dict;
 892   CreatePrintSettingsDictionary(&dict);
 893   OnPrintPreview(dict);
 894
 895   VerifyPrintPreviewInvalidPrinterSettings(true);
 896   EXPECT_EQ(0, chrome_render_thread_->print_preview_pages_remaining());
 897
 898   // It should receive the invalid printer settings message only.
 899   VerifyPrintPreviewFailed(false);
 900   VerifyPrintPreviewGenerated(false);
 901 }
 902
 903 // Tests that when the selected printer has invalid content settings, print
 904 // preview receives error message.
 905 TEST_F(PrintWebViewHelperPreviewTest,
 906        OnPrintPreviewUsingInvalidContentSize) {
 907   LoadHTML(kPrintPreviewHTML);
 908
 909   chrome_render_thread_->printer()->UseInvalidContentSize();
 910
 911   base::DictionaryValue dict;
 912   CreatePrintSettingsDictionary(&dict);
 913   OnPrintPreview(dict);
 914
 915   VerifyPrintPreviewInvalidPrinterSettings(true);
 916   EXPECT_EQ(0, chrome_render_thread_->print_preview_pages_remaining());
 917
 918   // It should receive the invalid printer settings message only.
 919   VerifyPrintPreviewFailed(false);
 920   VerifyPrintPreviewGenerated(false);
 921 }
 922
 923 TEST_F(PrintWebViewHelperPreviewTest,
 924        OnPrintForPrintPreviewUsingInvalidPrinterSettings) {
 925   LoadHTML(kPrintPreviewHTML);
 926
 927   // Set mock printer to provide invalid settings.
 928   chrome_render_thread_->printer()->UseInvalidSettings();
 929
 930   // Fill in some dummy values.
 931   base::DictionaryValue dict;
 932   CreatePrintSettingsDictionary(&dict);
 933   OnPrintForPrintPreview(dict);
 934
 935   VerifyPrintFailed(true);
 936   VerifyPagesPrinted(false);
 937 }
 938
 939 #endif  // !defined(OS_CHROMEOS)
 940
 941 class PrintWebViewHelperKioskTest : public PrintWebViewHelperTestBase {
 942  public:
 943   PrintWebViewHelperKioskTest() {}
 944   virtual ~PrintWebViewHelperKioskTest() {}
 945
 946   virtual void SetUp() OVERRIDE {
 947     // Append the throttling disable switch before creating the
 948     // PrintWebViewHelper.
 949     CommandLine::ForCurrentProcess()->AppendSwitch(
 950         switches::kDisableScriptedPrintThrottling);
 951
 952     ChromeRenderViewTest::SetUp();
 953   }
 954
 955  protected:
 956   DISALLOW_COPY_AND_ASSIGN(PrintWebViewHelperKioskTest);
 957 };
 958
 959 // Tests that the switch overrides the throttling that blocks window.print()
 960 // calls if they occur too frequently. Compare with
 961 // PrintWebViewHelperTest.BlockScriptInitiatedPrinting above.
 962 TEST_F(PrintWebViewHelperKioskTest, DontBlockScriptInitiatedPrinting) {
 963   // Pretend user will cancel printing.
 964   chrome_render_thread_->set_print_dialog_user_response(false);
 965   // Try to print with window.print() a few times.
 966   PrintWithJavaScript();
 967   chrome_render_thread_->printer()->ResetPrinter();
 968   PrintWithJavaScript();
 969   chrome_render_thread_->printer()->ResetPrinter();
 970   PrintWithJavaScript();
 971   chrome_render_thread_->printer()->ResetPrinter();
 972   VerifyPagesPrinted(false);
 973
 974   // Pretend user will print, should not be throttled.
 975   chrome_render_thread_->set_print_dialog_user_response(true);
 976   PrintWithJavaScript();
 977   VerifyPagesPrinted(true);
 978 }
 979
 980 }  // namespace printing