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.
5 #ifndef PDF_PDFIUM_PDFIUM_ENGINE_H_
6 #define PDF_PDFIUM_PDFIUM_ENGINE_H_
13 #include "base/memory/scoped_ptr.h"
14 #include "base/time/time.h"
15 #include "pdf/document_loader.h"
16 #include "pdf/pdf_engine.h"
17 #include "pdf/pdfium/pdfium_page.h"
18 #include "pdf/pdfium/pdfium_range.h"
19 #include "ppapi/cpp/completion_callback.h"
20 #include "ppapi/cpp/dev/buffer_dev.h"
21 #include "ppapi/cpp/image_data.h"
22 #include "ppapi/cpp/point.h"
23 #include "third_party/pdfium/fpdfsdk/include/fpdf_dataavail.h"
24 #include "third_party/pdfium/fpdfsdk/include/fpdf_progressive.h"
25 #include "third_party/pdfium/fpdfsdk/include/fpdfformfill.h"
26 #include "third_party/pdfium/fpdfsdk/include/fpdfview.h"
29 class KeyboardInputEvent;
30 class MouseInputEvent;
33 namespace chrome_pdf {
37 class PDFiumEngine : public PDFEngine,
38 public DocumentLoader::Client,
39 public FPDF_FORMFILLINFO,
40 public IPDF_JSPLATFORM,
43 explicit PDFiumEngine(PDFEngine::Client* client);
44 virtual ~PDFiumEngine();
46 // PDFEngine implementation.
47 virtual bool New(const char* url);
48 virtual bool New(const char* url,
50 virtual void PageOffsetUpdated(const pp::Point& page_offset);
51 virtual void PluginSizeUpdated(const pp::Size& size);
52 virtual void ScrolledToXPosition(int position);
53 virtual void ScrolledToYPosition(int position);
54 virtual void PrePaint();
55 virtual void Paint(const pp::Rect& rect,
56 pp::ImageData* image_data,
57 std::vector<pp::Rect>* ready,
58 std::vector<pp::Rect>* pending);
59 virtual void PostPaint();
60 virtual bool HandleDocumentLoad(const pp::URLLoader& loader);
61 virtual bool HandleEvent(const pp::InputEvent& event);
62 virtual uint32_t QuerySupportedPrintOutputFormats();
63 virtual void PrintBegin();
64 virtual pp::Resource PrintPages(
65 const PP_PrintPageNumberRange_Dev* page_ranges,
66 uint32_t page_range_count,
67 const PP_PrintSettings_Dev& print_settings);
68 virtual void PrintEnd();
69 virtual void StartFind(const char* text, bool case_sensitive);
70 virtual bool SelectFindResult(bool forward);
71 virtual void StopFind();
72 virtual void ZoomUpdated(double new_zoom_level);
73 virtual void RotateClockwise();
74 virtual void RotateCounterclockwise();
75 virtual std::string GetSelectedText();
76 virtual std::string GetLinkAtPosition(const pp::Point& point);
77 virtual bool IsSelecting();
78 virtual bool HasPermission(DocumentPermission permission) const;
79 virtual void SelectAll();
80 virtual int GetNumberOfPages();
81 virtual int GetNamedDestinationPage(const std::string& destination);
82 virtual int GetFirstVisiblePage();
83 virtual int GetMostVisiblePage();
84 virtual pp::Rect GetPageRect(int index);
85 virtual pp::Rect GetPageContentsRect(int index);
86 virtual int GetVerticalScrollbarYPosition() { return position_.y(); }
87 virtual void PaintThumbnail(pp::ImageData* image_data, int index);
88 virtual void SetGrayscale(bool grayscale);
89 virtual void OnCallback(int id);
90 virtual std::string GetPageAsJSON(int index);
91 virtual bool GetPrintScaling();
92 virtual void AppendBlankPages(int num_pages);
93 virtual void AppendPage(PDFEngine* engine, int index);
94 virtual pp::Point GetScrollPosition();
95 virtual void SetScrollPosition(const pp::Point& position);
96 virtual bool IsProgressiveLoad();
98 // DocumentLoader::Client implementation.
99 virtual pp::Instance* GetPluginInstance();
100 virtual pp::URLLoader CreateURLLoader();
101 virtual void OnPartialDocumentLoaded();
102 virtual void OnPendingRequestComplete();
103 virtual void OnNewDataAvailable();
104 virtual void OnDocumentComplete();
106 void UnsupportedFeature(int type);
108 std::string current_find_text() const { return current_find_text_; }
110 FPDF_DOCUMENT doc() { return doc_; }
111 FPDF_FORMHANDLE form() { return form_; }
114 // This helper class is used to detect the difference in selection between
115 // construction and destruction. At destruction, it invalidates all the
116 // parts that are newly selected, along with all the parts that used to be
117 // selected but are not anymore.
118 class SelectionChangeInvalidator {
120 explicit SelectionChangeInvalidator(PDFiumEngine* engine);
121 ~SelectionChangeInvalidator();
123 // Sets the given container to the all the currently visible selection
124 // rectangles, in screen coordinates.
125 void GetVisibleSelectionsScreenRects(std::vector<pp::Rect>* rects);
127 PDFiumEngine* engine_;
128 // Screen rectangles that were selected on construction.
129 std::vector<pp::Rect> old_selections_;
130 // The origin at the time this object was constructed.
131 pp::Point previous_origin_;
134 friend class SelectionChangeInvalidator;
136 struct FileAvail : public FX_FILEAVAIL {
137 DocumentLoader* loader;
140 struct DownloadHints : public FX_DOWNLOADHINTS {
141 DocumentLoader* loader;
144 // PDFium interface to get block of data.
145 static int GetBlock(void* param, unsigned long position,
146 unsigned char* buffer, unsigned long size);
148 // PDFium interface to check is block of data is available.
149 static bool IsDataAvail(FX_FILEAVAIL* param,
150 size_t offset, size_t size);
152 // PDFium interface to request download of the block of data.
153 static void AddSegment(FX_DOWNLOADHINTS* param,
154 size_t offset, size_t size);
156 // We finished getting the pdf file, so load it. This will complete
157 // asynchronously (due to password fetching) and may be run multiple times.
160 // Try loading the document. Returns true if the document is successfully
161 // loaded or is already loaded otherwise it will return false. If
162 // |with_password| is set to true, the document will be loaded with
163 // |password|. If the document could not be loaded and needs a password,
164 // |needs_password| will be set to true.
165 bool TryLoadingDoc(bool with_password,
166 const std::string& password,
167 bool* needs_password);
169 // Ask the user for the document password and then continue loading the
171 void GetPasswordAndLoad();
173 // Called when the password has been retrieved.
174 void OnGetPasswordComplete(int32_t result,
175 const pp::Var& password);
177 // Continues loading the document when the password has been retrieved, or if
178 // there is no password.
179 void ContinueLoadingDocument(bool has_password,
180 const std::string& password);
182 // Finish loading the document and notify the client that the document has
183 // been loaded. This should only be run after |doc_| has been loaded and the
184 // document is fully downloaded. If this has been run once, it will result in
186 void FinishLoadingDocument();
188 // Loads information about the pages in the document and calculate the
190 void LoadPageInfo(bool reload);
192 // Calculate which pages should be displayed right now.
193 void CalculateVisiblePages();
195 // Returns true iff the given page index is visible. CalculateVisiblePages
196 // must have been called first.
197 bool IsPageVisible(int index) const;
199 // Checks if a page is now available, and if so marks it as such and returns
200 // true. Otherwise, it will return false and will add the index to the given
201 // array if it's not already there.
202 bool CheckPageAvailable(int index, std::vector<int>* pending);
204 // Helper function to get a given page's size in pixels. This is not part of
205 // PDFiumPage because we might not have that structure when we need this.
206 pp::Size GetPageSize(int index);
208 void UpdateTickMarks();
210 // Called to continue searching so we don't block the main thread.
211 void ContinueFind(int32_t result);
213 // Inserts a find result into find_results_, which is sorted.
214 void AddFindResult(const PDFiumRange& result);
216 // Search a page using PDFium's methods. Doesn't work with unicode. This
217 // function is just kept arount in case PDFium code is fixed.
218 void SearchUsingPDFium(const base::string16& term,
221 int character_to_start_searching_from,
224 // Search a page ourself using ICU.
225 void SearchUsingICU(const base::string16& term,
228 int character_to_start_searching_from,
231 // Input event handlers.
232 bool OnMouseDown(const pp::MouseInputEvent& event);
233 bool OnMouseUp(const pp::MouseInputEvent& event);
234 bool OnMouseMove(const pp::MouseInputEvent& event);
235 bool OnKeyDown(const pp::KeyboardInputEvent& event);
236 bool OnKeyUp(const pp::KeyboardInputEvent& event);
237 bool OnChar(const pp::KeyboardInputEvent& event);
239 pp::Buffer_Dev PrintPagesAsRasterPDF(
240 const PP_PrintPageNumberRange_Dev* page_ranges,
241 uint32_t page_range_count,
242 const PP_PrintSettings_Dev& print_settings);
243 pp::Buffer_Dev PrintPagesAsPDF(const PP_PrintPageNumberRange_Dev* page_ranges,
244 uint32_t page_range_count,
245 const PP_PrintSettings_Dev& print_settings);
246 pp::Buffer_Dev GetFlattenedPrintData(const FPDF_DOCUMENT& doc);
247 void FitContentsToPrintableAreaIfRequired(
248 const FPDF_DOCUMENT& doc,
249 const PP_PrintSettings_Dev& print_settings);
250 void SaveSelectedFormForPrint();
252 // Given a mouse event, returns which page and character location it's closest
254 PDFiumPage::Area GetCharIndex(const pp::MouseInputEvent& event,
257 PDFiumPage::LinkTarget* target);
258 PDFiumPage::Area GetCharIndex(const pp::Point& point,
261 PDFiumPage::LinkTarget* target);
263 void OnSingleClick(int page_index, int char_index);
264 void OnMultipleClick(int click_count, int page_index, int char_index);
266 // Starts a progressive paint operation given a rectangle in screen
267 // coordinates. Returns the index in progressive_rects_.
268 int StartPaint(int page_index, const pp::Rect& dirty);
270 // Continues a paint operation that was started earlier. Returns true if the
271 // paint is done, or false if it needs to be continued.
272 bool ContinuePaint(int progressive_index, pp::ImageData* image_data);
274 // Called once PDFium is finished rendering a page so that we draw our
275 // borders, highlighting etc.
276 void FinishPaint(int progressive_index, pp::ImageData* image_data);
278 // Stops any paints that are in progress.
281 // Invalidates all pages. Use this when some global parameter, such as page
282 // orientation, has changed.
283 void InvalidateAllPages();
285 // If the page is narrower than the document size, paint the extra space
286 // with the page background.
287 void FillPageSides(int progressive_index);
289 void PaintPageShadow(int progressive_index, pp::ImageData* image_data);
291 // Highlight visible find results and selections.
292 void DrawSelections(int progressive_index, pp::ImageData* image_data);
294 // Paints an page that hasn't finished downloading.
295 void PaintUnavailablePage(int page_index,
296 const pp::Rect& dirty,
297 pp::ImageData* image_data);
299 // Given a page index, returns the corresponding index in progressive_rects_,
300 // or -1 if it doesn't exist.
301 int GetProgressiveIndex(int page_index) const;
303 // Creates a FPDF_BITMAP from a rectangle in screen coordinates.
304 FPDF_BITMAP CreateBitmap(const pp::Rect& rect,
305 pp::ImageData* image_data) const;
307 // Given a rectangle in screen coordinates, returns the coordinates in the
308 // units that PDFium rendering functions expect.
309 void GetPDFiumRect(int page_index, const pp::Rect& rect, int* start_x,
310 int* start_y, int* size_x, int* size_y) const;
312 // Returns the rendering flags to pass to PDFium.
313 int GetRenderingFlags() const;
315 // Returns the currently visible rectangle in document coordinates.
316 pp::Rect GetVisibleRect() const;
318 // Returns a page's rect in screen coordinates, as well as its surrounding
319 // border areas and bottom separator.
320 pp::Rect GetPageScreenRect(int page_index) const;
322 // Given a rectangle in document coordinates, returns the rectange into screen
323 // coordinates (i.e. 0,0 is top left corner of plugin area). If it's not
324 // visible, an empty rectangle is returned.
325 pp::Rect GetScreenRect(const pp::Rect& rect) const;
327 // Highlights the given rectangle.
328 void Highlight(void* buffer,
330 const pp::Rect& rect,
331 std::vector<pp::Rect>* highlighted_rects);
333 // Helper function to convert a device to page coordinates. If the page is
334 // not yet loaded, page_x and page_y will be set to 0.
335 void DeviceToPage(int page_index,
341 // Helper function to get the index of a given FPDF_PAGE. Returns -1 if not
343 int GetVisiblePageIndex(FPDF_PAGE page);
345 // Helper function to change the current page, running page open/close
346 // triggers as necessary.
347 void SetCurrentPage(int index);
349 // Transform |page| contents to fit in the selected printer paper size.
350 void TransformPDFPageForPrinting(FPDF_PAGE page,
351 const PP_PrintSettings_Dev& print_settings);
353 void DrawPageShadow(const pp::Rect& page_rect,
354 const pp::Rect& shadow_rect,
355 const pp::Rect& clip_rect,
356 pp::ImageData* image_data);
358 void GetRegion(const pp::Point& location,
359 pp::ImageData* image_data,
363 // Called when the selection changes.
364 void OnSelectionChanged();
366 // FPDF_FORMFILLINFO callbacks.
367 static void Form_Invalidate(FPDF_FORMFILLINFO* param,
373 static void Form_OutputSelectedRect(FPDF_FORMFILLINFO* param,
379 static void Form_SetCursor(FPDF_FORMFILLINFO* param, int cursor_type);
380 static int Form_SetTimer(FPDF_FORMFILLINFO* param,
382 TimerCallback timer_func);
383 static void Form_KillTimer(FPDF_FORMFILLINFO* param, int timer_id);
384 static FPDF_SYSTEMTIME Form_GetLocalTime(FPDF_FORMFILLINFO* param);
385 static void Form_OnChange(FPDF_FORMFILLINFO* param);
386 static FPDF_PAGE Form_GetPage(FPDF_FORMFILLINFO* param,
387 FPDF_DOCUMENT document,
389 static FPDF_PAGE Form_GetCurrentPage(FPDF_FORMFILLINFO* param,
390 FPDF_DOCUMENT document);
391 static int Form_GetRotation(FPDF_FORMFILLINFO* param, FPDF_PAGE page);
392 static void Form_ExecuteNamedAction(FPDF_FORMFILLINFO* param,
393 FPDF_BYTESTRING named_action);
394 static void Form_SetTextFieldFocus(FPDF_FORMFILLINFO* param,
395 FPDF_WIDESTRING value,
398 static void Form_DoURIAction(FPDF_FORMFILLINFO* param, FPDF_BYTESTRING uri);
399 static void Form_DoGoToAction(FPDF_FORMFILLINFO* param,
402 float* position_array,
405 // IPDF_JSPLATFORM callbacks.
406 static int Form_Alert(IPDF_JSPLATFORM* param,
407 FPDF_WIDESTRING message,
408 FPDF_WIDESTRING title,
411 static void Form_Beep(IPDF_JSPLATFORM* param, int type);
412 static int Form_Response(IPDF_JSPLATFORM* param,
413 FPDF_WIDESTRING question,
414 FPDF_WIDESTRING title,
415 FPDF_WIDESTRING default_response,
416 FPDF_WIDESTRING label,
420 static int Form_GetFilePath(IPDF_JSPLATFORM* param,
423 static void Form_Mail(IPDF_JSPLATFORM* param,
428 FPDF_WIDESTRING subject,
431 FPDF_WIDESTRING message);
432 static void Form_Print(IPDF_JSPLATFORM* param,
437 FPDF_BOOL shrink_to_fit,
438 FPDF_BOOL print_as_image,
440 FPDF_BOOL annotations);
441 static void Form_SubmitForm(IPDF_JSPLATFORM* param,
444 FPDF_WIDESTRING url);
445 static void Form_GotoPage(IPDF_JSPLATFORM* param, int page_number);
446 static int Form_Browse(IPDF_JSPLATFORM* param, void* file_path, int length);
448 // IFSDK_PAUSE callbacks
449 static FPDF_BOOL Pause_NeedToPauseNow(IFSDK_PAUSE* param);
451 PDFEngine::Client* client_;
452 pp::Size document_size_; // Size of document in pixels.
454 // The scroll position in screen coordinates.
456 // The offset of the page into the viewport.
457 pp::Point page_offset_;
458 // The plugin size in screen coordinates.
459 pp::Size plugin_size_;
460 double current_zoom_;
461 unsigned int current_rotation_;
463 DocumentLoader doc_loader_; // Main document's loader.
465 std::string headers_;
466 pp::CompletionCallbackFactory<PDFiumEngine> find_factory_;
468 pp::CompletionCallbackFactory<PDFiumEngine> password_factory_;
469 int32_t password_tries_remaining_;
471 // The current text used for searching.
472 std::string current_find_text_;
474 // The PDFium wrapper object for the document.
477 // The PDFium wrapper for form data. Used even if there are no form controls
479 FPDF_FORMHANDLE form_;
481 // The page(s) of the document. Store a vector of pointers so that when the
482 // vector is resized we don't close the pages that are used in pending
484 std::vector<PDFiumPage*> pages_;
486 // The indexes of the pages currently visible.
487 std::vector<int> visible_pages_;
489 // The indexes of the pages pending download.
490 std::vector<int> pending_pages_;
492 // During handling of input events we don't want to unload any pages in
493 // callbacks to us from PDFium, since the current page can change while PDFium
494 // code still has a pointer to it.
495 bool defer_page_unload_;
496 std::vector<int> deferred_page_unloads_;
498 // Used for selection. There could be more than one range if selection spans
499 // more than one page.
500 std::vector<PDFiumRange> selection_;
501 // True if we're in the middle of selection.
504 // Used for searching.
505 typedef std::vector<PDFiumRange> FindResults;
506 FindResults find_results_;
507 // Which page to search next.
508 int next_page_to_search_;
509 // Where to stop searching.
510 int last_page_to_search_;
511 int last_character_index_to_search_; // -1 if search until end of page.
512 // Which result the user has currently selected.
513 int current_find_index_;
515 // Permissions bitfield.
516 unsigned long permissions_;
518 // Interface structure to provide access to document stream.
519 FPDF_FILEACCESS file_access_;
520 // Interface structure to check data availability in the document stream.
521 FileAvail file_availability_;
522 // Interface structure to request data chunks from the document stream.
523 DownloadHints download_hints_;
524 // Pointer to the document availability interface.
525 FPDF_AVAIL fpdf_availability_;
527 pp::Size default_page_size_;
529 // Used to manage timers that form fill API needs. The pair holds the timer
530 // period, in ms, and the callback function.
531 std::map<int, std::pair<int, TimerCallback> > timers_;
534 // Holds the page index of the last page that the mouse clicked on.
535 int last_page_mouse_down_;
537 // Holds the page index of the first visible page; refreshed by calling
538 // CalculateVisiblePages()
539 int first_visible_page_;
541 // Holds the page index of the most visible page; refreshed by calling
542 // CalculateVisiblePages()
543 int most_visible_page_;
545 // Set to true after FORM_DoDocumentJSAction/FORM_DoDocumentOpenAction have
546 // been called. Only after that can we call FORM_DoPageAAction.
547 bool called_do_document_action_;
549 // Records parts of form fields that need to be highlighted at next paint, in
550 // screen coordinates.
551 std::vector<pp::Rect> form_highlights_;
553 // Whether to render in grayscale or in color.
554 bool render_grayscale_;
556 // The link currently under the cursor.
557 std::string link_under_cursor_;
559 // Pending progressive paints.
560 struct ProgressivePaint {
561 pp::Rect rect; // In screen coordinates.
564 // Temporary used to figure out if in a series of Paint() calls whether this
565 // pending paint was updated or not.
568 std::vector<ProgressivePaint> progressive_paints_;
570 // Keeps track of when we started the last progressive paint, so that in our
571 // callback we can determine if we need to pause.
572 base::Time last_progressive_start_time_;
574 // The timeout to use for the current progressive paint.
575 int progressive_paint_timeout_;
577 // Shadow matrix for generating the page shadow bitmap.
578 scoped_ptr<ShadowMatrix> page_shadow_;
580 // Set to true if the user is being prompted for their password. Will be set
581 // to false after the user finishes getting their password.
582 bool getting_password_;
585 // Create a local variable of this when calling PDFium functions which can call
586 // our global callback when an unsupported feature is reached.
587 class ScopedUnsupportedFeature {
589 explicit ScopedUnsupportedFeature(PDFiumEngine* engine);
590 ~ScopedUnsupportedFeature();
592 PDFiumEngine* engine_;
593 PDFiumEngine* old_engine_;
596 class PDFiumEngineExports : public PDFEngineExports {
598 PDFiumEngineExports() {}
600 // See the definition of RenderPDFPageToDC in pdf.cc for details.
601 virtual bool RenderPDFPageToDC(const void* pdf_buffer,
604 const RenderingSettings& settings,
607 virtual bool RenderPDFPageToBitmap(const void* pdf_buffer,
610 const RenderingSettings& settings,
611 void* bitmap_buffer);
613 virtual bool GetPDFDocInfo(const void* pdf_buffer,
616 double* max_page_width);
618 // See the definition of GetPDFPageSizeByIndex in pdf.cc for details.
619 virtual bool GetPDFPageSizeByIndex(const void* pdf_buffer,
620 int pdf_buffer_size, int page_number,
621 double* width, double* height);
624 } // namespace chrome_pdf
626 #endif // PDF_PDFIUM_PDFIUM_ENGINE_H_