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 "pdf/pdfium/pdfium_engine.h" 6 7 #include <math.h> 8 9 #include "base/json/json_writer.h" 10 #include "base/logging.h" 11 #include "base/memory/scoped_ptr.h" 12 #include "base/stl_util.h" 13 #include "base/strings/string_number_conversions.h" 14 #include "base/strings/string_piece.h" 15 #include "base/strings/string_util.h" 16 #include "base/strings/utf_string_conversions.h" 17 #include "base/values.h" 18 #include "pdf/draw_utils.h" 19 #include "pdf/pdfium/pdfium_mem_buffer_file_read.h" 20 #include "pdf/pdfium/pdfium_mem_buffer_file_write.h" 21 #include "ppapi/c/pp_errors.h" 22 #include "ppapi/c/pp_input_event.h" 23 #include "ppapi/c/ppb_core.h" 24 #include "ppapi/c/private/ppb_pdf.h" 25 #include "ppapi/cpp/dev/memory_dev.h" 26 #include "ppapi/cpp/input_event.h" 27 #include "ppapi/cpp/instance.h" 28 #include "ppapi/cpp/module.h" 29 #include "ppapi/cpp/private/pdf.h" 30 #include "ppapi/cpp/trusted/browser_font_trusted.h" 31 #include "ppapi/cpp/url_response_info.h" 32 #include "ppapi/cpp/var.h" 33 #include "third_party/pdfium/fpdfsdk/include/fpdf_ext.h" 34 #include "third_party/pdfium/fpdfsdk/include/fpdf_flatten.h" 35 #include "third_party/pdfium/fpdfsdk/include/fpdf_searchex.h" 36 #include "third_party/pdfium/fpdfsdk/include/fpdf_sysfontinfo.h" 37 #include "third_party/pdfium/fpdfsdk/include/fpdf_transformpage.h" 38 #include "third_party/pdfium/fpdfsdk/include/fpdfedit.h" 39 #include "third_party/pdfium/fpdfsdk/include/fpdfoom.h" 40 #include "third_party/pdfium/fpdfsdk/include/fpdfppo.h" 41 #include "third_party/pdfium/fpdfsdk/include/fpdfsave.h" 42 #include "third_party/pdfium/fpdfsdk/include/pdfwindow/PDFWindow.h" 43 #include "third_party/pdfium/fpdfsdk/include/pdfwindow/PWL_FontMap.h" 44 #include "ui/events/keycodes/keyboard_codes.h" 45 46 namespace chrome_pdf { 47 48 namespace { 49 50 #define kPageShadowTop 3 51 #define kPageShadowBottom 7 52 #define kPageShadowLeft 5 53 #define kPageShadowRight 5 54 55 #define kPageSeparatorThickness 4 56 #define kHighlightColorR 153 57 #define kHighlightColorG 193 58 #define kHighlightColorB 218 59 60 const uint32 kPendingPageColor = 0xFFEEEEEE; 61 62 #define kFormHighlightColor 0xFFE4DD 63 #define kFormHighlightAlpha 100 64 65 #define kMaxPasswordTries 3 66 67 // See Table 3.20 in 68 // http://www.adobe.com/devnet/acrobat/pdfs/pdf_reference_1-7.pdf 69 #define kPDFPermissionPrintLowQualityMask 1 << 2 70 #define kPDFPermissionPrintHighQualityMask 1 << 11 71 #define kPDFPermissionCopyMask 1 << 4 72 #define kPDFPermissionCopyAccessibleMask 1 << 9 73 74 #define kLoadingTextVerticalOffset 50 75 76 // The maximum amount of time we'll spend doing a paint before we give back 77 // control of the thread. 78 #define kMaxProgressivePaintTimeMs 50 79 80 // The maximum amount of time we'll spend doing the first paint. This is less 81 // than the above to keep things smooth if the user is scrolling quickly. We 82 // try painting a little because with accelerated compositing, we get flushes 83 // only every 16 ms. If we were to wait until the next flush to paint the rest 84 // of the pdf, we would never get to draw the pdf and would only draw the 85 // scrollbars. This value is picked to give enough time for gpu related code to 86 // do its thing and still fit within the timelimit for 60Hz. For the 87 // non-composited case, this doesn't make things worse since we're still 88 // painting the scrollbars > 60 Hz. 89 #define kMaxInitialProgressivePaintTimeMs 10 90 91 // Copied from printing/units.cc because we don't want to depend on printing 92 // since it brings in libpng which causes duplicate symbols with PDFium. 93 const int kPointsPerInch = 72; 94 const int kPixelsPerInch = 96; 95 96 struct ClipBox { 97 float left; 98 float right; 99 float top; 100 float bottom; 101 }; 102 103 int ConvertUnit(int value, int old_unit, int new_unit) { 104 // With integer arithmetic, to divide a value with correct rounding, you need 105 // to add half of the divisor value to the dividend value. You need to do the 106 // reverse with negative number. 107 if (value >= 0) { 108 return ((value * new_unit) + (old_unit / 2)) / old_unit; 109 } else { 110 return ((value * new_unit) - (old_unit / 2)) / old_unit; 111 } 112 } 113 114 std::vector<uint32_t> GetPageNumbersFromPrintPageNumberRange( 115 const PP_PrintPageNumberRange_Dev* page_ranges, 116 uint32_t page_range_count) { 117 std::vector<uint32_t> page_numbers; 118 for (uint32_t index = 0; index < page_range_count; ++index) { 119 for (uint32_t page_number = page_ranges[index].first_page_number; 120 page_number <= page_ranges[index].last_page_number; ++page_number) { 121 page_numbers.push_back(page_number); 122 } 123 } 124 return page_numbers; 125 } 126 127 #if defined(OS_LINUX) 128 129 PP_Instance g_last_instance_id; 130 131 struct PDFFontSubstitution { 132 const char* pdf_name; 133 const char* face; 134 bool bold; 135 bool italic; 136 }; 137 138 PP_BrowserFont_Trusted_Weight WeightToBrowserFontTrustedWeight(int weight) { 139 COMPILE_ASSERT(PP_BROWSERFONT_TRUSTED_WEIGHT_100 == 0, 140 PP_BrowserFont_Trusted_Weight_Min); 141 COMPILE_ASSERT(PP_BROWSERFONT_TRUSTED_WEIGHT_900 == 8, 142 PP_BrowserFont_Trusted_Weight_Max); 143 const int kMinimumWeight = 100; 144 const int kMaximumWeight = 900; 145 int normalized_weight = 146 std::min(std::max(weight, kMinimumWeight), kMaximumWeight); 147 normalized_weight = (normalized_weight / 100) - 1; 148 return static_cast<PP_BrowserFont_Trusted_Weight>(normalized_weight); 149 } 150 151 // This list is for CPWL_FontMap::GetDefaultFontByCharset(). 152 // We pretend to have these font natively and let the browser (or underlying 153 // fontconfig) to pick the proper font on the system. 154 void EnumFonts(struct _FPDF_SYSFONTINFO* sysfontinfo, void* mapper) { 155 FPDF_AddInstalledFont(mapper, "Arial", FXFONT_DEFAULT_CHARSET); 156 157 int i = 0; 158 while (CPWL_FontMap::defaultTTFMap[i].charset != -1) { 159 FPDF_AddInstalledFont(mapper, 160 CPWL_FontMap::defaultTTFMap[i].fontname, 161 CPWL_FontMap::defaultTTFMap[i].charset); 162 ++i; 163 } 164 } 165 166 const PDFFontSubstitution PDFFontSubstitutions[] = { 167 {"Courier", "Courier New", false, false}, 168 {"Courier-Bold", "Courier New", true, false}, 169 {"Courier-BoldOblique", "Courier New", true, true}, 170 {"Courier-Oblique", "Courier New", false, true}, 171 {"Helvetica", "Arial", false, false}, 172 {"Helvetica-Bold", "Arial", true, false}, 173 {"Helvetica-BoldOblique", "Arial", true, true}, 174 {"Helvetica-Oblique", "Arial", false, true}, 175 {"Times-Roman", "Times New Roman", false, false}, 176 {"Times-Bold", "Times New Roman", true, false}, 177 {"Times-BoldItalic", "Times New Roman", true, true}, 178 {"Times-Italic", "Times New Roman", false, true}, 179 180 // MS P?(Mincho|Gothic) are the most notable fonts in Japanese PDF files 181 // without embedding the glyphs. Sometimes the font names are encoded 182 // in Japanese Windows's locale (CP932/Shift_JIS) without space. 183 // Most Linux systems don't have the exact font, but for outsourcing 184 // fontconfig to find substitutable font in the system, we pass ASCII 185 // font names to it. 186 {"MS-PGothic", "MS PGothic", false, false}, 187 {"MS-Gothic", "MS Gothic", false, false}, 188 {"MS-PMincho", "MS PMincho", false, false}, 189 {"MS-Mincho", "MS Mincho", false, false}, 190 // MS PGothic in Shift_JIS encoding. 191 {"\x82\x6C\x82\x72\x82\x6F\x83\x53\x83\x56\x83\x62\x83\x4E", 192 "MS PGothic", false, false}, 193 // MS Gothic in Shift_JIS encoding. 194 {"\x82\x6C\x82\x72\x83\x53\x83\x56\x83\x62\x83\x4E", 195 "MS Gothic", false, false}, 196 // MS PMincho in Shift_JIS encoding. 197 {"\x82\x6C\x82\x72\x82\x6F\x96\xBE\x92\xA9", 198 "MS PMincho", false, false}, 199 // MS Mincho in Shift_JIS encoding. 200 {"\x82\x6C\x82\x72\x96\xBE\x92\xA9", 201 "MS Mincho", false, false}, 202 }; 203 204 void* MapFont(struct _FPDF_SYSFONTINFO*, int weight, int italic, 205 int charset, int pitch_family, const char* face, int* exact) { 206 // Do not attempt to map fonts if pepper is not initialized (for privet local 207 // printing). 208 // TODO(noamsml): Real font substitution (http://crbug.com/391978) 209 if (!pp::Module::Get()) 210 return NULL; 211 212 pp::BrowserFontDescription description; 213 214 // Pretend the system does not have the Symbol font to force a fallback to 215 // the built in Symbol font in CFX_FontMapper::FindSubstFont(). 216 if (strcmp(face, "Symbol") == 0) 217 return NULL; 218 219 if (pitch_family & FXFONT_FF_FIXEDPITCH) { 220 description.set_family(PP_BROWSERFONT_TRUSTED_FAMILY_MONOSPACE); 221 } else if (pitch_family & FXFONT_FF_ROMAN) { 222 description.set_family(PP_BROWSERFONT_TRUSTED_FAMILY_SERIF); 223 } 224 225 // Map from the standard PDF fonts to TrueType font names. 226 size_t i; 227 for (i = 0; i < arraysize(PDFFontSubstitutions); ++i) { 228 if (strcmp(face, PDFFontSubstitutions[i].pdf_name) == 0) { 229 description.set_face(PDFFontSubstitutions[i].face); 230 if (PDFFontSubstitutions[i].bold) 231 description.set_weight(PP_BROWSERFONT_TRUSTED_WEIGHT_BOLD); 232 if (PDFFontSubstitutions[i].italic) 233 description.set_italic(true); 234 break; 235 } 236 } 237 238 if (i == arraysize(PDFFontSubstitutions)) { 239 // TODO(kochi): Pass the face in UTF-8. If face is not encoded in UTF-8, 240 // convert to UTF-8 before passing. 241 description.set_face(face); 242 243 description.set_weight(WeightToBrowserFontTrustedWeight(weight)); 244 description.set_italic(italic > 0); 245 } 246 247 if (!pp::PDF::IsAvailable()) { 248 NOTREACHED(); 249 return NULL; 250 } 251 252 PP_Resource font_resource = pp::PDF::GetFontFileWithFallback( 253 pp::InstanceHandle(g_last_instance_id), 254 &description.pp_font_description(), 255 static_cast<PP_PrivateFontCharset>(charset)); 256 long res_id = font_resource; 257 return reinterpret_cast<void*>(res_id); 258 } 259 260 unsigned long GetFontData(struct _FPDF_SYSFONTINFO*, void* font_id, 261 unsigned int table, unsigned char* buffer, 262 unsigned long buf_size) { 263 if (!pp::PDF::IsAvailable()) { 264 NOTREACHED(); 265 return 0; 266 } 267 268 uint32_t size = buf_size; 269 long res_id = reinterpret_cast<long>(font_id); 270 if (!pp::PDF::GetFontTableForPrivateFontFile(res_id, table, buffer, &size)) 271 return 0; 272 return size; 273 } 274 275 void DeleteFont(struct _FPDF_SYSFONTINFO*, void* font_id) { 276 long res_id = reinterpret_cast<long>(font_id); 277 pp::Module::Get()->core()->ReleaseResource(res_id); 278 } 279 280 FPDF_SYSFONTINFO g_font_info = { 281 1, 282 0, 283 EnumFonts, 284 MapFont, 285 0, 286 GetFontData, 287 0, 288 0, 289 DeleteFont 290 }; 291 #endif // defined(OS_LINUX) 292 293 void OOM_Handler(_OOM_INFO*) { 294 // Kill the process. This is important for security, since the code doesn't 295 // NULL-check many memory allocations. If a malloc fails, returns NULL, and 296 // the buffer is then used, it provides a handy mapping of memory starting at 297 // address 0 for an attacker to utilize. 298 abort(); 299 } 300 301 OOM_INFO g_oom_info = { 302 1, 303 OOM_Handler 304 }; 305 306 PDFiumEngine* g_engine_for_unsupported; 307 308 void Unsupported_Handler(UNSUPPORT_INFO*, int type) { 309 if (!g_engine_for_unsupported) { 310 NOTREACHED(); 311 return; 312 } 313 314 g_engine_for_unsupported->UnsupportedFeature(type); 315 } 316 317 UNSUPPORT_INFO g_unsuppored_info = { 318 1, 319 Unsupported_Handler 320 }; 321 322 // Set the destination page size and content area in points based on source 323 // page rotation and orientation. 324 // 325 // |rotated| True if source page is rotated 90 degree or 270 degree. 326 // |is_src_page_landscape| is true if the source page orientation is landscape. 327 // |page_size| has the actual destination page size in points. 328 // |content_rect| has the actual destination page printable area values in 329 // points. 330 void SetPageSizeAndContentRect(bool rotated, 331 bool is_src_page_landscape, 332 pp::Size* page_size, 333 pp::Rect* content_rect) { 334 bool is_dst_page_landscape = page_size->width() > page_size->height(); 335 bool page_orientation_mismatched = is_src_page_landscape != 336 is_dst_page_landscape; 337 bool rotate_dst_page = rotated ^ page_orientation_mismatched; 338 if (rotate_dst_page) { 339 page_size->SetSize(page_size->height(), page_size->width()); 340 content_rect->SetRect(content_rect->y(), content_rect->x(), 341 content_rect->height(), content_rect->width()); 342 } 343 } 344 345 // Calculate the scale factor between |content_rect| and a page of size 346 // |src_width| x |src_height|. 347 // 348 // |scale_to_fit| is true, if we need to calculate the scale factor. 349 // |content_rect| specifies the printable area of the destination page, with 350 // origin at left-bottom. Values are in points. 351 // |src_width| specifies the source page width in points. 352 // |src_height| specifies the source page height in points. 353 // |rotated| True if source page is rotated 90 degree or 270 degree. 354 double CalculateScaleFactor(bool scale_to_fit, 355 const pp::Rect& content_rect, 356 double src_width, double src_height, bool rotated) { 357 if (!scale_to_fit || src_width == 0 || src_height == 0) 358 return 1.0; 359 360 double actual_source_page_width = rotated ? src_height : src_width; 361 double actual_source_page_height = rotated ? src_width : src_height; 362 double ratio_x = static_cast<double>(content_rect.width()) / 363 actual_source_page_width; 364 double ratio_y = static_cast<double>(content_rect.height()) / 365 actual_source_page_height; 366 return std::min(ratio_x, ratio_y); 367 } 368 369 // Compute source clip box boundaries based on the crop box / media box of 370 // source page and scale factor. 371 // 372 // |page| Handle to the source page. Returned by FPDF_LoadPage function. 373 // |scale_factor| specifies the scale factor that should be applied to source 374 // clip box boundaries. 375 // |rotated| True if source page is rotated 90 degree or 270 degree. 376 // |clip_box| out param to hold the computed source clip box values. 377 void CalculateClipBoxBoundary(FPDF_PAGE page, double scale_factor, bool rotated, 378 ClipBox* clip_box) { 379 if (!FPDFPage_GetCropBox(page, &clip_box->left, &clip_box->bottom, 380 &clip_box->right, &clip_box->top)) { 381 if (!FPDFPage_GetMediaBox(page, &clip_box->left, &clip_box->bottom, 382 &clip_box->right, &clip_box->top)) { 383 // Make the default size to be letter size (8.5" X 11"). We are just 384 // following the PDFium way of handling these corner cases. PDFium always 385 // consider US-Letter as the default page size. 386 float paper_width = 612; 387 float paper_height = 792; 388 clip_box->left = 0; 389 clip_box->bottom = 0; 390 clip_box->right = rotated ? paper_height : paper_width; 391 clip_box->top = rotated ? paper_width : paper_height; 392 } 393 } 394 clip_box->left *= scale_factor; 395 clip_box->right *= scale_factor; 396 clip_box->bottom *= scale_factor; 397 clip_box->top *= scale_factor; 398 } 399 400 // Calculate the clip box translation offset for a page that does need to be 401 // scaled. All parameters are in points. 402 // 403 // |content_rect| specifies the printable area of the destination page, with 404 // origin at left-bottom. 405 // |source_clip_box| specifies the source clip box positions, relative to 406 // origin at left-bottom. 407 // |offset_x| and |offset_y| will contain the final translation offsets for the 408 // source clip box, relative to origin at left-bottom. 409 void CalculateScaledClipBoxOffset(const pp::Rect& content_rect, 410 const ClipBox& source_clip_box, 411 double* offset_x, double* offset_y) { 412 const float clip_box_width = source_clip_box.right - source_clip_box.left; 413 const float clip_box_height = source_clip_box.top - source_clip_box.bottom; 414 415 // Center the intended clip region to real clip region. 416 *offset_x = (content_rect.width() - clip_box_width) / 2 + content_rect.x() - 417 source_clip_box.left; 418 *offset_y = (content_rect.height() - clip_box_height) / 2 + content_rect.y() - 419 source_clip_box.bottom; 420 } 421 422 // Calculate the clip box offset for a page that does not need to be scaled. 423 // All parameters are in points. 424 // 425 // |content_rect| specifies the printable area of the destination page, with 426 // origin at left-bottom. 427 // |rotation| specifies the source page rotation values which are N / 90 428 // degrees. 429 // |page_width| specifies the screen destination page width. 430 // |page_height| specifies the screen destination page height. 431 // |source_clip_box| specifies the source clip box positions, relative to origin 432 // at left-bottom. 433 // |offset_x| and |offset_y| will contain the final translation offsets for the 434 // source clip box, relative to origin at left-bottom. 435 void CalculateNonScaledClipBoxOffset(const pp::Rect& content_rect, int rotation, 436 int page_width, int page_height, 437 const ClipBox& source_clip_box, 438 double* offset_x, double* offset_y) { 439 // Align the intended clip region to left-top corner of real clip region. 440 switch (rotation) { 441 case 0: 442 *offset_x = -1 * source_clip_box.left; 443 *offset_y = page_height - source_clip_box.top; 444 break; 445 case 1: 446 *offset_x = 0; 447 *offset_y = -1 * source_clip_box.bottom; 448 break; 449 case 2: 450 *offset_x = page_width - source_clip_box.right; 451 *offset_y = 0; 452 break; 453 case 3: 454 *offset_x = page_height - source_clip_box.right; 455 *offset_y = page_width - source_clip_box.top; 456 break; 457 default: 458 NOTREACHED(); 459 break; 460 } 461 } 462 463 // This formats a string with special 0xfffe end-of-line hyphens the same way 464 // as Adobe Reader. When a hyphen is encountered, the next non-CR/LF whitespace 465 // becomes CR+LF and the hyphen is erased. If there is no whitespace between 466 // two hyphens, the latter hyphen is erased and ignored. 467 void FormatStringWithHyphens(base::string16* text) { 468 // First pass marks all the hyphen positions. 469 struct HyphenPosition { 470 HyphenPosition() : position(0), next_whitespace_position(0) {} 471 size_t position; 472 size_t next_whitespace_position; // 0 for none 473 }; 474 std::vector<HyphenPosition> hyphen_positions; 475 HyphenPosition current_hyphen_position; 476 bool current_hyphen_position_is_valid = false; 477 const base::char16 kPdfiumHyphenEOL = 0xfffe; 478 479 for (size_t i = 0; i < text->size(); ++i) { 480 const base::char16& current_char = (*text)[i]; 481 if (current_char == kPdfiumHyphenEOL) { 482 if (current_hyphen_position_is_valid) 483 hyphen_positions.push_back(current_hyphen_position); 484 current_hyphen_position = HyphenPosition(); 485 current_hyphen_position.position = i; 486 current_hyphen_position_is_valid = true; 487 } else if (IsWhitespace(current_char)) { 488 if (current_hyphen_position_is_valid) { 489 if (current_char != L'\r' && current_char != L'\n') 490 current_hyphen_position.next_whitespace_position = i; 491 hyphen_positions.push_back(current_hyphen_position); 492 current_hyphen_position_is_valid = false; 493 } 494 } 495 } 496 if (current_hyphen_position_is_valid) 497 hyphen_positions.push_back(current_hyphen_position); 498 499 // With all the hyphen positions, do the search and replace. 500 while (!hyphen_positions.empty()) { 501 static const base::char16 kCr[] = {L'\r', L'\0'}; 502 const HyphenPosition& position = hyphen_positions.back(); 503 if (position.next_whitespace_position != 0) { 504 (*text)[position.next_whitespace_position] = L'\n'; 505 text->insert(position.next_whitespace_position, kCr); 506 } 507 text->erase(position.position, 1); 508 hyphen_positions.pop_back(); 509 } 510 511 // Adobe Reader also get rid of trailing spaces right before a CRLF. 512 static const base::char16 kSpaceCrCn[] = {L' ', L'\r', L'\n', L'\0'}; 513 static const base::char16 kCrCn[] = {L'\r', L'\n', L'\0'}; 514 ReplaceSubstringsAfterOffset(text, 0, kSpaceCrCn, kCrCn); 515 } 516 517 // Replace CR/LF with just LF on POSIX. 518 void FormatStringForOS(base::string16* text) { 519 #if defined(OS_POSIX) 520 static const base::char16 kCr[] = {L'\r', L'\0'}; 521 static const base::char16 kBlank[] = {L'\0'}; 522 base::ReplaceChars(*text, kCr, kBlank, text); 523 #elif defined(OS_WIN) 524 // Do nothing 525 #else 526 NOTIMPLEMENTED(); 527 #endif 528 } 529 530 } // namespace 531 532 bool InitializeSDK(void* data) { 533 FPDF_InitLibrary(data); 534 535 #if defined(OS_LINUX) 536 // Font loading doesn't work in the renderer sandbox in Linux. 537 FPDF_SetSystemFontInfo(&g_font_info); 538 #endif 539 540 FSDK_SetOOMHandler(&g_oom_info); 541 FSDK_SetUnSpObjProcessHandler(&g_unsuppored_info); 542 543 return true; 544 } 545 546 void ShutdownSDK() { 547 FPDF_DestroyLibrary(); 548 } 549 550 PDFEngine* PDFEngine::Create(PDFEngine::Client* client) { 551 return new PDFiumEngine(client); 552 } 553 554 PDFiumEngine::PDFiumEngine(PDFEngine::Client* client) 555 : client_(client), 556 current_zoom_(1.0), 557 current_rotation_(0), 558 doc_loader_(this), 559 password_tries_remaining_(0), 560 doc_(NULL), 561 form_(NULL), 562 defer_page_unload_(false), 563 selecting_(false), 564 mouse_down_state_(PDFiumPage::NONSELECTABLE_AREA, 565 PDFiumPage::LinkTarget()), 566 next_page_to_search_(-1), 567 last_page_to_search_(-1), 568 last_character_index_to_search_(-1), 569 current_find_index_(-1), 570 permissions_(0), 571 fpdf_availability_(NULL), 572 next_timer_id_(0), 573 last_page_mouse_down_(-1), 574 first_visible_page_(-1), 575 most_visible_page_(-1), 576 called_do_document_action_(false), 577 render_grayscale_(false), 578 progressive_paint_timeout_(0), 579 getting_password_(false) { 580 find_factory_.Initialize(this); 581 password_factory_.Initialize(this); 582 583 file_access_.m_FileLen = 0; 584 file_access_.m_GetBlock = &GetBlock; 585 file_access_.m_Param = &doc_loader_; 586 587 file_availability_.version = 1; 588 file_availability_.IsDataAvail = &IsDataAvail; 589 file_availability_.loader = &doc_loader_; 590 591 download_hints_.version = 1; 592 download_hints_.AddSegment = &AddSegment; 593 download_hints_.loader = &doc_loader_; 594 595 // Initialize FPDF_FORMFILLINFO member variables. Deriving from this struct 596 // allows the static callbacks to be able to cast the FPDF_FORMFILLINFO in 597 // callbacks to ourself instead of maintaining a map of them to 598 // PDFiumEngine. 599 FPDF_FORMFILLINFO::version = 1; 600 FPDF_FORMFILLINFO::m_pJsPlatform = this; 601 FPDF_FORMFILLINFO::Release = NULL; 602 FPDF_FORMFILLINFO::FFI_Invalidate = Form_Invalidate; 603 FPDF_FORMFILLINFO::FFI_OutputSelectedRect = Form_OutputSelectedRect; 604 FPDF_FORMFILLINFO::FFI_SetCursor = Form_SetCursor; 605 FPDF_FORMFILLINFO::FFI_SetTimer = Form_SetTimer; 606 FPDF_FORMFILLINFO::FFI_KillTimer = Form_KillTimer; 607 FPDF_FORMFILLINFO::FFI_GetLocalTime = Form_GetLocalTime; 608 FPDF_FORMFILLINFO::FFI_OnChange = Form_OnChange; 609 FPDF_FORMFILLINFO::FFI_GetPage = Form_GetPage; 610 FPDF_FORMFILLINFO::FFI_GetCurrentPage = Form_GetCurrentPage; 611 FPDF_FORMFILLINFO::FFI_GetRotation = Form_GetRotation; 612 FPDF_FORMFILLINFO::FFI_ExecuteNamedAction = Form_ExecuteNamedAction; 613 FPDF_FORMFILLINFO::FFI_SetTextFieldFocus = Form_SetTextFieldFocus; 614 FPDF_FORMFILLINFO::FFI_DoURIAction = Form_DoURIAction; 615 FPDF_FORMFILLINFO::FFI_DoGoToAction = Form_DoGoToAction; 616 617 IPDF_JSPLATFORM::version = 1; 618 IPDF_JSPLATFORM::app_alert = Form_Alert; 619 IPDF_JSPLATFORM::app_beep = Form_Beep; 620 IPDF_JSPLATFORM::app_response = Form_Response; 621 IPDF_JSPLATFORM::Doc_getFilePath = Form_GetFilePath; 622 IPDF_JSPLATFORM::Doc_mail = Form_Mail; 623 IPDF_JSPLATFORM::Doc_print = Form_Print; 624 IPDF_JSPLATFORM::Doc_submitForm = Form_SubmitForm; 625 IPDF_JSPLATFORM::Doc_gotoPage = Form_GotoPage; 626 IPDF_JSPLATFORM::Field_browse = Form_Browse; 627 628 IFSDK_PAUSE::version = 1; 629 IFSDK_PAUSE::user = NULL; 630 IFSDK_PAUSE::NeedToPauseNow = Pause_NeedToPauseNow; 631 } 632 633 PDFiumEngine::~PDFiumEngine() { 634 for (size_t i = 0; i < pages_.size(); ++i) 635 pages_[i]->Unload(); 636 637 if (doc_) { 638 if (form_) { 639 FORM_DoDocumentAAction(form_, FPDFDOC_AACTION_WC); 640 FPDFDOC_ExitFormFillEnviroument(form_); 641 } 642 FPDF_CloseDocument(doc_); 643 } 644 645 if (fpdf_availability_) 646 FPDFAvail_Destroy(fpdf_availability_); 647 648 STLDeleteElements(&pages_); 649 } 650 651 int PDFiumEngine::GetBlock(void* param, unsigned long position, 652 unsigned char* buffer, unsigned long size) { 653 DocumentLoader* loader = static_cast<DocumentLoader*>(param); 654 return loader->GetBlock(position, size, buffer); 655 } 656 657 bool PDFiumEngine::IsDataAvail(FX_FILEAVAIL* param, 658 size_t offset, size_t size) { 659 PDFiumEngine::FileAvail* file_avail = 660 static_cast<PDFiumEngine::FileAvail*>(param); 661 return file_avail->loader->IsDataAvailable(offset, size); 662 } 663 664 void PDFiumEngine::AddSegment(FX_DOWNLOADHINTS* param, 665 size_t offset, size_t size) { 666 PDFiumEngine::DownloadHints* download_hints = 667 static_cast<PDFiumEngine::DownloadHints*>(param); 668 return download_hints->loader->RequestData(offset, size); 669 } 670 671 bool PDFiumEngine::New(const char* url) { 672 url_ = url; 673 headers_ = std::string(); 674 return true; 675 } 676 677 bool PDFiumEngine::New(const char* url, 678 const char* headers) { 679 url_ = url; 680 if (!headers) 681 headers_ = std::string(); 682 else 683 headers_ = headers; 684 return true; 685 } 686 687 void PDFiumEngine::PageOffsetUpdated(const pp::Point& page_offset) { 688 page_offset_ = page_offset; 689 } 690 691 void PDFiumEngine::PluginSizeUpdated(const pp::Size& size) { 692 CancelPaints(); 693 694 plugin_size_ = size; 695 CalculateVisiblePages(); 696 } 697 698 void PDFiumEngine::ScrolledToXPosition(int position) { 699 CancelPaints(); 700 701 int old_x = position_.x(); 702 position_.set_x(position); 703 CalculateVisiblePages(); 704 client_->Scroll(pp::Point(old_x - position, 0)); 705 } 706 707 void PDFiumEngine::ScrolledToYPosition(int position) { 708 CancelPaints(); 709 710 int old_y = position_.y(); 711 position_.set_y(position); 712 CalculateVisiblePages(); 713 client_->Scroll(pp::Point(0, old_y - position)); 714 } 715 716 void PDFiumEngine::PrePaint() { 717 for (size_t i = 0; i < progressive_paints_.size(); ++i) 718 progressive_paints_[i].painted_ = false; 719 } 720 721 void PDFiumEngine::Paint(const pp::Rect& rect, 722 pp::ImageData* image_data, 723 std::vector<pp::Rect>* ready, 724 std::vector<pp::Rect>* pending) { 725 pp::Rect leftover = rect; 726 for (size_t i = 0; i < visible_pages_.size(); ++i) { 727 int index = visible_pages_[i]; 728 pp::Rect page_rect = pages_[index]->rect(); 729 // Convert the current page's rectangle to screen rectangle. We do this 730 // instead of the reverse (converting the dirty rectangle from screen to 731 // page coordinates) because then we'd have to convert back to screen 732 // coordinates, and the rounding errors sometime leave pixels dirty or even 733 // move the text up or down a pixel when zoomed. 734 pp::Rect page_rect_in_screen = GetPageScreenRect(index); 735 pp::Rect dirty_in_screen = page_rect_in_screen.Intersect(leftover); 736 if (dirty_in_screen.IsEmpty()) 737 continue; 738 739 leftover = leftover.Subtract(dirty_in_screen); 740 741 if (pages_[index]->available()) { 742 int progressive = GetProgressiveIndex(index); 743 if (progressive != -1 && 744 progressive_paints_[progressive].rect != dirty_in_screen) { 745 // The PDFium code can only handle one progressive paint at a time, so 746 // queue this up. Previously we used to merge the rects when this 747 // happened, but it made scrolling up on complex PDFs very slow since 748 // there would be a damaged rect at the top (from scroll) and at the 749 // bottom (from toolbar). 750 pending->push_back(dirty_in_screen); 751 continue; 752 } 753 754 if (progressive == -1) { 755 progressive = StartPaint(index, dirty_in_screen); 756 progressive_paint_timeout_ = kMaxInitialProgressivePaintTimeMs; 757 } else { 758 progressive_paint_timeout_ = kMaxProgressivePaintTimeMs; 759 } 760 761 progressive_paints_[progressive].painted_ = true; 762 if (ContinuePaint(progressive, image_data)) { 763 FinishPaint(progressive, image_data); 764 ready->push_back(dirty_in_screen); 765 } else { 766 pending->push_back(dirty_in_screen); 767 } 768 } else { 769 PaintUnavailablePage(index, dirty_in_screen, image_data); 770 ready->push_back(dirty_in_screen); 771 } 772 } 773 } 774 775 void PDFiumEngine::PostPaint() { 776 for (size_t i = 0; i < progressive_paints_.size(); ++i) { 777 if (progressive_paints_[i].painted_) 778 continue; 779 780 // This rectangle must have been merged with another one, that's why we 781 // weren't asked to paint it. Remove it or otherwise we'll never finish 782 // painting. 783 FPDF_RenderPage_Close( 784 pages_[progressive_paints_[i].page_index]->GetPage()); 785 FPDFBitmap_Destroy(progressive_paints_[i].bitmap); 786 progressive_paints_.erase(progressive_paints_.begin() + i); 787 --i; 788 } 789 } 790 791 bool PDFiumEngine::HandleDocumentLoad(const pp::URLLoader& loader) { 792 password_tries_remaining_ = kMaxPasswordTries; 793 return doc_loader_.Init(loader, url_, headers_); 794 } 795 796 pp::Instance* PDFiumEngine::GetPluginInstance() { 797 return client_->GetPluginInstance(); 798 } 799 800 pp::URLLoader PDFiumEngine::CreateURLLoader() { 801 return client_->CreateURLLoader(); 802 } 803 804 void PDFiumEngine::AppendPage(PDFEngine* engine, int index) { 805 // Unload and delete the blank page before appending. 806 pages_[index]->Unload(); 807 pages_[index]->set_calculated_links(false); 808 pp::Size curr_page_size = GetPageSize(index); 809 FPDFPage_Delete(doc_, index); 810 FPDF_ImportPages(doc_, 811 static_cast<PDFiumEngine*>(engine)->doc(), 812 "1", 813 index); 814 pp::Size new_page_size = GetPageSize(index); 815 if (curr_page_size != new_page_size) 816 LoadPageInfo(true); 817 client_->Invalidate(GetPageScreenRect(index)); 818 } 819 820 pp::Point PDFiumEngine::GetScrollPosition() { 821 return position_; 822 } 823 824 void PDFiumEngine::SetScrollPosition(const pp::Point& position) { 825 position_ = position; 826 } 827 828 bool PDFiumEngine::IsProgressiveLoad() { 829 return doc_loader_.is_partial_document(); 830 } 831 832 void PDFiumEngine::OnPartialDocumentLoaded() { 833 file_access_.m_FileLen = doc_loader_.document_size(); 834 fpdf_availability_ = FPDFAvail_Create(&file_availability_, &file_access_); 835 DCHECK(fpdf_availability_); 836 837 // Currently engine does not deal efficiently with some non-linearized files. 838 // See http://code.google.com/p/chromium/issues/detail?id=59400 839 // To improve user experience we download entire file for non-linearized PDF. 840 if (!FPDFAvail_IsLinearized(fpdf_availability_)) { 841 doc_loader_.RequestData(0, doc_loader_.document_size()); 842 return; 843 } 844 845 LoadDocument(); 846 } 847 848 void PDFiumEngine::OnPendingRequestComplete() { 849 if (!doc_ || !form_) { 850 LoadDocument(); 851 return; 852 } 853 854 // LoadDocument() will result in |pending_pages_| being reset so there's no 855 // need to run the code below in that case. 856 bool update_pages = false; 857 std::vector<int> still_pending; 858 for (size_t i = 0; i < pending_pages_.size(); ++i) { 859 if (CheckPageAvailable(pending_pages_[i], &still_pending)) { 860 update_pages = true; 861 if (IsPageVisible(pending_pages_[i])) 862 client_->Invalidate(GetPageScreenRect(pending_pages_[i])); 863 } 864 } 865 pending_pages_.swap(still_pending); 866 if (update_pages) 867 LoadPageInfo(true); 868 } 869 870 void PDFiumEngine::OnNewDataAvailable() { 871 client_->DocumentLoadProgress(doc_loader_.GetAvailableData(), 872 doc_loader_.document_size()); 873 } 874 875 void PDFiumEngine::OnDocumentComplete() { 876 if (!doc_ || !form_) { 877 file_access_.m_FileLen = doc_loader_.document_size(); 878 LoadDocument(); 879 return; 880 } 881 882 bool need_update = false; 883 for (size_t i = 0; i < pages_.size(); ++i) { 884 if (pages_[i]->available()) 885 continue; 886 887 pages_[i]->set_available(true); 888 // We still need to call IsPageAvail() even if the whole document is 889 // already downloaded. 890 FPDFAvail_IsPageAvail(fpdf_availability_, i, &download_hints_); 891 need_update = true; 892 if (IsPageVisible(i)) 893 client_->Invalidate(GetPageScreenRect(i)); 894 } 895 if (need_update) 896 LoadPageInfo(true); 897 898 FinishLoadingDocument(); 899 } 900 901 void PDFiumEngine::FinishLoadingDocument() { 902 DCHECK(doc_loader_.IsDocumentComplete() && doc_); 903 if (called_do_document_action_) 904 return; 905 called_do_document_action_ = true; 906 907 // These can only be called now, as the JS might end up needing a page. 908 FORM_DoDocumentJSAction(form_); 909 FORM_DoDocumentOpenAction(form_); 910 if (most_visible_page_ != -1) { 911 FPDF_PAGE new_page = pages_[most_visible_page_]->GetPage(); 912 FORM_DoPageAAction(new_page, form_, FPDFPAGE_AACTION_OPEN); 913 } 914 915 if (doc_) // This can only happen if loading |doc_| fails. 916 client_->DocumentLoadComplete(pages_.size()); 917 } 918 919 void PDFiumEngine::UnsupportedFeature(int type) { 920 std::string feature; 921 switch (type) { 922 case FPDF_UNSP_DOC_XFAFORM: 923 feature = "XFA"; 924 break; 925 case FPDF_UNSP_DOC_PORTABLECOLLECTION: 926 feature = "Portfolios_Packages"; 927 break; 928 case FPDF_UNSP_DOC_ATTACHMENT: 929 case FPDF_UNSP_ANNOT_ATTACHMENT: 930 feature = "Attachment"; 931 break; 932 case FPDF_UNSP_DOC_SECURITY: 933 feature = "Rights_Management"; 934 break; 935 case FPDF_UNSP_DOC_SHAREDREVIEW: 936 feature = "Shared_Review"; 937 break; 938 case FPDF_UNSP_DOC_SHAREDFORM_ACROBAT: 939 case FPDF_UNSP_DOC_SHAREDFORM_FILESYSTEM: 940 case FPDF_UNSP_DOC_SHAREDFORM_EMAIL: 941 feature = "Shared_Form"; 942 break; 943 case FPDF_UNSP_ANNOT_3DANNOT: 944 feature = "3D"; 945 break; 946 case FPDF_UNSP_ANNOT_MOVIE: 947 feature = "Movie"; 948 break; 949 case FPDF_UNSP_ANNOT_SOUND: 950 feature = "Sound"; 951 break; 952 case FPDF_UNSP_ANNOT_SCREEN_MEDIA: 953 case FPDF_UNSP_ANNOT_SCREEN_RICHMEDIA: 954 feature = "Screen"; 955 break; 956 case FPDF_UNSP_ANNOT_SIG: 957 feature = "Digital_Signature"; 958 break; 959 } 960 client_->DocumentHasUnsupportedFeature(feature); 961 } 962 963 void PDFiumEngine::ContinueFind(int32_t result) { 964 StartFind(current_find_text_.c_str(), !!result); 965 } 966 967 bool PDFiumEngine::HandleEvent(const pp::InputEvent& event) { 968 DCHECK(!defer_page_unload_); 969 defer_page_unload_ = true; 970 bool rv = false; 971 switch (event.GetType()) { 972 case PP_INPUTEVENT_TYPE_MOUSEDOWN: 973 rv = OnMouseDown(pp::MouseInputEvent(event)); 974 break; 975 case PP_INPUTEVENT_TYPE_MOUSEUP: 976 rv = OnMouseUp(pp::MouseInputEvent(event)); 977 break; 978 case PP_INPUTEVENT_TYPE_MOUSEMOVE: 979 rv = OnMouseMove(pp::MouseInputEvent(event)); 980 break; 981 case PP_INPUTEVENT_TYPE_KEYDOWN: 982 rv = OnKeyDown(pp::KeyboardInputEvent(event)); 983 break; 984 case PP_INPUTEVENT_TYPE_KEYUP: 985 rv = OnKeyUp(pp::KeyboardInputEvent(event)); 986 break; 987 case PP_INPUTEVENT_TYPE_CHAR: 988 rv = OnChar(pp::KeyboardInputEvent(event)); 989 break; 990 default: 991 break; 992 } 993 994 DCHECK(defer_page_unload_); 995 defer_page_unload_ = false; 996 for (size_t i = 0; i < deferred_page_unloads_.size(); ++i) 997 pages_[deferred_page_unloads_[i]]->Unload(); 998 deferred_page_unloads_.clear(); 999 return rv; 1000 } 1001 1002 uint32_t PDFiumEngine::QuerySupportedPrintOutputFormats() { 1003 if (!HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY)) 1004 return 0; 1005 return PP_PRINTOUTPUTFORMAT_PDF; 1006 } 1007 1008 void PDFiumEngine::PrintBegin() { 1009 FORM_DoDocumentAAction(form_, FPDFDOC_AACTION_WP); 1010 } 1011 1012 pp::Resource PDFiumEngine::PrintPages( 1013 const PP_PrintPageNumberRange_Dev* page_ranges, uint32_t page_range_count, 1014 const PP_PrintSettings_Dev& print_settings) { 1015 if (HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY)) 1016 return PrintPagesAsPDF(page_ranges, page_range_count, print_settings); 1017 else if (HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY)) 1018 return PrintPagesAsRasterPDF(page_ranges, page_range_count, print_settings); 1019 return pp::Resource(); 1020 } 1021 1022 FPDF_DOCUMENT PDFiumEngine::CreateSinglePageRasterPdf( 1023 double source_page_width, 1024 double source_page_height, 1025 const PP_PrintSettings_Dev& print_settings, 1026 PDFiumPage* page_to_print) { 1027 FPDF_DOCUMENT temp_doc = FPDF_CreateNewDocument(); 1028 if (!temp_doc) 1029 return temp_doc; 1030 1031 const pp::Size& bitmap_size(page_to_print->rect().size()); 1032 1033 FPDF_PAGE temp_page = 1034 FPDFPage_New(temp_doc, 0, source_page_width, source_page_height); 1035 1036 pp::ImageData image = pp::ImageData(client_->GetPluginInstance(), 1037 PP_IMAGEDATAFORMAT_BGRA_PREMUL, 1038 bitmap_size, 1039 false); 1040 1041 FPDF_BITMAP bitmap = FPDFBitmap_CreateEx(bitmap_size.width(), 1042 bitmap_size.height(), 1043 FPDFBitmap_BGRx, 1044 image.data(), 1045 image.stride()); 1046 1047 // Clear the bitmap 1048 FPDFBitmap_FillRect( 1049 bitmap, 0, 0, bitmap_size.width(), bitmap_size.height(), 0xFFFFFFFF); 1050 1051 pp::Rect page_rect = page_to_print->rect(); 1052 FPDF_RenderPageBitmap(bitmap, 1053 page_to_print->GetPrintPage(), 1054 page_rect.x(), 1055 page_rect.y(), 1056 page_rect.width(), 1057 page_rect.height(), 1058 print_settings.orientation, 1059 FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH); 1060 1061 double ratio_x = (static_cast<double>(bitmap_size.width()) * kPointsPerInch) / 1062 print_settings.dpi; 1063 double ratio_y = 1064 (static_cast<double>(bitmap_size.height()) * kPointsPerInch) / 1065 print_settings.dpi; 1066 1067 // Add the bitmap to an image object and add the image object to the output 1068 // page. 1069 FPDF_PAGEOBJECT temp_img = FPDFPageObj_NewImgeObj(temp_doc); 1070 FPDFImageObj_SetBitmap(&temp_page, 1, temp_img, bitmap); 1071 FPDFImageObj_SetMatrix(temp_img, ratio_x, 0, 0, ratio_y, 0, 0); 1072 FPDFPage_InsertObject(temp_page, temp_img); 1073 FPDFPage_GenerateContent(temp_page); 1074 FPDF_ClosePage(temp_page); 1075 1076 page_to_print->ClosePrintPage(); 1077 FPDFBitmap_Destroy(bitmap); 1078 1079 return temp_doc; 1080 } 1081 1082 pp::Buffer_Dev PDFiumEngine::PrintPagesAsRasterPDF( 1083 const PP_PrintPageNumberRange_Dev* page_ranges, uint32_t page_range_count, 1084 const PP_PrintSettings_Dev& print_settings) { 1085 if (!page_range_count) 1086 return pp::Buffer_Dev(); 1087 1088 // If document is not downloaded yet, disable printing. 1089 if (doc_ && !doc_loader_.IsDocumentComplete()) 1090 return pp::Buffer_Dev(); 1091 1092 FPDF_DOCUMENT output_doc = FPDF_CreateNewDocument(); 1093 if (!output_doc) 1094 return pp::Buffer_Dev(); 1095 1096 SaveSelectedFormForPrint(); 1097 1098 std::vector<PDFiumPage> pages_to_print; 1099 // width and height of source PDF pages. 1100 std::vector<std::pair<double, double> > source_page_sizes; 1101 // Collect pages to print and sizes of source pages. 1102 std::vector<uint32_t> page_numbers = 1103 GetPageNumbersFromPrintPageNumberRange(page_ranges, page_range_count); 1104 for (size_t i = 0; i < page_numbers.size(); ++i) { 1105 uint32_t page_number = page_numbers[i]; 1106 FPDF_PAGE pdf_page = FPDF_LoadPage(doc_, page_number); 1107 double source_page_width = FPDF_GetPageWidth(pdf_page); 1108 double source_page_height = FPDF_GetPageHeight(pdf_page); 1109 source_page_sizes.push_back(std::make_pair(source_page_width, 1110 source_page_height)); 1111 1112 int width_in_pixels = ConvertUnit(source_page_width, 1113 static_cast<int>(kPointsPerInch), 1114 print_settings.dpi); 1115 int height_in_pixels = ConvertUnit(source_page_height, 1116 static_cast<int>(kPointsPerInch), 1117 print_settings.dpi); 1118 1119 pp::Rect rect(width_in_pixels, height_in_pixels); 1120 pages_to_print.push_back(PDFiumPage(this, page_number, rect, true)); 1121 FPDF_ClosePage(pdf_page); 1122 } 1123 1124 #if defined(OS_LINUX) 1125 g_last_instance_id = client_->GetPluginInstance()->pp_instance(); 1126 #endif 1127 1128 size_t i = 0; 1129 for (; i < pages_to_print.size(); ++i) { 1130 double source_page_width = source_page_sizes[i].first; 1131 double source_page_height = source_page_sizes[i].second; 1132 1133 // Use temp_doc to compress image by saving PDF to buffer. 1134 FPDF_DOCUMENT temp_doc = CreateSinglePageRasterPdf(source_page_width, 1135 source_page_height, 1136 print_settings, 1137 &pages_to_print[i]); 1138 1139 if (!temp_doc) 1140 break; 1141 1142 pp::Buffer_Dev buffer = GetFlattenedPrintData(temp_doc); 1143 FPDF_CloseDocument(temp_doc); 1144 1145 PDFiumMemBufferFileRead file_read(buffer.data(), buffer.size()); 1146 temp_doc = FPDF_LoadCustomDocument(&file_read, NULL); 1147 1148 FPDF_BOOL imported = FPDF_ImportPages(output_doc, temp_doc, "1", i); 1149 FPDF_CloseDocument(temp_doc); 1150 if (!imported) 1151 break; 1152 } 1153 1154 pp::Buffer_Dev buffer; 1155 if (i == pages_to_print.size()) { 1156 FPDF_CopyViewerPreferences(output_doc, doc_); 1157 FitContentsToPrintableAreaIfRequired(output_doc, print_settings); 1158 // Now flatten all the output pages. 1159 buffer = GetFlattenedPrintData(output_doc); 1160 } 1161 FPDF_CloseDocument(output_doc); 1162 return buffer; 1163 } 1164 1165 pp::Buffer_Dev PDFiumEngine::GetFlattenedPrintData(const FPDF_DOCUMENT& doc) { 1166 int page_count = FPDF_GetPageCount(doc); 1167 bool flatten_succeeded = true; 1168 for (int i = 0; i < page_count; ++i) { 1169 FPDF_PAGE page = FPDF_LoadPage(doc, i); 1170 DCHECK(page); 1171 if (page) { 1172 int flatten_ret = FPDFPage_Flatten(page, FLAT_PRINT); 1173 FPDF_ClosePage(page); 1174 if (flatten_ret == FLATTEN_FAIL) { 1175 flatten_succeeded = false; 1176 break; 1177 } 1178 } else { 1179 flatten_succeeded = false; 1180 break; 1181 } 1182 } 1183 if (!flatten_succeeded) { 1184 FPDF_CloseDocument(doc); 1185 return pp::Buffer_Dev(); 1186 } 1187 1188 pp::Buffer_Dev buffer; 1189 PDFiumMemBufferFileWrite output_file_write; 1190 if (FPDF_SaveAsCopy(doc, &output_file_write, 0)) { 1191 buffer = pp::Buffer_Dev( 1192 client_->GetPluginInstance(), output_file_write.size()); 1193 if (!buffer.is_null()) { 1194 memcpy(buffer.data(), output_file_write.buffer().c_str(), 1195 output_file_write.size()); 1196 } 1197 } 1198 return buffer; 1199 } 1200 1201 pp::Buffer_Dev PDFiumEngine::PrintPagesAsPDF( 1202 const PP_PrintPageNumberRange_Dev* page_ranges, uint32_t page_range_count, 1203 const PP_PrintSettings_Dev& print_settings) { 1204 if (!page_range_count) 1205 return pp::Buffer_Dev(); 1206 1207 DCHECK(doc_); 1208 FPDF_DOCUMENT output_doc = FPDF_CreateNewDocument(); 1209 if (!output_doc) 1210 return pp::Buffer_Dev(); 1211 1212 SaveSelectedFormForPrint(); 1213 1214 std::string page_number_str; 1215 for (uint32_t index = 0; index < page_range_count; ++index) { 1216 if (!page_number_str.empty()) 1217 page_number_str.append(","); 1218 page_number_str.append( 1219 base::IntToString(page_ranges[index].first_page_number + 1)); 1220 if (page_ranges[index].first_page_number != 1221 page_ranges[index].last_page_number) { 1222 page_number_str.append("-"); 1223 page_number_str.append( 1224 base::IntToString(page_ranges[index].last_page_number + 1)); 1225 } 1226 } 1227 1228 std::vector<uint32_t> page_numbers = 1229 GetPageNumbersFromPrintPageNumberRange(page_ranges, page_range_count); 1230 for (size_t i = 0; i < page_numbers.size(); ++i) { 1231 uint32_t page_number = page_numbers[i]; 1232 pages_[page_number]->GetPage(); 1233 if (!IsPageVisible(page_numbers[i])) 1234 pages_[page_number]->Unload(); 1235 } 1236 1237 FPDF_CopyViewerPreferences(output_doc, doc_); 1238 if (!FPDF_ImportPages(output_doc, doc_, page_number_str.c_str(), 0)) { 1239 FPDF_CloseDocument(output_doc); 1240 return pp::Buffer_Dev(); 1241 } 1242 1243 FitContentsToPrintableAreaIfRequired(output_doc, print_settings); 1244 1245 // Now flatten all the output pages. 1246 pp::Buffer_Dev buffer = GetFlattenedPrintData(output_doc); 1247 FPDF_CloseDocument(output_doc); 1248 return buffer; 1249 } 1250 1251 void PDFiumEngine::FitContentsToPrintableAreaIfRequired( 1252 const FPDF_DOCUMENT& doc, const PP_PrintSettings_Dev& print_settings) { 1253 // Check to see if we need to fit pdf contents to printer paper size. 1254 if (print_settings.print_scaling_option != 1255 PP_PRINTSCALINGOPTION_SOURCE_SIZE) { 1256 int num_pages = FPDF_GetPageCount(doc); 1257 // In-place transformation is more efficient than creating a new 1258 // transformed document from the source document. Therefore, transform 1259 // every page to fit the contents in the selected printer paper. 1260 for (int i = 0; i < num_pages; ++i) { 1261 FPDF_PAGE page = FPDF_LoadPage(doc, i); 1262 TransformPDFPageForPrinting(page, print_settings); 1263 FPDF_ClosePage(page); 1264 } 1265 } 1266 } 1267 1268 void PDFiumEngine::SaveSelectedFormForPrint() { 1269 FORM_ForceToKillFocus(form_); 1270 client_->FormTextFieldFocusChange(false); 1271 } 1272 1273 void PDFiumEngine::PrintEnd() { 1274 FORM_DoDocumentAAction(form_, FPDFDOC_AACTION_DP); 1275 } 1276 1277 PDFiumPage::Area PDFiumEngine::GetCharIndex( 1278 const pp::MouseInputEvent& event, int* page_index, 1279 int* char_index, PDFiumPage::LinkTarget* target) { 1280 // First figure out which page this is in. 1281 pp::Point mouse_point = event.GetPosition(); 1282 pp::Point point( 1283 static_cast<int>((mouse_point.x() + position_.x()) / current_zoom_), 1284 static_cast<int>((mouse_point.y() + position_.y()) / current_zoom_)); 1285 return GetCharIndex(point, page_index, char_index, target); 1286 } 1287 1288 PDFiumPage::Area PDFiumEngine::GetCharIndex( 1289 const pp::Point& point, 1290 int* page_index, 1291 int* char_index, 1292 PDFiumPage::LinkTarget* target) { 1293 int page = -1; 1294 for (size_t i = 0; i < visible_pages_.size(); ++i) { 1295 if (pages_[visible_pages_[i]]->rect().Contains(point)) { 1296 page = visible_pages_[i]; 1297 break; 1298 } 1299 } 1300 if (page == -1) 1301 return PDFiumPage::NONSELECTABLE_AREA; 1302 1303 // If the page hasn't finished rendering, calling into the page sometimes 1304 // leads to hangs. 1305 for (size_t i = 0; i < progressive_paints_.size(); ++i) { 1306 if (progressive_paints_[i].page_index == page) 1307 return PDFiumPage::NONSELECTABLE_AREA; 1308 } 1309 1310 *page_index = page; 1311 return pages_[page]->GetCharIndex(point, current_rotation_, char_index, 1312 target); 1313 } 1314 1315 bool PDFiumEngine::OnMouseDown(const pp::MouseInputEvent& event) { 1316 if (event.GetButton() != PP_INPUTEVENT_MOUSEBUTTON_LEFT) 1317 return false; 1318 1319 SelectionChangeInvalidator selection_invalidator(this); 1320 selection_.clear(); 1321 1322 int page_index = -1; 1323 int char_index = -1; 1324 PDFiumPage::LinkTarget target; 1325 PDFiumPage::Area area = GetCharIndex(event, &page_index, 1326 &char_index, &target); 1327 mouse_down_state_.Set(area, target); 1328 1329 // Decide whether to open link or not based on user action in mouse up and 1330 // mouse move events. 1331 if (area == PDFiumPage::WEBLINK_AREA) 1332 return true; 1333 1334 if (area == PDFiumPage::DOCLINK_AREA) { 1335 client_->ScrollToPage(target.page); 1336 client_->FormTextFieldFocusChange(false); 1337 return true; 1338 } 1339 1340 if (page_index != -1) { 1341 last_page_mouse_down_ = page_index; 1342 double page_x, page_y; 1343 pp::Point point = event.GetPosition(); 1344 DeviceToPage(page_index, point.x(), point.y(), &page_x, &page_y); 1345 1346 FORM_OnLButtonDown(form_, pages_[page_index]->GetPage(), 0, page_x, page_y); 1347 int control = FPDPage_HasFormFieldAtPoint( 1348 form_, pages_[page_index]->GetPage(), page_x, page_y); 1349 if (control > FPDF_FORMFIELD_UNKNOWN) { // returns -1 sometimes... 1350 client_->FormTextFieldFocusChange(control == FPDF_FORMFIELD_TEXTFIELD || 1351 control == FPDF_FORMFIELD_COMBOBOX); 1352 return true; // Return now before we get into the selection code. 1353 } 1354 } 1355 1356 client_->FormTextFieldFocusChange(false); 1357 1358 if (area != PDFiumPage::TEXT_AREA) 1359 return true; // Return true so WebKit doesn't do its own highlighting. 1360 1361 if (event.GetClickCount() == 1) { 1362 OnSingleClick(page_index, char_index); 1363 } else if (event.GetClickCount() == 2 || 1364 event.GetClickCount() == 3) { 1365 OnMultipleClick(event.GetClickCount(), page_index, char_index); 1366 } 1367 1368 return true; 1369 } 1370 1371 void PDFiumEngine::OnSingleClick(int page_index, int char_index) { 1372 selecting_ = true; 1373 selection_.push_back(PDFiumRange(pages_[page_index], char_index, 0)); 1374 } 1375 1376 void PDFiumEngine::OnMultipleClick(int click_count, 1377 int page_index, 1378 int char_index) { 1379 // It would be more efficient if the SDK could support finding a space, but 1380 // now it doesn't. 1381 int start_index = char_index; 1382 do { 1383 base::char16 cur = pages_[page_index]->GetCharAtIndex(start_index); 1384 // For double click, we want to select one word so we look for whitespace 1385 // boundaries. For triple click, we want the whole line. 1386 if (cur == '\n' || (click_count == 2 && (cur == ' ' || cur == '\t'))) 1387 break; 1388 } while (--start_index >= 0); 1389 if (start_index) 1390 start_index++; 1391 1392 int end_index = char_index; 1393 int total = pages_[page_index]->GetCharCount(); 1394 while (end_index++ <= total) { 1395 base::char16 cur = pages_[page_index]->GetCharAtIndex(end_index); 1396 if (cur == '\n' || (click_count == 2 && (cur == ' ' || cur == '\t'))) 1397 break; 1398 } 1399 1400 selection_.push_back(PDFiumRange( 1401 pages_[page_index], start_index, end_index - start_index)); 1402 } 1403 1404 bool PDFiumEngine::OnMouseUp(const pp::MouseInputEvent& event) { 1405 if (event.GetButton() != PP_INPUTEVENT_MOUSEBUTTON_LEFT) 1406 return false; 1407 1408 int page_index = -1; 1409 int char_index = -1; 1410 PDFiumPage::LinkTarget target; 1411 PDFiumPage::Area area = 1412 GetCharIndex(event, &page_index, &char_index, &target); 1413 1414 // Open link on mouse up for same link for which mouse down happened earlier. 1415 if (mouse_down_state_.Matches(area, target)) { 1416 if (area == PDFiumPage::WEBLINK_AREA) { 1417 bool open_in_new_tab = !!(event.GetModifiers() & kDefaultKeyModifier); 1418 client_->NavigateTo(target.url, open_in_new_tab); 1419 client_->FormTextFieldFocusChange(false); 1420 return true; 1421 } 1422 } 1423 1424 if (page_index != -1) { 1425 double page_x, page_y; 1426 pp::Point point = event.GetPosition(); 1427 DeviceToPage(page_index, point.x(), point.y(), &page_x, &page_y); 1428 FORM_OnLButtonUp( 1429 form_, pages_[page_index]->GetPage(), 0, page_x, page_y); 1430 } 1431 1432 if (!selecting_) 1433 return false; 1434 1435 selecting_ = false; 1436 return true; 1437 } 1438 1439 bool PDFiumEngine::OnMouseMove(const pp::MouseInputEvent& event) { 1440 int page_index = -1; 1441 int char_index = -1; 1442 PDFiumPage::LinkTarget target; 1443 PDFiumPage::Area area = 1444 GetCharIndex(event, &page_index, &char_index, &target); 1445 1446 // Clear |mouse_down_state_| if mouse moves away from where the mouse down 1447 // happened. 1448 if (!mouse_down_state_.Matches(area, target)) 1449 mouse_down_state_.Reset(); 1450 1451 if (!selecting_) { 1452 PP_CursorType_Dev cursor; 1453 switch (area) { 1454 case PDFiumPage::TEXT_AREA: 1455 cursor = PP_CURSORTYPE_IBEAM; 1456 break; 1457 case PDFiumPage::WEBLINK_AREA: 1458 case PDFiumPage::DOCLINK_AREA: 1459 cursor = PP_CURSORTYPE_HAND; 1460 break; 1461 case PDFiumPage::NONSELECTABLE_AREA: 1462 default: 1463 cursor = PP_CURSORTYPE_POINTER; 1464 break; 1465 } 1466 1467 if (page_index != -1) { 1468 double page_x, page_y; 1469 pp::Point point = event.GetPosition(); 1470 DeviceToPage(page_index, point.x(), point.y(), &page_x, &page_y); 1471 1472 FORM_OnMouseMove(form_, pages_[page_index]->GetPage(), 0, page_x, page_y); 1473 int control = FPDPage_HasFormFieldAtPoint( 1474 form_, pages_[page_index]->GetPage(), page_x, page_y); 1475 switch (control) { 1476 case FPDF_FORMFIELD_PUSHBUTTON: 1477 case FPDF_FORMFIELD_CHECKBOX: 1478 case FPDF_FORMFIELD_RADIOBUTTON: 1479 case FPDF_FORMFIELD_COMBOBOX: 1480 case FPDF_FORMFIELD_LISTBOX: 1481 cursor = PP_CURSORTYPE_HAND; 1482 break; 1483 case FPDF_FORMFIELD_TEXTFIELD: 1484 cursor = PP_CURSORTYPE_IBEAM; 1485 break; 1486 default: 1487 break; 1488 } 1489 } 1490 1491 client_->UpdateCursor(cursor); 1492 pp::Point point = event.GetPosition(); 1493 std::string url = GetLinkAtPosition(event.GetPosition()); 1494 if (url != link_under_cursor_) { 1495 link_under_cursor_ = url; 1496 pp::PDF::SetLinkUnderCursor(GetPluginInstance(), url.c_str()); 1497 } 1498 // No need to swallow the event, since this might interfere with the 1499 // scrollbars if the user is dragging them. 1500 return false; 1501 } 1502 1503 // We're selecting but right now we're not over text, so don't change the 1504 // current selection. 1505 if (area != PDFiumPage::TEXT_AREA && area != PDFiumPage::WEBLINK_AREA && 1506 area != PDFiumPage::DOCLINK_AREA) { 1507 return false; 1508 } 1509 1510 SelectionChangeInvalidator selection_invalidator(this); 1511 1512 // Check if the user has descreased their selection area and we need to remove 1513 // pages from selection_. 1514 for (size_t i = 0; i < selection_.size(); ++i) { 1515 if (selection_[i].page_index() == page_index) { 1516 // There should be no other pages after this. 1517 selection_.erase(selection_.begin() + i + 1, selection_.end()); 1518 break; 1519 } 1520 } 1521 1522 if (selection_.size() == 0) 1523 return false; 1524 1525 int last = selection_.size() - 1; 1526 if (selection_[last].page_index() == page_index) { 1527 // Selecting within a page. 1528 int count; 1529 if (char_index >= selection_[last].char_index()) { 1530 // Selecting forward. 1531 count = char_index - selection_[last].char_index() + 1; 1532 } else { 1533 count = char_index - selection_[last].char_index() - 1; 1534 } 1535 selection_[last].SetCharCount(count); 1536 } else if (selection_[last].page_index() < page_index) { 1537 // Selecting into the next page. 1538 1539 // First make sure that there are no gaps in selection, i.e. if mousedown on 1540 // page one but we only get mousemove over page three, we want page two. 1541 for (int i = selection_[last].page_index() + 1; i < page_index; ++i) { 1542 selection_.push_back(PDFiumRange(pages_[i], 0, 1543 pages_[i]->GetCharCount())); 1544 } 1545 1546 int count = pages_[selection_[last].page_index()]->GetCharCount(); 1547 selection_[last].SetCharCount(count - selection_[last].char_index()); 1548 selection_.push_back(PDFiumRange(pages_[page_index], 0, char_index)); 1549 } else { 1550 // Selecting into the previous page. 1551 selection_[last].SetCharCount(-selection_[last].char_index()); 1552 1553 // First make sure that there are no gaps in selection, i.e. if mousedown on 1554 // page three but we only get mousemove over page one, we want page two. 1555 for (int i = selection_[last].page_index() - 1; i > page_index; --i) { 1556 selection_.push_back(PDFiumRange(pages_[i], 0, 1557 pages_[i]->GetCharCount())); 1558 } 1559 1560 int count = pages_[page_index]->GetCharCount(); 1561 selection_.push_back( 1562 PDFiumRange(pages_[page_index], count, count - char_index)); 1563 } 1564 1565 return true; 1566 } 1567 1568 bool PDFiumEngine::OnKeyDown(const pp::KeyboardInputEvent& event) { 1569 if (last_page_mouse_down_ == -1) 1570 return false; 1571 1572 bool rv = !!FORM_OnKeyDown( 1573 form_, pages_[last_page_mouse_down_]->GetPage(), 1574 event.GetKeyCode(), event.GetModifiers()); 1575 1576 if (event.GetKeyCode() == ui::VKEY_BACK || 1577 event.GetKeyCode() == ui::VKEY_ESCAPE) { 1578 // Chrome doesn't send char events for backspace or escape keys, see 1579 // PlatformKeyboardEventBuilder::isCharacterKey() and 1580 // http://chrome-corpsvn.mtv.corp.google.com/viewvc?view=rev&root=chrome&revision=31805 1581 // for more information. So just fake one since PDFium uses it. 1582 std::string str; 1583 str.push_back(event.GetKeyCode()); 1584 pp::KeyboardInputEvent synthesized(pp::KeyboardInputEvent( 1585 client_->GetPluginInstance(), 1586 PP_INPUTEVENT_TYPE_CHAR, 1587 event.GetTimeStamp(), 1588 event.GetModifiers(), 1589 event.GetKeyCode(), 1590 str)); 1591 OnChar(synthesized); 1592 } 1593 1594 return rv; 1595 } 1596 1597 bool PDFiumEngine::OnKeyUp(const pp::KeyboardInputEvent& event) { 1598 if (last_page_mouse_down_ == -1) 1599 return false; 1600 1601 return !!FORM_OnKeyUp( 1602 form_, pages_[last_page_mouse_down_]->GetPage(), 1603 event.GetKeyCode(), event.GetModifiers()); 1604 } 1605 1606 bool PDFiumEngine::OnChar(const pp::KeyboardInputEvent& event) { 1607 if (last_page_mouse_down_ == -1) 1608 return false; 1609 1610 base::string16 str = base::UTF8ToUTF16(event.GetCharacterText().AsString()); 1611 return !!FORM_OnChar( 1612 form_, pages_[last_page_mouse_down_]->GetPage(), 1613 str[0], 1614 event.GetModifiers()); 1615 } 1616 1617 void PDFiumEngine::StartFind(const char* text, bool case_sensitive) { 1618 // We can get a call to StartFind before we have any page information (i.e. 1619 // before the first call to LoadDocument has happened). Handle this case. 1620 if (pages_.empty()) 1621 return; 1622 1623 bool first_search = false; 1624 int character_to_start_searching_from = 0; 1625 if (current_find_text_ != text) { // First time we search for this text. 1626 first_search = true; 1627 std::vector<PDFiumRange> old_selection = selection_; 1628 StopFind(); 1629 current_find_text_ = text; 1630 1631 if (old_selection.empty()) { 1632 // Start searching from the beginning of the document. 1633 next_page_to_search_ = 0; 1634 last_page_to_search_ = pages_.size() - 1; 1635 last_character_index_to_search_ = -1; 1636 } else { 1637 // There's a current selection, so start from it. 1638 next_page_to_search_ = old_selection[0].page_index(); 1639 last_character_index_to_search_ = old_selection[0].char_index(); 1640 character_to_start_searching_from = old_selection[0].char_index(); 1641 last_page_to_search_ = next_page_to_search_; 1642 } 1643 } 1644 1645 int current_page = next_page_to_search_; 1646 1647 if (pages_[current_page]->available()) { 1648 base::string16 str = base::UTF8ToUTF16(text); 1649 // Don't use PDFium to search for now, since it doesn't support unicode text. 1650 // Leave the code for now to avoid bit-rot, in case it's fixed later. 1651 if (0) { 1652 SearchUsingPDFium( 1653 str, case_sensitive, first_search, character_to_start_searching_from, 1654 current_page); 1655 } else { 1656 SearchUsingICU( 1657 str, case_sensitive, first_search, character_to_start_searching_from, 1658 current_page); 1659 } 1660 1661 if (!IsPageVisible(current_page)) 1662 pages_[current_page]->Unload(); 1663 } 1664 1665 if (next_page_to_search_ != last_page_to_search_ || 1666 (first_search && last_character_index_to_search_ != -1)) { 1667 ++next_page_to_search_; 1668 } 1669 1670 if (next_page_to_search_ == static_cast<int>(pages_.size())) 1671 next_page_to_search_ = 0; 1672 // If there's only one page in the document and we start searching midway, 1673 // then we'll want to search the page one more time. 1674 bool end_of_search = 1675 next_page_to_search_ == last_page_to_search_ && 1676 // Only one page but didn't start midway. 1677 ((pages_.size() == 1 && last_character_index_to_search_ == -1) || 1678 // Started midway, but only 1 page and we already looped around. 1679 (pages_.size() == 1 && !first_search) || 1680 // Started midway, and we've just looped around. 1681 (pages_.size() > 1 && current_page == next_page_to_search_)); 1682 1683 if (end_of_search) { 1684 // Send the final notification. 1685 client_->NotifyNumberOfFindResultsChanged(find_results_.size(), true); 1686 } else { 1687 pp::CompletionCallback callback = 1688 find_factory_.NewCallback(&PDFiumEngine::ContinueFind); 1689 pp::Module::Get()->core()->CallOnMainThread( 1690 0, callback, case_sensitive ? 1 : 0); 1691 } 1692 } 1693 1694 void PDFiumEngine::SearchUsingPDFium(const base::string16& term, 1695 bool case_sensitive, 1696 bool first_search, 1697 int character_to_start_searching_from, 1698 int current_page) { 1699 // Find all the matches in the current page. 1700 unsigned long flags = case_sensitive ? FPDF_MATCHCASE : 0; 1701 FPDF_SCHHANDLE find = FPDFText_FindStart( 1702 pages_[current_page]->GetTextPage(), 1703 reinterpret_cast<const unsigned short*>(term.c_str()), 1704 flags, character_to_start_searching_from); 1705 1706 // Note: since we search one page at a time, we don't find matches across 1707 // page boundaries. We could do this manually ourself, but it seems low 1708 // priority since Reader itself doesn't do it. 1709 while (FPDFText_FindNext(find)) { 1710 PDFiumRange result(pages_[current_page], 1711 FPDFText_GetSchResultIndex(find), 1712 FPDFText_GetSchCount(find)); 1713 1714 if (!first_search && 1715 last_character_index_to_search_ != -1 && 1716 result.page_index() == last_page_to_search_ && 1717 result.char_index() >= last_character_index_to_search_) { 1718 break; 1719 } 1720 1721 AddFindResult(result); 1722 } 1723 1724 FPDFText_FindClose(find); 1725 } 1726 1727 void PDFiumEngine::SearchUsingICU(const base::string16& term, 1728 bool case_sensitive, 1729 bool first_search, 1730 int character_to_start_searching_from, 1731 int current_page) { 1732 base::string16 page_text; 1733 int text_length = pages_[current_page]->GetCharCount(); 1734 if (character_to_start_searching_from) { 1735 text_length -= character_to_start_searching_from; 1736 } else if (!first_search && 1737 last_character_index_to_search_ != -1 && 1738 current_page == last_page_to_search_) { 1739 text_length = last_character_index_to_search_; 1740 } 1741 if (text_length <= 0) 1742 return; 1743 unsigned short* data = 1744 reinterpret_cast<unsigned short*>(WriteInto(&page_text, text_length + 1)); 1745 FPDFText_GetText(pages_[current_page]->GetTextPage(), 1746 character_to_start_searching_from, 1747 text_length, 1748 data); 1749 std::vector<PDFEngine::Client::SearchStringResult> results; 1750 client_->SearchString( 1751 page_text.c_str(), term.c_str(), case_sensitive, &results); 1752 for (size_t i = 0; i < results.size(); ++i) { 1753 // Need to map the indexes from the page text, which may have generated 1754 // characters like space etc, to character indices from the page. 1755 int temp_start = results[i].start_index + character_to_start_searching_from; 1756 int start = FPDFText_GetCharIndexFromTextIndex( 1757 pages_[current_page]->GetTextPage(), temp_start); 1758 int end = FPDFText_GetCharIndexFromTextIndex( 1759 pages_[current_page]->GetTextPage(), 1760 temp_start + results[i].length); 1761 AddFindResult(PDFiumRange(pages_[current_page], start, end - start)); 1762 } 1763 } 1764 1765 void PDFiumEngine::AddFindResult(const PDFiumRange& result) { 1766 // Figure out where to insert the new location, since we could have 1767 // started searching midway and now we wrapped. 1768 size_t i; 1769 int page_index = result.page_index(); 1770 int char_index = result.char_index(); 1771 for (i = 0; i < find_results_.size(); ++i) { 1772 if (find_results_[i].page_index() > page_index || 1773 (find_results_[i].page_index() == page_index && 1774 find_results_[i].char_index() > char_index)) { 1775 break; 1776 } 1777 } 1778 find_results_.insert(find_results_.begin() + i, result); 1779 UpdateTickMarks(); 1780 1781 if (current_find_index_ == -1) { 1782 // Select the first match. 1783 SelectFindResult(true); 1784 } else if (static_cast<int>(i) <= current_find_index_) { 1785 // Update the current match index 1786 current_find_index_++; 1787 client_->NotifySelectedFindResultChanged(current_find_index_); 1788 } 1789 client_->NotifyNumberOfFindResultsChanged(find_results_.size(), false); 1790 } 1791 1792 bool PDFiumEngine::SelectFindResult(bool forward) { 1793 if (find_results_.empty()) { 1794 NOTREACHED(); 1795 return false; 1796 } 1797 1798 SelectionChangeInvalidator selection_invalidator(this); 1799 1800 // Move back/forward through the search locations we previously found. 1801 if (forward) { 1802 if (++current_find_index_ == static_cast<int>(find_results_.size())) 1803 current_find_index_ = 0; 1804 } else { 1805 if (--current_find_index_ < 0) { 1806 current_find_index_ = find_results_.size() - 1; 1807 } 1808 } 1809 1810 // Update the selection before telling the client to scroll, since it could 1811 // paint then. 1812 selection_.clear(); 1813 selection_.push_back(find_results_[current_find_index_]); 1814 1815 // If the result is not in view, scroll to it. 1816 size_t i; 1817 pp::Rect bounding_rect; 1818 pp::Rect visible_rect = GetVisibleRect(); 1819 // Use zoom of 1.0 since visible_rect is without zoom. 1820 std::vector<pp::Rect> rects = find_results_[current_find_index_]. 1821 GetScreenRects(pp::Point(), 1.0, current_rotation_); 1822 for (i = 0; i < rects.size(); ++i) 1823 bounding_rect = bounding_rect.Union(rects[i]); 1824 if (!visible_rect.Contains(bounding_rect)) { 1825 pp::Point center = bounding_rect.CenterPoint(); 1826 // Make the page centered. 1827 int new_y = static_cast<int>(center.y() * current_zoom_) - 1828 static_cast<int>(visible_rect.height() * current_zoom_ / 2); 1829 if (new_y < 0) 1830 new_y = 0; 1831 client_->ScrollToY(new_y); 1832 1833 // Only move horizontally if it's not visible. 1834 if (center.x() < visible_rect.x() || center.x() > visible_rect.right()) { 1835 int new_x = static_cast<int>(center.x() * current_zoom_) - 1836 static_cast<int>(visible_rect.width() * current_zoom_ / 2); 1837 if (new_x < 0) 1838 new_x = 0; 1839 client_->ScrollToX(new_x); 1840 } 1841 } 1842 1843 client_->NotifySelectedFindResultChanged(current_find_index_); 1844 1845 return true; 1846 } 1847 1848 void PDFiumEngine::StopFind() { 1849 SelectionChangeInvalidator selection_invalidator(this); 1850 1851 selection_.clear(); 1852 selecting_ = false; 1853 find_results_.clear(); 1854 next_page_to_search_ = -1; 1855 last_page_to_search_ = -1; 1856 last_character_index_to_search_ = -1; 1857 current_find_index_ = -1; 1858 current_find_text_.clear(); 1859 UpdateTickMarks(); 1860 find_factory_.CancelAll(); 1861 } 1862 1863 void PDFiumEngine::UpdateTickMarks() { 1864 std::vector<pp::Rect> tickmarks; 1865 for (size_t i = 0; i < find_results_.size(); ++i) { 1866 pp::Rect rect; 1867 // Always use an origin of 0,0 since scroll positions don't affect tickmark. 1868 std::vector<pp::Rect> rects = find_results_[i].GetScreenRects( 1869 pp::Point(0, 0), current_zoom_, current_rotation_); 1870 for (size_t j = 0; j < rects.size(); ++j) 1871 rect = rect.Union(rects[j]); 1872 tickmarks.push_back(rect); 1873 } 1874 1875 client_->UpdateTickMarks(tickmarks); 1876 } 1877 1878 void PDFiumEngine::ZoomUpdated(double new_zoom_level) { 1879 CancelPaints(); 1880 1881 current_zoom_ = new_zoom_level; 1882 1883 CalculateVisiblePages(); 1884 UpdateTickMarks(); 1885 } 1886 1887 void PDFiumEngine::RotateClockwise() { 1888 current_rotation_ = (current_rotation_ + 1) % 4; 1889 InvalidateAllPages(); 1890 } 1891 1892 void PDFiumEngine::RotateCounterclockwise() { 1893 current_rotation_ = (current_rotation_ - 1) % 4; 1894 InvalidateAllPages(); 1895 } 1896 1897 void PDFiumEngine::InvalidateAllPages() { 1898 selection_.clear(); 1899 find_results_.clear(); 1900 1901 CancelPaints(); 1902 LoadPageInfo(true); 1903 UpdateTickMarks(); 1904 client_->Invalidate(pp::Rect(plugin_size_)); 1905 } 1906 1907 std::string PDFiumEngine::GetSelectedText() { 1908 base::string16 result; 1909 for (size_t i = 0; i < selection_.size(); ++i) { 1910 if (i > 0 && 1911 selection_[i - 1].page_index() > selection_[i].page_index()) { 1912 result = selection_[i].GetText() + result; 1913 } else { 1914 result.append(selection_[i].GetText()); 1915 } 1916 } 1917 1918 FormatStringWithHyphens(&result); 1919 FormatStringForOS(&result); 1920 return base::UTF16ToUTF8(result); 1921 } 1922 1923 std::string PDFiumEngine::GetLinkAtPosition(const pp::Point& point) { 1924 int temp; 1925 PDFiumPage::LinkTarget target; 1926 pp::Point point_in_page( 1927 static_cast<int>((point.x() + position_.x()) / current_zoom_), 1928 static_cast<int>((point.y() + position_.y()) / current_zoom_)); 1929 PDFiumPage::Area area = GetCharIndex(point_in_page, &temp, &temp, &target); 1930 if (area == PDFiumPage::WEBLINK_AREA) 1931 return target.url; 1932 return std::string(); 1933 } 1934 1935 bool PDFiumEngine::IsSelecting() { 1936 return selecting_; 1937 } 1938 1939 bool PDFiumEngine::HasPermission(DocumentPermission permission) const { 1940 switch (permission) { 1941 case PERMISSION_COPY: 1942 return (permissions_ & kPDFPermissionCopyMask) != 0; 1943 case PERMISSION_COPY_ACCESSIBLE: 1944 return (permissions_ & kPDFPermissionCopyAccessibleMask) != 0; 1945 case PERMISSION_PRINT_LOW_QUALITY: 1946 return (permissions_ & kPDFPermissionPrintLowQualityMask) != 0; 1947 case PERMISSION_PRINT_HIGH_QUALITY: 1948 return (permissions_ & kPDFPermissionPrintLowQualityMask) != 0 && 1949 (permissions_ & kPDFPermissionPrintHighQualityMask) != 0; 1950 default: 1951 return true; 1952 }; 1953 } 1954 1955 void PDFiumEngine::SelectAll() { 1956 SelectionChangeInvalidator selection_invalidator(this); 1957 1958 selection_.clear(); 1959 for (size_t i = 0; i < pages_.size(); ++i) 1960 if (pages_[i]->available()) { 1961 selection_.push_back(PDFiumRange(pages_[i], 0, 1962 pages_[i]->GetCharCount())); 1963 } 1964 } 1965 1966 int PDFiumEngine::GetNumberOfPages() { 1967 return pages_.size(); 1968 } 1969 1970 int PDFiumEngine::GetNamedDestinationPage(const std::string& destination) { 1971 // Look for the destination. 1972 FPDF_DEST dest = FPDF_GetNamedDestByName(doc_, destination.c_str()); 1973 if (!dest) { 1974 // Look for a bookmark with the same name. 1975 base::string16 destination_wide = base::UTF8ToUTF16(destination); 1976 FPDF_WIDESTRING destination_pdf_wide = 1977 reinterpret_cast<FPDF_WIDESTRING>(destination_wide.c_str()); 1978 FPDF_BOOKMARK bookmark = FPDFBookmark_Find(doc_, destination_pdf_wide); 1979 if (!bookmark) 1980 return -1; 1981 dest = FPDFBookmark_GetDest(doc_, bookmark); 1982 } 1983 return dest ? FPDFDest_GetPageIndex(doc_, dest) : -1; 1984 } 1985 1986 int PDFiumEngine::GetFirstVisiblePage() { 1987 CalculateVisiblePages(); 1988 return first_visible_page_; 1989 } 1990 1991 int PDFiumEngine::GetMostVisiblePage() { 1992 CalculateVisiblePages(); 1993 return most_visible_page_; 1994 } 1995 1996 pp::Rect PDFiumEngine::GetPageRect(int index) { 1997 pp::Rect rc(pages_[index]->rect()); 1998 rc.Inset(-kPageShadowLeft, -kPageShadowTop, 1999 -kPageShadowRight, -kPageShadowBottom); 2000 return rc; 2001 } 2002 2003 pp::Rect PDFiumEngine::GetPageContentsRect(int index) { 2004 return GetScreenRect(pages_[index]->rect()); 2005 } 2006 2007 void PDFiumEngine::PaintThumbnail(pp::ImageData* image_data, int index) { 2008 FPDF_BITMAP bitmap = FPDFBitmap_CreateEx( 2009 image_data->size().width(), image_data->size().height(), 2010 FPDFBitmap_BGRx, image_data->data(), image_data->stride()); 2011 2012 if (pages_[index]->available()) { 2013 FPDFBitmap_FillRect(bitmap, 0, 0, image_data->size().width(), 2014 image_data->size().height(), 0xFFFFFFFF); 2015 2016 FPDF_RenderPageBitmap( 2017 bitmap, pages_[index]->GetPage(), 0, 0, image_data->size().width(), 2018 image_data->size().height(), 0, GetRenderingFlags()); 2019 } else { 2020 FPDFBitmap_FillRect(bitmap, 0, 0, image_data->size().width(), 2021 image_data->size().height(), kPendingPageColor); 2022 } 2023 2024 FPDFBitmap_Destroy(bitmap); 2025 } 2026 2027 void PDFiumEngine::SetGrayscale(bool grayscale) { 2028 render_grayscale_ = grayscale; 2029 } 2030 2031 void PDFiumEngine::OnCallback(int id) { 2032 if (!timers_.count(id)) 2033 return; 2034 2035 timers_[id].second(id); 2036 if (timers_.count(id)) // The callback might delete the timer. 2037 client_->ScheduleCallback(id, timers_[id].first); 2038 } 2039 2040 std::string PDFiumEngine::GetPageAsJSON(int index) { 2041 if (!(HasPermission(PERMISSION_COPY) || 2042 HasPermission(PERMISSION_COPY_ACCESSIBLE))) { 2043 return "{}"; 2044 } 2045 2046 if (index < 0 || static_cast<size_t>(index) > pages_.size() - 1) 2047 return "{}"; 2048 2049 // TODO(thestig) Remove after debugging http://crbug.com/402035 2050 CHECK(pages_[index]); 2051 scoped_ptr<base::Value> node( 2052 pages_[index]->GetAccessibleContentAsValue(current_rotation_)); 2053 std::string page_json; 2054 base::JSONWriter::Write(node.get(), &page_json); 2055 return page_json; 2056 } 2057 2058 bool PDFiumEngine::GetPrintScaling() { 2059 return !!FPDF_VIEWERREF_GetPrintScaling(doc_); 2060 } 2061 2062 void PDFiumEngine::AppendBlankPages(int num_pages) { 2063 DCHECK(num_pages != 0); 2064 2065 if (!doc_) 2066 return; 2067 2068 selection_.clear(); 2069 pending_pages_.clear(); 2070 2071 // Delete all pages except the first one. 2072 while (pages_.size() > 1) { 2073 delete pages_.back(); 2074 pages_.pop_back(); 2075 FPDFPage_Delete(doc_, pages_.size()); 2076 } 2077 2078 // Calculate document size and all page sizes. 2079 std::vector<pp::Rect> page_rects; 2080 pp::Size page_size = GetPageSize(0); 2081 page_size.Enlarge(kPageShadowLeft + kPageShadowRight, 2082 kPageShadowTop + kPageShadowBottom); 2083 pp::Size old_document_size = document_size_; 2084 document_size_ = pp::Size(page_size.width(), 0); 2085 for (int i = 0; i < num_pages; ++i) { 2086 if (i != 0) { 2087 // Add space for horizontal separator. 2088 document_size_.Enlarge(0, kPageSeparatorThickness); 2089 } 2090 2091 pp::Rect rect(pp::Point(0, document_size_.height()), page_size); 2092 page_rects.push_back(rect); 2093 2094 document_size_.Enlarge(0, page_size.height()); 2095 } 2096 2097 // Create blank pages. 2098 for (int i = 1; i < num_pages; ++i) { 2099 pp::Rect page_rect(page_rects[i]); 2100 page_rect.Inset(kPageShadowLeft, kPageShadowTop, 2101 kPageShadowRight, kPageShadowBottom); 2102 double width_in_points = 2103 page_rect.width() * kPointsPerInch / kPixelsPerInch; 2104 double height_in_points = 2105 page_rect.height() * kPointsPerInch / kPixelsPerInch; 2106 FPDFPage_New(doc_, i, width_in_points, height_in_points); 2107 pages_.push_back(new PDFiumPage(this, i, page_rect, true)); 2108 // TODO(thestig) Remove after debugging http://crbug.com/402035 2109 CHECK(pages_.back()); 2110 } 2111 2112 CalculateVisiblePages(); 2113 if (document_size_ != old_document_size) 2114 client_->DocumentSizeUpdated(document_size_); 2115 } 2116 2117 void PDFiumEngine::LoadDocument() { 2118 // Check if the document is ready for loading. If it isn't just bail for now, 2119 // we will call LoadDocument() again later. 2120 if (!doc_ && !doc_loader_.IsDocumentComplete() && 2121 !FPDFAvail_IsDocAvail(fpdf_availability_, &download_hints_)) { 2122 return; 2123 } 2124 2125 // If we're in the middle of getting a password, just return. We will retry 2126 // loading the document after we get the password anyway. 2127 if (getting_password_) 2128 return; 2129 2130 ScopedUnsupportedFeature scoped_unsupported_feature(this); 2131 bool needs_password = false; 2132 if (TryLoadingDoc(false, std::string(), &needs_password)) { 2133 ContinueLoadingDocument(false, std::string()); 2134 return; 2135 } 2136 if (needs_password) 2137 GetPasswordAndLoad(); 2138 else 2139 client_->DocumentLoadFailed(); 2140 } 2141 2142 bool PDFiumEngine::TryLoadingDoc(bool with_password, 2143 const std::string& password, 2144 bool* needs_password) { 2145 *needs_password = false; 2146 if (doc_) 2147 return true; 2148 2149 const char* password_cstr = NULL; 2150 if (with_password) { 2151 password_cstr = password.c_str(); 2152 password_tries_remaining_--; 2153 } 2154 if (doc_loader_.IsDocumentComplete()) 2155 doc_ = FPDF_LoadCustomDocument(&file_access_, password_cstr); 2156 else 2157 doc_ = FPDFAvail_GetDocument(fpdf_availability_, password_cstr); 2158 2159 if (!doc_ && FPDF_GetLastError() == FPDF_ERR_PASSWORD) 2160 *needs_password = true; 2161 2162 return doc_ != NULL; 2163 } 2164 2165 void PDFiumEngine::GetPasswordAndLoad() { 2166 getting_password_ = true; 2167 DCHECK(!doc_ && FPDF_GetLastError() == FPDF_ERR_PASSWORD); 2168 client_->GetDocumentPassword(password_factory_.NewCallbackWithOutput( 2169 &PDFiumEngine::OnGetPasswordComplete)); 2170 } 2171 2172 void PDFiumEngine::OnGetPasswordComplete(int32_t result, 2173 const pp::Var& password) { 2174 getting_password_ = false; 2175 2176 bool password_given = false; 2177 std::string password_text; 2178 if (result == PP_OK && password.is_string()) { 2179 password_text = password.AsString(); 2180 if (!password_text.empty()) 2181 password_given = true; 2182 } 2183 ContinueLoadingDocument(password_given, password_text); 2184 } 2185 2186 void PDFiumEngine::ContinueLoadingDocument( 2187 bool has_password, 2188 const std::string& password) { 2189 ScopedUnsupportedFeature scoped_unsupported_feature(this); 2190 2191 bool needs_password = false; 2192 bool loaded = TryLoadingDoc(has_password, password, &needs_password); 2193 bool password_incorrect = !loaded && has_password && needs_password; 2194 if (password_incorrect && password_tries_remaining_ > 0) { 2195 GetPasswordAndLoad(); 2196 return; 2197 } 2198 2199 if (!doc_) { 2200 client_->DocumentLoadFailed(); 2201 return; 2202 } 2203 2204 if (FPDFDoc_GetPageMode(doc_) == PAGEMODE_USEOUTLINES) 2205 client_->DocumentHasUnsupportedFeature("Bookmarks"); 2206 2207 permissions_ = FPDF_GetDocPermissions(doc_); 2208 2209 if (!form_) { 2210 // Only returns 0 when data isn't available. If form data is downloaded, or 2211 // if this isn't a form, returns positive values. 2212 if (!doc_loader_.IsDocumentComplete() && 2213 !FPDFAvail_IsFormAvail(fpdf_availability_, &download_hints_)) { 2214 return; 2215 } 2216 2217 form_ = FPDFDOC_InitFormFillEnviroument( 2218 doc_, static_cast<FPDF_FORMFILLINFO*>(this)); 2219 FPDF_SetFormFieldHighlightColor(form_, 0, kFormHighlightColor); 2220 FPDF_SetFormFieldHighlightAlpha(form_, kFormHighlightAlpha); 2221 } 2222 2223 if (!doc_loader_.IsDocumentComplete()) { 2224 // Check if the first page is available. In a linearized PDF, that is not 2225 // always page 0. Doing this gives us the default page size, since when the 2226 // document is available, the first page is available as well. 2227 CheckPageAvailable(FPDFAvail_GetFirstPageNum(doc_), &pending_pages_); 2228 } 2229 2230 LoadPageInfo(false); 2231 2232 if (doc_loader_.IsDocumentComplete()) 2233 FinishLoadingDocument(); 2234 } 2235 2236 void PDFiumEngine::LoadPageInfo(bool reload) { 2237 pending_pages_.clear(); 2238 pp::Size old_document_size = document_size_; 2239 document_size_ = pp::Size(); 2240 std::vector<pp::Rect> page_rects; 2241 int page_count = FPDF_GetPageCount(doc_); 2242 bool doc_complete = doc_loader_.IsDocumentComplete(); 2243 for (int i = 0; i < page_count; ++i) { 2244 if (i != 0) { 2245 // Add space for horizontal separator. 2246 document_size_.Enlarge(0, kPageSeparatorThickness); 2247 } 2248 2249 // Get page availability. If reload==false, and document is not loaded yet 2250 // (we are using async loading) - mark all pages as unavailable. 2251 // If reload==true (we have document constructed already), get page 2252 // availability flag from already existing PDFiumPage class. 2253 bool page_available = reload ? pages_[i]->available() : doc_complete; 2254 2255 pp::Size size = page_available ? GetPageSize(i) : default_page_size_; 2256 size.Enlarge(kPageShadowLeft + kPageShadowRight, 2257 kPageShadowTop + kPageShadowBottom); 2258 pp::Rect rect(pp::Point(0, document_size_.height()), size); 2259 page_rects.push_back(rect); 2260 2261 if (size.width() > document_size_.width()) 2262 document_size_.set_width(size.width()); 2263 2264 document_size_.Enlarge(0, size.height()); 2265 } 2266 2267 for (int i = 0; i < page_count; ++i) { 2268 // Center pages relative to the entire document. 2269 page_rects[i].set_x((document_size_.width() - page_rects[i].width()) / 2); 2270 pp::Rect page_rect(page_rects[i]); 2271 page_rect.Inset(kPageShadowLeft, kPageShadowTop, 2272 kPageShadowRight, kPageShadowBottom); 2273 if (reload) { 2274 pages_[i]->set_rect(page_rect); 2275 } else { 2276 pages_.push_back(new PDFiumPage(this, i, page_rect, doc_complete)); 2277 // TODO(thestig) Remove after debugging http://crbug.com/402035 2278 CHECK(pages_.back()); 2279 } 2280 } 2281 2282 CalculateVisiblePages(); 2283 if (document_size_ != old_document_size) 2284 client_->DocumentSizeUpdated(document_size_); 2285 } 2286 2287 void PDFiumEngine::CalculateVisiblePages() { 2288 // Clear pending requests queue, since it may contain requests to the pages 2289 // that are already invisible (after scrolling for example). 2290 pending_pages_.clear(); 2291 doc_loader_.ClearPendingRequests(); 2292 2293 visible_pages_.clear(); 2294 pp::Rect visible_rect(plugin_size_); 2295 for (size_t i = 0; i < pages_.size(); ++i) { 2296 // Check an entire PageScreenRect, since we might need to repaint side 2297 // borders and shadows even if the page itself is not visible. 2298 // For example, when user use pdf with different page sizes and zoomed in 2299 // outside page area. 2300 if (visible_rect.Intersects(GetPageScreenRect(i))) { 2301 visible_pages_.push_back(i); 2302 CheckPageAvailable(i, &pending_pages_); 2303 } else { 2304 // Need to unload pages when we're not using them, since some PDFs use a 2305 // lot of memory. See http://crbug.com/48791 2306 if (defer_page_unload_) { 2307 deferred_page_unloads_.push_back(i); 2308 } else { 2309 pages_[i]->Unload(); 2310 } 2311 2312 // If the last mouse down was on a page that's no longer visible, reset 2313 // that variable so that we don't send keyboard events to it (the focus 2314 // will be lost when the page is first closed anyways). 2315 if (static_cast<int>(i) == last_page_mouse_down_) 2316 last_page_mouse_down_ = -1; 2317 } 2318 } 2319 2320 // Any pending highlighting of form fields will be invalid since these are in 2321 // screen coordinates. 2322 form_highlights_.clear(); 2323 2324 if (visible_pages_.size() == 0) 2325 first_visible_page_ = -1; 2326 else 2327 first_visible_page_ = visible_pages_.front(); 2328 2329 int most_visible_page = first_visible_page_; 2330 // Check if the next page is more visible than the first one. 2331 if (most_visible_page != -1 && 2332 pages_.size() > 0 && 2333 most_visible_page < static_cast<int>(pages_.size()) - 1) { 2334 pp::Rect rc_first = 2335 visible_rect.Intersect(GetPageScreenRect(most_visible_page)); 2336 pp::Rect rc_next = 2337 visible_rect.Intersect(GetPageScreenRect(most_visible_page + 1)); 2338 if (rc_next.height() > rc_first.height()) 2339 most_visible_page++; 2340 } 2341 2342 SetCurrentPage(most_visible_page); 2343 } 2344 2345 bool PDFiumEngine::IsPageVisible(int index) const { 2346 for (size_t i = 0; i < visible_pages_.size(); ++i) { 2347 if (visible_pages_[i] == index) 2348 return true; 2349 } 2350 2351 return false; 2352 } 2353 2354 bool PDFiumEngine::CheckPageAvailable(int index, std::vector<int>* pending) { 2355 if (!doc_ || !form_) 2356 return false; 2357 2358 if (static_cast<int>(pages_.size()) > index && pages_[index]->available()) 2359 return true; 2360 2361 if (!FPDFAvail_IsPageAvail(fpdf_availability_, index, &download_hints_)) { 2362 size_t j; 2363 for (j = 0; j < pending->size(); ++j) { 2364 if ((*pending)[j] == index) 2365 break; 2366 } 2367 2368 if (j == pending->size()) 2369 pending->push_back(index); 2370 return false; 2371 } 2372 2373 if (static_cast<int>(pages_.size()) > index) 2374 pages_[index]->set_available(true); 2375 if (!default_page_size_.GetArea()) 2376 default_page_size_ = GetPageSize(index); 2377 return true; 2378 } 2379 2380 pp::Size PDFiumEngine::GetPageSize(int index) { 2381 pp::Size size; 2382 double width_in_points = 0; 2383 double height_in_points = 0; 2384 int rv = FPDF_GetPageSizeByIndex( 2385 doc_, index, &width_in_points, &height_in_points); 2386 2387 if (rv) { 2388 int width_in_pixels = static_cast<int>( 2389 width_in_points * kPixelsPerInch / kPointsPerInch); 2390 int height_in_pixels = static_cast<int>( 2391 height_in_points * kPixelsPerInch / kPointsPerInch); 2392 if (current_rotation_ % 2 == 1) 2393 std::swap(width_in_pixels, height_in_pixels); 2394 size = pp::Size(width_in_pixels, height_in_pixels); 2395 } 2396 return size; 2397 } 2398 2399 int PDFiumEngine::StartPaint(int page_index, const pp::Rect& dirty) { 2400 // For the first time we hit paint, do nothing and just record the paint for 2401 // the next callback. This keeps the UI responsive in case the user is doing 2402 // a lot of scrolling. 2403 ProgressivePaint progressive; 2404 progressive.rect = dirty; 2405 progressive.page_index = page_index; 2406 progressive.bitmap = NULL; 2407 progressive.painted_ = false; 2408 progressive_paints_.push_back(progressive); 2409 return progressive_paints_.size() - 1; 2410 } 2411 2412 bool PDFiumEngine::ContinuePaint(int progressive_index, 2413 pp::ImageData* image_data) { 2414 #if defined(OS_LINUX) 2415 g_last_instance_id = client_->GetPluginInstance()->pp_instance(); 2416 #endif 2417 2418 int rv; 2419 int page_index = progressive_paints_[progressive_index].page_index; 2420 last_progressive_start_time_ = base::Time::Now(); 2421 if (progressive_paints_[progressive_index].bitmap) { 2422 rv = FPDF_RenderPage_Continue( 2423 pages_[page_index]->GetPage(), static_cast<IFSDK_PAUSE*>(this)); 2424 } else { 2425 pp::Rect dirty = progressive_paints_[progressive_index].rect; 2426 progressive_paints_[progressive_index].bitmap = CreateBitmap(dirty, 2427 image_data); 2428 int start_x, start_y, size_x, size_y; 2429 GetPDFiumRect( 2430 page_index, dirty, &start_x, &start_y, &size_x, &size_y); 2431 FPDFBitmap_FillRect(progressive_paints_[progressive_index].bitmap, start_x, 2432 start_y, size_x, size_y, 0xFFFFFFFF); 2433 rv = FPDF_RenderPageBitmap_Start( 2434 progressive_paints_[progressive_index].bitmap, 2435 pages_[page_index]->GetPage(), start_x, start_y, size_x, size_y, 2436 current_rotation_, 2437 GetRenderingFlags(), static_cast<IFSDK_PAUSE*>(this)); 2438 } 2439 return rv != FPDF_RENDER_TOBECOUNTINUED; 2440 } 2441 2442 void PDFiumEngine::FinishPaint(int progressive_index, 2443 pp::ImageData* image_data) { 2444 int page_index = progressive_paints_[progressive_index].page_index; 2445 pp::Rect dirty_in_screen = progressive_paints_[progressive_index].rect; 2446 FPDF_BITMAP bitmap = progressive_paints_[progressive_index].bitmap; 2447 int start_x, start_y, size_x, size_y; 2448 GetPDFiumRect( 2449 page_index, dirty_in_screen, &start_x, &start_y, &size_x, &size_y); 2450 2451 // Draw the forms. 2452 FPDF_FFLDraw( 2453 form_, bitmap, pages_[page_index]->GetPage(), start_x, start_y, size_x, 2454 size_y, current_rotation_, GetRenderingFlags()); 2455 2456 FillPageSides(progressive_index); 2457 2458 // Paint the page shadows. 2459 PaintPageShadow(progressive_index, image_data); 2460 2461 DrawSelections(progressive_index, image_data); 2462 2463 FPDF_RenderPage_Close(pages_[page_index]->GetPage()); 2464 FPDFBitmap_Destroy(bitmap); 2465 progressive_paints_.erase(progressive_paints_.begin() + progressive_index); 2466 2467 client_->DocumentPaintOccurred(); 2468 } 2469 2470 void PDFiumEngine::CancelPaints() { 2471 for (size_t i = 0; i < progressive_paints_.size(); ++i) { 2472 FPDF_RenderPage_Close(pages_[progressive_paints_[i].page_index]->GetPage()); 2473 FPDFBitmap_Destroy(progressive_paints_[i].bitmap); 2474 } 2475 progressive_paints_.clear(); 2476 } 2477 2478 void PDFiumEngine::FillPageSides(int progressive_index) { 2479 int page_index = progressive_paints_[progressive_index].page_index; 2480 pp::Rect dirty_in_screen = progressive_paints_[progressive_index].rect; 2481 FPDF_BITMAP bitmap = progressive_paints_[progressive_index].bitmap; 2482 2483 pp::Rect page_rect = pages_[page_index]->rect(); 2484 if (page_rect.x() > 0) { 2485 pp::Rect left(0, 2486 page_rect.y() - kPageShadowTop, 2487 page_rect.x() - kPageShadowLeft, 2488 page_rect.height() + kPageShadowTop + 2489 kPageShadowBottom + kPageSeparatorThickness); 2490 left = GetScreenRect(left).Intersect(dirty_in_screen); 2491 2492 FPDFBitmap_FillRect(bitmap, left.x() - dirty_in_screen.x(), 2493 left.y() - dirty_in_screen.y(), left.width(), 2494 left.height(), kBackgroundColor); 2495 } 2496 2497 if (page_rect.right() < document_size_.width()) { 2498 pp::Rect right(page_rect.right() + kPageShadowRight, 2499 page_rect.y() - kPageShadowTop, 2500 document_size_.width() - page_rect.right() - 2501 kPageShadowRight, 2502 page_rect.height() + kPageShadowTop + 2503 kPageShadowBottom + kPageSeparatorThickness); 2504 right = GetScreenRect(right).Intersect(dirty_in_screen); 2505 2506 FPDFBitmap_FillRect(bitmap, right.x() - dirty_in_screen.x(), 2507 right.y() - dirty_in_screen.y(), right.width(), 2508 right.height(), kBackgroundColor); 2509 } 2510 2511 // Paint separator. 2512 pp::Rect bottom(page_rect.x() - kPageShadowLeft, 2513 page_rect.bottom() + kPageShadowBottom, 2514 page_rect.width() + kPageShadowLeft + kPageShadowRight, 2515 kPageSeparatorThickness); 2516 bottom = GetScreenRect(bottom).Intersect(dirty_in_screen); 2517 2518 FPDFBitmap_FillRect(bitmap, bottom.x() - dirty_in_screen.x(), 2519 bottom.y() - dirty_in_screen.y(), bottom.width(), 2520 bottom.height(), kBackgroundColor); 2521 } 2522 2523 void PDFiumEngine::PaintPageShadow(int progressive_index, 2524 pp::ImageData* image_data) { 2525 int page_index = progressive_paints_[progressive_index].page_index; 2526 pp::Rect dirty_in_screen = progressive_paints_[progressive_index].rect; 2527 pp::Rect page_rect = pages_[page_index]->rect(); 2528 pp::Rect shadow_rect(page_rect); 2529 shadow_rect.Inset(-kPageShadowLeft, -kPageShadowTop, 2530 -kPageShadowRight, -kPageShadowBottom); 2531 2532 // Due to the rounding errors of the GetScreenRect it is possible to get 2533 // different size shadows on the left and right sides even they are defined 2534 // the same. To fix this issue let's calculate shadow rect and then shrink 2535 // it by the size of the shadows. 2536 shadow_rect = GetScreenRect(shadow_rect); 2537 page_rect = shadow_rect; 2538 2539 page_rect.Inset(static_cast<int>(ceil(kPageShadowLeft * current_zoom_)), 2540 static_cast<int>(ceil(kPageShadowTop * current_zoom_)), 2541 static_cast<int>(ceil(kPageShadowRight * current_zoom_)), 2542 static_cast<int>(ceil(kPageShadowBottom * current_zoom_))); 2543 2544 DrawPageShadow(page_rect, shadow_rect, dirty_in_screen, image_data); 2545 } 2546 2547 void PDFiumEngine::DrawSelections(int progressive_index, 2548 pp::ImageData* image_data) { 2549 int page_index = progressive_paints_[progressive_index].page_index; 2550 pp::Rect dirty_in_screen = progressive_paints_[progressive_index].rect; 2551 2552 void* region = NULL; 2553 int stride; 2554 GetRegion(dirty_in_screen.point(), image_data, ®ion, &stride); 2555 2556 std::vector<pp::Rect> highlighted_rects; 2557 pp::Rect visible_rect = GetVisibleRect(); 2558 for (size_t k = 0; k < selection_.size(); ++k) { 2559 if (selection_[k].page_index() != page_index) 2560 continue; 2561 std::vector<pp::Rect> rects = selection_[k].GetScreenRects( 2562 visible_rect.point(), current_zoom_, current_rotation_); 2563 for (size_t j = 0; j < rects.size(); ++j) { 2564 pp::Rect visible_selection = rects[j].Intersect(dirty_in_screen); 2565 if (visible_selection.IsEmpty()) 2566 continue; 2567 2568 visible_selection.Offset( 2569 -dirty_in_screen.point().x(), -dirty_in_screen.point().y()); 2570 Highlight(region, stride, visible_selection, &highlighted_rects); 2571 } 2572 } 2573 2574 for (size_t k = 0; k < form_highlights_.size(); ++k) { 2575 pp::Rect visible_selection = form_highlights_[k].Intersect(dirty_in_screen); 2576 if (visible_selection.IsEmpty()) 2577 continue; 2578 2579 visible_selection.Offset( 2580 -dirty_in_screen.point().x(), -dirty_in_screen.point().y()); 2581 Highlight(region, stride, visible_selection, &highlighted_rects); 2582 } 2583 form_highlights_.clear(); 2584 } 2585 2586 void PDFiumEngine::PaintUnavailablePage(int page_index, 2587 const pp::Rect& dirty, 2588 pp::ImageData* image_data) { 2589 int start_x, start_y, size_x, size_y; 2590 GetPDFiumRect(page_index, dirty, &start_x, &start_y, &size_x, &size_y); 2591 FPDF_BITMAP bitmap = CreateBitmap(dirty, image_data); 2592 FPDFBitmap_FillRect(bitmap, start_x, start_y, size_x, size_y, 2593 kPendingPageColor); 2594 2595 pp::Rect loading_text_in_screen( 2596 pages_[page_index]->rect().width() / 2, 2597 pages_[page_index]->rect().y() + kLoadingTextVerticalOffset, 0, 0); 2598 loading_text_in_screen = GetScreenRect(loading_text_in_screen); 2599 FPDFBitmap_Destroy(bitmap); 2600 } 2601 2602 int PDFiumEngine::GetProgressiveIndex(int page_index) const { 2603 for (size_t i = 0; i < progressive_paints_.size(); ++i) { 2604 if (progressive_paints_[i].page_index == page_index) 2605 return i; 2606 } 2607 return -1; 2608 } 2609 2610 FPDF_BITMAP PDFiumEngine::CreateBitmap(const pp::Rect& rect, 2611 pp::ImageData* image_data) const { 2612 void* region; 2613 int stride; 2614 GetRegion(rect.point(), image_data, ®ion, &stride); 2615 if (!region) 2616 return NULL; 2617 return FPDFBitmap_CreateEx( 2618 rect.width(), rect.height(), FPDFBitmap_BGRx, region, stride); 2619 } 2620 2621 void PDFiumEngine::GetPDFiumRect( 2622 int page_index, const pp::Rect& rect, int* start_x, int* start_y, 2623 int* size_x, int* size_y) const { 2624 pp::Rect page_rect = GetScreenRect(pages_[page_index]->rect()); 2625 page_rect.Offset(-rect.x(), -rect.y()); 2626 2627 *start_x = page_rect.x(); 2628 *start_y = page_rect.y(); 2629 *size_x = page_rect.width(); 2630 *size_y = page_rect.height(); 2631 } 2632 2633 int PDFiumEngine::GetRenderingFlags() const { 2634 int flags = FPDF_LCD_TEXT | FPDF_NO_CATCH; 2635 if (render_grayscale_) 2636 flags |= FPDF_GRAYSCALE; 2637 if (client_->IsPrintPreview()) 2638 flags |= FPDF_PRINTING; 2639 return flags; 2640 } 2641 2642 pp::Rect PDFiumEngine::GetVisibleRect() const { 2643 pp::Rect rv; 2644 rv.set_x(static_cast<int>(position_.x() / current_zoom_)); 2645 rv.set_y(static_cast<int>(position_.y() / current_zoom_)); 2646 rv.set_width(static_cast<int>(ceil(plugin_size_.width() / current_zoom_))); 2647 rv.set_height(static_cast<int>(ceil(plugin_size_.height() / current_zoom_))); 2648 return rv; 2649 } 2650 2651 pp::Rect PDFiumEngine::GetPageScreenRect(int page_index) const { 2652 // Since we use this rect for creating the PDFium bitmap, also include other 2653 // areas around the page that we might need to update such as the page 2654 // separator and the sides if the page is narrower than the document. 2655 return GetScreenRect(pp::Rect( 2656 0, 2657 pages_[page_index]->rect().y() - kPageShadowTop, 2658 document_size_.width(), 2659 pages_[page_index]->rect().height() + kPageShadowTop + 2660 kPageShadowBottom + kPageSeparatorThickness)); 2661 } 2662 2663 pp::Rect PDFiumEngine::GetScreenRect(const pp::Rect& rect) const { 2664 pp::Rect rv; 2665 int right = 2666 static_cast<int>(ceil(rect.right() * current_zoom_ - position_.x())); 2667 int bottom = 2668 static_cast<int>(ceil(rect.bottom() * current_zoom_ - position_.y())); 2669 2670 rv.set_x(static_cast<int>(rect.x() * current_zoom_ - position_.x())); 2671 rv.set_y(static_cast<int>(rect.y() * current_zoom_ - position_.y())); 2672 rv.set_width(right - rv.x()); 2673 rv.set_height(bottom - rv.y()); 2674 return rv; 2675 } 2676 2677 void PDFiumEngine::Highlight(void* buffer, 2678 int stride, 2679 const pp::Rect& rect, 2680 std::vector<pp::Rect>* highlighted_rects) { 2681 if (!buffer) 2682 return; 2683 2684 pp::Rect new_rect = rect; 2685 for (size_t i = 0; i < highlighted_rects->size(); ++i) 2686 new_rect = new_rect.Subtract((*highlighted_rects)[i]); 2687 2688 highlighted_rects->push_back(new_rect); 2689 int l = new_rect.x(); 2690 int t = new_rect.y(); 2691 int w = new_rect.width(); 2692 int h = new_rect.height(); 2693 2694 for (int y = t; y < t + h; ++y) { 2695 for (int x = l; x < l + w; ++x) { 2696 uint8* pixel = static_cast<uint8*>(buffer) + y * stride + x * 4; 2697 // This is our highlight color. 2698 pixel[0] = static_cast<uint8>( 2699 pixel[0] * (kHighlightColorB / 255.0)); 2700 pixel[1] = static_cast<uint8>( 2701 pixel[1] * (kHighlightColorG / 255.0)); 2702 pixel[2] = static_cast<uint8>( 2703 pixel[2] * (kHighlightColorR / 255.0)); 2704 } 2705 } 2706 } 2707 2708 PDFiumEngine::SelectionChangeInvalidator::SelectionChangeInvalidator( 2709 PDFiumEngine* engine) : engine_(engine) { 2710 previous_origin_ = engine_->GetVisibleRect().point(); 2711 GetVisibleSelectionsScreenRects(&old_selections_); 2712 } 2713 2714 PDFiumEngine::SelectionChangeInvalidator::~SelectionChangeInvalidator() { 2715 // Offset the old selections if the document scrolled since we recorded them. 2716 pp::Point offset = previous_origin_ - engine_->GetVisibleRect().point(); 2717 for (size_t i = 0; i < old_selections_.size(); ++i) 2718 old_selections_[i].Offset(offset); 2719 2720 std::vector<pp::Rect> new_selections; 2721 GetVisibleSelectionsScreenRects(&new_selections); 2722 for (size_t i = 0; i < new_selections.size(); ++i) { 2723 for (size_t j = 0; j < old_selections_.size(); ++j) { 2724 if (new_selections[i] == old_selections_[j]) { 2725 // Rectangle was selected before and after, so no need to invalidate it. 2726 // Mark the rectangles by setting them to empty. 2727 new_selections[i] = old_selections_[j] = pp::Rect(); 2728 } 2729 } 2730 } 2731 2732 for (size_t i = 0; i < old_selections_.size(); ++i) { 2733 if (!old_selections_[i].IsEmpty()) 2734 engine_->client_->Invalidate(old_selections_[i]); 2735 } 2736 for (size_t i = 0; i < new_selections.size(); ++i) { 2737 if (!new_selections[i].IsEmpty()) 2738 engine_->client_->Invalidate(new_selections[i]); 2739 } 2740 engine_->OnSelectionChanged(); 2741 } 2742 2743 void 2744 PDFiumEngine::SelectionChangeInvalidator::GetVisibleSelectionsScreenRects( 2745 std::vector<pp::Rect>* rects) { 2746 pp::Rect visible_rect = engine_->GetVisibleRect(); 2747 for (size_t i = 0; i < engine_->selection_.size(); ++i) { 2748 int page_index = engine_->selection_[i].page_index(); 2749 if (!engine_->IsPageVisible(page_index)) 2750 continue; // This selection is on a page that's not currently visible. 2751 2752 std::vector<pp::Rect> selection_rects = 2753 engine_->selection_[i].GetScreenRects( 2754 visible_rect.point(), 2755 engine_->current_zoom_, 2756 engine_->current_rotation_); 2757 rects->insert(rects->end(), selection_rects.begin(), selection_rects.end()); 2758 } 2759 } 2760 2761 PDFiumEngine::MouseDownState::MouseDownState( 2762 const PDFiumPage::Area& area, 2763 const PDFiumPage::LinkTarget& target) 2764 : area_(area), target_(target) { 2765 } 2766 2767 PDFiumEngine::MouseDownState::~MouseDownState() { 2768 } 2769 2770 void PDFiumEngine::MouseDownState::Set(const PDFiumPage::Area& area, 2771 const PDFiumPage::LinkTarget& target) { 2772 area_ = area; 2773 target_ = target; 2774 } 2775 2776 void PDFiumEngine::MouseDownState::Reset() { 2777 area_ = PDFiumPage::NONSELECTABLE_AREA; 2778 target_ = PDFiumPage::LinkTarget(); 2779 } 2780 2781 bool PDFiumEngine::MouseDownState::Matches( 2782 const PDFiumPage::Area& area, 2783 const PDFiumPage::LinkTarget& target) const { 2784 if (area_ == area) { 2785 if (area == PDFiumPage::WEBLINK_AREA) 2786 return target_.url == target.url; 2787 if (area == PDFiumPage::DOCLINK_AREA) 2788 return target_.page == target.page; 2789 return true; 2790 } 2791 return false; 2792 } 2793 2794 void PDFiumEngine::DeviceToPage(int page_index, 2795 float device_x, 2796 float device_y, 2797 double* page_x, 2798 double* page_y) { 2799 *page_x = *page_y = 0; 2800 int temp_x = static_cast<int>((device_x + position_.x())/ current_zoom_ - 2801 pages_[page_index]->rect().x()); 2802 int temp_y = static_cast<int>((device_y + position_.y())/ current_zoom_ - 2803 pages_[page_index]->rect().y()); 2804 FPDF_DeviceToPage( 2805 pages_[page_index]->GetPage(), 0, 0, 2806 pages_[page_index]->rect().width(), pages_[page_index]->rect().height(), 2807 current_rotation_, temp_x, temp_y, page_x, page_y); 2808 } 2809 2810 int PDFiumEngine::GetVisiblePageIndex(FPDF_PAGE page) { 2811 for (size_t i = 0; i < visible_pages_.size(); ++i) { 2812 if (pages_[visible_pages_[i]]->GetPage() == page) 2813 return visible_pages_[i]; 2814 } 2815 return -1; 2816 } 2817 2818 void PDFiumEngine::SetCurrentPage(int index) { 2819 if (index == most_visible_page_ || !form_) 2820 return; 2821 if (most_visible_page_ != -1 && called_do_document_action_) { 2822 FPDF_PAGE old_page = pages_[most_visible_page_]->GetPage(); 2823 FORM_DoPageAAction(old_page, form_, FPDFPAGE_AACTION_CLOSE); 2824 } 2825 most_visible_page_ = index; 2826 #if defined(OS_LINUX) 2827 g_last_instance_id = client_->GetPluginInstance()->pp_instance(); 2828 #endif 2829 if (most_visible_page_ != -1 && called_do_document_action_) { 2830 FPDF_PAGE new_page = pages_[most_visible_page_]->GetPage(); 2831 FORM_DoPageAAction(new_page, form_, FPDFPAGE_AACTION_OPEN); 2832 } 2833 } 2834 2835 void PDFiumEngine::TransformPDFPageForPrinting( 2836 FPDF_PAGE page, 2837 const PP_PrintSettings_Dev& print_settings) { 2838 // Get the source page width and height in points. 2839 const double src_page_width = FPDF_GetPageWidth(page); 2840 const double src_page_height = FPDF_GetPageHeight(page); 2841 2842 const int src_page_rotation = FPDFPage_GetRotation(page); 2843 const bool fit_to_page = print_settings.print_scaling_option == 2844 PP_PRINTSCALINGOPTION_FIT_TO_PRINTABLE_AREA; 2845 2846 pp::Size page_size(print_settings.paper_size); 2847 pp::Rect content_rect(print_settings.printable_area); 2848 const bool rotated = (src_page_rotation % 2 == 1); 2849 SetPageSizeAndContentRect(rotated, 2850 src_page_width > src_page_height, 2851 &page_size, 2852 &content_rect); 2853 2854 // Compute the screen page width and height in points. 2855 const int actual_page_width = 2856 rotated ? page_size.height() : page_size.width(); 2857 const int actual_page_height = 2858 rotated ? page_size.width() : page_size.height(); 2859 2860 const double scale_factor = CalculateScaleFactor(fit_to_page, content_rect, 2861 src_page_width, 2862 src_page_height, rotated); 2863 2864 // Calculate positions for the clip box. 2865 ClipBox source_clip_box; 2866 CalculateClipBoxBoundary(page, scale_factor, rotated, &source_clip_box); 2867 2868 // Calculate the translation offset values. 2869 double offset_x = 0; 2870 double offset_y = 0; 2871 if (fit_to_page) { 2872 CalculateScaledClipBoxOffset(content_rect, source_clip_box, &offset_x, 2873 &offset_y); 2874 } else { 2875 CalculateNonScaledClipBoxOffset(content_rect, src_page_rotation, 2876 actual_page_width, actual_page_height, 2877 source_clip_box, &offset_x, &offset_y); 2878 } 2879 2880 // Reset the media box and crop box. When the page has crop box and media box, 2881 // the plugin will display the crop box contents and not the entire media box. 2882 // If the pages have different crop box values, the plugin will display a 2883 // document of multiple page sizes. To give better user experience, we 2884 // decided to have same crop box and media box values. Hence, the user will 2885 // see a list of uniform pages. 2886 FPDFPage_SetMediaBox(page, 0, 0, page_size.width(), page_size.height()); 2887 FPDFPage_SetCropBox(page, 0, 0, page_size.width(), page_size.height()); 2888 2889 // Transformation is not required, return. Do this check only after updating 2890 // the media box and crop box. For more detailed information, please refer to 2891 // the comment block right before FPDF_SetMediaBox and FPDF_GetMediaBox calls. 2892 if (scale_factor == 1.0 && offset_x == 0 && offset_y == 0) 2893 return; 2894 2895 2896 // All the positions have been calculated, now manipulate the PDF. 2897 FS_MATRIX matrix = {static_cast<float>(scale_factor), 2898 0, 2899 0, 2900 static_cast<float>(scale_factor), 2901 static_cast<float>(offset_x), 2902 static_cast<float>(offset_y)}; 2903 FS_RECTF cliprect = {static_cast<float>(source_clip_box.left+offset_x), 2904 static_cast<float>(source_clip_box.top+offset_y), 2905 static_cast<float>(source_clip_box.right+offset_x), 2906 static_cast<float>(source_clip_box.bottom+offset_y)}; 2907 FPDFPage_TransFormWithClip(page, &matrix, &cliprect); 2908 FPDFPage_TransformAnnots(page, scale_factor, 0, 0, scale_factor, 2909 offset_x, offset_y); 2910 } 2911 2912 void PDFiumEngine::DrawPageShadow(const pp::Rect& page_rc, 2913 const pp::Rect& shadow_rc, 2914 const pp::Rect& clip_rc, 2915 pp::ImageData* image_data) { 2916 pp::Rect page_rect(page_rc); 2917 page_rect.Offset(page_offset_); 2918 2919 pp::Rect shadow_rect(shadow_rc); 2920 shadow_rect.Offset(page_offset_); 2921 2922 pp::Rect clip_rect(clip_rc); 2923 clip_rect.Offset(page_offset_); 2924 2925 // Page drop shadow parameters. 2926 const double factor = 0.5; 2927 uint32 depth = std::max( 2928 std::max(page_rect.x() - shadow_rect.x(), 2929 page_rect.y() - shadow_rect.y()), 2930 std::max(shadow_rect.right() - page_rect.right(), 2931 shadow_rect.bottom() - page_rect.bottom())); 2932 depth = static_cast<uint32>(depth * 1.5) + 1; 2933 2934 // We need to check depth only to verify our copy of shadow matrix is correct. 2935 if (!page_shadow_.get() || page_shadow_->depth() != depth) 2936 page_shadow_.reset(new ShadowMatrix(depth, factor, kBackgroundColor)); 2937 2938 DCHECK(!image_data->is_null()); 2939 DrawShadow(image_data, shadow_rect, page_rect, clip_rect, *page_shadow_); 2940 } 2941 2942 void PDFiumEngine::GetRegion(const pp::Point& location, 2943 pp::ImageData* image_data, 2944 void** region, 2945 int* stride) const { 2946 if (image_data->is_null()) { 2947 DCHECK(plugin_size_.IsEmpty()); 2948 *stride = 0; 2949 *region = NULL; 2950 return; 2951 } 2952 char* buffer = static_cast<char*>(image_data->data()); 2953 *stride = image_data->stride(); 2954 2955 pp::Point offset_location = location + page_offset_; 2956 // TODO: update this when we support BIDI and scrollbars can be on the left. 2957 if (!buffer || 2958 !pp::Rect(page_offset_, plugin_size_).Contains(offset_location)) { 2959 *region = NULL; 2960 return; 2961 } 2962 2963 buffer += location.y() * (*stride); 2964 buffer += (location.x() + page_offset_.x()) * 4; 2965 *region = buffer; 2966 } 2967 2968 void PDFiumEngine::OnSelectionChanged() { 2969 if (HasPermission(PDFEngine::PERMISSION_COPY)) 2970 pp::PDF::SetSelectedText(GetPluginInstance(), GetSelectedText().c_str()); 2971 } 2972 2973 void PDFiumEngine::Form_Invalidate(FPDF_FORMFILLINFO* param, 2974 FPDF_PAGE page, 2975 double left, 2976 double top, 2977 double right, 2978 double bottom) { 2979 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 2980 int page_index = engine->GetVisiblePageIndex(page); 2981 if (page_index == -1) { 2982 // This can sometime happen when the page is closed because it went off 2983 // screen, and PDFium invalidates the control as it's being deleted. 2984 return; 2985 } 2986 2987 pp::Rect rect = engine->pages_[page_index]->PageToScreen( 2988 engine->GetVisibleRect().point(), engine->current_zoom_, left, top, right, 2989 bottom, engine->current_rotation_); 2990 engine->client_->Invalidate(rect); 2991 } 2992 2993 void PDFiumEngine::Form_OutputSelectedRect(FPDF_FORMFILLINFO* param, 2994 FPDF_PAGE page, 2995 double left, 2996 double top, 2997 double right, 2998 double bottom) { 2999 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 3000 int page_index = engine->GetVisiblePageIndex(page); 3001 if (page_index == -1) { 3002 NOTREACHED(); 3003 return; 3004 } 3005 pp::Rect rect = engine->pages_[page_index]->PageToScreen( 3006 engine->GetVisibleRect().point(), engine->current_zoom_, left, top, right, 3007 bottom, engine->current_rotation_); 3008 engine->form_highlights_.push_back(rect); 3009 } 3010 3011 void PDFiumEngine::Form_SetCursor(FPDF_FORMFILLINFO* param, int cursor_type) { 3012 // We don't need this since it's not enough to change the cursor in all 3013 // scenarios. Instead, we check which form field we're under in OnMouseMove. 3014 } 3015 3016 int PDFiumEngine::Form_SetTimer(FPDF_FORMFILLINFO* param, 3017 int elapse, 3018 TimerCallback timer_func) { 3019 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 3020 engine->timers_[++engine->next_timer_id_] = 3021 std::pair<int, TimerCallback>(elapse, timer_func); 3022 engine->client_->ScheduleCallback(engine->next_timer_id_, elapse); 3023 return engine->next_timer_id_; 3024 } 3025 3026 void PDFiumEngine::Form_KillTimer(FPDF_FORMFILLINFO* param, int timer_id) { 3027 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 3028 engine->timers_.erase(timer_id); 3029 } 3030 3031 FPDF_SYSTEMTIME PDFiumEngine::Form_GetLocalTime(FPDF_FORMFILLINFO* param) { 3032 base::Time time = base::Time::Now(); 3033 base::Time::Exploded exploded; 3034 time.LocalExplode(&exploded); 3035 3036 FPDF_SYSTEMTIME rv; 3037 rv.wYear = exploded.year; 3038 rv.wMonth = exploded.month; 3039 rv.wDayOfWeek = exploded.day_of_week; 3040 rv.wDay = exploded.day_of_month; 3041 rv.wHour = exploded.hour; 3042 rv.wMinute = exploded.minute; 3043 rv.wSecond = exploded.second; 3044 rv.wMilliseconds = exploded.millisecond; 3045 return rv; 3046 } 3047 3048 void PDFiumEngine::Form_OnChange(FPDF_FORMFILLINFO* param) { 3049 // Don't care about. 3050 } 3051 3052 FPDF_PAGE PDFiumEngine::Form_GetPage(FPDF_FORMFILLINFO* param, 3053 FPDF_DOCUMENT document, 3054 int page_index) { 3055 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 3056 if (page_index < 0 || page_index >= static_cast<int>(engine->pages_.size())) 3057 return NULL; 3058 return engine->pages_[page_index]->GetPage(); 3059 } 3060 3061 FPDF_PAGE PDFiumEngine::Form_GetCurrentPage(FPDF_FORMFILLINFO* param, 3062 FPDF_DOCUMENT document) { 3063 // TODO(jam): find out what this is used for. 3064 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 3065 int index = engine->last_page_mouse_down_; 3066 if (index == -1) { 3067 index = engine->GetMostVisiblePage(); 3068 if (index == -1) { 3069 NOTREACHED(); 3070 return NULL; 3071 } 3072 } 3073 3074 return engine->pages_[index]->GetPage(); 3075 } 3076 3077 int PDFiumEngine::Form_GetRotation(FPDF_FORMFILLINFO* param, FPDF_PAGE page) { 3078 return 0; 3079 } 3080 3081 void PDFiumEngine::Form_ExecuteNamedAction(FPDF_FORMFILLINFO* param, 3082 FPDF_BYTESTRING named_action) { 3083 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 3084 std::string action(named_action); 3085 if (action == "Print") { 3086 engine->client_->Print(); 3087 return; 3088 } 3089 3090 int index = engine->last_page_mouse_down_; 3091 /* Don't try to calculate the most visible page if we don't have a left click 3092 before this event (this code originally copied Form_GetCurrentPage which of 3093 course needs to do that and which doesn't have recursion). This can end up 3094 causing infinite recursion. See http://crbug.com/240413 for more 3095 information. Either way, it's not necessary for the spec'd list of named 3096 actions. 3097 if (index == -1) 3098 index = engine->GetMostVisiblePage(); 3099 */ 3100 if (index == -1) 3101 return; 3102 3103 // This is the only list of named actions per the spec (see 12.6.4.11). Adobe 3104 // Reader supports more, like FitWidth, but since they're not part of the spec 3105 // and we haven't got bugs about them, no need to now. 3106 if (action == "NextPage") { 3107 engine->client_->ScrollToPage(index + 1); 3108 } else if (action == "PrevPage") { 3109 engine->client_->ScrollToPage(index - 1); 3110 } else if (action == "FirstPage") { 3111 engine->client_->ScrollToPage(0); 3112 } else if (action == "LastPage") { 3113 engine->client_->ScrollToPage(engine->pages_.size() - 1); 3114 } 3115 } 3116 3117 void PDFiumEngine::Form_SetTextFieldFocus(FPDF_FORMFILLINFO* param, 3118 FPDF_WIDESTRING value, 3119 FPDF_DWORD valueLen, 3120 FPDF_BOOL is_focus) { 3121 // Do nothing for now. 3122 // TODO(gene): use this signal to trigger OSK. 3123 } 3124 3125 void PDFiumEngine::Form_DoURIAction(FPDF_FORMFILLINFO* param, 3126 FPDF_BYTESTRING uri) { 3127 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 3128 engine->client_->NavigateTo(std::string(uri), false); 3129 } 3130 3131 void PDFiumEngine::Form_DoGoToAction(FPDF_FORMFILLINFO* param, 3132 int page_index, 3133 int zoom_mode, 3134 float* position_array, 3135 int size_of_array) { 3136 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 3137 engine->client_->ScrollToPage(page_index); 3138 } 3139 3140 int PDFiumEngine::Form_Alert(IPDF_JSPLATFORM* param, 3141 FPDF_WIDESTRING message, 3142 FPDF_WIDESTRING title, 3143 int type, 3144 int icon) { 3145 // See fpdfformfill.h for these values. 3146 enum AlertType { 3147 ALERT_TYPE_OK = 0, 3148 ALERT_TYPE_OK_CANCEL, 3149 ALERT_TYPE_YES_ON, 3150 ALERT_TYPE_YES_NO_CANCEL 3151 }; 3152 3153 enum AlertResult { 3154 ALERT_RESULT_OK = 1, 3155 ALERT_RESULT_CANCEL, 3156 ALERT_RESULT_NO, 3157 ALERT_RESULT_YES 3158 }; 3159 3160 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 3161 std::string message_str = 3162 base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(message)); 3163 if (type == ALERT_TYPE_OK) { 3164 engine->client_->Alert(message_str); 3165 return ALERT_RESULT_OK; 3166 } 3167 3168 bool rv = engine->client_->Confirm(message_str); 3169 if (type == ALERT_TYPE_OK_CANCEL) 3170 return rv ? ALERT_RESULT_OK : ALERT_RESULT_CANCEL; 3171 return rv ? ALERT_RESULT_YES : ALERT_RESULT_NO; 3172 } 3173 3174 void PDFiumEngine::Form_Beep(IPDF_JSPLATFORM* param, int type) { 3175 // Beeps are annoying, and not possible using javascript, so ignore for now. 3176 } 3177 3178 int PDFiumEngine::Form_Response(IPDF_JSPLATFORM* param, 3179 FPDF_WIDESTRING question, 3180 FPDF_WIDESTRING title, 3181 FPDF_WIDESTRING default_response, 3182 FPDF_WIDESTRING label, 3183 FPDF_BOOL password, 3184 void* response, 3185 int length) { 3186 std::string question_str = base::UTF16ToUTF8( 3187 reinterpret_cast<const base::char16*>(question)); 3188 std::string default_str = base::UTF16ToUTF8( 3189 reinterpret_cast<const base::char16*>(default_response)); 3190 3191 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 3192 std::string rv = engine->client_->Prompt(question_str, default_str); 3193 base::string16 rv_16 = base::UTF8ToUTF16(rv); 3194 int rv_bytes = rv_16.size() * sizeof(base::char16); 3195 if (response) { 3196 int bytes_to_copy = rv_bytes < length ? rv_bytes : length; 3197 memcpy(response, rv_16.c_str(), bytes_to_copy); 3198 } 3199 return rv_bytes; 3200 } 3201 3202 int PDFiumEngine::Form_GetFilePath(IPDF_JSPLATFORM* param, 3203 void* file_path, 3204 int length) { 3205 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 3206 std::string rv = engine->client_->GetURL(); 3207 if (file_path && rv.size() <= static_cast<size_t>(length)) 3208 memcpy(file_path, rv.c_str(), rv.size()); 3209 return rv.size(); 3210 } 3211 3212 void PDFiumEngine::Form_Mail(IPDF_JSPLATFORM* param, 3213 void* mail_data, 3214 int length, 3215 FPDF_BOOL ui, 3216 FPDF_WIDESTRING to, 3217 FPDF_WIDESTRING subject, 3218 FPDF_WIDESTRING cc, 3219 FPDF_WIDESTRING bcc, 3220 FPDF_WIDESTRING message) { 3221 DCHECK(length == 0); // Don't handle attachments; no way with mailto. 3222 std::string to_str = 3223 base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(to)); 3224 std::string cc_str = 3225 base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(cc)); 3226 std::string bcc_str = 3227 base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(bcc)); 3228 std::string subject_str = 3229 base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(subject)); 3230 std::string message_str = 3231 base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(message)); 3232 3233 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 3234 engine->client_->Email(to_str, cc_str, bcc_str, subject_str, message_str); 3235 } 3236 3237 void PDFiumEngine::Form_Print(IPDF_JSPLATFORM* param, 3238 FPDF_BOOL ui, 3239 int start, 3240 int end, 3241 FPDF_BOOL silent, 3242 FPDF_BOOL shrink_to_fit, 3243 FPDF_BOOL print_as_image, 3244 FPDF_BOOL reverse, 3245 FPDF_BOOL annotations) { 3246 // No way to pass the extra information to the print dialog using JavaScript. 3247 // Just opening it is fine for now. 3248 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 3249 engine->client_->Print(); 3250 } 3251 3252 void PDFiumEngine::Form_SubmitForm(IPDF_JSPLATFORM* param, 3253 void* form_data, 3254 int length, 3255 FPDF_WIDESTRING url) { 3256 std::string url_str = 3257 base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(url)); 3258 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 3259 engine->client_->SubmitForm(url_str, form_data, length); 3260 } 3261 3262 void PDFiumEngine::Form_GotoPage(IPDF_JSPLATFORM* param, 3263 int page_number) { 3264 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 3265 engine->client_->ScrollToPage(page_number); 3266 } 3267 3268 int PDFiumEngine::Form_Browse(IPDF_JSPLATFORM* param, 3269 void* file_path, 3270 int length) { 3271 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 3272 std::string path = engine->client_->ShowFileSelectionDialog(); 3273 if (path.size() + 1 <= static_cast<size_t>(length)) 3274 memcpy(file_path, &path[0], path.size() + 1); 3275 return path.size() + 1; 3276 } 3277 3278 FPDF_BOOL PDFiumEngine::Pause_NeedToPauseNow(IFSDK_PAUSE* param) { 3279 PDFiumEngine* engine = static_cast<PDFiumEngine*>(param); 3280 return (base::Time::Now() - engine->last_progressive_start_time_). 3281 InMilliseconds() > engine->progressive_paint_timeout_; 3282 } 3283 3284 ScopedUnsupportedFeature::ScopedUnsupportedFeature(PDFiumEngine* engine) 3285 : engine_(engine), old_engine_(g_engine_for_unsupported) { 3286 g_engine_for_unsupported = engine_; 3287 } 3288 3289 ScopedUnsupportedFeature::~ScopedUnsupportedFeature() { 3290 g_engine_for_unsupported = old_engine_; 3291 } 3292 3293 PDFEngineExports* PDFEngineExports::Create() { 3294 return new PDFiumEngineExports; 3295 } 3296 3297 namespace { 3298 3299 int CalculatePosition(FPDF_PAGE page, 3300 const PDFiumEngineExports::RenderingSettings& settings, 3301 pp::Rect* dest) { 3302 int page_width = static_cast<int>( 3303 FPDF_GetPageWidth(page) * settings.dpi_x / kPointsPerInch); 3304 int page_height = static_cast<int>( 3305 FPDF_GetPageHeight(page) * settings.dpi_y / kPointsPerInch); 3306 3307 // Start by assuming that we will draw exactly to the bounds rect 3308 // specified. 3309 *dest = settings.bounds; 3310 3311 int rotate = 0; // normal orientation. 3312 3313 // Auto-rotate landscape pages to print correctly. 3314 if (settings.autorotate && 3315 (dest->width() > dest->height()) != (page_width > page_height)) { 3316 rotate = 3; // 90 degrees counter-clockwise. 3317 std::swap(page_width, page_height); 3318 } 3319 3320 // See if we need to scale the output 3321 bool scale_to_bounds = false; 3322 if (settings.fit_to_bounds && 3323 ((page_width > dest->width()) || (page_height > dest->height()))) { 3324 scale_to_bounds = true; 3325 } else if (settings.stretch_to_bounds && 3326 ((page_width < dest->width()) || (page_height < dest->height()))) { 3327 scale_to_bounds = true; 3328 } 3329 3330 if (scale_to_bounds) { 3331 // If we need to maintain aspect ratio, calculate the actual width and 3332 // height. 3333 if (settings.keep_aspect_ratio) { 3334 double scale_factor_x = page_width; 3335 scale_factor_x /= dest->width(); 3336 double scale_factor_y = page_height; 3337 scale_factor_y /= dest->height(); 3338 if (scale_factor_x > scale_factor_y) { 3339 dest->set_height(page_height / scale_factor_x); 3340 } else { 3341 dest->set_width(page_width / scale_factor_y); 3342 } 3343 } 3344 } else { 3345 // We are not scaling to bounds. Draw in the actual page size. If the 3346 // actual page size is larger than the bounds, the output will be 3347 // clipped. 3348 dest->set_width(page_width); 3349 dest->set_height(page_height); 3350 } 3351 3352 if (settings.center_in_bounds) { 3353 pp::Point offset((settings.bounds.width() - dest->width()) / 2, 3354 (settings.bounds.height() - dest->height()) / 2); 3355 dest->Offset(offset); 3356 } 3357 return rotate; 3358 } 3359 3360 } // namespace 3361 3362 #if defined(OS_WIN) 3363 bool PDFiumEngineExports::RenderPDFPageToDC(const void* pdf_buffer, 3364 int buffer_size, 3365 int page_number, 3366 const RenderingSettings& settings, 3367 HDC dc) { 3368 FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, buffer_size, NULL); 3369 if (!doc) 3370 return false; 3371 FPDF_PAGE page = FPDF_LoadPage(doc, page_number); 3372 if (!page) { 3373 FPDF_CloseDocument(doc); 3374 return false; 3375 } 3376 RenderingSettings new_settings = settings; 3377 // calculate the page size 3378 if (new_settings.dpi_x == -1) 3379 new_settings.dpi_x = GetDeviceCaps(dc, LOGPIXELSX); 3380 if (new_settings.dpi_y == -1) 3381 new_settings.dpi_y = GetDeviceCaps(dc, LOGPIXELSY); 3382 3383 pp::Rect dest; 3384 int rotate = CalculatePosition(page, new_settings, &dest); 3385 3386 int save_state = SaveDC(dc); 3387 // The caller wanted all drawing to happen within the bounds specified. 3388 // Based on scale calculations, our destination rect might be larger 3389 // than the bounds. Set the clip rect to the bounds. 3390 IntersectClipRect(dc, settings.bounds.x(), settings.bounds.y(), 3391 settings.bounds.x() + settings.bounds.width(), 3392 settings.bounds.y() + settings.bounds.height()); 3393 3394 // A temporary hack. PDFs generated by Cairo (used by Chrome OS to generate 3395 // a PDF output from a webpage) result in very large metafiles and the 3396 // rendering using FPDF_RenderPage is incorrect. In this case, render as a 3397 // bitmap. Note that this code does not kick in for PDFs printed from Chrome 3398 // because in that case we create a temp PDF first before printing and this 3399 // temp PDF does not have a creator string that starts with "cairo". 3400 base::string16 creator; 3401 size_t buffer_bytes = FPDF_GetMetaText(doc, "Creator", NULL, 0); 3402 if (buffer_bytes > 1) { 3403 FPDF_GetMetaText(doc, "Creator", WriteInto(&creator, buffer_bytes), 3404 buffer_bytes); 3405 } 3406 bool use_bitmap = false; 3407 if (StartsWith(creator, L"cairo", false)) 3408 use_bitmap = true; 3409 3410 // Another temporary hack. Some PDFs seems to render very slowly if 3411 // FPDF_RenderPage is directly used on a printer DC. I suspect it is 3412 // because of the code to talk Postscript directly to the printer if 3413 // the printer supports this. Need to discuss this with PDFium. For now, 3414 // render to a bitmap and then blit the bitmap to the DC if we have been 3415 // supplied a printer DC. 3416 int device_type = GetDeviceCaps(dc, TECHNOLOGY); 3417 if (use_bitmap || 3418 (device_type == DT_RASPRINTER) || (device_type == DT_PLOTTER)) { 3419 FPDF_BITMAP bitmap = FPDFBitmap_Create(dest.width(), dest.height(), 3420 FPDFBitmap_BGRx); 3421 // Clear the bitmap 3422 FPDFBitmap_FillRect(bitmap, 0, 0, dest.width(), dest.height(), 0xFFFFFFFF); 3423 FPDF_RenderPageBitmap( 3424 bitmap, page, 0, 0, dest.width(), dest.height(), rotate, 3425 FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH); 3426 int stride = FPDFBitmap_GetStride(bitmap); 3427 BITMAPINFO bmi; 3428 memset(&bmi, 0, sizeof(bmi)); 3429 bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); 3430 bmi.bmiHeader.biWidth = dest.width(); 3431 bmi.bmiHeader.biHeight = -dest.height(); // top-down image 3432 bmi.bmiHeader.biPlanes = 1; 3433 bmi.bmiHeader.biBitCount = 32; 3434 bmi.bmiHeader.biCompression = BI_RGB; 3435 bmi.bmiHeader.biSizeImage = stride * dest.height(); 3436 StretchDIBits(dc, dest.x(), dest.y(), dest.width(), dest.height(), 3437 0, 0, dest.width(), dest.height(), 3438 FPDFBitmap_GetBuffer(bitmap), &bmi, DIB_RGB_COLORS, SRCCOPY); 3439 FPDFBitmap_Destroy(bitmap); 3440 } else { 3441 FPDF_RenderPage(dc, page, dest.x(), dest.y(), dest.width(), dest.height(), 3442 rotate, FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH); 3443 } 3444 RestoreDC(dc, save_state); 3445 FPDF_ClosePage(page); 3446 FPDF_CloseDocument(doc); 3447 return true; 3448 } 3449 #endif // OS_WIN 3450 3451 bool PDFiumEngineExports::RenderPDFPageToBitmap( 3452 const void* pdf_buffer, 3453 int pdf_buffer_size, 3454 int page_number, 3455 const RenderingSettings& settings, 3456 void* bitmap_buffer) { 3457 FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, NULL); 3458 if (!doc) 3459 return false; 3460 FPDF_PAGE page = FPDF_LoadPage(doc, page_number); 3461 if (!page) { 3462 FPDF_CloseDocument(doc); 3463 return false; 3464 } 3465 3466 pp::Rect dest; 3467 int rotate = CalculatePosition(page, settings, &dest); 3468 3469 FPDF_BITMAP bitmap = 3470 FPDFBitmap_CreateEx(settings.bounds.width(), settings.bounds.height(), 3471 FPDFBitmap_BGRA, bitmap_buffer, 3472 settings.bounds.width() * 4); 3473 // Clear the bitmap 3474 FPDFBitmap_FillRect(bitmap, 0, 0, settings.bounds.width(), 3475 settings.bounds.height(), 0xFFFFFFFF); 3476 // Shift top-left corner of bounds to (0, 0) if it's not there. 3477 dest.set_point(dest.point() - settings.bounds.point()); 3478 FPDF_RenderPageBitmap( 3479 bitmap, page, dest.x(), dest.y(), dest.width(), dest.height(), rotate, 3480 FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH); 3481 FPDFBitmap_Destroy(bitmap); 3482 FPDF_ClosePage(page); 3483 FPDF_CloseDocument(doc); 3484 return true; 3485 } 3486 3487 bool PDFiumEngineExports::GetPDFDocInfo(const void* pdf_buffer, 3488 int buffer_size, 3489 int* page_count, 3490 double* max_page_width) { 3491 FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, buffer_size, NULL); 3492 if (!doc) 3493 return false; 3494 int page_count_local = FPDF_GetPageCount(doc); 3495 if (page_count) { 3496 *page_count = page_count_local; 3497 } 3498 if (max_page_width) { 3499 *max_page_width = 0; 3500 for (int page_number = 0; page_number < page_count_local; page_number++) { 3501 double page_width = 0; 3502 double page_height = 0; 3503 FPDF_GetPageSizeByIndex(doc, page_number, &page_width, &page_height); 3504 if (page_width > *max_page_width) { 3505 *max_page_width = page_width; 3506 } 3507 } 3508 } 3509 FPDF_CloseDocument(doc); 3510 return true; 3511 } 3512 3513 bool PDFiumEngineExports::GetPDFPageSizeByIndex( 3514 const void* pdf_buffer, 3515 int pdf_buffer_size, 3516 int page_number, 3517 double* width, 3518 double* height) { 3519 FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, NULL); 3520 if (!doc) 3521 return false; 3522 bool success = FPDF_GetPageSizeByIndex(doc, page_number, width, height) != 0; 3523 FPDF_CloseDocument(doc); 3524 return success; 3525 } 3526 3527 } // namespace chrome_pdf 3528